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

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

@@ -0,0 +1,634 @@
+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';
+export declare namespace ClosureControl {
+    enum Feature {
+        Positioning = "Positioning",
+        MotionLatching = "MotionLatching",
+        Instantaneous = "Instantaneous",
+        Speed = "Speed",
+        Ventilation = "Ventilation",
+        Pedestrian = "Pedestrian",
+        Calibration = "Calibration",
+        Protection = "Protection",
+        ManuallyOperable = "ManuallyOperable"
+    }
+    enum ClosureError {
+        PhysicallyBlocked = 0,
+        BlockedBySensor = 1,
+        TemperatureLimited = 2,
+        MaintenanceRequired = 3,
+        InternalInterference = 4
+    }
+    enum CurrentPosition {
+        FullyClosed = 0,
+        FullyOpened = 1,
+        PartiallyOpened = 2,
+        OpenedForPedestrian = 3,
+        OpenedForVentilation = 4,
+        OpenedAtSignature = 5
+    }
+    enum MainState {
+        Stopped = 0,
+        Moving = 1,
+        WaitingForMotion = 2,
+        Error = 3,
+        Calibrating = 4,
+        Protected = 5,
+        Disengaged = 6,
+        SetupRequired = 7
+    }
+    enum TargetPosition {
+        MoveToFullyClosed = 0,
+        MoveToFullyOpen = 1,
+        MoveToPedestrianPosition = 2,
+        MoveToVentilationPosition = 3,
+        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> {
+    }
+    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> {
+    }
+    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> {
+    }
+    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> {
+    }
+    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> {
+    }
+}
+export type ClosureControlCluster = ClosureControl.Cluster;
+export declare const ClosureControlCluster: 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<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;
+    }];
+}>;