@matterbridge/core 3.6.0-dev-20260302-e3a7eb0 → 3.6.0-dev-20260303-2f99eca

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

@@ -0,0 +1,830 @@
+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';
+export declare namespace ClosureDimension {
+    enum Feature {
+        Positioning = "Positioning",
+        MotionLatching = "MotionLatching",
+        Unit = "Unit",
+        Limitation = "Limitation",
+        Speed = "Speed",
+        Translation = "Translation",
+        Rotation = "Rotation",
+        Modulation = "Modulation"
+    }
+    enum ClosureUnit {
+        Millimeter = 0,
+        Degree = 1
+    }
+    enum ModulationType {
+        SlatsOrientation = 0,
+        SlatsOpenwork = 1,
+        StripesAlignment = 2,
+        Opacity = 3,
+        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
+    }
+    enum RotationAxis {
+        Left = 0,
+        CenteredVertical = 1,
+        LeftAndRight = 2,
+        Right = 3,
+        Top = 4,
+        CenteredHorizontal = 5,
+        TopAndBottom = 6,
+        Bottom = 7,
+        LeftBarrier = 8,
+        LeftAndRightBarriers = 9,
+        RightBarrier = 10
+    }
+    enum StepDirection {
+        Decrease = 0,
+        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
+    }
+    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> {
+    }
+    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> {
+    }
+    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> {
+    }
+    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> {
+    }
+    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> {
+    }
+}
+export type ClosureDimensionCluster = ClosureDimension.Cluster;
+export declare const ClosureDimensionCluster: 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<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;
+    }];
+}>;