Data Models↲

Data models are used to strongly type and verify API request and response structure. All API calls require a data model to be passed in as a parameter. Each module in the pyvesync.models module is for a specific product type or API call.

The dataclasses inherit from mashumaro's DataClassORJSONMixin which allows for easy serialization and deserialization of the data models, as well as providing a discrimintor for subclasses.

The bypassv2_models module is a generic mixin for the bypassv2 API calls.

• Data Models
• Data Models Module
• Base Models
• BypassV2 Models
• VeSync General API Models
• Bulb Models
• Fan Models
• Humidifier Models
• Outlet Models
• Purifier Models
• Switch Models
• Fryer Models
• Thermostat Models

Data Models Module↲

Data models for VeSync API requests and responses.

Models should follow the naming convention of Request/Response + API Name. Internal models can have any descriptive name.

The base_models module contains the base classes for the VeSync API models, while the models for each device type and other API calls are stored in their respective modules.

The bypassv2_models module contains the models for the common bypassV2 API calls.

Base Models↲

Base data models for API requests and response.

These models are used to define the structure of the requests and responses from the API. They use Mashumaro for serialization and deserialization. The DataClassConfigMixin class sets default options for orjson and Mashumaro.

Note

Dataclasses should follow the naming convention of Request/Response + API Name. Internal models can have any descriptive name.

All models should inherit ResponseBaseModel or RequestBaseModel. Use pyvesync.const to set default values and import here.

Attributes are inherited from the const module for default values.

Classes↲

DefaultValues dataclass ↲

Default request fields.

Attributes for the default values of the request fields and static methods for preparing calculated fields.

Source code in src\pyvesync\models\base_models.py

@dataclass
class DefaultValues:
    """Default request fields.

    Attributes for the default values of the request fields
    and static methods for preparing calculated fields.
    """
    _call_number: ClassVar[int] = 0
    userType: str = USER_TYPE
    appVersion: str = APP_VERSION
    phoneBrand: str = PHONE_BRAND
    phoneOS: str = PHONE_OS
    mobileId: str = MOBILE_ID
    deviceRegion: str = DEFAULT_REGION
    countryCode: str = DEFAULT_REGION
    userCountryCode: str = DEFAULT_REGION
    acceptLanguage: str = DEFAULT_LANGUAGE
    timeZone: str = DEFAULT_TZ
    terminalId: str = TERMINAL_ID
    debugMode: bool = False

    @staticmethod
    def traceId() -> str:
        """Trace ID CSRF token."""
        return str(int(time()))

    @staticmethod
    def newTraceId() -> str:
        """Generate a new trace ID."""
        DefaultValues._call_number += 1
        return f'APP{TERMINAL_ID[-5:-1]}{int(time())}-{DefaultValues._call_number:0>5}'

Functions↲

newTraceId staticmethod ↲

newTraceId() -> str

Generate a new trace ID.

Source code in src\pyvesync\models\base_models.py

@staticmethod
def newTraceId() -> str:
    """Generate a new trace ID."""
    DefaultValues._call_number += 1
    return f'APP{TERMINAL_ID[-5:-1]}{int(time())}-{DefaultValues._call_number:0>5}'

traceId staticmethod ↲

traceId() -> str

Trace ID CSRF token.

Source code in src\pyvesync\models\base_models.py

@staticmethod
def traceId() -> str:
    """Trace ID CSRF token."""
    return str(int(time()))

RequestBaseModel dataclass ↲

Bases: DataClassORJSONMixin

Base request model for API requests.

Forbids extra keys in the request JSON.

Source code in src\pyvesync\models\base_models.py

@dataclass
class RequestBaseModel(DataClassORJSONMixin):
    """Base request model for API requests.

    Forbids extra keys in the request JSON.
    """

    class Config(BaseModelConfig):
        """orjson config for dataclasses."""
        forbid_extra_keys = True
        orjson_options = orjson.OPT_NON_STR_KEYS

ResponseBaseModel dataclass ↲

Bases: DataClassORJSONMixin

Base response model for API responses.

Allows extra keys in the response model and non-string keys in the JSON.

Source code in src\pyvesync\models\base_models.py

@dataclass
class ResponseBaseModel(DataClassORJSONMixin):
    """Base response model for API responses.

    Allows extra keys in the response model and
    non-string keys in the JSON.
    """

    class Config(BaseConfig):
        """Config for dataclasses."""
        orjson_options = orjson.OPT_NON_STR_KEYS
        forbid_extra_keys = False

ResponseCodeModel dataclass ↲

Bases: ResponseBaseModel

Model for the 'result' field in response.

Source code in src\pyvesync\models\base_models.py

@dataclass
class ResponseCodeModel(ResponseBaseModel):
    """Model for the 'result' field in response."""
    traceId: str
    code: int
    msg: str | None

Attributes↲

code instance-attribute ↲

code: int

Inherited From ResponseCodeModel

msg instance-attribute ↲

msg: str | None

Inherited From ResponseCodeModel

traceId instance-attribute ↲

traceId: str

Inherited From ResponseCodeModel

BypassV2 Models↲

Request Models for Bypass V2 Endpoints.

API calls to bypassV2 endpoints have similar request structures. These models are used to serialize and deserialize the JSON requests for the bypassV2 endpoints.

Classes↲

BypassV1Result dataclass ↲

Bases: DataClassORJSONMixin

Bypass V1 Response Dict.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class BypassV1Result(DataClassORJSONMixin):
    """Bypass V1 Response Dict."""

BypassV2InnerResult dataclass ↲

Bases: DataClassORJSONMixin

Inner Bypass V2 Result Data Model.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class BypassV2InnerResult(DataClassORJSONMixin):
    """Inner Bypass V2 Result Data Model."""

    class Config(BaseModelConfig):
        """Configure the Outer Result model."""
        allow_deserialization_not_by_alias = True

BypassV2OuterResult dataclass ↲

Bases: DataClassORJSONMixin

Bypass V2 Outer Result Data Model.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class BypassV2OuterResult(DataClassORJSONMixin):
    """Bypass V2 Outer Result Data Model."""

    code: int
    result: BypassV2InnerResult | None = field(
        default=None,
        metadata={
            "serialize": pass_through,
            "deserialize": pass_through,
        },
    )

    class Config(BaseModelConfig):
        """Configure the Outer Result model."""
        allow_deserialization_not_by_alias = True

BypassV2RequestPayload dataclass ↲

Bases: RequestBaseModel

Generic Bypass V2 Payload Request model.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class BypassV2RequestPayload(RequestBaseModel):
    """Generic Bypass V2 Payload Request model."""
    data: dict
    method: str
    source: str = "APP"

BypassV2ResultError dataclass ↲

Bases: DataClassORJSONMixin

Bypass V2 Result Error Data Model.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class BypassV2ResultError(DataClassORJSONMixin):
    """Bypass V2 Result Error Data Model."""
    msg: str

RequestBypassV1 dataclass ↲

Bases: RequestBaseModel

Bypass V1 Status Request Dict.

This is the bypassV1 request model for API calls that use the configModel and deviceId fields.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class RequestBypassV1(RequestBaseModel):
    """Bypass V1 Status Request Dict.

    This is the bypassV1 request model for API calls
    that use the `configModel` and `deviceId` fields.
    """
    acceptLanguage: str
    accountID: str
    appVersion: str
    cid: str
    configModule: str
    debugMode: bool
    method: str
    phoneBrand: str
    phoneOS: str
    traceId: str
    timeZone: str
    token: str
    userCountryCode: str
    uuid: str
    deviceId: str
    configModel: str

    class Config(BaseConfig):   # type: ignore[override]
        """Configure omit None value keys."""
        omit_none = True
        orjson_options = orjson.OPT_NON_STR_KEYS
        forbid_extra_keys = True

Attributes↲

acceptLanguage instance-attribute ↲

acceptLanguage: str

Inherited From RequestBypassV1

accountID instance-attribute ↲

accountID: str

Inherited From RequestBypassV1

appVersion instance-attribute ↲

appVersion: str

Inherited From RequestBypassV1

cid instance-attribute ↲

cid: str

Inherited From RequestBypassV1

configModel instance-attribute ↲

configModel: str

Inherited From RequestBypassV1

configModule instance-attribute ↲

configModule: str

Inherited From RequestBypassV1

debugMode instance-attribute ↲

debugMode: bool

Inherited From RequestBypassV1

deviceId instance-attribute ↲

deviceId: str

Inherited From RequestBypassV1

method instance-attribute ↲

method: str

Inherited From RequestBypassV1

phoneBrand instance-attribute ↲

phoneBrand: str

Inherited From RequestBypassV1

phoneOS instance-attribute ↲

phoneOS: str

Inherited From RequestBypassV1

timeZone instance-attribute ↲

timeZone: str

Inherited From RequestBypassV1

token instance-attribute ↲

token: str

Inherited From RequestBypassV1

traceId instance-attribute ↲

traceId: str

Inherited From RequestBypassV1

userCountryCode instance-attribute ↲

userCountryCode: str

Inherited From RequestBypassV1

uuid instance-attribute ↲

uuid: str

Inherited From RequestBypassV1

RequestBypassV2 dataclass ↲

Bases: RequestBaseModel

Bypass V2 Status Request Dict.

This is the bypassV2 request model for API calls that use the configModel and deviceId fields.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class RequestBypassV2(RequestBaseModel):
    """Bypass V2 Status Request Dict.

    This is the bypassV2 request model for API calls
    that use the `configModel` and `deviceId` fields.
    """
    acceptLanguage: str
    accountID: str
    appVersion: str
    cid: str
    configModule: str
    debugMode: bool
    method: str
    phoneBrand: str
    phoneOS: str
    traceId: str
    timeZone: str
    token: str
    userCountryCode: str
    deviceId: str
    configModel: str
    payload: BypassV2RequestPayload

RequestV1ClearTimer dataclass ↲

Bases: RequestBypassV1

Request model for clearing Bypass V1 API outlet timer.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class RequestV1ClearTimer(RequestBypassV1):
    """Request model for clearing Bypass V1 API outlet timer."""
    timerId: str
    status: str | None = None

RequestV1GetTimer dataclass ↲

Bases: RequestBypassV1

Request model for getting timers from v1 API.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class RequestV1GetTimer(RequestBypassV1):
    """Request model for getting timers from v1 API."""
    switchNo: str | None = None

RequestV1SetTime dataclass ↲

Bases: RequestBypassV1

Request model for setting timer with counterTime.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class RequestV1SetTime(RequestBypassV1):
    """Request model for setting timer with counterTime."""
    counterTime: str
    action: str
    status: str | None = None
    switchNo: int | None = None

RequestV1SetTimer dataclass ↲

Bases: RequestBypassV1

Request model for timer with counterTimer key.

Attributes:

Name	Type	Description
counterTimer	str	The timer value in seconds.
action	str	The action to perform (e.g., "on", "off").
switchNo	int | None	The switch number for the timer.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class RequestV1SetTimer(RequestBypassV1):
    """Request model for timer with counterTimer key.

    Attributes:
        counterTimer (str): The timer value in seconds.
        action (str): The action to perform (e.g., "on", "off").
        switchNo (int | None): The switch number for the timer.
    """
    counterTimer: str
    action: str
    switchNo: int | None = None

ResponseBypassV1 dataclass ↲

Bases: ResponseCodeModel

Bypass V1 Response Dict.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class ResponseBypassV1(ResponseCodeModel):
    """Bypass V1 Response Dict."""
    result: BypassV1Result | None = field(
        default=None,
        metadata={
            "serialize": pass_through,
            "deserialize": pass_through,
        },
    )

ResponseBypassV2 dataclass ↲

Bases: ResponseCodeModel

Bypass V2 Response Dict.

This is the bypassV2 response model for API calls that use the configModel and deviceId fields.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class ResponseBypassV2(ResponseCodeModel):
    """Bypass V2 Response Dict.

    This is the bypassV2 response model for API calls
    that use the `configModel` and `deviceId` fields.
    """
    result: BypassV2OuterResult | None = None

ResultV1GetTimerList dataclass ↲

Bases: BypassV1Result

Get timers result for v1 API.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class ResultV1GetTimerList(BypassV1Result):
    """Get timers result for v1 API."""
    timers: list[TimeItemV1] | list[TimerItemV1] | TimerItemV1 | None = None

ResultV1SetTimer dataclass ↲

Bases: BypassV1Result

Result model for setting Bypass V1 API timer.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class ResultV1SetTimer(BypassV1Result):
    """Result model for setting Bypass V1 API timer."""
    timerID: str
    conflictTimerIds: list[str] | None = None

ResultV2GetTimer dataclass ↲

Bases: BypassV2InnerResult

Inner result for Bypass V2 GetTimer method.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class ResultV2GetTimer(BypassV2InnerResult):
    """Inner result for Bypass V2 GetTimer method."""
    timers: list[TimerItemV2] | None = None

ResultV2SetTimer dataclass ↲

Bases: BypassV2InnerResult

Result for Bypass V2 SetTimer method.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class ResultV2SetTimer(BypassV2InnerResult):
    """Result for Bypass V2 SetTimer method."""
    id: int

TimeItemV1 dataclass ↲

Bases: ResponseBaseModel

Data model for Bypass V1 Timers.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class TimeItemV1(ResponseBaseModel):
    """Data model for Bypass V1 Timers."""
    timerID: str
    counterTime: str
    action: str
    status: str
    resetTime: str
    uuid: str

TimerItemV1 dataclass ↲

Bases: ResponseBaseModel

Data model for Bypass V1 Timers.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class TimerItemV1(ResponseBaseModel):
    """Data model for Bypass V1 Timers."""
    timerID: str
    counterTimer: str
    action: str
    status: str
    resetTime: str

TimerItemV2 dataclass ↲

Bases: ResponseBaseModel

Data model for Bypass V2 Timers.

Source code in src\pyvesync\models\bypass_models.py

@dataclass
class TimerItemV2(ResponseBaseModel):
    """Data model for Bypass V2 Timers."""
    id: int
    remain: int
    action: str
    total: int

TimerModels ↲

Class holding all common timer models.

Attributes:

Name	Type	Description
ResultV2GetTimer	ResultV2GetTimer	Result model for Bypass V2 GetTimer method.
ResultV2SetTimer	ResultV2SetTimer	Result model for Bypass V2 SetTimer method.
ResultV1SetTimer	ResultV1SetTimer	Result model V1 API for setting timer.
ResultV1GetTimer	ResultV1GetTimerList	Get timers result for v1 API.
TimeItemV1	TimeItemV1	Data model for Bypass V1 Timers.
TimerItemV1	TimerItemV1	Data model for Bypass V1 Timers.
TimerItemV2	TimerItemV2	Data model for Bypass V2 Timers.
RequestV1ClearTimer	RequestV1ClearTimer	Model for deleting timer.
RequestV1SetTimer	RequestV1SetTimer	Model for timer with counterTimer key.
RequestV1GetTimer	RequestV1GetTimer	Model for getting timers from v1 API.
RequestV1SetTime	RequestV1SetTime	Model for setting timer with counterTime key.

Source code in src\pyvesync\models\bypass_models.py

class TimerModels:
    """Class holding all common timer models.

    Attributes:
        ResultV2GetTimer (ResultV2GetTimer): Result model for Bypass V2 GetTimer method.
        ResultV2SetTimer (ResultV2SetTimer): Result model for Bypass V2 SetTimer method.
        ResultV1SetTimer (ResultV1SetTimer): Result model V1 API for setting timer.
        ResultV1GetTimer (ResultV1GetTimerList): Get timers result for v1 API.
        TimeItemV1 (TimeItemV1): Data model for Bypass V1 Timers.
        TimerItemV1 (TimerItemV1): Data model for Bypass V1 Timers.
        TimerItemV2 (TimerItemV2): Data model for Bypass V2 Timers.
        RequestV1ClearTimer (RequestV1ClearTimer): Model for deleting timer.
        RequestV1SetTimer (RequestV1SetTimer): Model for timer with counterTimer key.
        RequestV1GetTimer (RequestV1GetTimer): Model for getting timers from v1 API.
        RequestV1SetTime (RequestV1SetTime): Model for setting timer with counterTime key.
    """
    ResultV2GetTimer = ResultV2GetTimer
    ResultV2SetTimer = ResultV2SetTimer
    ResultV1SetTimer = ResultV1SetTimer
    ResultV1GetTimer = ResultV1GetTimerList
    TimeItemV1 = TimeItemV1
    TimerItemV1 = TimerItemV1
    TimerItemV2 = TimerItemV2
    RequestV1ClearTimer = RequestV1ClearTimer
    RequestV1SetTimer = RequestV1SetTimer
    RequestV1GetTimer = RequestV1GetTimer
    RequestV1SetTime = RequestV1SetTime

VeSync General API Models↲

Models for general VeSync API requests and responses.

Dataclasses should follow the naming convention of Request/Response + + Model. Internal models should be named starting with IntResp/IntReqModel.

Note

All models should inherit ResponseBaseModel or RequestBaseModel. Use pyvesync.models.base_models.DefaultValues to set default values. There should be no repeating keys set in the child models.

Classes↲

IntRespLoginResultModel dataclass ↲

Bases: ResponseBaseModel

Model for the 'result' field in login response containing token and account ID.

This class is referenced by the ResponseLoginModel class.

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class IntRespLoginResultModel(ResponseBaseModel):
    """Model for the 'result' field in login response containing token and account ID.

    This class is referenced by the `ResponseLoginModel` class.
    """
    accountID: str
    acceptLanguage: str
    countryCode: str
    token: str

InternalDeviceListExtension dataclass ↲

Bases: ResponseBaseModel

Internal Optional 'extension' field in device list response.

Used by the InnerRespDeviceListDevModel class to populate the extension field in the device list response.

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class InternalDeviceListExtension(ResponseBaseModel):
    """Internal Optional 'extension' field in device list response.

    Used by the `InnerRespDeviceListDevModel` class to populate
    the extension field in the device list response.
    """
    airQuality: None | int
    airQualityLevel: None | int
    mode: None | str
    fanSpeedLevel: None | str

InternalDeviceListResult dataclass ↲

Bases: ResponseBaseModel

Internal model for the 'result' field in device list response.

Notes

Used by the ResponseDeviceListModel class to populate result field.

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class InternalDeviceListResult(ResponseBaseModel):
    """Internal model for the 'result' field in device list response.

    Notes:
      Used by the `ResponseDeviceListModel` class to populate result field.
    """
    total: int
    pageSize: int
    pageNo: int
    list: list[ResponseDeviceDetailsModel]

RequestDeviceListModel dataclass ↲

Bases: RequestBaseModel

Model for the device list request.

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class RequestDeviceListModel(RequestBaseModel):
    """Model for the device list request."""
    token: str
    accountID: str
    timeZone: str = DefaultValues.timeZone
    method: str = 'devices'
    pageNo: int = 1
    pageSize: int = 100
    appVersion: str = DefaultValues.appVersion
    phoneBrand: str = DefaultValues.phoneBrand
    phoneOS: str = DefaultValues.phoneOS
    acceptLanguage: str = DefaultValues.acceptLanguage
    traceId: str = str(DefaultValues.traceId())

RequestLoginModel dataclass ↲

Bases: RequestBaseModel

Request model for login.

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class RequestLoginModel(RequestBaseModel):
    """Request model for login."""
    # Arguments to set
    email: str
    method: str
    password: str
    # default values
    acceptLanguage: str = DefaultValues.acceptLanguage
    appVersion: str = DefaultValues.appVersion
    timeZone: str = DefaultValues.timeZone
    phoneBrand: str = DefaultValues.phoneBrand
    phoneOS: str = DefaultValues.phoneOS
    traceId: str = field(default_factory=DefaultValues.traceId)
    # Non-default constants
    userType: str = '1'
    devToken: str = ''

    def __post_init__(self) -> None:
        """Set the method field."""
        self.password = self.hash_password(self.password)

    @staticmethod
    def hash_password(string: str) -> str:
        """Encode password."""
        return hashlib.md5(string.encode('utf-8')).hexdigest()  # noqa: S324

Functions↲

hash_password staticmethod ↲

hash_password(string: str) -> str

Encode password.

Source code in src\pyvesync\models\vesync_models.py

@staticmethod
def hash_password(string: str) -> str:
    """Encode password."""
    return hashlib.md5(string.encode('utf-8')).hexdigest()  # noqa: S324

RequestPID dataclass ↲

Bases: RequestBaseModel

Model for the PID request.

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class RequestPID(RequestBaseModel):
    """Model for the PID request."""
    method: str
    appVersion: str
    phoneBrand: str
    phoneOS: str
    traceId: str
    token: str
    accountID: str
    mobileID: str
    configModule: str
    region: str

ResponseDeviceDetailsModel dataclass ↲

Bases: ResponseBaseModel

Internal response model for each device in device list response.

Populates the 'list' field in the InternalDeviceListResult.

Certain Devices have device status information in the deviceProp or extension fields. This model flattens those fields into the deviceStatus and connectionStatus fields before deserialization.

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class ResponseDeviceDetailsModel(ResponseBaseModel):
    """Internal response model for each device in device list response.

    Populates the 'list' field in the `InternalDeviceListResult`.

    Certain Devices have device status information in the `deviceProp` or `extension`
    fields. This model flattens those fields into the `deviceStatus` and
    `connectionStatus` fields before deserialization.
    """
    deviceRegion: str
    isOwner: bool
    deviceName: str
    deviceImg: str
    cid: str
    connectionType: str
    deviceType: str
    type: str
    uuid: str | None
    configModule: str
    macID: str
    mode: str
    speed: str | None
    currentFirmVersion: str
    subDeviceType: str | None
    subDeviceList: None | str
    extension: None | InternalDeviceListExtension
    subDeviceNo: int | None = None
    deviceStatus: str = "off"
    connectionStatus: str = "offline"
    productType: str | None = None
    # deviceProp: InitVar[None | InternalDevicePropModel] = None

    # def __post_init__(self, deviceProp: None | IntRespDevicePropModel) -> None:
    #     """Set productType based on deviceType."""
    #     if deviceProp is not None:
    #         if deviceProp.powerSwitch == 1:
    #             self.deviceStatus = "on"
    #         elif deviceProp.powerSwitch == 0:
    #             self.deviceStatus = "off"
    #         if isinstance(deviceProp.connectionStatus, str) and \
    #                 self.connectionStatus != deviceProp.connectionStatus:
    #             self.connectionStatus = deviceProp.connectionStatus

    @classmethod
    def __pre_deserialize__(cls, d: dict[Any, Any]) -> dict[Any, Any]:
        """Perform device_list pre-deserialization processes.

        This performs the following:
            - Flattens the deviceProp field into deviceStatus and connectionStatus fields
            - Sets subDeviceNo to 0 if not present
            - Sets cid to uuid or macID if null
        """
        super().__pre_deserialize__(d)
        d = _flatten_device_prop(d)
        if d.get('cid') is None:
            d['cid'] = d.get('uuid') if d.get('uuid') is not None else d.get("macID")
        return d

ResponseDeviceListModel dataclass ↲

Bases: ResponseCodeModel

Device list response model.

Inherits from BaseResultModel. The BaseResultModel class provides the defaults "code" and "msg" fields for the response.

Attributes:

Name	Type	Description
result	InternalDeviceListResult	InternalDeviceListResult The inner model for the 'result' field in the device list response.
module	str | None	str | None
stacktrace	str | None	str | None

Notes

See the DeviceListResultModel and DeviceListDeviceModel classes for the inner model of the 'result' field.

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class ResponseDeviceListModel(ResponseCodeModel):
    """Device list response model.

    Inherits from `BaseResultModel`. The `BaseResultModel` class provides the
    defaults "code" and "msg" fields for the response.

    Attributes:
        result: InternalDeviceListResult
            The inner model for the 'result' field in the device list response.
        module: str | None
        stacktrace: str | None

    Notes:
        See the `DeviceListResultModel` and `DeviceListDeviceModel` classes for
        the inner model of the 'result' field.
    """
    module: str | None
    stacktrace: str | None
    result: InternalDeviceListResult

ResponseLoginModel dataclass ↲

Bases: ResponseCodeModel

Model for the login response.

Inherits from BaseResultModel. The BaseResultModel class provides the defaults "code" and "msg" fields for the response.

Attributes:

Name	Type	Description
result	IntRespLoginResultModel	ResponseLoginResultModel The inner model for the 'result' field in the login response.

Examples:

a = {
    "code": 0,
    "msg": "success",
    "stacktrace": null,
    "module": null,
    "traceId": "123456",
    "result": {
        "accountID": "123456",
        "acceptLanguage": "en",
        "countryCode": "US",
        }
}
b = ResponseLoginModel.from_dict(a)
account_id = b.result.accountId
token = b.result.token

Source code in src\pyvesync\models\vesync_models.py

@dataclass
class ResponseLoginModel(ResponseCodeModel):
    """Model for the login response.

    Inherits from `BaseResultModel`. The `BaseResultModel` class provides the
    defaults "code" and "msg" fields for the response.

    Attributes:
        result: ResponseLoginResultModel
            The inner model for the 'result' field in the login response.

    Examples:
        ```python
        a = {
            "code": 0,
            "msg": "success",
            "stacktrace": null,
            "module": null,
            "traceId": "123456",
            "result": {
                "accountID": "123456",
                "acceptLanguage": "en",
                "countryCode": "US",
                }
        }
        b = ResponseLoginModel.from_dict(a)
        account_id = b.result.accountId
        token = b.result.token
        ```
    """
    result: IntRespLoginResultModel

Bulb Models↲

Models for VeSync Bulb API responses and requests.

These models are used to serialize and deserialize the JSON responses from the VeSync API. The models are used in the VeSync API class methods to provide type hints and data validation.

Classes↲

JSONCMD dataclass ↲

Bases: DataClassORJSONMixin

Tunable Bulb JSON CMD dict.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class JSONCMD(DataClassORJSONMixin):
    """Tunable Bulb JSON CMD dict."""
    light: None | JSONCMDLight = None
    getLightStatus: None | str = None

    class Config(BaseConfig):
        """Configure the JSONCMD model."""
        omit_none = True

JSONCMDLight dataclass ↲

Bases: DataClassORJSONMixin

Light JSON CMD dict.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class JSONCMDLight(DataClassORJSONMixin):
    """Light JSON CMD dict."""
    action: str
    brightness: int | None = None
    colorTempe: int | None = None

    class Config(BaseConfig):
        """Configure the JSONCMDLight model."""
        omit_none = True

RequestESL100Brightness dataclass ↲

Bases: RequestBypassV1

Request model for Etekcity bulb details.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class RequestESL100Brightness(RequestBypassV1):
    """Request model for Etekcity bulb details."""
    status: str
    brightNess: int

RequestESL100CWBase dataclass ↲

Bases: RequestBypassV1

Request model for ESL100CW bulb.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class RequestESL100CWBase(RequestBypassV1):
    """Request model for ESL100CW bulb."""
    jsonCmd: JSONCMD

RequestESL100Detail dataclass ↲

Bases: RequestBypassV1

Request model for Etekcity bulb details.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class RequestESL100Detail(RequestBypassV1):
    """Request model for Etekcity bulb details."""

RequestESL100Status dataclass ↲

Bases: RequestBypassV1

Request model for Etekcity bulb details.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class RequestESL100Status(RequestBypassV1):
    """Request model for Etekcity bulb details."""
    status: str

ResponseESL100CWDetail dataclass ↲

Bases: ResponseCodeModel

Response model for Etekcity bulb details.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseESL100CWDetail(ResponseCodeModel):
    """Response model for Etekcity bulb details."""
    result: ResponseESL100CWDetailResult

ResponseESL100CWDetailResult dataclass ↲

Bases: ResponseBaseModel

Result model for ESL100CW Tunable bulb details.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseESL100CWDetailResult(ResponseBaseModel):
    """Result model for ESL100CW Tunable bulb details."""
    light: ResponseESL100CWLight

ResponseESL100CWLight dataclass ↲

Bases: ResponseBaseModel

ESL100CW Tunable Bulb Device Detail Response.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseESL100CWLight(ResponseBaseModel):
    """ESL100CW Tunable Bulb Device Detail Response."""
    brightness: int | None
    action: str = "on"
    colorTempe: int = 0

ResponseESL100Detail dataclass ↲

Bases: ResponseCodeModel

Response model for Etekcity bulb details.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseESL100Detail(ResponseCodeModel):
    """Response model for Etekcity bulb details."""
    traceId: str
    code: int
    msg: str | None
    result: ResponseESL100DetailResult

Attributes↲

code instance-attribute ↲

code: int

Inherited From ResponseCodeModel

msg instance-attribute ↲

msg: str | None

Inherited From ResponseCodeModel

traceId instance-attribute ↲

traceId: str

Inherited From ResponseCodeModel

ResponseESL100DetailResult dataclass ↲

Bases: ResponseBaseModel

ESL100 Dimmable Bulb Device Detail Response.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseESL100DetailResult(ResponseBaseModel):
    """ESL100 Dimmable Bulb Device Detail Response."""
    deviceName: str | None
    name: str | None
    brightness: int | None = field(metadata=field_options(alias="brightNess"))
    activeTime: int | None
    deviceStatus: str = "off"
    connectionStatus: str = "offline"

    @classmethod
    def __post_deserialize__(  # type: ignore[override]
            cls, obj: Self) -> Self:
        """Set values depending on color or white mode."""
        if obj.brightness is None:
            obj.brightness = 0
        if obj.activeTime is None:
            obj.activeTime = 0
        return obj

ResponseESL100MCOuterResult dataclass ↲

ESL100MC Multi-Color Bulb Status Response.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseESL100MCOuterResult:
    """ESL100MC Multi-Color Bulb Status Response."""
    traceId: str
    code: int
    result: ResponseESL100MCResult

ResponseESL100MCResult dataclass ↲

ESL100MC Multi-Color Bulb Status Response.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseESL100MCResult:
    """ESL100MC Multi-Color Bulb Status Response."""
    colorMode: str
    action: str
    brightness: int = 0
    red: int = 0
    green: int = 0
    blue: int = 0

ResponseESL100MCStatus dataclass ↲

Bases: ResponseCodeModel

Response model for Etekcity bulb status.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseESL100MCStatus(ResponseCodeModel):
    """Response model for Etekcity bulb status."""
    result: ResponseESL100MCOuterResult

ResponseValcenoOuterResult dataclass ↲

Bases: ResponseBaseModel

Valceno Bulb Status Response.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseValcenoOuterResult(ResponseBaseModel):
    """Valceno Bulb Status Response."""
    result: ResponseValcenoStatusResult
    traceId: str = ""
    code: int = 0

ResponseValcenoStatus dataclass ↲

Bases: ResponseCodeModel

Response model for Valceno bulb status.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseValcenoStatus(ResponseCodeModel):
    """Response model for Valceno bulb status."""
    result: ResponseValcenoOuterResult

ResponseValcenoStatusResult dataclass ↲

Bases: ResponseBaseModel

Valceno Bulb Status Result.

Source code in src\pyvesync\models\bulb_models.py

@dataclass
class ResponseValcenoStatusResult(ResponseBaseModel):
    """Valceno Bulb Status Result."""
    colorMode: str = ""
    colorTemp: int = 0
    brightness: int = 0
    hue: int = 0
    saturation: int = 0
    value: int = 0
    enabled: str = "off"

ValcenoStatusPayload ↲

Bases: TypedDict

Typed Dict for setting Valceno bulb status.

Source code in src\pyvesync\models\bulb_models.py

class ValcenoStatusPayload(TypedDict):
    """Typed Dict for setting Valceno bulb status."""
    colorMode: str
    colorTemp: int | str
    brightness: int | str
    hue: int | str
    saturation: int | str
    value: int | str
    force: int

Fan Models↲

Data models for VeSync Fans.

These models inherit from ResponseBaseModel and RequestBaseModel from the base_models module.

Classes↲

FanSleepPreferences dataclass ↲

Bases: DataClassORJSONMixin

Fan Sleep Preferences.

Source code in src\pyvesync\models\fan_models.py

@dataclass
class FanSleepPreferences(DataClassORJSONMixin):
    """Fan Sleep Preferences."""
    sleepPreferenceType: int
    oscillationSwitch: int
    fallAsleepRemain: int
    autoChangeFanLevelSwitch: int

TowerFanResult dataclass ↲

Bases: BypassV2InnerResult

Vital 100S/200S and Everest Fan Result Model.

Source code in src\pyvesync\models\fan_models.py

@dataclass
class TowerFanResult(BypassV2InnerResult):
    """Vital 100S/200S and Everest Fan Result Model."""
    powerSwitch: int
    filterLifePercent: int
    workMode: str
    manualSpeedLevel: int
    fanSpeedLevel: int
    screenState: int
    screenSwitch: int
    oscillationSwitch: int
    oscillationState: int
    muteSwitch: int
    muteState: int
    timerRemain: int
    temperature: int
    humidity: int
    thermalComfort: int
    errorCode: int
    scheduleCount: int
    displayingType: int = IntFlag.NOT_SUPPORTED
    sleepPreference: FanSleepPreferences | None = None

Humidifier Models↲

Data models for VeSync Humidifier devices.

These models inherit from ResponseBaseModel and RequestBaseModel from the base_models module.

The InnerHumidifierBaseResult class is used as a base class for the inner humidifier result models. The correct subclass is determined by the mashumaro discriminator.

Classes↲

BypassV2InnerErrorResult dataclass ↲

Bases: InnerHumidifierBaseResult

Inner Error Result Model.

Source code in src\pyvesync\models\humidifier_models.py

class BypassV2InnerErrorResult(InnerHumidifierBaseResult):
    """Inner Error Result Model."""
    msg: str

ClassicLVHumidResult dataclass ↲

Bases: InnerHumidifierBaseResult

Classic 200S Humidifier Result Model.

Inherits from InnerHumidifierBaseResult.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class ClassicLVHumidResult(InnerHumidifierBaseResult):
    """Classic 200S Humidifier Result Model.

    Inherits from InnerHumidifierBaseResult.
    """
    enabled: bool
    mist_virtual_level: int
    mist_level: int
    mode: str
    display: Annotated[bool, Alias("indicator_light_status")]
    water_lacks: bool
    humidity: int | None = None
    humidity_high: bool = False
    automatic_stop_reach_target: bool = False
    water_tank_lifted: bool = False
    warm_enabled: bool = False
    warm_level: int = IntFlag.NOT_SUPPORTED
    night_light_brightness: int = IntFlag.NOT_SUPPORTED
    configuration: ClassicConfig | None = None

InnerHumidifierBaseResult dataclass ↲

Bases: ResponseBaseModel

Base class for inner humidifier results model.

All inner results models inherit from this class and are correctly subclassed by the mashumaro discriminator.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class InnerHumidifierBaseResult(ResponseBaseModel):
    """Base class for inner humidifier results model.

    All inner results models inherit from this class and are
    correctly subclassed by the mashumaro discriminator.
    """

    class Config(BaseConfig):  # type: ignore[override]
        """Configure the results model to use subclass discriminator."""
        # discriminator = Discriminator(include_subtypes=True)
        allow_deserialization_not_by_alias = True

LV600SExtension dataclass ↲

Bases: ResponseBaseModel

LV 600S Humidifier Configuration Model.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class LV600SExtension(ResponseBaseModel):
    """LV 600S Humidifier Configuration Model."""
    timer_remain: int = 0
    schedule_count: int = 0

LV600SHumidResult dataclass ↲

Bases: InnerHumidifierBaseResult

LV600S Humidifier Result Model.

Inherits from InnerHumidifierBaseResult.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class LV600SHumidResult(InnerHumidifierBaseResult):
    """LV600S Humidifier Result Model.

    Inherits from InnerHumidifierBaseResult.
    """
    automatic_stop_reach_target: bool
    display: bool
    enabled: bool
    humidity: int
    humidity_high: bool
    mist_level: int
    mist_virtual_level: int
    mode: str
    water_lacks: bool
    water_tank_lifted: bool
    extension: LV600SExtension | None = None
    configuration: LV600SConfig | None = None

Levoit1000SResult dataclass ↲

Bases: InnerHumidifierBaseResult

Levoit 1000S Humidifier Result Model.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class Levoit1000SResult(InnerHumidifierBaseResult):
    """Levoit 1000S Humidifier Result Model."""
    powerSwitch: int
    humidity: int
    targetHumidity: int
    virtualLevel: int
    mistLevel: int
    workMode: str
    waterLacksState: int
    waterTankLifted: int
    autoStopSwitch: int
    autoStopState: int
    screenSwitch: int
    screenState: int
    scheduleCount: int
    timerRemain: int
    errorCode: int

OuterHumidifierResult dataclass ↲

Bases: ResponseBaseModel

Humidifier Result Dict.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class OuterHumidifierResult(ResponseBaseModel):
    """Humidifier Result Dict."""
    code: int
    result: InnerHumidifierBaseResult

ResponseHumidifierBase dataclass ↲

Bases: ResponseCodeModel

Humidifier Base Response Dict.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class ResponseHumidifierBase(ResponseCodeModel):
    """Humidifier Base Response Dict."""
    result: OuterHumidifierResult

Superior6000SDryingMode dataclass ↲

Bases: ResponseBaseModel

Drying Mode Model for Superior 6000S Humidifier.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class Superior6000SDryingMode(ResponseBaseModel):
    """Drying Mode Model for Superior 6000S Humidifier."""
    dryingLevel: int
    autoDryingSwitch: int
    dryingState: int
    dryingRemain: int

Superior6000SResult dataclass ↲

Bases: InnerHumidifierBaseResult

Superior 6000S Humidifier Result Model.

Inherits from InnerHumidifierBaseResult.

Source code in src\pyvesync\models\humidifier_models.py

@dataclass
class Superior6000SResult(InnerHumidifierBaseResult):
    """Superior 6000S Humidifier Result Model.

    Inherits from InnerHumidifierBaseResult.
    """
    powerSwitch: int
    humidity: int
    targetHumidity: int
    virtualLevel: int
    mistLevel: int
    workMode: str
    waterLacksState: int
    waterTankLifted: int
    autoStopSwitch: int
    autoStopState: int
    screenSwitch: int
    screenState: int
    scheduleCount: int
    timerRemain: int
    errorCode: int
    autoPreference: int
    childLockSwitch: int
    filterLifePercent: int
    temperature: int
    dryingMode: Superior6000SDryingMode | None = None

Outlet Models↲

Data models for VeSync outlets.

Classes↲

EnergyInfo dataclass ↲

Energy Info list items.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class EnergyInfo:
    """Energy Info list items."""
    timestamp: int
    energyKWH: float
    money: float

Request15ADetails dataclass ↲

Bases: RequestBypassV1

Request data model for 15A outlet Details.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class Request15ADetails(RequestBypassV1):
    """Request data model for 15A outlet Details."""

Request15ANightlight dataclass ↲

Bases: RequestBypassV1

Nightlight request data model for 15A Outlets.

Inherits from RequestBypassV1.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class Request15ANightlight(RequestBypassV1):
    """Nightlight request data model for 15A Outlets.

    Inherits from RequestBypassV1.
    """
    mode: str

Request15AStatus dataclass ↲

Bases: RequestBypassV1

Request data model for 15A outlet.

Inherits from RequestBypassV1.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class Request15AStatus(RequestBypassV1):
    """Request data model for 15A outlet.

    Inherits from RequestBypassV1.
    """
    status: str

RequestEnergyHistory dataclass ↲

Bases: RequestBaseModel

Request model for energy history.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class RequestEnergyHistory(RequestBaseModel):
    """Request model for energy history."""
    acceptLanguage: str
    appVersion: str
    accountID: str
    method: str
    phoneBrand: str
    phoneOS: str
    timeZone: str
    token: str
    traceId: str
    userCountryCode: str
    debugMode: bool
    homeTimeZone: str
    uuid: str

RequestOutdoorStatus dataclass ↲

Bases: RequestBypassV1

Request model for outlet status.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class RequestOutdoorStatus(RequestBypassV1):
    """Request model for outlet status."""
    status: str
    switchNo: str

Response10ADetails dataclass ↲

Bases: ResponseCodeModel

Response model for Etekcity outlet details.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class Response10ADetails(ResponseCodeModel):
    """Response model for Etekcity outlet details."""
    deviceStatus: str
    connectionStatus: str
    activeTime: int
    power: float
    voltage: float
    energy: float | None = None
    nightLightStatus: str | None = None
    nightLightAutoMode: str | None = None
    nightLightBrightness: int | None = None

Response15ADetails dataclass ↲

Bases: ResponseCodeModel

Response for 15A Outlets.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class Response15ADetails(ResponseCodeModel):
    """Response for 15A Outlets."""
    result: Response15AOutletResult

Response15AOutletResult dataclass ↲

Bases: ResponseBaseModel

Response model for 15A outlet.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class Response15AOutletResult(ResponseBaseModel):
    """Response model for 15A outlet."""
    deviceStatus: str
    connectionStatus: str
    activeTime: int
    power: float
    voltage: float
    energy: float | None = None
    nightLightStatus: str | None = None
    nightLightAutoMode: str | None = None
    nightLightBrightness: int | None = None

Response7AOutlet dataclass ↲

Bases: ResponseBaseModel

Response model for 7A outlet.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class Response7AOutlet(ResponseBaseModel):
    """Response model for 7A outlet."""
    activeTime: int
    energy: float
    deviceStatus: str
    power: float | str
    voltage: float | str

ResponseBSDGO1Details dataclass ↲

Bases: ResponseCodeModel

Response model for BSDGO1 outlet.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResponseBSDGO1Details(ResponseCodeModel):
    """Response model for BSDGO1 outlet."""
    result: ResponseBSDGO1OutletResult

ResponseBSDGO1OutletResult dataclass ↲

Bases: ResponseBaseModel

Response model for BSDGO1 outlet.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResponseBSDGO1OutletResult(ResponseBaseModel):
    """Response model for BSDGO1 outlet."""
    powerSwitch_1: int
    active_time: int
    connectionStatus: str
    code: int

ResponseEnergyHistory dataclass ↲

Bases: ResponseCodeModel

Response model for energy history.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResponseEnergyHistory(ResponseCodeModel):
    """Response model for energy history."""
    result: ResponseEnergyResult

ResponseEnergyResult dataclass ↲

Bases: ResponseBaseModel

Response model for energy result.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResponseEnergyResult(ResponseBaseModel):
    """Response model for energy result."""
    energyConsumptionOfToday: float
    costPerKWH: float
    maxEnergy: float
    totalEnergy: float
    energyInfos: list[EnergyInfo]

ResponseOldEnergy dataclass ↲

Bases: ResponseCodeModel

Response model for old energy history.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResponseOldEnergy(ResponseCodeModel):
    """Response model for old energy history."""
    energyConsumptionOfToday: float
    costPerKWH: float
    maxEnergy: float
    totalEnergy: float
    data: list[float]

ResponseOutdoorDetails dataclass ↲

Bases: ResponseCodeModel

Response model for outdoor outlet.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResponseOutdoorDetails(ResponseCodeModel):
    """Response model for outdoor outlet."""
    result: ResponseOutdoorOutletResult

ResponseOutdoorOutletResult dataclass ↲

Bases: ResponseBaseModel

Response model for outdoor outlet.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResponseOutdoorOutletResult(ResponseBaseModel):
    """Response model for outdoor outlet."""
    deviceStatus: str
    connectionStatus: str
    activeTime: int
    power: float
    voltage: float
    energy: float
    subDevices: list[ResponseOutdoorSubDevices]

ResponseOutdoorSubDevices dataclass ↲

Bases: ResponseBaseModel

Response model for outdoor energy.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResponseOutdoorSubDevices(ResponseBaseModel):
    """Response model for outdoor energy."""
    subDeviceNo: int
    defaultName: str
    subDeviceName: str
    subDeviceStatus: str

ResultESW10Details dataclass ↲

Bases: ResponseBaseModel

Response model for ESW10 outlet.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class ResultESW10Details(ResponseBaseModel):
    """Response model for ESW10 outlet."""
    enabled: bool

Timer7AItem dataclass ↲

Bases: ResponseBaseModel

Timer item for 7A outlet.

Source code in src\pyvesync\models\outlet_models.py

@dataclass
class Timer7AItem(ResponseBaseModel):
    """Timer item for 7A outlet."""
    timerID: str
    counterTimer: int
    action: str
    timerStatus: str

Purifier Models↲

Data models for VeSync Purifiers.

These models inherit from ResponseBaseModel and RequestBaseModel from the base_models module.

The InnerPurifierBaseResult class is used as a base class for the inner purifier result models for all models and the mashumaro discriminator determines the correct subclass when deserializing.

Classes↲

InnerPurifierBaseResult dataclass ↲

Bases: BypassV2InnerResult

Base class for inner purifier results model.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class InnerPurifierBaseResult(BypassV2InnerResult):
    """Base class for inner purifier results model."""

    class Config(BaseConfig):  # type: ignore[override]
        """Configure the results model to use subclass discriminator."""
        discriminator = Discriminator(include_subtypes=True)

Purifier131Filter dataclass ↲

Bases: ResponseBaseModel

Filter details model for LV PUR131.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class Purifier131Filter(ResponseBaseModel):
    """Filter details model for LV PUR131."""
    change: bool
    useHour: int
    percent: int

Purifier131Result dataclass ↲

Bases: BypassV1Result

Purifier 131 Details Response Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class Purifier131Result(BypassV1Result):
    """Purifier 131 Details Response Dict."""
    screenStatus: str
    filterLife: Purifier131Filter
    activeTime: int
    levelNew: int
    level: int | None
    mode: str
    airQuality: str
    deviceName: str
    childLock: str
    deviceStatus: str
    connectionStatus: str

PurifierCoreDetailsResult dataclass ↲

Bases: InnerPurifierBaseResult

Purifier inner Result Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class PurifierCoreDetailsResult(InnerPurifierBaseResult):
    """Purifier inner Result Dict."""
    enabled: bool
    filter_life: int
    mode: str
    level: int
    device_error_code: int
    air_quality: int | None = None
    display: bool | None = None
    child_lock: bool | None = None
    configuration: PurifierCoreDetailsConfig | None = None
    extension: dict | None = None
    air_quality_value: int | None = None
    night_light: str | None = StrFlag.NOT_SUPPORTED
    fan_rotate: str | None = StrFlag.NOT_SUPPORTED

PurifierDetailsExtension dataclass ↲

Bases: ResponseBaseModel

Extension dict in purifier details response for Core 200/300/400.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class PurifierDetailsExtension(ResponseBaseModel):
    """Extension dict in purifier details response for Core 200/300/400."""
    schedule_count: int
    timer_remain: int

PurifierGetTimerResult dataclass ↲

Bases: InnerPurifierBaseResult

Purifier inner Timer Result Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class PurifierGetTimerResult(InnerPurifierBaseResult):
    """Purifier inner Timer Result Dict."""
    timers: list[ResponsePurifierTimerItems] | None

PurifierModifyTimerResult dataclass ↲

Bases: InnerPurifierBaseResult

Purifier inner Add Timer Result Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class PurifierModifyTimerResult(InnerPurifierBaseResult):
    """Purifier inner Add Timer Result Dict."""
    id: int

PurifierV2DetailsResult dataclass ↲

Bases: InnerPurifierBaseResult

Vital 100S/200S and Everest Purifier Result Model.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class PurifierV2DetailsResult(InnerPurifierBaseResult):
    """Vital 100S/200S and Everest Purifier Result Model."""
    powerSwitch: int
    filterLifePercent: int
    workMode: str
    manualSpeedLevel: int
    fanSpeedLevel: int
    AQLevel: int
    PM25: int
    screenState: int
    childLockSwitch: int
    screenSwitch: int
    lightDetectionSwitch: int
    environmentLightState: int
    scheduleCount: int
    timerRemain: int
    efficientModeTimeRemain: int
    errorCode: int
    autoPreference: VitalAutoPreferences | None = None
    fanRotateAngle: int | None = IntFlag.NOT_SUPPORTED
    filterOpenState: int | None = IntFlag.NOT_SUPPORTED
    PM1: int | None = IntFlag.NOT_SUPPORTED
    PM10: int | None = IntFlag.NOT_SUPPORTED
    AQPercent: int | None = IntFlag.NOT_SUPPORTED

PurifierV2EventTiming dataclass ↲

Bases: RequestBaseModel

Purifier Event Timing Request Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class PurifierV2EventTiming(RequestBaseModel):
    """Purifier Event Timing Request Dict."""
    clkSec: int

PurifierV2TimerActionItems dataclass ↲

Bases: RequestBaseModel

Purifier Timer Action Items Request Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class PurifierV2TimerActionItems(RequestBaseModel):
    """Purifier Timer Action Items Request Dict."""
    type: str
    act: int
    num: int = 0

PurifierV2TimerPayloadData dataclass ↲

Bases: RequestBaseModel

Purifier Timer Payload Data Request Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class PurifierV2TimerPayloadData(RequestBaseModel):
    """Purifier Timer Payload Data Request Dict."""
    enabled: bool
    startAct: list[PurifierV2TimerActionItems]
    tmgEvt: PurifierV2EventTiming | None = None
    type: int = 0
    subDeviceNo: int = 0
    repeat: int = 0

RequestPurifier131 dataclass ↲

Bases: RequestBypassV1

Purifier 131 Request Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class RequestPurifier131(RequestBypassV1):
    """Purifier 131 Request Dict."""
    status: str | None = None

RequestPurifier131Level dataclass ↲

Bases: RequestBypassV1

Purifier 131 Request Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class RequestPurifier131Level(RequestBypassV1):
    """Purifier 131 Request Dict."""
    level: int

RequestPurifier131Mode dataclass ↲

Bases: RequestBypassV1

Purifier 131 Request Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class RequestPurifier131Mode(RequestBypassV1):
    """Purifier 131 Request Dict."""
    mode: str

ResponsePurifierTimerItems dataclass ↲

Bases: ResponseBaseModel

Purifier Timer Items Response Dict.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class ResponsePurifierTimerItems(ResponseBaseModel):
    """Purifier Timer Items Response Dict."""
    id: int
    remain: int
    total: int
    action: str

VitalAutoPreferences dataclass ↲

Vital 100S/200S Auto Preferences.

Source code in src\pyvesync\models\purifier_models.py

@dataclass
class VitalAutoPreferences:
    """Vital 100S/200S Auto Preferences."""
    autoPreferenceType: str
    roomSize: int

Switch Models↲

Data models for VeSync switches.

These models inherit from ResponseBaseModel and RequestBaseModel from the base_models module.

Classes↲

InternalDimmerDetailsResult dataclass ↲

Bases: ResponseBaseModel

Dimmer Details Result Dict.

Source code in src\pyvesync\models\switch_models.py

@dataclass
class InternalDimmerDetailsResult(ResponseBaseModel):
    """Dimmer Details Result Dict."""
    devicename: str
    brightness: int
    indicatorlightStatus: str
    rgbStatus: str
    rgbValue: DimmerRGB
    deviceStatus: str
    connectionStatus: str
    activeTime: int = 0
    timer: Any | None = None
    schedule: Any | None = None
    deviceImg: str | None = None

InternalSwitchResult dataclass ↲

Bases: ResponseBaseModel

Dimmer Status Response Dict.

Source code in src\pyvesync\models\switch_models.py

@dataclass
class InternalSwitchResult(ResponseBaseModel):
    """Dimmer Status Response Dict."""
    deviceStatus: str
    connectionStatus: str
    activeTime: int

RequestDimmerBrightness dataclass ↲

Bases: RequestBypassV1

Dimmer Status Request Dict.

Source code in src\pyvesync\models\switch_models.py

@dataclass
class RequestDimmerBrightness(RequestBypassV1):
    """Dimmer Status Request Dict."""
    brightness: str

RequestDimmerDetails dataclass ↲

Bases: RequestBypassV1

Dimmer Details Request Dict.

Source code in src\pyvesync\models\switch_models.py

@dataclass
class RequestDimmerDetails(RequestBypassV1):
    """Dimmer Details Request Dict."""

RequestDimmerStatus dataclass ↲

Bases: RequestBypassV1

Dimmer Status Request Dict.

Source code in src\pyvesync\models\switch_models.py

@dataclass
class RequestDimmerStatus(RequestBypassV1):
    """Dimmer Status Request Dict."""
    status: str
    rgbValue: dict | None = None

    class Config(BaseConfig):  # type: ignore[override]
        """Dimmer Indicator Control Config Dict."""
        omit_none = True
        omit_default = True
        orjson_options = orjson.OPT_NON_STR_KEYS

RequestSwitchBase dataclass ↲

Bases: RequestBypassV1

Base Dimmer Request Dict.

Inherits from RequestBypassV1 to include the common fields for all requests.

Source code in src\pyvesync\models\switch_models.py

@dataclass
class RequestSwitchBase(RequestBypassV1):
    """Base Dimmer Request Dict.

    Inherits from RequestBypassV1 to include the common fields for all requests.
    """

RequestSwitchStatus dataclass ↲

Bases: RequestBypassV1

Dimmer Details Request Dict.

Source code in src\pyvesync\models\switch_models.py

@dataclass
class RequestSwitchStatus(RequestBypassV1):
    """Dimmer Details Request Dict."""
    status: str
    switchNo: int

ResponseSwitchDetails dataclass ↲

Bases: ResponseCodeModel

Dimmer and Wall Switch Details Response Dict.

Source code in src\pyvesync\models\switch_models.py

@dataclass
class ResponseSwitchDetails(ResponseCodeModel):
    """Dimmer and Wall Switch Details Response Dict."""
    result: InternalDimmerDetailsResult | InternalSwitchResult | None = None

Fryer Models↲

Data models for VeSync air fryers.

Classes↲

FryerBaseReturnStatus dataclass ↲

Bases: ResponseBaseModel

Result returnStatus model for air fryer status.

Source code in src\pyvesync\models\fryer_models.py

@dataclass
class FryerBaseReturnStatus(ResponseBaseModel):
    """Result returnStatus model for air fryer status."""
    cookStatus: str

FryerCookingReturnStatus dataclass ↲

Bases: ResponseBaseModel

Result returnStatus model for air fryer status.

Source code in src\pyvesync\models\fryer_models.py

@dataclass
class FryerCookingReturnStatus(ResponseBaseModel):
    """Result returnStatus model for air fryer status."""
    currentTemp: int
    cookSetTemp: int
    mode: str
    cookSetTime: int
    cookLastTime: int
    cookStatus: str
    tempUnit: str

ResultFryerDetails dataclass ↲

Bases: ResponseBaseModel

Result model for air fryer details.

Source code in src\pyvesync\models\fryer_models.py

@dataclass
class ResultFryerDetails(ResponseBaseModel):
    """Result model for air fryer details."""
    returnStatus: FryerCookingReturnStatus | FryerBaseReturnStatus | None = None

Thermostat Models↲

Data models for VeSync thermostats.

Classes↲

ResultThermostatDetails dataclass ↲

Bases: BypassV2InnerResult

Result model for thermostat details.

Source code in src\pyvesync\models\thermostat_models.py

@dataclass
class ResultThermostatDetails(BypassV2InnerResult):
    """Result model for thermostat details."""
    supportMode: list[int]
    workMode: int
    workStatus: int
    fanMode: int
    fanStatus: int
    tempUnit: str
    temperature: float
    humidity: int
    heatToTemp: int
    coolToTemp: int
    lockStatus: bool
    scheduleOrHold: int
    holdEndTime: int
    holdOption: int
    deadband: int
    ecoType: int
    alertStatus: int
    routines: list[ThermostatSimpleRoutine]
    routineRunningId: int | None = None

ThermostatAlarm dataclass ↲

Bases: DataClassORJSONMixin

Model for thermostat alarm.

Source code in src\pyvesync\models\thermostat_models.py

@dataclass
class ThermostatAlarm(DataClassORJSONMixin):
    """Model for thermostat alarm."""
    code: int
    enabled: bool
    code_name: str | None = None
    aux_runtime_limit: int | None = field(
        default=None, metadata=field_options(alias="auxRunTimeLimit")
    )

    @classmethod
    def __post_deserialize__(cls, obj: ThermostatAlarm) -> ThermostatAlarm:  # type: ignore[override]
        """Post-deserialization processing."""
        if obj.code is not None:
            obj.code_name = ThermostatConst.AlarmCode(obj.code).name
        return obj

ThermostatMinorDetails dataclass ↲

Bases: DataClassORJSONMixin

Model for thermostat minor details.

Source code in src\pyvesync\models\thermostat_models.py

@dataclass
class ThermostatMinorDetails(DataClassORJSONMixin):
    """Model for thermostat minor details."""
    mcu_version: str = field(metadata=field_options(alias="mcuVersion"))
    hvac_capacity: int = field(metadata=field_options(alias="hvacCapcity"))
    timestamp: int = field(metadata=field_options(alias="timeStamp"))
    time_zone: int = field(metadata=field_options(alias="timeZone"))
    offset_in_sec: int = field(metadata=field_options(alias="offsetInSec"))
    time_fmt: int = field(metadata=field_options(alias="timeFmt"))
    date_fmt: int = field(metadata=field_options(alias="dateFmt"))
    fan_delay_time: int = field(metadata=field_options(alias="fanDelayTime"))
    fan_circulation_time: int = field(metadata=field_options(alias="fanCirTime"))
    hvac_protect_time: int = field(metadata=field_options(alias="hvacProtecTime"))
    hvac_min_on_time: int = field(metadata=field_options(alias="hvacMinOnTime"))
    aux_min_on_time: int = field(metadata=field_options(alias="auxMinOnTime"))
    screen_brightness: int = field(metadata=field_options(alias="screenBrightness"))
    standby_timeout: int = field(metadata=field_options(alias="standbyTimeOut"))
    aux_low_temperature: int = field(metadata=field_options(alias="auxLowBalanceTemp"))
    aux_high_temperature: int = field(metadata=field_options(alias="auxHighBalanceTemp"))
    keytone: bool = field(metadata=field_options(alias="keyTone"))
    smart_schedule_enabled: bool = field(
        metadata=field_options(alias="smartScheduleEnabled")
        )
    time_to_temp_enabled: bool = field(metadata=field_options(alias="timeToTempEnabled"))
    early_on_enabled: bool = field(metadata=field_options(alias="earlyOnEnabled"))
    reminder_list: list[ThermostatReminder] = field(
        metadata=field_options(alias="reminderList")
    )
    alarm_list: list[ThermostatAlarm] = field(metadata=field_options(alias="alarmList"))

ThermostatReminder dataclass ↲

Bases: DataClassORJSONMixin

Model for thermostat reminder.

Source code in src\pyvesync\models\thermostat_models.py

@dataclass
class ThermostatReminder(DataClassORJSONMixin):
    """Model for thermostat reminder."""
    code: int
    enabled: bool
    frequency: int
    code_name: str | None = None
    last_maintenance_time: int | None = field(
        default=None, metadata=field_options(alias="lastMaintenTime")
    )

    @classmethod
    def __post_deserialize__(cls, obj: ThermostatReminder) -> ThermostatReminder:  # type: ignore[override]
        """Post-deserialization processing."""
        if isinstance(obj.code, int):
            obj.code_name = ThermostatConst.ReminderCode(obj.code).name
        return obj

ThermostatRoutine dataclass ↲

Bases: DataClassORJSONMixin

Model for full thermostat routine.

Source code in src\pyvesync\models\thermostat_models.py

@dataclass
class ThermostatRoutine(DataClassORJSONMixin):
    """Model for full thermostat routine."""
    name: str
    routineId: int
    type: int
    heatToTemp: int
    coolToTemp: int
    heatFanMode: int
    coolFanMode: int
    usuallyMask: int
    sensorIds: list[str]

ThermostatSimpleRoutine dataclass ↲

Bases: DataClassORJSONMixin

Thermostat routine model.

Source code in src\pyvesync\models\thermostat_models.py

@dataclass
class ThermostatSimpleRoutine(DataClassORJSONMixin):
    """Thermostat routine model."""
    name: str
    routineId: int