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

package/dist/clusters/closure-dimension.d.ts

@@ -1,830 +1,164 @@
-import { Identity } from '@matter/general';
-import { Attribute, Command, FixedAttribute, MutableCluster } from '@matter/types/cluster';
-import { ThreeLevelAuto } from '@matter/types/globals';
-import { BitFlag } from '@matter/types/schema';
-import { TypeFromSchema } from '@matter/types/tlv';
+import { type MaybePromise } from '@matter/general';
+import { ClusterElement, ClusterModel } from '@matter/main/model';
+import { ClusterType, type ClusterTyping } from '@matter/types/cluster';
+import { type ClusterId } from '@matter/types/datatype';
+import { type ThreeLevelAuto } from '@matter/types/globals';
+export declare const ClosureDimensionDefinition: ClusterElement;
+export declare const ClosureDimensionModel: ClusterModel;
 export declare namespace ClosureDimension {
-    enum Feature {
-        Positioning = "Positioning",
-        MotionLatching = "MotionLatching",
-        Unit = "Unit",
-        Limitation = "Limitation",
-        Speed = "Speed",
-        Translation = "Translation",
-        Rotation = "Rotation",
-        Modulation = "Modulation"
+    interface FeatureEnum {
+        readonly Positioning: 'Positioning';
+        readonly MotionLatching: 'MotionLatching';
+        readonly Unit: 'Unit';
+        readonly Limitation: 'Limitation';
+        readonly Speed: 'Speed';
+        readonly Translation: 'Translation';
+        readonly Rotation: 'Rotation';
+        readonly Modulation: 'Modulation';
     }
-    enum ClosureUnit {
-        Millimeter = 0,
-        Degree = 1
+    interface ClosureUnitEnum {
+        readonly Millimeter: 0;
+        readonly Degree: 1;
     }
-    enum ModulationType {
-        SlatsOrientation = 0,
-        SlatsOpenwork = 1,
-        StripesAlignment = 2,
-        Opacity = 3,
-        Ventilation = 4
+    interface ModulationTypeEnum {
+        readonly SlatsOrientation: 0;
+        readonly SlatsOpenwork: 1;
+        readonly StripesAlignment: 2;
+        readonly Opacity: 3;
+        readonly Ventilation: 4;
     }
-    enum Overflow {
-        NoOverflow = 0,
-        Inside = 1,
-        Outside = 2,
-        TopInside = 3,
-        TopOutside = 4,
-        BottomInside = 5,
-        BottomOutside = 6,
-        LeftInside = 7,
-        LeftOutside = 8,
-        RightInside = 9,
-        RightOutside = 10
+    interface OverflowEnum {
+        readonly NoOverflow: 0;
+        readonly Inside: 1;
+        readonly Outside: 2;
+        readonly TopInside: 3;
+        readonly TopOutside: 4;
+        readonly BottomInside: 5;
+        readonly BottomOutside: 6;
+        readonly LeftInside: 7;
+        readonly LeftOutside: 8;
+        readonly RightInside: 9;
+        readonly RightOutside: 10;
     }
-    enum RotationAxis {
-        Left = 0,
-        CenteredVertical = 1,
-        LeftAndRight = 2,
-        Right = 3,
-        Top = 4,
-        CenteredHorizontal = 5,
-        TopAndBottom = 6,
-        Bottom = 7,
-        LeftBarrier = 8,
-        LeftAndRightBarriers = 9,
-        RightBarrier = 10
+    interface RotationAxisEnum {
+        readonly Left: 0;
+        readonly CenteredVertical: 1;
+        readonly LeftAndRight: 2;
+        readonly Right: 3;
+        readonly Top: 4;
+        readonly CenteredHorizontal: 5;
+        readonly TopAndBottom: 6;
+        readonly Bottom: 7;
+        readonly LeftBarrier: 8;
+        readonly LeftAndRightBarriers: 9;
+        readonly RightBarrier: 10;
     }
-    enum StepDirection {
-        Decrease = 0,
-        Increase = 1
+    interface StepDirectionEnum {
+        readonly Decrease: 0;
+        readonly Increase: 1;
     }
-    enum TranslationDirection {
-        Downward = 0,
-        Upward = 1,
-        VerticalMask = 2,
-        VerticalSymmetry = 3,
-        Leftward = 4,
-        Rightward = 5,
-        HorizontalMask = 6,
-        HorizontalSymmetry = 7,
-        Forward = 8,
-        Backward = 9,
-        DepthMask = 10,
-        DepthSymmetry = 11
+    interface TranslationDirectionEnum {
+        readonly Downward: 0;
+        readonly Upward: 1;
+        readonly VerticalMask: 2;
+        readonly VerticalSymmetry: 3;
+        readonly Leftward: 4;
+        readonly Rightward: 5;
+        readonly HorizontalMask: 6;
+        readonly HorizontalSymmetry: 7;
+        readonly Forward: 8;
+        readonly Backward: 9;
+        readonly DepthMask: 10;
+        readonly DepthSymmetry: 11;
     }
-    const LatchControlModes: {
-        remoteLatching: BitFlag;
-        remoteUnlatching: BitFlag;
-    };
-    const TlvDimensionState: import("@matter/types/tlv").ObjectSchema<{
-        position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-        latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-        speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-    }>;
-    interface DimensionState extends TypeFromSchema<typeof TlvDimensionState> {
+    type Feature = FeatureEnum[keyof FeatureEnum];
+    type Features = Feature;
+    type ClosureUnit = ClosureUnitEnum[keyof ClosureUnitEnum];
+    type ModulationType = ModulationTypeEnum[keyof ModulationTypeEnum];
+    type Overflow = OverflowEnum[keyof OverflowEnum];
+    type RotationAxis = RotationAxisEnum[keyof RotationAxisEnum];
+    type StepDirection = StepDirectionEnum[keyof StepDirectionEnum];
+    type TranslationDirection = TranslationDirectionEnum[keyof TranslationDirectionEnum];
+    interface LatchControlModesBitmap {
+        remoteLatching?: boolean;
+        remoteUnlatching?: boolean;
     }
-    const TlvRangePercent100ths: import("@matter/types/tlv").ObjectSchema<{
-        min: import("@matter/types/tlv").FieldType<number>;
-        max: import("@matter/types/tlv").FieldType<number>;
-    }>;
-    const TlvUnitRange: import("@matter/types/tlv").ObjectSchema<{
-        min: import("@matter/types/tlv").FieldType<number>;
-        max: import("@matter/types/tlv").FieldType<number>;
-    }>;
-    const TlvSetTargetRequest: import("@matter/types/tlv").ObjectSchema<{
-        position: import("@matter/types/tlv").OptionalFieldType<number>;
-        latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-        speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-    }>;
-    interface SetTargetRequest extends TypeFromSchema<typeof TlvSetTargetRequest> {
+    interface DimensionState {
+        position?: number | null;
+        latch?: boolean | null;
+        speed?: ThreeLevelAuto;
     }
-    const TlvStepRequest: import("@matter/types/tlv").ObjectSchema<{
-        direction: import("@matter/types/tlv").FieldType<StepDirection>;
-        numberOfSteps: import("@matter/types/tlv").FieldType<number>;
-        speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-    }>;
-    interface StepRequest extends TypeFromSchema<typeof TlvStepRequest> {
+    interface RangePercent100ths {
+        min: number;
+        max: number;
     }
-    const PositioningComponent: {
-        readonly attributes: {
-            readonly resolution: FixedAttribute<number, any>;
-            readonly stepValue: FixedAttribute<number, any>;
-        };
-        readonly commands: {
-            readonly step: Command<import("@matter/types/tlv").TypeFromFields<{
-                direction: import("@matter/types/tlv").FieldType<StepDirection>;
-                numberOfSteps: import("@matter/types/tlv").FieldType<number>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }>, void, any>;
-        };
-    };
-    const MotionLatchingComponent: {
-        readonly attributes: {
-            readonly latchControlModes: FixedAttribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
-                remoteLatching: BitFlag;
-                remoteUnlatching: BitFlag;
-            }>, any>;
-        };
-    };
-    const UnitComponent: {
-        readonly attributes: {
-            readonly unit: FixedAttribute<ClosureUnit, any>;
-            readonly unitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                min: import("@matter/types/tlv").FieldType<number>;
-                max: import("@matter/types/tlv").FieldType<number>;
-            }> | null, any>;
-        };
-    };
-    const LimitationComponent: {
-        readonly attributes: {
-            readonly limitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                min: import("@matter/types/tlv").FieldType<number>;
-                max: import("@matter/types/tlv").FieldType<number>;
-            }>, any>;
-        };
-    };
-    const TranslationComponent: {
-        readonly attributes: {
-            readonly translationDirection: FixedAttribute<TranslationDirection, any>;
-        };
-    };
-    const RotationComponent: {
-        readonly attributes: {
-            readonly rotationAxis: FixedAttribute<RotationAxis, any>;
-            readonly overflow: FixedAttribute<Overflow, any>;
-        };
-    };
-    const ModulationComponent: {
-        readonly attributes: {
-            readonly modulationType: FixedAttribute<ModulationType, any>;
-        };
-    };
-    const Base: {
-        readonly id: 261;
-        readonly name: "ClosureDimension";
-        readonly revision: 1;
-        readonly features: {
-            readonly positioning: BitFlag;
-            readonly motionLatching: BitFlag;
-            readonly unit: BitFlag;
-            readonly limitation: BitFlag;
-            readonly speed: BitFlag;
-            readonly translation: BitFlag;
-            readonly rotation: BitFlag;
-            readonly modulation: BitFlag;
-        };
-        readonly attributes: {
-            readonly currentState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-            readonly targetState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-        };
-        readonly commands: {
-            readonly setTarget: Command<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }>, void, any>;
-        };
-        readonly extensions: readonly [{
-            readonly flags: {
-                readonly positioning: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly resolution: FixedAttribute<number, any>;
-                    readonly stepValue: FixedAttribute<number, any>;
-                };
-                readonly commands: {
-                    readonly step: Command<import("@matter/types/tlv").TypeFromFields<{
-                        direction: import("@matter/types/tlv").FieldType<StepDirection>;
-                        numberOfSteps: import("@matter/types/tlv").FieldType<number>;
-                        speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-                    }>, void, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly motionLatching: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly latchControlModes: FixedAttribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
-                        remoteLatching: BitFlag;
-                        remoteUnlatching: BitFlag;
-                    }>, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly unit: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly unit: FixedAttribute<ClosureUnit, any>;
-                    readonly unitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                        min: import("@matter/types/tlv").FieldType<number>;
-                        max: import("@matter/types/tlv").FieldType<number>;
-                    }> | null, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly limitation: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly limitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                        min: import("@matter/types/tlv").FieldType<number>;
-                        max: import("@matter/types/tlv").FieldType<number>;
-                    }>, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly translation: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly translationDirection: FixedAttribute<TranslationDirection, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly rotation: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly rotationAxis: FixedAttribute<RotationAxis, any>;
-                    readonly overflow: FixedAttribute<Overflow, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly modulation: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly modulationType: FixedAttribute<ModulationType, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly positioning: false;
-                readonly motionLatching: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly unit: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly limitation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly speed: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly translation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly rotation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly modulation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly translation: true;
-                readonly rotation: true;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly translation: true;
-                readonly modulation: true;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly rotation: true;
-                readonly modulation: true;
-            };
-            readonly component: false;
-        }];
-    };
-    const Cluster: MutableCluster.ExtensibleOnly<{
-        readonly id: 261;
-        readonly name: "ClosureDimension";
-        readonly revision: 1;
-        readonly features: {
-            readonly positioning: BitFlag;
-            readonly motionLatching: BitFlag;
-            readonly unit: BitFlag;
-            readonly limitation: BitFlag;
-            readonly speed: BitFlag;
-            readonly translation: BitFlag;
-            readonly rotation: BitFlag;
-            readonly modulation: BitFlag;
-        };
-        readonly attributes: {
-            readonly currentState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-            readonly targetState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-        };
-        readonly commands: {
-            readonly setTarget: Command<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }>, void, any>;
-        };
-        readonly extensions: readonly [{
-            readonly flags: {
-                readonly positioning: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly resolution: FixedAttribute<number, any>;
-                    readonly stepValue: FixedAttribute<number, any>;
-                };
-                readonly commands: {
-                    readonly step: Command<import("@matter/types/tlv").TypeFromFields<{
-                        direction: import("@matter/types/tlv").FieldType<StepDirection>;
-                        numberOfSteps: import("@matter/types/tlv").FieldType<number>;
-                        speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-                    }>, void, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly motionLatching: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly latchControlModes: FixedAttribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
-                        remoteLatching: BitFlag;
-                        remoteUnlatching: BitFlag;
-                    }>, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly unit: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly unit: FixedAttribute<ClosureUnit, any>;
-                    readonly unitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                        min: import("@matter/types/tlv").FieldType<number>;
-                        max: import("@matter/types/tlv").FieldType<number>;
-                    }> | null, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly limitation: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly limitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                        min: import("@matter/types/tlv").FieldType<number>;
-                        max: import("@matter/types/tlv").FieldType<number>;
-                    }>, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly translation: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly translationDirection: FixedAttribute<TranslationDirection, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly rotation: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly rotationAxis: FixedAttribute<RotationAxis, any>;
-                    readonly overflow: FixedAttribute<Overflow, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly modulation: true;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly modulationType: FixedAttribute<ModulationType, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly positioning: false;
-                readonly motionLatching: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly unit: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly limitation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly speed: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly translation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly rotation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly modulation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly translation: true;
-                readonly rotation: true;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly translation: true;
-                readonly modulation: true;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly rotation: true;
-                readonly modulation: true;
-            };
-            readonly component: false;
-        }];
-    }>;
-    interface Cluster extends Identity<typeof Cluster> {
+    interface UnitRange {
+        min: number;
+        max: number;
     }
-    const Complete: MutableCluster<{
-        readonly id: 261;
-        readonly name: "ClosureDimension";
-        readonly revision: 1;
-        readonly features: {
-            readonly positioning: BitFlag;
-            readonly motionLatching: BitFlag;
-            readonly unit: BitFlag;
-            readonly limitation: BitFlag;
-            readonly speed: BitFlag;
-            readonly translation: BitFlag;
-            readonly rotation: BitFlag;
-            readonly modulation: BitFlag;
-        };
-        readonly attributes: {
-            readonly resolution: FixedAttribute<number, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    positioning: boolean;
-                }];
-            };
-            readonly stepValue: FixedAttribute<number, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    positioning: boolean;
-                }];
-            };
-            readonly unit: FixedAttribute<ClosureUnit, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    unit: boolean;
-                }];
-            };
-            readonly unitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                min: import("@matter/types/tlv").FieldType<number>;
-                max: import("@matter/types/tlv").FieldType<number>;
-            }> | null, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    unit: boolean;
-                }];
-            };
-            readonly limitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                min: import("@matter/types/tlv").FieldType<number>;
-                max: import("@matter/types/tlv").FieldType<number>;
-            }>, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    limitation: boolean;
-                }];
-            };
-            readonly translationDirection: FixedAttribute<TranslationDirection, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    translation: boolean;
-                }];
-            };
-            readonly rotationAxis: FixedAttribute<RotationAxis, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    rotation: boolean;
-                }];
-            };
-            readonly overflow: FixedAttribute<Overflow, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    rotation: boolean;
-                }];
-            };
-            readonly modulationType: FixedAttribute<ModulationType, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    modulation: boolean;
-                }];
-            };
-            readonly latchControlModes: FixedAttribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
-                remoteLatching: BitFlag;
-                remoteUnlatching: BitFlag;
-            }>, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    motionLatching: boolean;
-                }];
-            };
-            readonly currentState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-            readonly targetState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-        };
-        readonly commands: {
-            readonly step: Command<import("@matter/types/tlv").TypeFromFields<{
-                direction: import("@matter/types/tlv").FieldType<StepDirection>;
-                numberOfSteps: import("@matter/types/tlv").FieldType<number>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }>, void, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    positioning: boolean;
-                }];
-            };
-            readonly setTarget: Command<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<number>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }>, void, any>;
-        };
-    }, []>;
-    interface Complete extends Identity<typeof Complete> {
+    interface SetTargetRequest {
+        position?: number;
+        latch?: boolean;
+        speed?: ThreeLevelAuto;
+    }
+    interface StepRequest {
+        direction: StepDirection;
+        numberOfSteps: number;
+        speed?: ThreeLevelAuto;
+    }
+    interface Attributes {
+        currentState: DimensionState | null;
+        targetState: DimensionState | null;
+        resolution?: number;
+        stepValue?: number;
+        unit?: ClosureUnit;
+        unitRange?: UnitRange | null;
+        limitRange?: RangePercent100ths;
+        translationDirection?: TranslationDirection;
+        rotationAxis?: RotationAxis;
+        overflow?: Overflow;
+        modulationType?: ModulationType;
+        latchControlModes?: LatchControlModesBitmap;
+    }
+    interface Commands {
+        setTarget(request: SetTargetRequest): MaybePromise;
+        step?(request: StepRequest): MaybePromise;
+    }
+    type Components = [{
+        flags: {};
+        attributes: Attributes;
+        commands: Commands;
+    }];
+    interface Typing extends ClusterTyping {
+        Attributes: ClosureDimension.Attributes;
+        Commands: ClosureDimension.Commands;
+        Features: ClosureDimension.Features;
+        Components: ClosureDimension.Components;
     }
 }
-export type ClosureDimensionCluster = ClosureDimension.Cluster;
-export declare const ClosureDimensionCluster: MutableCluster.ExtensibleOnly<{
-    readonly id: 261;
+export declare const ClosureDimension: ClusterType.Concrete & {
+    readonly id: ClusterId & 261;
     readonly name: "ClosureDimension";
     readonly revision: 1;
-    readonly features: {
-        readonly positioning: BitFlag;
-        readonly motionLatching: BitFlag;
-        readonly unit: BitFlag;
-        readonly limitation: BitFlag;
-        readonly speed: BitFlag;
-        readonly translation: BitFlag;
-        readonly rotation: BitFlag;
-        readonly modulation: BitFlag;
-    };
-    readonly attributes: {
-        readonly currentState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-            position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-            latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-            speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-        }> | null, any>;
-        readonly targetState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-            position: import("@matter/types/tlv").OptionalFieldType<number | null>;
-            latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-            speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-        }> | null, any>;
-    };
-    readonly commands: {
-        readonly setTarget: Command<import("@matter/types/tlv").TypeFromFields<{
-            position: import("@matter/types/tlv").OptionalFieldType<number>;
-            latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-            speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-        }>, void, any>;
-    };
-    readonly extensions: readonly [{
-        readonly flags: {
-            readonly positioning: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly resolution: FixedAttribute<number, any>;
-                readonly stepValue: FixedAttribute<number, any>;
-            };
-            readonly commands: {
-                readonly step: Command<import("@matter/types/tlv").TypeFromFields<{
-                    direction: import("@matter/types/tlv").FieldType<ClosureDimension.StepDirection>;
-                    numberOfSteps: import("@matter/types/tlv").FieldType<number>;
-                    speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-                }>, void, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly motionLatching: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly latchControlModes: FixedAttribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
-                    remoteLatching: BitFlag;
-                    remoteUnlatching: BitFlag;
-                }>, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly unit: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly unit: FixedAttribute<ClosureDimension.ClosureUnit, any>;
-                readonly unitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                    min: import("@matter/types/tlv").FieldType<number>;
-                    max: import("@matter/types/tlv").FieldType<number>;
-                }> | null, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly limitation: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly limitRange: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                    min: import("@matter/types/tlv").FieldType<number>;
-                    max: import("@matter/types/tlv").FieldType<number>;
-                }>, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly translation: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly translationDirection: FixedAttribute<ClosureDimension.TranslationDirection, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly rotation: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly rotationAxis: FixedAttribute<ClosureDimension.RotationAxis, any>;
-                readonly overflow: FixedAttribute<ClosureDimension.Overflow, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly modulation: true;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly modulationType: FixedAttribute<ClosureDimension.ModulationType, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly positioning: false;
-            readonly motionLatching: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly unit: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly limitation: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly speed: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly translation: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly rotation: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly modulation: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly translation: true;
-            readonly rotation: true;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly translation: true;
-            readonly modulation: true;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly rotation: true;
-            readonly modulation: true;
-        };
-        readonly component: false;
-    }];
-}>;
+    readonly schema: ClusterModel;
+    readonly attributes: ClusterType.AttributeObjects<ClosureDimension.Attributes>;
+    readonly commands: ClusterType.CommandObjects<ClosureDimension.Commands>;
+    readonly events: ClusterType.EventObjects<Record<string, never>>;
+    readonly Feature: ClosureDimension.FeatureEnum;
+    readonly ClosureUnit: ClosureDimension.ClosureUnitEnum;
+    readonly ModulationType: ClosureDimension.ModulationTypeEnum;
+    readonly Overflow: ClosureDimension.OverflowEnum;
+    readonly RotationAxis: ClosureDimension.RotationAxisEnum;
+    readonly StepDirection: ClosureDimension.StepDirectionEnum;
+    readonly TranslationDirection: ClosureDimension.TranslationDirectionEnum;
+    readonly LatchControlModes: new (value?: Partial<ClosureDimension.LatchControlModesBitmap> | number) => ClosureDimension.LatchControlModesBitmap;
+    readonly DimensionState: new (value?: Partial<ClosureDimension.DimensionState>) => ClosureDimension.DimensionState;
+    readonly RangePercent100ths: new (value?: Partial<ClosureDimension.RangePercent100ths>) => ClosureDimension.RangePercent100ths;
+    readonly UnitRange: new (value?: Partial<ClosureDimension.UnitRange>) => ClosureDimension.UnitRange;
+    readonly SetTargetRequest: new (value?: Partial<ClosureDimension.SetTargetRequest>) => ClosureDimension.SetTargetRequest;
+    readonly StepRequest: new (value?: Partial<ClosureDimension.StepRequest>) => ClosureDimension.StepRequest;
+    readonly Typing: ClosureDimension.Typing;
+    readonly Cluster: typeof ClosureDimension;
+    readonly Complete: typeof ClosureDimension;
+    with(...features: ClosureDimension.Feature[]): typeof ClosureDimension;
+};