zigbee-herdsman-converters
Version:
Collection of device converters to be used with zigbee-herdsman
1,264 lines • 61.7 kB
TypeScript
import type { MiboxerZone } from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";
import * as exposes from "./exposes";
import * as modernExtend from "./modernExtend";
import type { Expose, Fz, KeyValue, KeyValueAny, ModernExtend, Publish, Range, Tuya, Tz, Zh } from "./types";
export interface TuyaClosuresWindowCovering {
attributes: {
tuyaMovingState: number;
tuyaCalibration: number;
tuyaMotorReversal: number;
moesCalibrationTime: number;
};
commands: never;
commandResponses: never;
}
export interface TuyaGenBasic {
attributes: never;
commands: {
tuyaSetup: Record<string, never>;
};
commandResponses: never;
}
export interface TuyaGenGroups {
attributes: never;
commands: {
miboxerSetZones: {
zones: MiboxerZone[];
};
};
commandResponses: never;
}
export interface TuyaGenOnOff {
attributes: {
tuyaBacklightSwitch: number;
tuyaBacklightMode: number;
moesStartUpOnOff: number;
tuyaOperationMode: number;
};
commands: {
tuyaCountdown: {
data: Buffer;
};
tuyaAction2: {
value: number;
};
tuyaAction: {
value: number;
data: Buffer;
};
};
commandResponses: never;
}
export interface TuyaGenLevelCtrl {
attributes: never;
commands: {
moveToLevelTuya: {
level: number;
transtime: number;
};
};
commandResponses: never;
}
export interface TuyaLightingColorCtrl {
attributes: {
tuyaRgbMode: number;
tuyaBrightness: number;
};
commands: {
tuyaMoveToHueAndSaturationBrightness: {
hue: number;
saturation: number;
transtime: number;
brightness: number;
};
tuyaSetMinimumBrightness: {
minimum: number;
};
tuyaMoveToHueAndSaturationBrightness2: {
hue: number;
saturation: number;
brightness: number;
};
tuyaRgbMode: {
enable: number;
};
tuyaOnStartUp: {
mode: number;
data: number[];
};
tuyaDoNotDisturb: {
enable: number;
};
tuyaOnOffTransitionTime: {
unknown: number;
onTransitionTime: number;
offTransitionTime: number;
};
};
commandResponses: never;
}
export interface ManuSpecificTuya2 {
attributes: {
alarmTemperatureMax: number;
alarmTemperatureMin: number;
alarmHumidityMax: number;
alarmHumidityMin: number;
alarmHumidity: number;
alarmTemperature: number;
unknown: number;
};
commands: never;
commandResponses: never;
}
export interface ManuSpecificTuya3 {
attributes: {
powerOnBehavior: number;
switchMode: number;
switchType: number;
};
commands: {
setOptions1: {
data: Buffer;
};
setOptions2: {
data: Buffer;
};
setOptions3: {
data: Buffer;
};
};
commandResponses: never;
}
interface Tuya4 {
attributes: {
random_timing: string;
cycle_timing: string;
inching: string;
};
commands: {
setRandomTiming: {
payload: Buffer;
};
setCycleTiming: {
payload: Buffer;
};
setInchingSwitch: {
payload: Buffer;
};
};
commandResponses: never;
}
export interface InchingInput {
state?: string;
minutes?: number;
seconds?: number;
}
export interface InchingMetaState {
state: {
inching?: {
state: string;
minutes: number;
seconds: number;
};
[key: string]: unknown;
};
}
export interface AlarmSet1Input {
leakage_current_alarm?: number;
leakage_current_threshold?: number;
device_temperature_alarm?: number;
device_temperature_threshold?: number;
}
export interface AlarmSet1MetaState extends Tz.Meta {
state: {
alarm_set_1?: AlarmSet1Input;
[key: string]: unknown;
};
}
export interface AlarmSet2Input {
over_current_alarm?: number;
over_current_threshold?: number;
over_voltage_alarm?: number;
over_voltage_threshold?: number;
under_voltage_alarm?: number;
under_voltage_threshold?: number;
}
export interface AlarmSet2MetaState extends Tz.Meta {
state: {
alarm_set_2?: AlarmSet2Input;
[key: string]: unknown;
};
}
export interface AlarmSet3Input {
lost_flow_alarm?: number;
lost_flow_threshold?: number;
}
export interface AlarmSet3MetaState {
state: {
alarm_set_3?: AlarmSet3Input;
[key: string]: unknown;
};
}
export declare const circuitBreakerFaultList: string[];
export declare const dataTypes: {
raw: number;
bool: number;
number: number;
string: number;
enum: number;
bitmap: number;
};
export interface TuyaWeatherCondition {
sunny?: number;
heavy_rain?: number;
cloudy?: number;
sandstorm?: number;
light_snow?: number;
snow?: number;
freezing_fog?: number;
rainstorm?: number;
shower?: number;
dust?: number;
spit?: number;
sleet?: number;
yin?: number;
freezing_rain?: number;
rain?: number;
fog?: number;
heavy_shower?: number;
heavy_snow?: number;
heavy_downpour?: number;
blizzard?: number;
hailstone?: number;
snow_shower?: number;
haze?: number;
thunder_shower?: number;
floating_dust?: number;
thunder_and_lighting?: number;
dust_storm?: number;
light_shower?: number;
rain_and_snow?: number;
dust_bowl?: number;
ice_pellets?: number;
strong_dust_storms?: number;
sandy?: number;
light_to_moderate_rain?: number;
mostly_sunny?: number;
very_heavy_rain?: number;
ice_pod?: number;
light_to_moderate_snow?: number;
few_clouds?: number;
light_snow_showers?: number;
moderate_snow?: number;
icy_needles?: number;
thunderstorm_with_ice_pods?: number;
light_rain?: number;
thunder?: number;
moderate_rain?: number;
thunderstorm?: number;
moderate_to_heavy_rain?: number;
}
export declare const M8ProTuyaWeatherCondition: TuyaWeatherCondition;
export declare const F3ProTuyaWeatherCondition: TuyaWeatherCondition;
export declare enum TuyaWeatherID {
Temperature = 1,
Humidity = 2,
Condition = 3
}
export type ThermostatSchedule = KeyValue & {
enabled: boolean;
work_mode: "cooling" | "heating";
temperature_f: number;
start: {
hour: number;
minute: number;
};
end: {
hour: number;
minute: number;
};
week_days: {
sunday: boolean;
monday: boolean;
tuesday: boolean;
wednesday: boolean;
thursday: boolean;
friday: boolean;
saturday: boolean;
};
};
export type FromValue = string | number[] | Uint8Array;
export declare function convertBufferToNumber(chunks: Buffer | number[]): number;
export declare function convertDecimalValueTo4ByteHexArray(value: number): number[];
export declare function dpValueFromString(dp: number, string: string): {
dp: number;
datatype: number;
data: Buffer<ArrayBuffer>;
};
export declare function sendDataPointValue(entity: Zh.Group | Zh.Endpoint, dp: number, value: number, cmd?: string, seq?: number): Promise<number>;
export declare function sendDataPointBool(entity: Zh.Group | Zh.Endpoint, dp: number, value: boolean, cmd?: string, seq?: number): Promise<number>;
export declare function sendDataPointEnum(entity: Zh.Group | Zh.Endpoint, dp: number, value: number, cmd?: string, seq?: number): Promise<number>;
export declare function sendDataPointRaw(entity: Zh.Group | Zh.Endpoint, dp: number, value: Buffer, cmd?: string, seq?: number): Promise<number>;
export declare function sendDataPointBitmap(entity: Zh.Group | Zh.Endpoint, dp: number, value: number, cmd?: string, seq?: number): Promise<number>;
export declare function sendDataPointStringBuffer(entity: Zh.Group | Zh.Endpoint, dp: number, value: string, cmd?: string, seq?: number): Promise<number>;
declare const tuyaExposes: {
alarmTime: () => exposes.Numeric;
alarmMode: () => exposes.Enum;
lightType: () => exposes.Enum;
lightBrightnessWithMinMax: () => exposes.Light;
lightBrightness: () => exposes.Light;
countdown: () => exposes.Numeric;
countdown_min: () => exposes.Numeric;
on_with_countdown: () => exposes.Numeric;
countdown_left: () => exposes.Numeric;
single_watering_duration: () => exposes.Numeric;
flow_switch: () => exposes.Binary;
quantitative_watering: () => exposes.Numeric;
single_watering_amount: () => exposes.Numeric;
surplus_flow: () => exposes.Numeric;
water_total: () => exposes.Numeric;
water_current: () => exposes.Numeric;
water_total_reset: () => exposes.Enum;
refresh: () => exposes.Enum;
status_sprinkler: () => exposes.Enum;
switch: () => exposes.Switch;
selfTest: () => exposes.Binary;
selfTestResult: () => exposes.Enum;
fault: () => exposes.Binary;
faultAlarm: () => exposes.Binary;
silence: () => exposes.Binary;
frostProtection: (extraNote?: string) => exposes.Binary;
errorStatus: () => exposes.Numeric;
scheduleAllDays: (access: number, example: string) => exposes.Text[];
temperatureUnit: () => exposes.Enum;
temperatureCalibration: () => exposes.Numeric;
humidityCalibration: () => exposes.Numeric;
soilCalibration: () => exposes.Numeric;
temperatureSampling: () => exposes.Numeric;
soilSampling: () => exposes.Numeric;
soilWarning: () => exposes.Numeric;
gasValue: () => exposes.Numeric;
energyWithPhase: (phase: string) => exposes.Numeric;
energyProducedWithPhase: (phase: string) => exposes.Numeric;
energyFlowWithPhase: (phase: string, more: [string]) => exposes.Enum;
voltageWithPhase: (phase: string) => exposes.Numeric;
powerWithPhase: (phase: string) => exposes.Numeric;
currentWithPhase: (phase: string) => exposes.Numeric;
powerFactorWithPhase: (phase: string) => exposes.Numeric;
switchType: () => exposes.Enum;
switchTypeCurtain: () => exposes.Enum;
switchTypeButton: () => exposes.Enum;
backlightModeLowMediumHigh: () => exposes.Enum;
backlightModeOffNormalInverted: () => exposes.Enum;
backlightModeOffOn: () => exposes.Binary;
indicatorMode: () => exposes.Enum;
indicatorModeNoneRelayPos: () => exposes.Enum;
powerOutageMemory: () => exposes.Enum;
batteryState: () => exposes.Enum;
doNotDisturb: () => exposes.Binary;
colorPowerOnBehavior: () => exposes.Enum;
powerOnBehavior: () => exposes.Enum;
switchMode: () => exposes.Enum;
switchMode2: () => exposes.Enum;
lightMode: () => exposes.Enum;
inchingSwitch: (quantity: number) => exposes.Composite;
inchingSwitch2: () => exposes.Composite;
circuitBreakerFaults: () => exposes.List;
circuitBreakerStatus: () => exposes.Enum;
leakageCurrent: () => exposes.Numeric;
reclosing: () => exposes.Binary;
reclosing_delay: () => exposes.Numeric;
reclosing_count: () => exposes.Numeric;
energyPrepayment: () => exposes.Binary;
energyBalance: () => exposes.Numeric;
energyBalanceAdd: () => exposes.Numeric;
energyBalanceReset: () => exposes.Enum;
leakageCurrentAndTemperatureAlarm: () => exposes.Composite;
currentAndVoltageAlarm: () => exposes.Composite;
overCurrentThresholdTime: () => exposes.Numeric;
lostFlowAlarm: () => exposes.Composite;
lostFlowThresholdTime: () => exposes.Numeric;
liquidLevelPercent: () => exposes.Numeric;
liquidDepth: () => exposes.Numeric;
liquidDepthMax: () => exposes.Numeric;
liquidInstallationHeight: () => exposes.Numeric;
liquidMinimalPercent: () => exposes.Numeric;
liquidMaximalPercent: () => exposes.Numeric;
liquidState: () => exposes.Enum;
};
export { tuyaExposes as exposes };
export declare const skip: {
stateOnAndBrightnessPresent: (meta: Tz.Meta) => boolean;
};
export declare const configureMagicPacket: (device: Zh.Device, coordinatorEndpoint: Zh.Endpoint) => Promise<void>;
export declare const configureQuery: (device: Zh.Device, coordinatorEndpoint: Zh.Endpoint) => Promise<void>;
export declare const configureMcuVersionRequest: (device: Zh.Device, coordinatorEndpoint: Zh.Endpoint) => Promise<void>;
export declare const configureBindBasic: (device: Zh.Device, coordinatorEndpoint: Zh.Endpoint) => Promise<void>;
export declare const fingerprint: (modelID: string, manufacturerNames: string[]) => {
modelID: string;
manufacturerName: string;
}[];
export declare const whitelabel: (vendor: string, model: string, description: string, manufacturerNames: string[]) => {
vendor: string;
model: string;
description: string;
fingerprint: {
manufacturerName: string;
}[];
};
declare class Base {
value: number;
constructor(value: number);
valueOf(): number;
}
export declare class Enum extends Base {
}
declare const enumConstructor: (value: number) => Enum;
export { enumConstructor as enum };
export declare const BacklightColorEnum: {
readonly red: Enum;
readonly blue: Enum;
readonly green: Enum;
readonly white: Enum;
readonly yellow: Enum;
readonly magenta: Enum;
readonly cyan: Enum;
readonly warm_white: Enum;
};
export declare class Bitmap extends Base {
}
type LookupMap = {
[s: string]: number | boolean | Enum | string;
};
export declare const valueConverterBasic: {
lookup: (map: LookupMap | ((options: KeyValue, device: Zh.Device) => LookupMap), fallbackValue?: number | boolean | KeyValue | string | null) => {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
scale: (min1: number, max1: number, min2: number, max2: number) => {
to: (v: number) => number;
from: (v: number) => number;
};
raw: () => {
to: (v: string | number | boolean) => string | number | boolean;
from: (v: string | number | boolean) => string | number | boolean;
};
divideBy: (value: number) => {
to: (v: number) => number;
from: (v: number) => number;
};
multiplyBy: (value: number) => {
to: (v: number) => number;
from: (v: number) => number;
};
divideByFromOnly: (value: number) => {
to: (v: number) => number;
from: (v: number) => number;
};
divideByWithLimits: (value: number, min: number, max: number) => {
to: (v: number) => number;
from: (v: number) => number;
};
trueFalse: (valueTrue: number | Enum) => {
from: (v: number) => boolean;
};
};
export declare const valueConverter: {
trueFalse0: {
from: (v: number) => boolean;
};
trueFalse1: {
from: (v: number) => boolean;
};
trueFalseInvert: {
to: (v: boolean) => boolean;
from: (v: boolean) => boolean;
};
trueFalseEnum0: {
from: (v: number) => boolean;
};
trueFalseEnum1: {
from: (v: number) => boolean;
};
onOff: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
onOffEnumOn1: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
onOffEnumOn0: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
powerOnBehavior: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
powerOnBehaviorEnum: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
switchType: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
switchTypeCurtain: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
switchTypeButton: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
switchType2: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
backlightModeOffNormalInverted: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
backlightModeOffLowMediumHigh: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
lightType: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
countdown: {
to: (v: string | number | boolean) => string | number | boolean;
from: (v: string | number | boolean) => string | number | boolean;
};
scale0_254to0_1000: {
to: (v: number) => number;
from: (v: number) => number;
};
scale0_1to0_1000: {
to: (v: number) => number;
from: (v: number) => number;
};
temperatureUnit: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
temperatureUnitEnum: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
batteryState: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
divideBy2: {
to: (v: number) => number;
from: (v: number) => number;
};
divideBy10: {
to: (v: number) => number;
from: (v: number) => number;
};
divideBy100: {
to: (v: number) => number;
from: (v: number) => number;
};
divideBy1000: {
to: (v: number) => number;
from: (v: number) => number;
};
multiplyBy10: {
to: (v: number) => number;
from: (v: number) => number;
};
divideBy10FromOnly: {
to: (v: number) => number;
from: (v: number) => number;
};
switchMode: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
switchMode2: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
lightMode: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
raw: {
to: (v: string | number | boolean) => string | number | boolean;
from: (v: string | number | boolean) => string | number | boolean;
};
fault: {
from: (v: Bitmap) => boolean;
};
alarmMode: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
localTemperatureCalibration: {
from: (value: number) => number;
to: (value: number) => number;
};
localTemperatureCalibration_256: {
from: (value: number) => number;
to: (value: number) => number;
};
refresh: {
to: (v: string) => v is "refresh";
from: () => string;
};
waterConsumption: {
from: (v: string) => number;
};
fertility: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
temperature_humidity_alarm: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
setLimit: {
to: (v: number) => number;
from: (v: number) => number;
};
coverPosition: {
to: (v: number, meta: Tz.Meta) => number;
from: (v: number, meta: Fz.Meta, options: KeyValue, publish: Publish) => number;
};
coverPositionInverted: {
to: (v: number, meta: Tz.Meta) => number;
from: (v: number, meta: Fz.Meta, options: KeyValue, publish: Publish) => number;
};
tubularMotorDirection: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
plus1: {
from: (v: number) => number;
to: (v: number) => number;
};
static: (value: string | number) => {
from: (v: string | number) => string | number;
};
phaseVariant1: {
from: (v: string) => {
voltage: number;
current: number;
};
};
phaseVariant2: {
from: (v: string) => {
voltage: number;
current: number;
power: number;
};
};
phaseVariant2WithPhase: (phase: string) => {
from: (v: string) => {
[x: string]: number;
};
};
phaseVariant3: {
from: (v: string) => {
voltage: number;
current: number;
power: number;
};
};
phaseVariant4: {
from: (v: Buffer) => {
voltage: number;
current: number;
power: number;
};
};
onOffWithZeros: {
to: (v: string) => boolean;
from: (v: boolean, meta: Fz.Meta, options: KeyValue, publish: Publish) => string;
};
onOffFingerbot: {
to: (v: string) => boolean;
from: (v: boolean, meta: Fz.Meta, options: KeyValue, publish: Publish) => "ON" | "OFF";
};
power: {
from: (v: number) => number;
};
threshold: {
from: (v: string) => {
threshold_1_protection: unknown;
threshold_1: unknown;
threshold_1_value: number;
threshold_2_protection: unknown;
threshold_2: unknown;
threshold_2_value: number;
};
};
threshold_2: {
to: (v: number, meta: Tz.Meta) => Promise<void>;
from: (v: string) => KeyValue;
};
threshold_3: {
to: (v: number, meta: Tz.Meta) => Promise<void>;
from: (v: string) => KeyValue;
};
threshold_4: {
from: (v: Buffer) => {
leakage_current_alarm: string;
leakage_current_threshold: number;
device_temperature_alarm: string;
device_temperature_threshold: number;
};
to: (v: AlarmSet1Input, meta: AlarmSet1MetaState) => number[];
};
threshold_5: {
from: (v: Buffer) => {
over_current_alarm: string;
over_current_threshold: number;
over_voltage_alarm: string;
over_voltage_threshold: number;
under_voltage_alarm: string;
under_voltage_threshold: number;
};
to: (v: AlarmSet2Input, meta: AlarmSet2MetaState) => number[];
};
threshold_6: {
from: (v: Buffer) => {
lost_flow_alarm: string;
lost_flow_threshold: number;
};
to: (v: AlarmSet3Input, meta: AlarmSet3MetaState) => number[];
};
selfTestResult: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
lockUnlock: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
localTempCalibration1: {
from: (v: number) => number;
to: (v: number) => number;
};
localTempCalibration2: {
from: (v: number) => number;
to: (v: number) => number;
};
localTempCalibration3: {
from: (v: number) => number;
to: (v: number) => number;
};
localTempCalibration4: {
from: (v: number) => number;
to: (v: number) => number;
};
localTempCalibration5: {
from: (v: number) => number;
to: (v: number) => number;
};
thermostatHolidayStartStop: {
from: (v: string) => string;
to: (v: string) => string;
};
thermostatHolidayStartStopUnixTS: {
from: (v: number[]) => string;
to: (v: string) => number[];
};
thermostatScheduleDaySingleDP: {
from: (v: number[]) => string;
to: (v: KeyValue, meta: Tz.Meta) => unknown[];
};
thermostatScheduleDayMultiDP: {
from: (v: string) => string;
to: (v: string) => number[];
};
thermostatScheduleDayMultiDPWithTransitionCount: (transitionCount?: number) => {
from: (v: string) => string;
to: (v: string) => number[];
};
thermostatScheduleDayMultiDPWithDayNumber: (dayNum: number, transitionCount?: number) => {
from: (v: string) => string;
to: (v: string) => number[];
};
thermostatScheduleDayMultiDP_TRV602Z: {
from: (v: string) => string;
to: (v: string) => number[];
};
thermostatScheduleDayMultiDP_TRV602Z_WithDayNumber: (dayNum: number) => {
from: (v: string) => string;
to: (v: string) => number[];
};
thermostatScheduleDayMultiDP_TRV603WZ: {
from: (v: number[]) => string;
to: (v: string) => number[];
};
thermostatSchedule: {
from: (value: string) => ThermostatSchedule[];
to: (schedules: ThermostatSchedule[]) => string;
};
tv02Preset: () => {
from: (v: number) => "manual" | "auto" | "holiday";
to: (v: string, meta: Tz.Meta) => Enum;
};
/** @deprecated left for compatibility, use {@link thermostatSystemModeAndPresetMap} */
thermostatSystemModeAndPreset: (toKey: string) => {
from: (v: string) => {
preset: string;
system_mode: string;
};
to: (v: string) => Enum;
};
ZWT198_schedule: {
from: (value: number[], meta: Fz.Meta, options: KeyValue) => {
schedule_weekday: string;
schedule_holiday: string;
};
to: (v: string, meta: Tz.Meta) => Promise<void>;
};
PO_BOCO_ELEC_schedule: (day: number) => {
to: (v: string) => number[];
from: (v: number[]) => string;
};
PO_BOCO_ELEC_holiday: {
to: (v: string) => number[];
from: (v: number[]) => string;
};
TV02SystemMode: {
to: (v: number, meta: Tz.Meta) => Promise<void>;
from: (v: boolean) => {
system_mode: string;
heating_stop: string;
};
};
TV02FrostProtection: {
to: (v: unknown, meta: Tz.Meta) => Promise<void>;
from: (v: unknown) => {
frost_protection: string;
};
};
inverse: {
to: (v: boolean) => boolean;
from: (v: boolean) => boolean;
};
onOffNotStrict: {
from: (v: string) => "ON" | "OFF";
to: (v: string) => v is "ON";
};
errorOrBatteryLow: {
from: (v: number) => {
battery_low: boolean;
error?: undefined;
} | {
error: number;
battery_low?: undefined;
};
};
inchingSwitch: {
to: (value: KeyValueAny) => string;
from: (value: string) => KeyValue;
};
/** @param toMap the key is 'system_mode' or 'preset' related value */
thermostatSystemModeAndPresetMap: ({ fromMap, toMap, }: {
fromMap?: {
[modeId: number]: {
deviceMode: string;
systemMode: string;
preset: string;
};
};
toMap?: {
[key: string]: Enum;
};
}) => {
from: (v: string) => {
running_mode: string;
system_mode: string;
preset: string;
};
to: (v: string) => Enum;
};
utf16BEHexString: {
to: (v: string) => string;
from: (hex?: string) => string;
};
inchingSwitch2: {
to: (value: InchingInput, meta: InchingMetaState) => string;
from: (value: FromValue) => {
state: string;
minutes: number;
seconds: number;
};
};
circuitBreakerFaults: {
from: (value: number) => string[];
};
energyBalanceReset: {
to: (v: string) => v is "RESET";
from: (v: boolean) => string;
};
energyBalanceAdd: {
to: (v: number) => number;
from: (v: number) => number;
};
circuitBreakerStatus: {
to: (v: string, meta: Tz.Meta) => string | number | boolean | Enum;
from: (v: number, _meta: Fz.Meta, options: KeyValue) => string | number | boolean | KeyValue;
};
cycleSchedule: {
from: (v: string) => {
enabled: boolean;
daysMask: number;
startTime: number;
endTime: number;
onDuration: number;
offDuration: number;
}[];
};
GX03ValveState: (zoneNum: number) => {
from: (value: unknown, meta: Fz.Meta, options: KeyValue, publish: Publish) => string;
};
autoAdjustment: {
to: (v: string) => v is "START";
from: (v: boolean) => string;
};
switchStates: {
to: (v: string, meta: Tz.Meta) => boolean;
from: (v: boolean) => string;
};
};
declare const tuyaTz: {
power_on_behavior_1: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
power_on_behavior_2: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
switch_type: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
switch_type_curtain: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
switch_type_button: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
backlight_indicator_mode_1: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
backlight_indicator_mode_2: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
backlight_indicator_mode_none_relay_pos: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
child_lock: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<void>;
};
min_brightness_attribute: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
min_brightness: number;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
min_brightness_command: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
min_brightness: number;
};
}>;
};
color_power_on_behavior: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
color_power_on_behavior: unknown;
};
}>;
};
datapoints: {
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: KeyValue;
}>;
};
do_not_disturb: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
do_not_disturb: unknown;
};
}>;
};
on_off_countdown: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: KeyValue;
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
inchingSwitch: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
inching_control_set: unknown;
};
}>;
};
cover_calibration: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
operation_mode: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
operation_mode: string;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
TS110E_onoff_brightness: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<Tz.ConvertSetResult>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
TS110E_options: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
[x: string]: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
TS110E_light_onoff_brightness: {
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<Tz.ConvertSetResult>;
key?: string[];
options?: import("./types").Option[] | ((definition: import("./types").Definition) => import("./types").Option[]);
endpoints?: string[];
convertGet?: (entity: Zh.Endpoint | Zh.Group, key: string, meta: Tz.Meta) => Promise<void>;
};
cover_reversal: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
motor_reversal: unknown;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
moes_cover_calibration: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
calibration_time: number;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
led_control: {
key: string[];
options: exposes.Binary[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: KeyValueAny;
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
relay_din_led_indicator: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
indicator_mode: unknown;
};
}>;
};
led_controller: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<{
state: {
state: string;
};
}>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
ts0216_duration: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<void>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
ts0216_volume: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<void>;
convertGet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, meta: Tz.Meta) => Promise<void>;
};
ts0216_alarm: {
key: string[];
convertSet: (entity: import("zigbee-herdsman/dist/controller/model").Group | import("zigbee-herdsman/dist/controller/model").Endpoint, key: string, value: unknown, meta: Tz.Meta) => Promise<void>;
};
};
export { tuyaTz as tz };
declare const tuyaFz: {
brightness: {
cluster: "genLevelCtrl";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genLevelCtrl", undefined, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
[x: string]: number;
};
};
power_on_behavior_1: {
cluster: "genOnOff";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
[x: string]: unknown;
};
};
power_on_behavior_2: {
cluster: "manuSpecificTuya3";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"manuSpecificTuya3", ManuSpecificTuya3, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
[x: string]: unknown;
};
};
power_outage_memory: {
cluster: "genOnOff";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
[x: string]: unknown;
};
};
switch_type: {
cluster: "manuSpecificTuya3";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"manuSpecificTuya3", ManuSpecificTuya3, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
switch_type: unknown;
};
};
switch_type_curtain: {
cluster: "manuSpecificTuya3";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"manuSpecificTuya3", ManuSpecificTuya3, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
switch_type_curtain: unknown;
};
};
switch_type_button: {
cluster: "manuSpecificTuya3";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"manuSpecificTuya3", ManuSpecificTuya3, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
switch_type_button: unknown;
};
};
backlight_mode_low_medium_high: {
cluster: "genOnOff";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
backlight_mode: unknown;
};
};
backlight_mode_off_normal_inverted: {
cluster: "genOnOff";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
backlight_mode: string;
};
};
backlight_mode_off_on: {
cluster: "genOnOff";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
backlight_mode: string;
};
};
indicator_mode: {
cluster: "genOnOff";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
indicator_mode: string;
};
};
indicator_mode_none_relay_pos: {
cluster: "genOnOff";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
indicator_mode: string;
};
};
child_lock: {
cluster: "genOnOff";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", undefined, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
child_lock: string;
};
};
min_brightness_attribute: {
cluster: "genLevelCtrl";
type: ["attributeReport", "readResponse"];
convert: (model: import("./types").Definition, msg: Fz.Message<"genLevelCtrl", undefined, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
[x: string]: number;
};
};
datapoints: {
cluster: "manuSpecificTuya";
type: ["commandDataResponse", "commandDataReport", "commandActiveStatusReport", "commandActiveStatusReportAlt"];
convert: (model: import("./types").Definition, msg: Fz.Message<"manuSpecificTuya", undefined, ["commandDataResponse", "commandDataReport", "commandActiveStatusReport", "commandActiveStatusReportAlt"]>, publish: Publish, options: KeyValue,