"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.definitions = void 0;
const exposes_1 = require("../lib/exposes");
const m = __importStar(require("../lib/modernExtend"));
const pushokExtend = {
    valveStatus: (args) => m.enumLookup({
        name: "status",
        lookup: { OFF: 0, ON: 1, MOVING: 2, STUCK: 3 },
        cluster: "genMultistateInput",
        attribute: "presentValue",
        zigbeeCommandOptions: {},
        description: "Actual valve status",
        access: "STATE_GET",
        reporting: null,
        ...args,
    }),
    stallTime: (args) => m.numeric({
        name: "stall_time",
        cluster: "genMultistateValue",
        attribute: "presentValue",
        description: "Timeout for state transition",
        unit: "s",
        access: "ALL",
        valueMin: 0,
        valueMax: 60,
        valueStep: 1,
        reporting: null,
        ...args,
    }),
    extendedTemperature: () => {
        const exposes = [exposes_1.presets.numeric("temperature", exposes_1.access.STATE).withUnit("°C").withDescription("Measured temperature value")];
        const fromZigbee = [
            {
                cluster: "msTemperatureMeasurement",
                type: ["attributeReport", "readResponse"],
                convert: (model, msg, publish, options, meta) => {
                    if (msg.data.measuredValue !== undefined) {
                        let temperature = msg.data.measuredValue / 100.0;
                        if (msg.data[0xf001] !== undefined) {
                            temperature += msg.data[0xf001] / 10.0;
                        }
                        return { temperature };
                    }
                    return {};
                },
            },
        ];
        const toZigbee = [];
        return {
            exposes,
            fromZigbee,
            toZigbee,
            isModernExtend: true,
        };
    },
    pok020Thermostat: () => {
        const exposes = [
            exposes_1.presets
                .climate()
                .withSetpoint("occupied_heating_setpoint", -45, 60, 0.1, exposes_1.access.ALL)
                .withSetpoint("unoccupied_heating_setpoint", -45, 60, 0.1, exposes_1.access.ALL)
                .withLocalTemperature(exposes_1.access.STATE_GET)
                .withSystemMode(["off", "heat"], exposes_1.access.ALL)
                .withLocalTemperatureCalibration(),
            exposes_1.presets.enum("sensor_source", exposes_1.access.ALL, ["internal", "external"]).withDescription("Temperature sensor used for control"),
            exposes_1.presets
                .enum("alarm", exposes_1.access.STATE_GET, [
                "ok",
                "never_calibrated",
                "calibration_error_p0",
                "calibration_error_p1_not_found",
                "calibration_error_p1_too_close",
                "calibration_error_p2_too_small",
                "calibration_error_p2_not_found",
                "calibration_lost",
            ])
                .withDescription("Calibration status alarm"),
        ];
        const fromZigbee = [
            {
                cluster: "hvacThermostat",
                type: ["attributeReport", "readResponse"],
                convert: (model, msg, publish, options, meta) => {
                    const data = msg.data;
                    const result = {};
                    if (data.localTemp !== undefined) {
                        result.local_temperature = data.localTemp / 100.0;
                    }
                    if (data.occupiedHeatingSetpoint !== undefined) {
                        result.occupied_heating_setpoint = data.occupiedHeatingSetpoint / 100.0;
                    }
                    if (data.unoccupiedHeatingSetpoint !== undefined) {
                        result.unoccupied_heating_setpoint = data.unoccupiedHeatingSetpoint / 100.0;
                    }
                    if (data.systemMode !== undefined) {
                        const map = {
                            0: "off",
                            4: "heat",
                        };
                        const raw = data.systemMode;
                        result.system_mode = map[raw] ?? raw;
                    }
                    if (data.localTemperatureCalibration !== undefined) {
                        const raw = data.localTemperatureCalibration;
                        result.local_temperature_calibration = raw / 10.0;
                    }
                    if (data.remoteSensing !== undefined) {
                        const rs = data.remoteSensing;
                        result.remote_sensing = rs;
                        result.sensor_source = (rs & 0x01) !== 0 ? "external" : "internal";
                    }
                    if (data.alarmMask !== undefined) {
                        const am = data.alarmMask;
                        const alarmMap = {
                            0: "ok",
                            1: "never_calibrated",
                            2: "calibration_error_p0",
                            3: "calibration_error_p1_not_found",
                            4: "calibration_error_p1_too_close",
                            5: "calibration_error_p2_too_small",
                            6: "calibration_error_p2_not_found",
                            7: "calibration_lost",
                        };
                        result.alarm_mask = am;
                        result.alarm = alarmMap[am] || `unknown_${am}`;
                    }
                    return result;
                },
            },
        ];
        const toZigbee = [
            {
                key: ["occupied_heating_setpoint"],
                convertSet: async (entity, key, value, meta) => {
                    const temp = Number(value);
                    const raw = Math.round(temp * 100);
                    await entity.write("hvacThermostat", { occupiedHeatingSetpoint: raw });
                    return { state: { occupied_heating_setpoint: temp } };
                },
            },
            {
                key: ["unoccupied_heating_setpoint"],
                convertSet: async (entity, key, value, meta) => {
                    const temp = Number(value);
                    const raw = Math.round(temp * 100);
                    await entity.write("hvacThermostat", { unoccupiedHeatingSetpoint: raw });
                    return { state: { unoccupied_heating_setpoint: temp } };
                },
            },
            {
                key: ["system_mode"],
                convertSet: async (entity, key, value, meta) => {
                    const v = String(value).toLowerCase();
                    const map = {
                        off: 0,
                        heat: 4,
                    };
                    const raw = map[v];
                    if (raw === undefined) {
                        throw new Error(`Unsupported system_mode: ${value}`);
                    }
                    await entity.write("hvacThermostat", { systemMode: raw });
                    return { state: { system_mode: v } };
                },
            },
            {
                key: ["local_temperature_calibration"],
                convertSet: async (entity, key, value, meta) => {
                    let v = Number(value);
                    v = Math.round(v * 10) / 10;
                    const raw = Math.round(v * 10);
                    await entity.write("hvacThermostat", { localTemperatureCalibration: raw });
                    return { state: { local_temperature_calibration: v } };
                },
            },
            {
                key: ["sensor_source"],
                convertSet: async (entity, key, value, meta) => {
                    const src = String(value);
                    const current = meta.state?.remote_sensing ?? 0;
                    let newMask = current & ~0x01;
                    if (src === "external") {
                        newMask |= 0x01;
                    }
                    await entity.write("hvacThermostat", { remoteSensing: newMask });
                    return {
                        state: {
                            sensor_source: src,
                            remote_sensing: newMask,
                        },
                    };
                },
            },
        ];
        return {
            exposes,
            fromZigbee,
            toZigbee,
            isModernExtend: true,
        };
    },
    pulseCounter: () => {
        const exposes = [
            exposes_1.presets.numeric("pulse_frequency", exposes_1.access.STATE_GET).withUnit("Hz").withDescription("Pulse frequency (counter mode)"),
            exposes_1.presets.numeric("pulse_count", exposes_1.access.STATE_GET).withDescription("Total pulse count (counter mode)"),
        ];
        const fromZigbee = [
            {
                cluster: "genAnalogOutput",
                type: ["attributeReport", "readResponse"],
                convert: (model, msg, publish, options, meta) => {
                    const result = {};
                    if (msg.data.presentValue !== undefined) {
                        result.pulse_frequency = msg.data.presentValue;
                    }
                    if (msg.data.applicationType !== undefined) {
                        result.pulse_count = msg.data.applicationType;
                    }
                    return result;
                },
            },
        ];
        const toZigbee = [
            {
                key: ["pulse_frequency", "pulse_count"],
                convertGet: async (entity, key, meta) => {
                    if (key === "pulse_frequency") {
                        await entity.read("genAnalogOutput", ["presentValue"]);
                    }
                    else if (key === "pulse_count") {
                        await entity.read("genAnalogOutput", ["applicationType"]);
                    }
                },
            },
        ];
        return {
            exposes,
            fromZigbee,
            toZigbee,
            isModernExtend: true,
        };
    },
    mp3Play: () => {
        const volumeLevels = ["3", "6", "9", "12", "15", "18", "21", "24", "27", "30"];
        const defaultVolumeIndex = 7;
        const exposes = [
            exposes_1.presets
                .numeric("track", exposes_1.access.SET)
                .withValueMin(1)
                .withValueMax(255)
                .withValueStep(1)
                .withDescription("Track number to play; writing it starts playback at the current volume"),
            exposes_1.presets.enum("volume", exposes_1.access.SET, volumeLevels).withDescription("Playback volume"),
        ];
        const fromZigbee = [];
        const toZigbee = [
            {
                key: ["track", "volume"],
                convertSet: async (entity, key, value, meta) => {
                    if (key === "volume") {
                        return { state: { volume: value } };
                    }
                    let track = Math.round(Number(value));
                    if (track < 1)
                        track = 1;
                    if (track > 255)
                        track = 255;
                    let volumeIndex = volumeLevels.indexOf(String(meta.state?.volume));
                    if (volumeIndex < 0)
                        volumeIndex = defaultVolumeIndex;
                    await entity.command("genOnOff", "onWithTimedOff", { ctrlbits: 0, ontime: track, offwaittime: volumeIndex }, { disableDefaultResponse: true });
                    return { state: { track } };
                },
            },
        ];
        return {
            exposes,
            fromZigbee,
            toZigbee,
            isModernExtend: true,
        };
    },
};
exports.definitions = [
    {
        zigbeeModel: ["POK001"],
        model: "POK001",
        vendor: "PushOk Hardware",
        description: "Battery powered retrofit valve",
        extend: [
            m.onOff({ powerOnBehavior: false, configureReporting: false }),
            m.battery({ percentage: true, voltage: true, lowStatus: true, percentageReporting: false }),
            pushokExtend.valveStatus({
                lookup: { OFF: 0, ON: 1, MOVING: 2, STUCK: 3, OFFLINE_CLOSE: 4, OFFLINE_OPEN: 5, BLOCKED: 6 },
            }),
            m.identify({ isSleepy: true }),
            m.enumLookup({
                name: "kamikaze",
                lookup: { OFF: 0, ON: 1 },
                cluster: "genBinaryValue",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Allow operation on low battery (can destroy battery)",
                access: "ALL",
                reporting: null,
            }),
            pushokExtend.stallTime(),
            m.enumLookup({
                name: "battery_type",
                lookup: { LIION: 0, ALKALINE: 1, NIMH: 2 },
                cluster: "genMultistateOutput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Battery type",
                access: "ALL",
                reporting: null,
            }),
            m.numeric({
                name: "end_lag",
                cluster: "genAnalogValue",
                attribute: "presentValue",
                description: "Endstop lag angle (wrong value can cause damage)",
                unit: "°",
                access: "ALL",
                valueMin: 0,
                valueMax: 15,
                valueStep: 1,
                reporting: null,
            }),
            m.enumLookup({
                name: "offline_action",
                lookup: { NONE: 1, CLOSE_RESTORE: 2, OPEN_RESTORE: 3, CLOSE: 4, OPEN: 5 },
                cluster: "genAnalogOutput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "What the valve does when the coordinator stops answering. " +
                    "The RESTORE variants return to the previous position once it answers again",
                access: "ALL",
                reporting: null,
            }),
            m.binary({
                name: "inverted",
                valueOn: ["ON", 0x01],
                valueOff: ["OFF", 0x00],
                cluster: "genBinaryOutput",
                attribute: "presentValue",
                description: "Swap the two valve positions, for actuators fitted the other way round. " +
                    "Changing this does not move the valve, it only changes which position is reported as on " +
                    "and which command drives where",
                access: "ALL",
                reporting: null,
            }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK002", "POK007"],
        model: "POK002_POK007",
        vendor: "PushOk Hardware",
        description: "Soil moisture and temperature sensor",
        extend: [
            m.humidity({ reporting: null, description: "Measured soil moisture" }),
            m.temperature({ reporting: null }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
            m.numeric({
                name: "max_moisture",
                cluster: "genMultistateValue",
                attribute: "presentValue",
                description: "Upper limit of soil moisture for this location",
                unit: "%",
                access: "ALL",
                valueMin: 1,
                valueMax: 100,
                valueStep: 1,
                reporting: null,
            }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK003"],
        model: "POK003",
        vendor: "PushOk Hardware",
        description: "Water level and temperature sensor",
        extend: [
            m.binary({
                name: "contact",
                valueOn: ["ON", 0x01],
                valueOff: ["OFF", 0x00],
                cluster: "genBinaryInput",
                attribute: "presentValue",
                description: "Indicates if the contact is closed (= true) or open (= false)",
                access: "STATE_GET",
                reporting: null,
            }),
            m.temperature({ reporting: null }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
            pushokExtend.pulseCounter(),
            m.enumLookup({
                name: "operating_mode",
                lookup: { contact: 1, counter: 2 },
                cluster: "genMultistateInput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Operating mode: contact sensor or pulse counter",
                access: "ALL",
                reporting: null,
            }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK004"],
        model: "POK004",
        vendor: "PushOk Hardware",
        description: "Solar powered zigbee router and illuminance sensor",
        extend: [m.illuminance({ reporting: null }), m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false })],
        ota: true,
    },
    {
        zigbeeModel: ["POK005"],
        model: "POK005",
        vendor: "PushOk Hardware",
        description: "Temperature and Humidity sensor",
        extend: [
            m.humidity({ reporting: null }),
            m.temperature({ reporting: null }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK006"],
        model: "POK006",
        vendor: "PushOk Hardware",
        description: "Battery powered garden valve",
        extend: [
            m.onOff({ powerOnBehavior: false, configureReporting: false }),
            m.battery({ percentage: true, voltage: true, lowStatus: true, percentageReporting: false }),
            pushokExtend.valveStatus(),
            m.identify({ isSleepy: true }),
            pushokExtend.stallTime(),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK008"],
        model: "POK008",
        vendor: "PushOk Hardware",
        description: "Battery powered thermostat relay",
        extend: [
            m.onOff({ powerOnBehavior: false, configureReporting: false }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
            m.temperature({ reporting: null }),
            m.numeric({
                name: "tgt_temperature",
                cluster: "genAnalogOutput",
                attribute: "presentValue",
                description: "Target temperature",
                unit: "C",
                access: "ALL",
                valueMin: -45,
                valueMax: 125,
                valueStep: 1,
                reporting: null,
            }),
            m.numeric({
                name: "hysteresis",
                cluster: "genAnalogValue",
                attribute: "presentValue",
                description: "Temperature hysteresis",
                unit: "C",
                access: "ALL",
                valueMin: 0.1,
                valueMax: 40,
                valueStep: 0.1,
                reporting: null,
            }),
            m.enumLookup({
                name: "set_op_mode",
                lookup: { monitor: 0, heater: 1, cooler: 2, monitor_inverted: 3, heater_inverted: 4, cooler_inverted: 5 },
                cluster: "genMultistateOutput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Operation mode",
                access: "ALL",
                reporting: null,
            }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK009"],
        model: "POK009",
        vendor: "PushOk Hardware",
        description: "Voltage monitor",
        extend: [
            m.numeric({
                name: "ext_voltage",
                cluster: "genAnalogInput",
                attribute: "presentValue",
                description: "Mains voltage",
                unit: "V",
                precision: 1,
                access: "STATE_GET",
                reporting: null,
            }),
            m.binary({
                name: "comp_state",
                valueOn: ["NORMAL", 0x01],
                valueOff: ["LOW", 0x00],
                cluster: "genBinaryInput",
                attribute: "presentValue",
                description: "Voltage status",
                access: "STATE_GET",
                reporting: null,
            }),
            m.numeric({
                name: "tgt_voltage",
                cluster: "genMultistateValue",
                attribute: "presentValue",
                description: "Voltage threshold",
                unit: "V",
                access: "ALL",
                valueMin: 4,
                valueMax: 340,
                valueStep: 1,
                reporting: null,
            }),
            m.enumLookup({
                name: "voltage_type",
                lookup: { AC: 0, DC: 1, DC_COUNTER: 2 },
                cluster: "genMultistateOutput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Mode",
                access: "ALL",
                reporting: null,
            }),
            m.identify({ isSleepy: true }),
            m.battery({ percentage: true, voltage: true, lowStatus: true, percentageReporting: false }),
            pushokExtend.pulseCounter(),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK010"],
        model: "POK010",
        vendor: "PushOk Hardware",
        description: "Water level and temperature sensor",
        extend: [
            m.binary({
                name: "contact",
                valueOn: ["ON", 0x01],
                valueOff: ["OFF", 0x00],
                cluster: "genBinaryInput",
                attribute: "presentValue",
                description: "Indicates if the contact is closed (= true) or open (= false)",
                access: "STATE_GET",
                reporting: null,
            }),
            m.temperature({ reporting: null }),
            m.humidity({ reporting: null, access: "STATE" }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
            pushokExtend.pulseCounter(),
            m.enumLookup({
                name: "operating_mode",
                lookup: { contact: 1, counter: 2 },
                cluster: "genMultistateInput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Operating mode: contact sensor or pulse counter",
                access: "ALL",
                reporting: null,
            }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK011"],
        model: "POK011",
        vendor: "PushOk Hardware",
        description: "Illuminance sensor",
        extend: [m.illuminance({ reporting: null }), m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false })],
        ota: true,
    },
    {
        zigbeeModel: ["POK012"],
        model: "POK012",
        vendor: "PushOk Hardware",
        description: "20 dBm Zigbee router with battery backup for indoor/outdoor use",
        extend: [
            m.enumLookup({
                name: "battery_state",
                lookup: { missing: 0, charging: 1, full: 2, discharging: 3 },
                cluster: "genMultistateInput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Battery state",
                access: "STATE_GET",
                entityCategory: "diagnostic",
                reporting: null,
            }),
            m.iasZoneAlarm({
                zoneType: "generic",
                zoneAttributes: ["ac_status", "battery_defect"],
                alarmTimeout: false,
            }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK014"],
        model: "POK014",
        vendor: "PushOk Hardware",
        description: "External probe temperature sensor: k-type",
        extend: [pushokExtend.extendedTemperature(), m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false })],
        ota: true,
    },
    {
        zigbeeModel: ["POK015"],
        model: "POK015",
        vendor: "PushOk Hardware",
        description: "External probe temperature sensor: pt1000",
        extend: [pushokExtend.extendedTemperature(), m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false })],
        ota: true,
    },
    {
        zigbeeModel: ["POK016"],
        model: "POK016",
        vendor: "PushOk Hardware",
        description: "Battery powered window opener",
        extend: [
            m.windowCovering({ controls: ["lift"], coverInverted: false, stateSource: "lift", configureReporting: false, coverMode: false }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
            m.enumLookup({
                name: "force_level",
                lookup: { low: 0, mid: 1, high: 2 },
                cluster: "genMultistateOutput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Force level at which the window stops",
                access: "ALL",
                reporting: null,
            }),
            m.enumLookup({
                name: "status",
                lookup: { off: 0, on: 1, moving: 2, stuck: 3, middle: 4 },
                cluster: "genMultistateInput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Actual window status",
                access: "STATE_GET",
                reporting: null,
            }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK017"],
        model: "POK017",
        vendor: "PushOk Hardware",
        description: "Battery powered greenhouse vent",
        extend: [
            m.windowCovering({ controls: ["lift"], coverInverted: false, stateSource: "lift", configureReporting: false, coverMode: false }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
            m.enumLookup({
                name: "thermostat_preset",
                lookup: { off: 0, level_1: 1, level_2: 2, level_3: 3, level_4: 4, level_5: 5, level_6: 6, level_7: 7, level_8: 8, level_9: 9 },
                cluster: "genMultistateOutput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Heat sensitivity level for automatic vent opening",
                access: "ALL",
                reporting: null,
            }),
            m.enumLookup({
                name: "status",
                lookup: { off: 0, on: 1, moving: 2, stuck: 3, middle: 4 },
                cluster: "genMultistateInput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Actual window status",
                access: "STATE_GET",
                reporting: null,
            }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK020"],
        model: "POK020",
        vendor: "PushOk Hardware",
        description: "Battery powered thermostat valve",
        extend: [
            m.onOff({ powerOnBehavior: false, configureReporting: false }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
            m.numeric({
                name: "rod_zero_position",
                cluster: "genAnalogInput",
                attribute: "resolution",
                description: "Rod zero position",
                unit: "mm",
                access: "STATE_GET",
                precision: 1,
                reporting: null,
            }),
            m.numeric({
                name: "rod_length",
                cluster: "genAnalogInput",
                attribute: "presentValue",
                description: "Rod length",
                unit: "mm",
                access: "STATE_GET",
                precision: 1,
                reporting: null,
            }),
            m.numeric({
                name: "rod_position",
                cluster: "genAnalogOutput",
                attribute: "presentValue",
                description: "Rod position",
                unit: "%",
                access: "ALL",
                valueMin: 0,
                valueMax: 100,
                valueStep: 0.5,
                precision: 1,
                reporting: null,
            }),
            m.numeric({
                name: "external_temperature",
                cluster: "genAnalogValue",
                attribute: "presentValue",
                description: "External temperature",
                unit: "°C",
                access: "ALL",
                valueMin: -50,
                valueMax: 120,
                valueStep: 0.5,
                precision: 1,
                reporting: null,
            }),
            m.enumLookup({
                name: "control_preset",
                lookup: { conservative: 0, moderate: 1, aggressive: 2 },
                cluster: "genMultistateOutput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Control steps preset",
                access: "ALL",
                reporting: null,
            }),
            pushokExtend.pok020Thermostat(),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK021"],
        model: "POK021",
        vendor: "PushOk Hardware",
        description: "Gas pulse meter",
        extend: [m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }), pushokExtend.pulseCounter()],
        ota: true,
    },
    {
        zigbeeModel: ["POK019"],
        model: "POK019",
        vendor: "PushOk Hardware",
        description: "Battery powered window handle",
        extend: [
            m.windowCovering({ controls: ["lift"], coverInverted: false, stateSource: "lift", configureReporting: false, coverMode: false }),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
            m.iasZoneAlarm({
                zoneType: "contact",
                zoneAttributes: ["alarm_1"],
                alarmTimeout: false,
                description: "Indicates whether the window is closed (= true) or opened (= false)",
            }),
            m.enumLookup({
                name: "window_opening_mode",
                lookup: {
                    two_position: 0,
                    three_position: 1,
                    four_position: 2,
                    reversed_two_position: 3,
                    reversed_three_position: 4,
                    reversed_four_position: 5,
                },
                cluster: "genMultistateOutput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Window opening mode depending on supported handle positions and installation orientation",
                access: "ALL",
                reporting: null,
            }),
            m.enumLookup({
                name: "status",
                lookup: { off: 0, on: 1, moving: 2, stuck: 3, middle: 4, micro_ventilation: 5, tilted: 6 },
                cluster: "genMultistateInput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Actual window status",
                access: "STATE_GET",
                reporting: null,
            }),
        ],
        ota: true,
    },
    {
        zigbeeModel: ["POK018"],
        model: "POK018",
        vendor: "PushOk Hardware",
        description: "Battery powered loudspeaker",
        extend: [
            m.enumLookup({
                name: "status",
                lookup: { unknown: 0, idle: 1, playing: 2, no_tracks: 3, no_sd_card: 4, no_module: 5 },
                cluster: "genMultistateInput",
                attribute: "presentValue",
                zigbeeCommandOptions: {},
                description: "Player status: idle/playing, or a fault. Refreshed only on a play attempt, so it reflects the last check.",
                access: "STATE_GET",
                reporting: null,
            }),
            m.numeric({
                name: "num_tracks",
                cluster: "genMultistateValue",
                attribute: "presentValue",
                description: "Total tracks on the SD card",
                access: "STATE_GET",
                valueMin: 0,
                valueMax: 255,
                valueStep: 1,
                reporting: null,
            }),
            pushokExtend.mp3Play(),
            m.battery({ percentage: true, voltage: true, lowStatus: false, percentageReporting: false }),
        ],
        ota: true,
    },
];
//# sourceMappingURL=pushok.js.map