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

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

@@ -1,634 +1,144 @@
-import { Identity } from '@matter/general';
-import { Attribute, Command, Event, 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 ClosureControlDefinition: ClusterElement;
+export declare const ClosureControlModel: ClusterModel;
 export declare namespace ClosureControl {
-    enum Feature {
-        Positioning = "Positioning",
-        MotionLatching = "MotionLatching",
-        Instantaneous = "Instantaneous",
-        Speed = "Speed",
-        Ventilation = "Ventilation",
-        Pedestrian = "Pedestrian",
-        Calibration = "Calibration",
-        Protection = "Protection",
-        ManuallyOperable = "ManuallyOperable"
+    interface FeatureEnum {
+        readonly Positioning: 'Positioning';
+        readonly MotionLatching: 'MotionLatching';
+        readonly Instantaneous: 'Instantaneous';
+        readonly Speed: 'Speed';
+        readonly Ventilation: 'Ventilation';
+        readonly Pedestrian: 'Pedestrian';
+        readonly Calibration: 'Calibration';
+        readonly Protection: 'Protection';
+        readonly ManuallyOperable: 'ManuallyOperable';
     }
-    enum ClosureError {
-        PhysicallyBlocked = 0,
-        BlockedBySensor = 1,
-        TemperatureLimited = 2,
-        MaintenanceRequired = 3,
-        InternalInterference = 4
+    interface ClosureErrorEnum {
+        readonly PhysicallyBlocked: 0;
+        readonly BlockedBySensor: 1;
+        readonly TemperatureLimited: 2;
+        readonly MaintenanceRequired: 3;
+        readonly InternalInterference: 4;
     }
-    enum CurrentPosition {
-        FullyClosed = 0,
-        FullyOpened = 1,
-        PartiallyOpened = 2,
-        OpenedForPedestrian = 3,
-        OpenedForVentilation = 4,
-        OpenedAtSignature = 5
+    interface CurrentPositionEnum {
+        readonly FullyClosed: 0;
+        readonly FullyOpened: 1;
+        readonly PartiallyOpened: 2;
+        readonly OpenedForPedestrian: 3;
+        readonly OpenedForVentilation: 4;
+        readonly OpenedAtSignature: 5;
     }
-    enum MainState {
-        Stopped = 0,
-        Moving = 1,
-        WaitingForMotion = 2,
-        Error = 3,
-        Calibrating = 4,
-        Protected = 5,
-        Disengaged = 6,
-        SetupRequired = 7
+    interface MainStateEnum {
+        readonly Stopped: 0;
+        readonly Moving: 1;
+        readonly WaitingForMotion: 2;
+        readonly Error: 3;
+        readonly Calibrating: 4;
+        readonly Protected: 5;
+        readonly Disengaged: 6;
+        readonly SetupRequired: 7;
     }
-    enum TargetPosition {
-        MoveToFullyClosed = 0,
-        MoveToFullyOpen = 1,
-        MoveToPedestrianPosition = 2,
-        MoveToVentilationPosition = 3,
-        MoveToSignaturePosition = 4
+    interface TargetPositionEnum {
+        readonly MoveToFullyClosed: 0;
+        readonly MoveToFullyOpen: 1;
+        readonly MoveToPedestrianPosition: 2;
+        readonly MoveToVentilationPosition: 3;
+        readonly MoveToSignaturePosition: 4;
     }
-    const LatchControlModes: {
-        remoteLatching: BitFlag;
-        remoteUnlatching: BitFlag;
-    };
-    const TlvOverallCurrentState: import("@matter/types/tlv").ObjectSchema<{
-        position: import("@matter/types/tlv").OptionalFieldType<CurrentPosition | null>;
-        latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-        speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-        secureState: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-    }>;
-    interface OverallCurrentState extends TypeFromSchema<typeof TlvOverallCurrentState> {
+    type Feature = FeatureEnum[keyof FeatureEnum];
+    type Features = Feature;
+    type ClosureError = ClosureErrorEnum[keyof ClosureErrorEnum];
+    type CurrentPosition = CurrentPositionEnum[keyof CurrentPositionEnum];
+    type MainState = MainStateEnum[keyof MainStateEnum];
+    type TargetPosition = TargetPositionEnum[keyof TargetPositionEnum];
+    interface LatchControlModesBitmap {
+        remoteLatching?: boolean;
+        remoteUnlatching?: boolean;
     }
-    const TlvOverallTargetState: import("@matter/types/tlv").ObjectSchema<{
-        position: import("@matter/types/tlv").OptionalFieldType<TargetPosition | null>;
-        latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-        speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-    }>;
-    interface OverallTargetState extends TypeFromSchema<typeof TlvOverallTargetState> {
+    interface OverallCurrentState {
+        position?: CurrentPosition | null;
+        latch?: boolean | null;
+        speed?: ThreeLevelAuto;
+        secureState: boolean | null;
     }
-    const TlvMoveToRequest: import("@matter/types/tlv").ObjectSchema<{
-        position: import("@matter/types/tlv").OptionalFieldType<TargetPosition>;
-        latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-        speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-    }>;
-    interface MoveToRequest extends TypeFromSchema<typeof TlvMoveToRequest> {
+    interface OverallTargetState {
+        position?: TargetPosition | null;
+        latch?: boolean | null;
+        speed?: ThreeLevelAuto;
     }
-    const TlvOperationalErrorEvent: import("@matter/types/tlv").ObjectSchema<{
-        errorState: import("@matter/types/tlv").FieldType<ClosureError[]>;
-    }>;
-    const TlvEngageStateChangedEvent: import("@matter/types/tlv").ObjectSchema<{
-        engageValue: import("@matter/types/tlv").FieldType<boolean>;
-    }>;
-    const TlvSecureStateChangedEvent: import("@matter/types/tlv").ObjectSchema<{
-        secureValue: import("@matter/types/tlv").FieldType<boolean>;
-    }>;
-    const CountdownTimeComponent: {
-        readonly attributes: {
-            readonly countdownTime: Attribute<number | null, any>;
-        };
-    };
-    const MotionLatchingComponent: {
-        readonly attributes: {
-            readonly latchControlModes: FixedAttribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
-                remoteLatching: BitFlag;
-                remoteUnlatching: BitFlag;
-            }>, any>;
-        };
-    };
-    const CalibrationComponent: {
-        readonly commands: {
-            readonly calibrate: Command<void, void, any>;
-        };
-    };
-    const ManuallyOperableComponent: {
-        readonly events: {
-            readonly engageStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-                engageValue: import("@matter/types/tlv").FieldType<boolean>;
-            }>, any>;
-        };
-    };
-    const NonInstantaneousComponent: {
-        readonly commands: {
-            readonly stop: Command<void, void, any>;
-        };
-        readonly events: {
-            readonly movementCompleted: Event<void, any>;
-        };
-    };
-    const Base: {
-        readonly id: 260;
-        readonly name: "ClosureControl";
-        readonly revision: 1;
-        readonly features: {
-            readonly positioning: BitFlag;
-            readonly motionLatching: BitFlag;
-            readonly instantaneous: BitFlag;
-            readonly speed: BitFlag;
-            readonly ventilation: BitFlag;
-            readonly pedestrian: BitFlag;
-            readonly calibration: BitFlag;
-            readonly protection: BitFlag;
-            readonly manuallyOperable: BitFlag;
-        };
-        readonly attributes: {
-            readonly mainState: Attribute<MainState, any>;
-            readonly currentErrorList: Attribute<ClosureError[], any>;
-            readonly overallCurrentState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<CurrentPosition | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-                secureState: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-            }> | null, any>;
-            readonly overallTargetState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<TargetPosition | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-        };
-        readonly commands: {
-            readonly moveTo: Command<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<TargetPosition>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }>, void, any>;
-        };
-        readonly events: {
-            readonly operationalError: Event<import("@matter/types/tlv").TypeFromFields<{
-                errorState: import("@matter/types/tlv").FieldType<ClosureError[]>;
-            }>, any>;
-            readonly secureStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-                secureValue: import("@matter/types/tlv").FieldType<boolean>;
-            }>, any>;
-        };
-        readonly extensions: readonly [{
-            readonly flags: {
-                readonly instantaneous: false;
-            };
-            readonly component: {
-                readonly commands: {
-                    readonly stop: Command<void, void, any>;
-                };
-                readonly events: {
-                    readonly movementCompleted: Event<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 calibration: true;
-            };
-            readonly component: {
-                readonly commands: {
-                    readonly calibrate: Command<void, void, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly manuallyOperable: true;
-            };
-            readonly component: {
-                readonly events: {
-                    readonly engageStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-                        engageValue: import("@matter/types/tlv").FieldType<boolean>;
-                    }>, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly positioning: true;
-                readonly instantaneous: false;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly countdownTime: Attribute<number | null, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly positioning: false;
-                readonly motionLatching: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly speed: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly speed: true;
-                readonly instantaneous: true;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly ventilation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly pedestrian: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly calibration: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }];
-    };
-    const Cluster: MutableCluster.ExtensibleOnly<{
-        readonly id: 260;
-        readonly name: "ClosureControl";
-        readonly revision: 1;
-        readonly features: {
-            readonly positioning: BitFlag;
-            readonly motionLatching: BitFlag;
-            readonly instantaneous: BitFlag;
-            readonly speed: BitFlag;
-            readonly ventilation: BitFlag;
-            readonly pedestrian: BitFlag;
-            readonly calibration: BitFlag;
-            readonly protection: BitFlag;
-            readonly manuallyOperable: BitFlag;
-        };
-        readonly attributes: {
-            readonly mainState: Attribute<MainState, any>;
-            readonly currentErrorList: Attribute<ClosureError[], any>;
-            readonly overallCurrentState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<CurrentPosition | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-                secureState: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-            }> | null, any>;
-            readonly overallTargetState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<TargetPosition | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-        };
-        readonly commands: {
-            readonly moveTo: Command<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<TargetPosition>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }>, void, any>;
-        };
-        readonly events: {
-            readonly operationalError: Event<import("@matter/types/tlv").TypeFromFields<{
-                errorState: import("@matter/types/tlv").FieldType<ClosureError[]>;
-            }>, any>;
-            readonly secureStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-                secureValue: import("@matter/types/tlv").FieldType<boolean>;
-            }>, any>;
-        };
-        readonly extensions: readonly [{
-            readonly flags: {
-                readonly instantaneous: false;
-            };
-            readonly component: {
-                readonly commands: {
-                    readonly stop: Command<void, void, any>;
-                };
-                readonly events: {
-                    readonly movementCompleted: Event<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 calibration: true;
-            };
-            readonly component: {
-                readonly commands: {
-                    readonly calibrate: Command<void, void, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly manuallyOperable: true;
-            };
-            readonly component: {
-                readonly events: {
-                    readonly engageStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-                        engageValue: import("@matter/types/tlv").FieldType<boolean>;
-                    }>, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly positioning: true;
-                readonly instantaneous: false;
-            };
-            readonly component: {
-                readonly attributes: {
-                    readonly countdownTime: Attribute<number | null, any>;
-                };
-            };
-        }, {
-            readonly flags: {
-                readonly positioning: false;
-                readonly motionLatching: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly speed: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly speed: true;
-                readonly instantaneous: true;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly ventilation: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly pedestrian: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }, {
-            readonly flags: {
-                readonly calibration: true;
-                readonly positioning: false;
-            };
-            readonly component: false;
-        }];
-    }>;
-    interface Cluster extends Identity<typeof Cluster> {
+    interface MoveToRequest {
+        position?: TargetPosition;
+        latch?: boolean;
+        speed?: ThreeLevelAuto;
     }
-    const Complete: MutableCluster<{
-        readonly id: 260;
-        readonly name: "ClosureControl";
-        readonly revision: 1;
-        readonly features: {
-            readonly positioning: BitFlag;
-            readonly motionLatching: BitFlag;
-            readonly instantaneous: BitFlag;
-            readonly speed: BitFlag;
-            readonly ventilation: BitFlag;
-            readonly pedestrian: BitFlag;
-            readonly calibration: BitFlag;
-            readonly protection: BitFlag;
-            readonly manuallyOperable: BitFlag;
-        };
-        readonly attributes: {
-            readonly countdownTime: Attribute<number | null, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | [{
-                    positioning: boolean;
-                    instantaneous: boolean;
-                }];
-                readonly mandatoryIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-            };
-            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 mainState: Attribute<MainState, any>;
-            readonly currentErrorList: Attribute<ClosureError[], any>;
-            readonly overallCurrentState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<CurrentPosition | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-                secureState: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-            }> | null, any>;
-            readonly overallTargetState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<TargetPosition | null>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }> | null, any>;
-        };
-        readonly commands: {
-            readonly stop: Command<void, void, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    instantaneous: boolean;
-                }];
-            };
-            readonly calibrate: Command<void, void, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    calibration: boolean;
-                }];
-            };
-            readonly moveTo: Command<import("@matter/types/tlv").TypeFromFields<{
-                position: import("@matter/types/tlv").OptionalFieldType<TargetPosition>;
-                latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-                speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            }>, void, any>;
-        };
-        readonly events: {
-            readonly movementCompleted: Event<void, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    instantaneous: boolean;
-                }];
-            };
-            readonly engageStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-                engageValue: import("@matter/types/tlv").FieldType<boolean>;
-            }>, any> & {
-                readonly optional: true;
-                readonly isConditional: true;
-                readonly optionalIf: [] | import("@matter/types/cluster").ConditionalFeatureList<import("@matter/types/schema").BitSchema>;
-                readonly mandatoryIf: [] | [{
-                    manuallyOperable: boolean;
-                }];
-            };
-            readonly operationalError: Event<import("@matter/types/tlv").TypeFromFields<{
-                errorState: import("@matter/types/tlv").FieldType<ClosureError[]>;
-            }>, any>;
-            readonly secureStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-                secureValue: import("@matter/types/tlv").FieldType<boolean>;
-            }>, any>;
-        };
-    }, []>;
-    interface Complete extends Identity<typeof Complete> {
+    interface OperationalErrorEvent {
+        errorState: ClosureError[];
+    }
+    interface EngageStateChangedEvent {
+        engageValue: boolean;
+    }
+    interface SecureStateChangedEvent {
+        secureValue: boolean;
+    }
+    interface Attributes {
+        countdownTime?: number | null;
+        mainState: MainState;
+        currentErrorList: ClosureError[];
+        overallCurrentState: OverallCurrentState | null;
+        overallTargetState: OverallTargetState | null;
+        latchControlModes?: LatchControlModesBitmap;
+    }
+    interface Commands {
+        moveTo(request: MoveToRequest): MaybePromise;
+        stop?(): MaybePromise;
+        calibrate?(): MaybePromise;
+    }
+    interface Events {
+        operationalError: OperationalErrorEvent;
+        movementCompleted?: Record<string, never>;
+        engageStateChanged?: EngageStateChangedEvent;
+        secureStateChanged: SecureStateChangedEvent;
+    }
+    type Components = [{
+        flags: {};
+        attributes: Attributes;
+        commands: Commands;
+        events: Events;
+    }];
+    interface Typing extends ClusterTyping {
+        Attributes: ClosureControl.Attributes;
+        Commands: ClosureControl.Commands;
+        Events: ClosureControl.Events;
+        Features: ClosureControl.Features;
+        Components: ClosureControl.Components;
     }
 }
-export type ClosureControlCluster = ClosureControl.Cluster;
-export declare const ClosureControlCluster: MutableCluster.ExtensibleOnly<{
-    readonly id: 260;
+export declare const ClosureControl: ClusterType.Concrete & {
+    readonly id: ClusterId & 260;
     readonly name: "ClosureControl";
     readonly revision: 1;
-    readonly features: {
-        readonly positioning: BitFlag;
-        readonly motionLatching: BitFlag;
-        readonly instantaneous: BitFlag;
-        readonly speed: BitFlag;
-        readonly ventilation: BitFlag;
-        readonly pedestrian: BitFlag;
-        readonly calibration: BitFlag;
-        readonly protection: BitFlag;
-        readonly manuallyOperable: BitFlag;
-    };
-    readonly attributes: {
-        readonly mainState: Attribute<ClosureControl.MainState, any>;
-        readonly currentErrorList: Attribute<ClosureControl.ClosureError[], any>;
-        readonly overallCurrentState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-            position: import("@matter/types/tlv").OptionalFieldType<ClosureControl.CurrentPosition | null>;
-            latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-            speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-            secureState: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-        }> | null, any>;
-        readonly overallTargetState: Attribute<import("@matter/types/tlv").TypeFromFields<{
-            position: import("@matter/types/tlv").OptionalFieldType<ClosureControl.TargetPosition | null>;
-            latch: import("@matter/types/tlv").OptionalFieldType<boolean | null>;
-            speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-        }> | null, any>;
-    };
-    readonly commands: {
-        readonly moveTo: Command<import("@matter/types/tlv").TypeFromFields<{
-            position: import("@matter/types/tlv").OptionalFieldType<ClosureControl.TargetPosition>;
-            latch: import("@matter/types/tlv").OptionalFieldType<boolean>;
-            speed: import("@matter/types/tlv").OptionalFieldType<ThreeLevelAuto>;
-        }>, void, any>;
-    };
-    readonly events: {
-        readonly operationalError: Event<import("@matter/types/tlv").TypeFromFields<{
-            errorState: import("@matter/types/tlv").FieldType<ClosureControl.ClosureError[]>;
-        }>, any>;
-        readonly secureStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-            secureValue: import("@matter/types/tlv").FieldType<boolean>;
-        }>, any>;
-    };
-    readonly extensions: readonly [{
-        readonly flags: {
-            readonly instantaneous: false;
-        };
-        readonly component: {
-            readonly commands: {
-                readonly stop: Command<void, void, any>;
-            };
-            readonly events: {
-                readonly movementCompleted: Event<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 calibration: true;
-        };
-        readonly component: {
-            readonly commands: {
-                readonly calibrate: Command<void, void, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly manuallyOperable: true;
-        };
-        readonly component: {
-            readonly events: {
-                readonly engageStateChanged: Event<import("@matter/types/tlv").TypeFromFields<{
-                    engageValue: import("@matter/types/tlv").FieldType<boolean>;
-                }>, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly positioning: true;
-            readonly instantaneous: false;
-        };
-        readonly component: {
-            readonly attributes: {
-                readonly countdownTime: Attribute<number | null, any>;
-            };
-        };
-    }, {
-        readonly flags: {
-            readonly positioning: false;
-            readonly motionLatching: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly speed: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly speed: true;
-            readonly instantaneous: true;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly ventilation: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly pedestrian: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }, {
-        readonly flags: {
-            readonly calibration: true;
-            readonly positioning: false;
-        };
-        readonly component: false;
-    }];
-}>;
+    readonly schema: ClusterModel;
+    readonly attributes: ClusterType.AttributeObjects<ClosureControl.Attributes>;
+    readonly commands: ClusterType.CommandObjects<ClosureControl.Commands>;
+    readonly events: ClusterType.EventObjects<ClosureControl.Events>;
+    readonly Feature: ClosureControl.FeatureEnum;
+    readonly ClosureError: ClosureControl.ClosureErrorEnum;
+    readonly CurrentPosition: ClosureControl.CurrentPositionEnum;
+    readonly MainState: ClosureControl.MainStateEnum;
+    readonly TargetPosition: ClosureControl.TargetPositionEnum;
+    readonly LatchControlModes: new (value?: Partial<ClosureControl.LatchControlModesBitmap>) => ClosureControl.LatchControlModesBitmap;
+    readonly OverallCurrentState: new (value?: Partial<ClosureControl.OverallCurrentState>) => ClosureControl.OverallCurrentState;
+    readonly OverallTargetState: new (value?: Partial<ClosureControl.OverallTargetState>) => ClosureControl.OverallTargetState;
+    readonly MoveToRequest: new (value?: Partial<ClosureControl.MoveToRequest>) => ClosureControl.MoveToRequest;
+    readonly OperationalErrorEvent: new (value?: Partial<ClosureControl.OperationalErrorEvent>) => ClosureControl.OperationalErrorEvent;
+    readonly EngageStateChangedEvent: new (value?: Partial<ClosureControl.EngageStateChangedEvent>) => ClosureControl.EngageStateChangedEvent;
+    readonly SecureStateChangedEvent: new (value?: Partial<ClosureControl.SecureStateChangedEvent>) => ClosureControl.SecureStateChangedEvent;
+    readonly Typing: ClosureControl.Typing;
+    readonly Cluster: typeof ClosureControl;
+    readonly Complete: typeof ClosureControl;
+    with(...features: ClosureControl.Feature[]): typeof ClosureControl;
+};