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 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 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: {
    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;
};
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;
    };
    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;
    };
    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;
        };
    };
    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;
    };
    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;
    };
    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;
    };
};
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>;
    };
    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>;
    };
};
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, meta: Fz.Meta) => KeyValue;
    };
    on_off_action: {
        cluster: "genOnOff";
        type: "commandTuyaAction";
        convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, "commandTuyaAction">, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
            action: string;
        };
    };
    on_off_countdown: {
        cluster: "genOnOff";
        type: ["attributeReport", "readResponse"];
        convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", undefined, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => KeyValue;
    };
    inchingSwitch: {
        cluster: "manuSpecificTuya4";
        type: ["attributeReport", "readResponse"];
        convert: (model: import("./types").Definition, msg: Fz.Message<"manuSpecificTuya4", Tuya4, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => KeyValue;
    };
    TS011F_electrical_measurement: {
        convert: (model: import("./types").Definition, msg: Fz.Message<"haElectricalMeasurement", undefined, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => KeyValueAny;
        cluster: "haElectricalMeasurement";
        type: ["attributeReport", "readResponse"];
        options?: import("./types").Option[] | ((definition: import("./types").Definition) => import("./types").Option[]);
    };
    cover_options: {
        cluster: "closuresWindowCovering";
        type: ["attributeReport", "readResponse"];
        convert: (model: import("./types").Definition, msg: Fz.Message<"closuresWindowCovering", TuyaClosuresWindowCovering, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => KeyValueAny;
    };
    cover_options_2: {
        cluster: "closuresWindowCovering";
        type: ["attributeReport", "readResponse"];
        convert: (model: import("./types").Definition, msg: Fz.Message<"closuresWindowCovering", TuyaClosuresWindowCovering, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => KeyValueAny;
    };
    operation_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) => {
            operation_mode: any;
        };
    };
    switch_scene: {
        cluster: "genOnOff";
        type: "commandTuyaAction";
        convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, "commandTuyaAction">, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
            action: string;
            action_scene: number;
        };
    };
    multi_action: {
        cluster: "genOnOff";
        type: ["commandTuyaAction", "commandTuyaAction2"];
        convert: (model: import("./types").Definition, msg: Fz.Message<"genOnOff", TuyaGenOnOff, ["commandTuyaAction", "commandTuyaAction2"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => {
            action: any;
        };
    };
    led_controller: {
        cluster: "lightingColorCtrl";
        type: ["attributeReport", "readResponse"];
        options: exposes.Binary[];
        convert: (model: import("./types").Definition, msg: Fz.Message<"lightingColorCtrl", TuyaLightingColorCtrl, ["attributeReport", "readResponse"]>, publish: Publish, options: KeyValue, meta: Fz.Meta) => KeyValueAny;
    };
};
export { tuyaFz as fz };
export declare function getHandlersForDP(name: string, dp: number, type: number, converter: Tuya.ValueConverterSingle, readOnly?: boolean, skip?: (meta: Tz.Meta) => boolean, endpoint?: string, useGlobalSequence?: boolean): [Fz.Converter<"manuSpecificTuya", undefined, any>[], Tz.Converter[]];
export interface TuyaDPEnumLookupArgs {
    name: string;
    dp: number;
    type?: number;
    lookup?: KeyValue;
    description?: string;
    readOnly?: boolean;
    endpoint?: string;
    skip?: (meta: Tz.Meta) => boolean;
    expose?: Expose;
}
export interface TuyaDPBinaryArgs {
    name: string;
    dp: number;
    type: number;
    valueOn: [string | boolean, unknown];
    valueOff: [string | boolean, unknown];
    description?: string;
    readOnly?: boolean;
    endpoint?: string;
    skip?: (meta: Tz.Meta) => boolean;
    expose?: Expose;
}
export interface TuyaDPNumericArgs {
    name: string;
    dp: number;
    type: number;
    description?: string;
    readOnly?: boolean;
    endpoint?: string;
    unit?: string;
    skip?: (meta: Tz.Meta) => boolean;
    valueMin?: number;
    valueMax?: number;
    valueStep?: number;
    scale?: number | [number, number, number, number];
    expose?: exposes.Numeric;
}
export interface TuyaDPLightArgs {
    state: {
        dp: number;
        type: number;
        valueOn: [string | boolean, unknown];
        valueOff: [string | boolean, unknown];
        skip?: (meta: Tz.Meta) => boolean;
    };
    brightness: {
        dp: number;
        type: number;
        scale?: number | [number, number, number, number];
    };
    max?: {
        dp: number;
        type: number;
        scale?: number | [number, number, number, number];
    };
    min?: {
        dp: number;
        type: number;
        scale?: number | [number, number, number, number];
    };
    colorTemp?: {
        dp: number;
        type: number;
        range: Range;
        scale?: number | [number, number, number, number];
    };
    endpoint?: string;
}
declare const tuyaModernExtend: {
    electricityMeasurementPoll(args?: {
        electricalMeasurement?: false | ((device: Zh.Device) => boolean);
        metering?: true | ((device: Zh.Device) => boolean);
        optionDescription?: string;
    }): ModernExtend;
    dpTHZBSettings(): ModernExtend;
    tuyaBase(args?: {
        dp?: true;
        queryOnDeviceAnnounce?: true;
        queryOnConfigure?: true;
        bindBasicOnConfigure?: true;
        queryIntervalSeconds?: number;
        respondToMcuVersionResponse?: true;
        mcuVersionRequestOnConfigure?: true;
        forceTimeUpdates?: true;
        timeStart?: "2000" | "1970";
    }): ModernExtend;
    dpEnumLookup(args: Partial<TuyaDPEnumLookupArgs>): ModernExtend;
    dpBinary(args: Partial<TuyaDPBinaryArgs>): ModernExtend;
    dpNumeric(args: Partial<TuyaDPNumericArgs>): ModernExtend;
    dpLight(args: TuyaDPLightArgs): ModernExtend;
    dpTemperature(args?: Partial<TuyaDPNumericArgs>): ModernExtend;
    dpHumidity(args?: Partial<TuyaDPNumericArgs>): ModernExtend;
    dpBattery(args?: Partial<TuyaDPNumericArgs>): ModernExtend;
    dpBatteryState(args?: Partial<TuyaDPEnumLookupArgs>): ModernExtend;
    dpTemperatureUnit(args?: Partial<TuyaDPEnumLookupArgs>): ModernExtend;
    dpContact(args?: Partial<TuyaDPBinaryArgs>, invert?: boolean): ModernExtend;
    dpAction(args?: Partial<TuyaDPEnumLookupArgs>): ModernExtend;
    dpIlluminance(args?: Partial<TuyaDPNumericArgs>): ModernExtend;
    dpGas(args?: Partial<TuyaDPBinaryArgs>, invert?: boolean): ModernExtend;
    dpOnOff(args?: Partial<TuyaDPBinaryArgs>): ModernExtend;
    dpPowerOnBehavior(args?: Partial<TuyaDPEnumLookupArgs>): ModernExtend;
    tuyaLight(args?: modernExtend.LightArgs & {
        minBrightness?: "none" | "attribute" | "command";
        switchType?: boolean;
        doNotDisturb?: boolean;
        colorPowerOnBehavior?: boolean;
    }): ModernExtend;
    tuyaOnOff: (args?: {
        endpoints?: string[];
        powerOutageMemory?: boolean | ((manufacturerName: string) => boolean);
        powerOnBehavior2?: boolean | ((manufacturerName: string) => boolean);
        powerOnBehavior3?: boolean;
        switchType?: boolean | ((manufacturerName: string) => boolean);
        switchTypeCurtain?: boolean;
        switchTypeButton?: boolean;
        backlightModeLowMediumHigh?: boolean;
        indicatorMode?: boolean | ((manufacturerName: string) => boolean);
        indicatorModeNoneRelayPos?: boolean;
        backlightModeOffNormalInverted?: boolean;
        backlightModeOffOn?: boolean | ((manufacturerName: string) => boolean);
        electricalMeasurements?: boolean;
        electricalMeasurementsFzConverter?: Fz.Converter<"haElectricalMeasurement", undefined, any>;
        childLock?: boolean | ((manufacturerName: string) => boolean);
        switchMode?: boolean;
        onOffCountdown?: boolean | ((manufacturerName: string) => boolean);
        inchingSwitch?: boolean | ((manufacturerName: string) => boolean);
    }) => ModernExtend;
    dpBacklightMode(args?: Partial<TuyaDPEnumLookupArgs>): ModernExtend;
    combineActions(actions: ModernExtend[]): ModernExtend;
    tuyaSwitchMode: (args?: Partial<modernExtend.EnumLookupArgs<"manuSpecificTuya3">>) => ModernExtend;
    tuyaLedIndicator(): ModernExtend;
    tuyaMagicPacket(): ModernExtend;
    tuyaOnOffAction(args?: Partial<modernExtend.ActionEnumLookupArgs<"genOnOff">>): ModernExtend;
    tuyaOnOffActionLegacy(args: {
        actions: ("single" | "double" | "hold")[];
        endpointNames?: string[];
    }): ModernExtend;
    dpChildLock(args?: Partial<TuyaDPBinaryArgs>): ModernExtend;
    tuyaWeatherForecast(args?: {
        includeCurrentWeather?: boolean;
        numberOfForecastDays?: number;
        correctForNegativeValues?: boolean;
        weatherConditionMap?: TuyaWeatherCondition;
    }): ModernExtend;
};
export { tuyaModernExtend as modernExtend };
declare const tuyaClusters: {
    addTuyaClosuresWindowCoveringCluster: () => ModernExtend;
    addTuyaGenBasicCluster: () => ModernExtend;
    addTuyaGenGroupsCluster: () => ModernExtend;
    addTuyaGenOnOffCluster: () => ModernExtend;
    addTuyaGenLevelCtrlCluster: () => ModernExtend;
    addTuyaLightingColorCtrlCluster: () => ModernExtend;
    addManuSpecificTuya2Cluster: () => ModernExtend;
    addManuSpecificTuya3Cluster: () => ModernExtend;
    addTuyaCommonPrivateCluster: () => ModernExtend;
};
export { tuyaClusters as clusters };
//# sourceMappingURL=tuya.d.ts.map