@jakobgoerke/ac-infinity-client 0.1.0 → 0.2.1

package/build/src/AcInfinityClient.d.ts

@@ -0,0 +1,40 @@
+import type { Controller, DeviceModeSettings, DeviceSettings, User } from './types';
+export declare enum Url {
+    AUTH = "/user/appUserLogin",
+    GET_CONTROLLERS = "/user/devInfoListAll",
+    GET_DEVICE_SETTINGS = "/dev/getDevSetting",
+    GET_DEVICE_MODE_SETTINGS = "/dev/getdevModeSettingList",
+    SET_DEVICE_MODE_SETTINGS = "/dev/addDevMode"
+}
+export interface Response<T> {
+    code: number;
+    data: T;
+}
+export interface AuthParams {
+    email: string;
+    password: string;
+}
+interface GetDeviceParams {
+    controllerId: string;
+    port: number;
+}
+interface SetDeviceModeSettingsParams extends GetDeviceParams {
+    settings: Pick<Partial<DeviceModeSettings>, 'levelWhileOn'>;
+}
+declare class AcInfinityClient {
+    constructor(args: AuthParams);
+    private api;
+    private token;
+    private email;
+    private password;
+    authenticate(): Promise<User>;
+    private ensureSuccess;
+    getControllers(): Promise<Controller[]>;
+    getDeviceSettings({ controllerId, port }: GetDeviceParams): Promise<DeviceSettings>;
+    getDeviceModeSettings({ controllerId, port }: GetDeviceParams): Promise<DeviceModeSettings>;
+    setDeviceModeSettings({ controllerId, port, settings }: SetDeviceModeSettingsParams): Promise<void>;
+    static build(args: AuthParams): Promise<AcInfinityClient>;
+}
+export { AcInfinityClient };
+export type { Controller, DeviceModeSettings, DeviceSettings, User };
+//# sourceMappingURL=AcInfinityClient.d.ts.map

package/build/src/AcInfinityClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcInfinityClient.d.ts","sourceRoot":"","sources":["../../src/AcInfinityClient.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAA2B,cAAc,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAG7G,oBAAY,GAAG;IACb,IAAI,uBAAuB;IAC3B,eAAe,yBAAyB;IACxC,mBAAmB,uBAAuB;IAC1C,wBAAwB,+BAA+B;IACvD,wBAAwB,oBAAoB;CAC7C;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,CAAC;CACT;AAOD,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,eAAe;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,2BAA4B,SAAQ,eAAe;IAC3D,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,cAAc,CAAC,CAAC;CAC7D;AAED,cAAM,gBAAgB;gBACR,IAAI,EAAE,UAAU;IAiB5B,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IAEZ,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB1C,OAAO,CAAC,aAAa;IAMR,cAAc,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAQvC,iBAAiB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IASnF,qBAAqB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAS3F,qBAAqB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;WAanG,KAAK,CAAC,IAAI,EAAE,UAAU;CAKpC;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC"}

package/build/src/AcInfinityClient.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcInfinityClient = exports.Url = void 0;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+var Url;
+(function (Url) {
+    Url["AUTH"] = "/user/appUserLogin";
+    Url["GET_CONTROLLERS"] = "/user/devInfoListAll";
+    Url["GET_DEVICE_SETTINGS"] = "/dev/getDevSetting";
+    Url["GET_DEVICE_MODE_SETTINGS"] = "/dev/getdevModeSettingList";
+    Url["SET_DEVICE_MODE_SETTINGS"] = "/dev/addDevMode";
+})(Url || (exports.Url = Url = {}));
+class AcInfinityClient {
+    constructor(args) {
+        const { email, password } = args;
+        this.email = email;
+        this.password = password;
+        this.token = '';
+        this.api = axios_1.default.create({
+            timeout: 5000,
+            baseURL: 'http://www.acinfinityserver.com/api',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
+            },
+        });
+    }
+    api;
+    token;
+    email;
+    password;
+    async authenticate() {
+        const response = await this.api.post(Url.AUTH, {
+            appEmail: this.email,
+            appPasswordl: this.password,
+        });
+        if (response.data.code !== 200) {
+            throw new errors_1.AuthenticationError();
+        }
+        const user = types_1.UserSchema.parse(response.data.data);
+        this.token = user.id;
+        this.api.defaults.headers.common.token = user.id;
+        return user;
+    }
+    ensureSuccess(response) {
+        if (response.code !== 200) {
+            throw new Error(`API request failed [code="${response.code}", msg="${response.msg}"]`);
+        }
+    }
+    async getControllers() {
+        const response = await this.api.post(Url.GET_CONTROLLERS, {
+            userId: this.token,
+        });
+        return response.data.data.map((device) => types_1.ControllerSchema.parse(device));
+    }
+    async getDeviceSettings({ controllerId, port }) {
+        const response = await this.api.post(Url.GET_DEVICE_SETTINGS, {
+            devId: controllerId,
+            port,
+        });
+        return types_1.DeviceSettingsSchema.parse(response.data.data);
+    }
+    async getDeviceModeSettings({ controllerId, port }) {
+        const response = await this.api.post(Url.GET_DEVICE_MODE_SETTINGS, {
+            devId: controllerId,
+            port,
+        });
+        return types_1.DeviceModeSettingsSchema.parse(response.data.data);
+    }
+    async setDeviceModeSettings({ controllerId, port, settings }) {
+        const rawCurrentSettings = await this.api.post(Url.GET_DEVICE_MODE_SETTINGS, {
+            devId: controllerId,
+            port,
+        });
+        const vendorChanges = (0, types_1.encodeDeviceModeSettings)(settings);
+        const payload = { ...rawCurrentSettings.data.data, ...vendorChanges };
+        const response = await this.api.post(Url.SET_DEVICE_MODE_SETTINGS, payload);
+        this.ensureSuccess(response.data);
+    }
+    static async build(args) {
+        const instance = new AcInfinityClient(args);
+        await instance.authenticate();
+        return instance;
+    }
+}
+exports.AcInfinityClient = AcInfinityClient;

package/build/src/errors/index.d.ts

@@ -0,0 +1,5 @@
+declare class AuthenticationError extends Error {
+    constructor(message?: string);
+}
+export { AuthenticationError };
+//# sourceMappingURL=index.d.ts.map

package/build/src/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAM,mBAAoB,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAQ7B;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/build/src/errors/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationError = void 0;
+class AuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+exports.AuthenticationError = AuthenticationError;

package/build/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AcInfinityClient';
+//# sourceMappingURL=index.d.ts.map

package/build/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/build/src/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AcInfinityClient"), exports);

package/build/src/types/Controller.d.ts

@@ -0,0 +1,176 @@
+import { z } from 'zod';
+import { DeviceMode, DeviceType } from './Device';
+export declare enum ControllerDeviceType {
+    UIS_CONTROLLER_69_PRO = 11,
+    UIS_CONTROLLER_69_PRO_PLUS = 10
+}
+export declare const ControllerPortSchema: z.ZodPipe<z.ZodObject<{
+    speak: z.ZodNumber;
+    port: z.ZodNumber;
+    curMode: z.ZodEnum<typeof DeviceMode>;
+    loadType: z.ZodEnum<typeof DeviceType>;
+    portName: z.ZodString;
+}, z.core.$strip>, z.ZodTransform<{
+    port: number;
+    currentLevel: number;
+    currentMode: DeviceMode;
+    deviceType: DeviceType;
+    deviceName: string;
+}, {
+    speak: number;
+    port: number;
+    curMode: DeviceMode;
+    loadType: DeviceType;
+    portName: string;
+}>>;
+export declare const ControllerDeviceInfoSchema: z.ZodPipe<z.ZodObject<{
+    temperature: z.ZodNumber;
+    humidity: z.ZodNumber;
+    vpdnums: z.ZodNumber;
+    ports: z.ZodArray<z.ZodPipe<z.ZodObject<{
+        speak: z.ZodNumber;
+        port: z.ZodNumber;
+        curMode: z.ZodEnum<typeof DeviceMode>;
+        loadType: z.ZodEnum<typeof DeviceType>;
+        portName: z.ZodString;
+    }, z.core.$strip>, z.ZodTransform<{
+        port: number;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        deviceType: DeviceType;
+        deviceName: string;
+    }, {
+        speak: number;
+        port: number;
+        curMode: DeviceMode;
+        loadType: DeviceType;
+        portName: string;
+    }>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    temperature: number;
+    humidity: number;
+    vpd: number;
+    ports: {
+        port: number;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        deviceType: DeviceType;
+        deviceName: string;
+    }[];
+}, {
+    temperature: number;
+    humidity: number;
+    vpdnums: number;
+    ports: {
+        port: number;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        deviceType: DeviceType;
+        deviceName: string;
+    }[];
+}>>;
+export declare const ControllerSchema: z.ZodPipe<z.ZodObject<{
+    devId: z.ZodString;
+    devCode: z.ZodString;
+    devName: z.ZodString;
+    devType: z.ZodEnum<typeof ControllerDeviceType>;
+    devPortCount: z.ZodNumber;
+    devVersion: z.ZodNumber;
+    online: z.ZodCoercedBoolean<unknown>;
+    firmwareVersion: z.ZodString;
+    hardwareVersion: z.ZodString;
+    deviceInfo: z.ZodPipe<z.ZodObject<{
+        temperature: z.ZodNumber;
+        humidity: z.ZodNumber;
+        vpdnums: z.ZodNumber;
+        ports: z.ZodArray<z.ZodPipe<z.ZodObject<{
+            speak: z.ZodNumber;
+            port: z.ZodNumber;
+            curMode: z.ZodEnum<typeof DeviceMode>;
+            loadType: z.ZodEnum<typeof DeviceType>;
+            portName: z.ZodString;
+        }, z.core.$strip>, z.ZodTransform<{
+            port: number;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
+        }, {
+            speak: number;
+            port: number;
+            curMode: DeviceMode;
+            loadType: DeviceType;
+            portName: string;
+        }>>>;
+    }, z.core.$strip>, z.ZodTransform<{
+        temperature: number;
+        humidity: number;
+        vpd: number;
+        ports: {
+            port: number;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
+        }[];
+    }, {
+        temperature: number;
+        humidity: number;
+        vpdnums: number;
+        ports: {
+            port: number;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
+        }[];
+    }>>;
+}, z.core.$strip>, z.ZodTransform<{
+    online: boolean;
+    firmwareVersion: string;
+    hardwareVersion: string;
+    deviceInfo: {
+        temperature: number;
+        humidity: number;
+        vpd: number;
+        ports: {
+            port: number;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
+        }[];
+    };
+    id: string;
+    code: string;
+    name: string;
+    type: ControllerDeviceType;
+    totalPorts: number;
+    version: number;
+}, {
+    devId: string;
+    devCode: string;
+    devName: string;
+    devType: ControllerDeviceType;
+    devPortCount: number;
+    devVersion: number;
+    online: boolean;
+    firmwareVersion: string;
+    hardwareVersion: string;
+    deviceInfo: {
+        temperature: number;
+        humidity: number;
+        vpd: number;
+        ports: {
+            port: number;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
+        }[];
+    };
+}>>;
+export type ControllerPort = z.infer<typeof ControllerPortSchema>;
+export type ControllerDeviceInfo = z.infer<typeof ControllerDeviceInfoSchema>;
+export type Controller = z.infer<typeof ControllerSchema>;
+//# sourceMappingURL=Controller.d.ts.map

package/build/src/types/Controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Controller.d.ts","sourceRoot":"","sources":["../../../src/types/Controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAElD,oBAAY,oBAAoB;IAC9B,qBAAqB,KAAK;IAC1B,0BAA0B,KAAK;CAChC;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;GAc5B,CAAC;AAEN,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYlC,CAAC;AAEN,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqBxB,CAAC;AAEN,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/build/src/types/Controller.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerSchema = exports.ControllerDeviceInfoSchema = exports.ControllerPortSchema = exports.ControllerDeviceType = void 0;
+const zod_1 = require("zod");
+const Device_1 = require("./Device");
+var ControllerDeviceType;
+(function (ControllerDeviceType) {
+    ControllerDeviceType[ControllerDeviceType["UIS_CONTROLLER_69_PRO"] = 11] = "UIS_CONTROLLER_69_PRO";
+    ControllerDeviceType[ControllerDeviceType["UIS_CONTROLLER_69_PRO_PLUS"] = 10] = "UIS_CONTROLLER_69_PRO_PLUS";
+})(ControllerDeviceType || (exports.ControllerDeviceType = ControllerDeviceType = {}));
+exports.ControllerPortSchema = zod_1.z
+    .object({
+    speak: zod_1.z.number(),
+    port: zod_1.z.number().positive(),
+    curMode: zod_1.z.enum(Device_1.DeviceMode),
+    loadType: zod_1.z.enum(Device_1.DeviceType),
+    portName: zod_1.z.string(),
+})
+    .transform((v) => ({
+    port: v.port,
+    currentLevel: v.speak,
+    currentMode: v.curMode,
+    deviceType: v.loadType,
+    deviceName: v.portName,
+}));
+exports.ControllerDeviceInfoSchema = zod_1.z
+    .object({
+    temperature: zod_1.z.number(),
+    humidity: zod_1.z.number(),
+    vpdnums: zod_1.z.number(),
+    ports: zod_1.z.array(exports.ControllerPortSchema),
+})
+    .transform((v) => ({
+    temperature: v.temperature / 100,
+    humidity: v.humidity / 100,
+    vpd: v.vpdnums / 100,
+    ports: v.ports,
+}));
+exports.ControllerSchema = zod_1.z
+    .object({
+    devId: zod_1.z.string(),
+    devCode: zod_1.z.string(),
+    devName: zod_1.z.string(),
+    devType: zod_1.z.enum(ControllerDeviceType),
+    devPortCount: zod_1.z.number().positive(),
+    devVersion: zod_1.z.number(),
+    online: zod_1.z.coerce.boolean(),
+    firmwareVersion: zod_1.z.string(),
+    hardwareVersion: zod_1.z.string(),
+    deviceInfo: exports.ControllerDeviceInfoSchema,
+})
+    .transform(({ devId, devCode, devName, devType, devPortCount, devVersion, ...rest }) => ({
+    id: devId,
+    code: devCode,
+    name: devName,
+    type: devType,
+    totalPorts: devPortCount,
+    version: devVersion,
+    ...rest,
+}));

package/build/src/types/Device.d.ts

@@ -0,0 +1,342 @@
+import { z } from 'zod';
+export declare enum DeviceType {
+    GROW_LIGHT = 1,
+    HUMIDIFIER = 2,
+    DEHUMIDIFIER = 3,
+    HEATER = 4,
+    AIR_CONDITION = 5,
+    FAN = 6
+}
+export declare enum DeviceMode {
+    OFF = 1,
+    ON = 2,
+    AUTO = 3,
+    TIMER_TO_ON = 4,
+    TIMER_TO_OFF = 5,
+    CYCLE = 6,
+    SCHEDULE = 7,
+    VPD = 8
+}
+export declare const DeviceSettingsSchema: z.ZodPipe<z.ZodObject<{
+    devId: z.ZodString;
+    devMacAddr: z.ZodNullable<z.ZodString>;
+    externalPort: z.ZodNumber;
+    offSpead: z.ZodNumber;
+    onSpead: z.ZodNumber;
+    onSelfSpead: z.ZodNumber;
+    ecUnit: z.ZodNumber;
+    tdsUnit: z.ZodNumber;
+    settingMode: z.ZodNumber;
+    vpdSettingMode: z.ZodNumber;
+    atType: z.ZodEnum<typeof DeviceMode>;
+    setId: z.ZodNullable<z.ZodString>;
+    port: z.ZodNumber;
+    devName: z.ZodNullable<z.ZodString>;
+    devLight: z.ZodNumber;
+    hasBacklightSwitch: z.ZodNumber;
+    backlightSwitch: z.ZodNumber;
+    hasKeytoneSwitch: z.ZodNumber;
+    keytoneSwitch: z.ZodNumber;
+    devCth: z.ZodNumber;
+    devCt: z.ZodNumber;
+    devCth2: z.ZodNullable<z.ZodNumber>;
+    devCt2: z.ZodNullable<z.ZodNumber>;
+    devCh: z.ZodNumber;
+    devTt: z.ZodNumber;
+    devTh: z.ZodNumber;
+    devCompany: z.ZodNumber;
+    devTth: z.ZodNumber;
+    vpdCth: z.ZodNumber;
+    vpdCt: z.ZodNumber;
+    vpdTransition: z.ZodNumber;
+    portResistance: z.ZodNullable<z.ZodNumber>;
+    devBth: z.ZodNumber;
+    devBt: z.ZodNumber;
+    devBh: z.ZodNumber;
+    devBvpd: z.ZodNumber;
+    isFlag: z.ZodNumber;
+    devTimeZone: z.ZodNullable<z.ZodString>;
+    loadType: z.ZodNumber;
+    tempCompare: z.ZodNumber;
+    humiCompare: z.ZodNumber;
+    onTimeSwitch: z.ZodNumber;
+    onTime: z.ZodNumber;
+    sensorSettingStr: z.ZodNullable<z.ZodString>;
+    sensorSetting: z.ZodNullable<z.ZodUnknown>;
+    sensorTransBuffStr: z.ZodNullable<z.ZodString>;
+    sensorTransBuff: z.ZodNullable<z.ZodUnknown>;
+    portParamData: z.ZodNullable<z.ZodString>;
+    photocellSwitch: z.ZodNumber;
+    isOpenDoseTime: z.ZodNumber;
+    onDoseTime: z.ZodNumber;
+    offDoseTime: z.ZodNumber;
+    isOnMinMaxTime: z.ZodNumber;
+    onMinTime: z.ZodNumber;
+    onMaxTime: z.ZodNumber;
+    ecOrTds: z.ZodNumber;
+    interchangeSensor: z.ZodNumber;
+    subDeviceId: z.ZodNullable<z.ZodString>;
+    subDeviceVersion: z.ZodNullable<z.ZodString>;
+    subDeviceType: z.ZodNullable<z.ZodNumber>;
+    supportOta: z.ZodNullable<z.ZodUnknown>;
+    otaUpdating: z.ZodNullable<z.ZodUnknown>;
+    secFucStatus: z.ZodNumber;
+    secFucDevtype: z.ZodNumber;
+    secFucDevEffect: z.ZodNumber;
+    secFucParamNums: z.ZodNumber;
+    secFucParams: z.ZodNullable<z.ZodUnknown>;
+    secFucReportTime: z.ZodNumber;
+    toward: z.ZodNullable<z.ZodUnknown>;
+    powerState: z.ZodNullable<z.ZodUnknown>;
+    updateAllPort: z.ZodBoolean;
+    timestamp: z.ZodNullable<z.ZodUnknown>;
+    calibrationTime: z.ZodNullable<z.ZodUnknown>;
+    fieldSet: z.ZodArray<z.ZodUnknown>;
+    plantCode: z.ZodNumber;
+    potSize: z.ZodNumber;
+    plantingNum: z.ZodNumber;
+    devCl: z.ZodNullable<z.ZodUnknown>;
+    devCsm1: z.ZodNullable<z.ZodUnknown>;
+    devCsm2: z.ZodNullable<z.ZodUnknown>;
+    devCsm3: z.ZodNullable<z.ZodUnknown>;
+    devCsm4: z.ZodNullable<z.ZodUnknown>;
+    uuidSta: z.ZodNumber;
+    uuidType: z.ZodNullable<z.ZodUnknown>;
+    uuid: z.ZodNullable<z.ZodString>;
+    matterCode: z.ZodNullable<z.ZodString>;
+    matterSta: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodTransform<{
+    id: string;
+    port: number;
+    levelWhileOff: number;
+    levelWhileOn: number;
+    mode: DeviceMode;
+}, {
+    devId: string;
+    devMacAddr: string | null;
+    externalPort: number;
+    offSpead: number;
+    onSpead: number;
+    onSelfSpead: number;
+    ecUnit: number;
+    tdsUnit: number;
+    settingMode: number;
+    vpdSettingMode: number;
+    atType: DeviceMode;
+    setId: string | null;
+    port: number;
+    devName: string | null;
+    devLight: number;
+    hasBacklightSwitch: number;
+    backlightSwitch: number;
+    hasKeytoneSwitch: number;
+    keytoneSwitch: number;
+    devCth: number;
+    devCt: number;
+    devCth2: number | null;
+    devCt2: number | null;
+    devCh: number;
+    devTt: number;
+    devTh: number;
+    devCompany: number;
+    devTth: number;
+    vpdCth: number;
+    vpdCt: number;
+    vpdTransition: number;
+    portResistance: number | null;
+    devBth: number;
+    devBt: number;
+    devBh: number;
+    devBvpd: number;
+    isFlag: number;
+    devTimeZone: string | null;
+    loadType: number;
+    tempCompare: number;
+    humiCompare: number;
+    onTimeSwitch: number;
+    onTime: number;
+    sensorSettingStr: string | null;
+    sensorSetting: unknown;
+    sensorTransBuffStr: string | null;
+    sensorTransBuff: unknown;
+    portParamData: string | null;
+    photocellSwitch: number;
+    isOpenDoseTime: number;
+    onDoseTime: number;
+    offDoseTime: number;
+    isOnMinMaxTime: number;
+    onMinTime: number;
+    onMaxTime: number;
+    ecOrTds: number;
+    interchangeSensor: number;
+    subDeviceId: string | null;
+    subDeviceVersion: string | null;
+    subDeviceType: number | null;
+    supportOta: unknown;
+    otaUpdating: unknown;
+    secFucStatus: number;
+    secFucDevtype: number;
+    secFucDevEffect: number;
+    secFucParamNums: number;
+    secFucParams: unknown;
+    secFucReportTime: number;
+    toward: unknown;
+    powerState: unknown;
+    updateAllPort: boolean;
+    timestamp: unknown;
+    calibrationTime: unknown;
+    fieldSet: unknown[];
+    plantCode: number;
+    potSize: number;
+    plantingNum: number;
+    devCl: unknown;
+    devCsm1: unknown;
+    devCsm2: unknown;
+    devCsm3: unknown;
+    devCsm4: unknown;
+    uuidSta: number;
+    uuidType: unknown;
+    uuid: string | null;
+    matterCode: string | null;
+    matterSta: unknown;
+}>>;
+export declare const DeviceModeSettingsSchema: z.ZodPipe<z.ZodObject<{
+    devId: z.ZodString;
+    devMacAddr: z.ZodNullable<z.ZodString>;
+    externalPort: z.ZodNumber;
+    offSpead: z.ZodNumber;
+    onSpead: z.ZodNumber;
+    onSelfSpead: z.ZodNumber;
+    ecUnit: z.ZodNumber;
+    tdsUnit: z.ZodNumber;
+    settingMode: z.ZodNumber;
+    vpdSettingMode: z.ZodNumber;
+    atType: z.ZodEnum<typeof DeviceMode>;
+    acitveTimerOff: z.ZodNumber;
+    acitveTimerOn: z.ZodNumber;
+    activeCycleOff: z.ZodNumber;
+    activeCycleOn: z.ZodNumber;
+    activeHh: z.ZodNumber;
+    activeHt: z.ZodNumber;
+    activeHtVpd: z.ZodNumber;
+    activeHtVpdNums: z.ZodNumber;
+    activeLh: z.ZodNumber;
+    activeLt: z.ZodNumber;
+    activeLtVpd: z.ZodNumber;
+    activeLtVpdNums: z.ZodNumber;
+    co2FanHighSwitch: z.ZodNumber;
+    co2FanHighValue: z.ZodNumber;
+    co2LowSwitch: z.ZodNumber;
+    co2LowValue: z.ZodNumber;
+    devHh: z.ZodNumber;
+    devHt: z.ZodNumber;
+    devHtf: z.ZodNumber;
+    devLh: z.ZodNumber;
+    devLt: z.ZodNumber;
+    devLtf: z.ZodNumber;
+    ecTdsLowSwitchEc: z.ZodNumber;
+    ecTdsLowSwitchTds: z.ZodNumber;
+    ecTdsLowValueEcUs: z.ZodNumber;
+    ecTdsLowValueTdsPpm: z.ZodNumber;
+    isOpenAutomation: z.ZodNumber;
+    modeType: z.ZodNumber;
+    moistureLowSwitch: z.ZodNumber;
+    moistureLowValue: z.ZodNumber;
+    onlyUpdateSpeed: z.ZodNumber;
+    phHighSwitch: z.ZodNumber;
+    phHighValue: z.ZodNumber;
+    phLowSwitch: z.ZodNumber;
+    phLowValue: z.ZodNumber;
+    schedEndtTime: z.ZodNumber;
+    schedStartTime: z.ZodNumber;
+    surplus: z.ZodNullable<z.ZodNumber>;
+    targetHumi: z.ZodNumber;
+    targetHumiSwitch: z.ZodNumber;
+    targetTSwitch: z.ZodNumber;
+    targetTemp: z.ZodNumber;
+    targetTempF: z.ZodNumber;
+    targetVpd: z.ZodNumber;
+    targetVpdSwitch: z.ZodNumber;
+    waterLevelLowSwitch: z.ZodNumber;
+    waterTempHighSwitch: z.ZodNumber;
+    waterTempHighValue: z.ZodNumber;
+    waterTempHighValueF: z.ZodNumber;
+    waterTempLowSwitch: z.ZodNumber;
+    waterTempLowValue: z.ZodNumber;
+    waterTempLowValueF: z.ZodNumber;
+}, z.core.$strip>, z.ZodTransform<{
+    id: string;
+    port: number;
+    levelWhileOff: number;
+    levelWhileOn: number;
+    mode: DeviceMode;
+}, {
+    devId: string;
+    devMacAddr: string | null;
+    externalPort: number;
+    offSpead: number;
+    onSpead: number;
+    onSelfSpead: number;
+    ecUnit: number;
+    tdsUnit: number;
+    settingMode: number;
+    vpdSettingMode: number;
+    atType: DeviceMode;
+    acitveTimerOff: number;
+    acitveTimerOn: number;
+    activeCycleOff: number;
+    activeCycleOn: number;
+    activeHh: number;
+    activeHt: number;
+    activeHtVpd: number;
+    activeHtVpdNums: number;
+    activeLh: number;
+    activeLt: number;
+    activeLtVpd: number;
+    activeLtVpdNums: number;
+    co2FanHighSwitch: number;
+    co2FanHighValue: number;
+    co2LowSwitch: number;
+    co2LowValue: number;
+    devHh: number;
+    devHt: number;
+    devHtf: number;
+    devLh: number;
+    devLt: number;
+    devLtf: number;
+    ecTdsLowSwitchEc: number;
+    ecTdsLowSwitchTds: number;
+    ecTdsLowValueEcUs: number;
+    ecTdsLowValueTdsPpm: number;
+    isOpenAutomation: number;
+    modeType: number;
+    moistureLowSwitch: number;
+    moistureLowValue: number;
+    onlyUpdateSpeed: number;
+    phHighSwitch: number;
+    phHighValue: number;
+    phLowSwitch: number;
+    phLowValue: number;
+    schedEndtTime: number;
+    schedStartTime: number;
+    surplus: number | null;
+    targetHumi: number;
+    targetHumiSwitch: number;
+    targetTSwitch: number;
+    targetTemp: number;
+    targetTempF: number;
+    targetVpd: number;
+    targetVpdSwitch: number;
+    waterLevelLowSwitch: number;
+    waterTempHighSwitch: number;
+    waterTempHighValue: number;
+    waterTempHighValueF: number;
+    waterTempLowSwitch: number;
+    waterTempLowValue: number;
+    waterTempLowValueF: number;
+}>>;
+export type DeviceSettings = z.infer<typeof DeviceSettingsSchema>;
+export type DeviceModeSettings = z.infer<typeof DeviceModeSettingsSchema>;
+export type DeviceModeSettingsInput = z.input<typeof DeviceModeSettingsSchema>;
+export declare function encodeDeviceModeSettings(settings: Partial<DeviceModeSettings>): Partial<DeviceModeSettingsInput>;
+//# sourceMappingURL=Device.d.ts.map

package/build/src/types/Device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Device.d.ts","sourceRoot":"","sources":["../../../src/types/Device.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oBAAY,UAAU;IACpB,UAAU,IAAI;IACd,UAAU,IAAI;IACd,YAAY,IAAI;IAChB,MAAM,IAAI;IACV,aAAa,IAAI;IACjB,GAAG,IAAI;CACR;AAED,oBAAY,UAAU;IACpB,GAAG,IAAI;IACP,EAAE,IAAI;IACN,IAAI,IAAI;IACR,WAAW,IAAI;IACf,YAAY,IAAI;IAChB,KAAK,IAAI;IACT,QAAQ,IAAI;IACZ,GAAG,IAAI;CACR;AA0BD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+E9B,CAAC;AAEJ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDlC,CAAC;AAEJ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE/E,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAIhH"}

package/build/src/types/Device.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceModeSettingsSchema = exports.DeviceSettingsSchema = exports.DeviceMode = exports.DeviceType = void 0;
+exports.encodeDeviceModeSettings = encodeDeviceModeSettings;
+const zod_1 = require("zod");
+var DeviceType;
+(function (DeviceType) {
+    DeviceType[DeviceType["GROW_LIGHT"] = 1] = "GROW_LIGHT";
+    DeviceType[DeviceType["HUMIDIFIER"] = 2] = "HUMIDIFIER";
+    DeviceType[DeviceType["DEHUMIDIFIER"] = 3] = "DEHUMIDIFIER";
+    DeviceType[DeviceType["HEATER"] = 4] = "HEATER";
+    DeviceType[DeviceType["AIR_CONDITION"] = 5] = "AIR_CONDITION";
+    DeviceType[DeviceType["FAN"] = 6] = "FAN";
+})(DeviceType || (exports.DeviceType = DeviceType = {}));
+var DeviceMode;
+(function (DeviceMode) {
+    DeviceMode[DeviceMode["OFF"] = 1] = "OFF";
+    DeviceMode[DeviceMode["ON"] = 2] = "ON";
+    DeviceMode[DeviceMode["AUTO"] = 3] = "AUTO";
+    DeviceMode[DeviceMode["TIMER_TO_ON"] = 4] = "TIMER_TO_ON";
+    DeviceMode[DeviceMode["TIMER_TO_OFF"] = 5] = "TIMER_TO_OFF";
+    DeviceMode[DeviceMode["CYCLE"] = 6] = "CYCLE";
+    DeviceMode[DeviceMode["SCHEDULE"] = 7] = "SCHEDULE";
+    DeviceMode[DeviceMode["VPD"] = 8] = "VPD";
+})(DeviceMode || (exports.DeviceMode = DeviceMode = {}));
+const DeviceBaseInputSchema = zod_1.z.object({
+    devId: zod_1.z.string(),
+    devMacAddr: zod_1.z.string().nullable(),
+    externalPort: zod_1.z.number(),
+    offSpead: zod_1.z.number().min(0).max(10),
+    onSpead: zod_1.z.number().min(0).max(10),
+    onSelfSpead: zod_1.z.number(),
+    ecUnit: zod_1.z.number(),
+    tdsUnit: zod_1.z.number(),
+    settingMode: zod_1.z.number(),
+    vpdSettingMode: zod_1.z.number(),
+    atType: zod_1.z.enum(DeviceMode),
+});
+const transformDeviceBase = ({ devId, externalPort, offSpead, onSpead, atType }) => ({
+    id: devId,
+    port: externalPort,
+    levelWhileOff: offSpead,
+    levelWhileOn: onSpead,
+    mode: atType,
+});
+exports.DeviceSettingsSchema = DeviceBaseInputSchema.extend({
+    setId: zod_1.z.string().nullable(),
+    port: zod_1.z.number(),
+    devName: zod_1.z.string().nullable(),
+    devLight: zod_1.z.number(),
+    hasBacklightSwitch: zod_1.z.number(),
+    backlightSwitch: zod_1.z.number(),
+    hasKeytoneSwitch: zod_1.z.number(),
+    keytoneSwitch: zod_1.z.number(),
+    devCth: zod_1.z.number(),
+    devCt: zod_1.z.number(),
+    devCth2: zod_1.z.number().nullable(),
+    devCt2: zod_1.z.number().nullable(),
+    devCh: zod_1.z.number(),
+    devTt: zod_1.z.number(),
+    devTh: zod_1.z.number(),
+    devCompany: zod_1.z.number(),
+    devTth: zod_1.z.number(),
+    vpdCth: zod_1.z.number(),
+    vpdCt: zod_1.z.number(),
+    vpdTransition: zod_1.z.number(),
+    portResistance: zod_1.z.number().nullable(),
+    devBth: zod_1.z.number(),
+    devBt: zod_1.z.number(),
+    devBh: zod_1.z.number(),
+    devBvpd: zod_1.z.number(),
+    isFlag: zod_1.z.number(),
+    devTimeZone: zod_1.z.string().nullable(),
+    loadType: zod_1.z.number(),
+    tempCompare: zod_1.z.number(),
+    humiCompare: zod_1.z.number(),
+    onTimeSwitch: zod_1.z.number(),
+    onTime: zod_1.z.number(),
+    sensorSettingStr: zod_1.z.string().nullable(),
+    sensorSetting: zod_1.z.unknown().nullable(),
+    sensorTransBuffStr: zod_1.z.string().nullable(),
+    sensorTransBuff: zod_1.z.unknown().nullable(),
+    portParamData: zod_1.z.string().nullable(),
+    photocellSwitch: zod_1.z.number(),
+    isOpenDoseTime: zod_1.z.number(),
+    onDoseTime: zod_1.z.number(),
+    offDoseTime: zod_1.z.number(),
+    isOnMinMaxTime: zod_1.z.number(),
+    onMinTime: zod_1.z.number(),
+    onMaxTime: zod_1.z.number(),
+    ecOrTds: zod_1.z.number(),
+    interchangeSensor: zod_1.z.number(),
+    subDeviceId: zod_1.z.string().nullable(),
+    subDeviceVersion: zod_1.z.string().nullable(),
+    subDeviceType: zod_1.z.number().nullable(),
+    supportOta: zod_1.z.unknown().nullable(),
+    otaUpdating: zod_1.z.unknown().nullable(),
+    secFucStatus: zod_1.z.number(),
+    secFucDevtype: zod_1.z.number(),
+    secFucDevEffect: zod_1.z.number(),
+    secFucParamNums: zod_1.z.number(),
+    secFucParams: zod_1.z.unknown().nullable(),
+    secFucReportTime: zod_1.z.number(),
+    toward: zod_1.z.unknown().nullable(),
+    powerState: zod_1.z.unknown().nullable(),
+    updateAllPort: zod_1.z.boolean(),
+    timestamp: zod_1.z.unknown().nullable(),
+    calibrationTime: zod_1.z.unknown().nullable(),
+    fieldSet: zod_1.z.array(zod_1.z.unknown()),
+    plantCode: zod_1.z.number(),
+    potSize: zod_1.z.number(),
+    plantingNum: zod_1.z.number(),
+    devCl: zod_1.z.unknown().nullable(),
+    devCsm1: zod_1.z.unknown().nullable(),
+    devCsm2: zod_1.z.unknown().nullable(),
+    devCsm3: zod_1.z.unknown().nullable(),
+    devCsm4: zod_1.z.unknown().nullable(),
+    uuidSta: zod_1.z.number(),
+    uuidType: zod_1.z.unknown().nullable(),
+    uuid: zod_1.z.string().nullable(),
+    matterCode: zod_1.z.string().nullable(),
+    matterSta: zod_1.z.unknown().nullable(),
+}).transform((v) => ({
+    ...transformDeviceBase(v),
+}));
+exports.DeviceModeSettingsSchema = DeviceBaseInputSchema.extend({
+    acitveTimerOff: zod_1.z.number(),
+    acitveTimerOn: zod_1.z.number(),
+    activeCycleOff: zod_1.z.number(),
+    activeCycleOn: zod_1.z.number(),
+    activeHh: zod_1.z.number(),
+    activeHt: zod_1.z.number(),
+    activeHtVpd: zod_1.z.number(),
+    activeHtVpdNums: zod_1.z.number(),
+    activeLh: zod_1.z.number(),
+    activeLt: zod_1.z.number(),
+    activeLtVpd: zod_1.z.number(),
+    activeLtVpdNums: zod_1.z.number(),
+    co2FanHighSwitch: zod_1.z.number(),
+    co2FanHighValue: zod_1.z.number(),
+    co2LowSwitch: zod_1.z.number(),
+    co2LowValue: zod_1.z.number(),
+    devHh: zod_1.z.number(),
+    devHt: zod_1.z.number(),
+    devHtf: zod_1.z.number(),
+    devLh: zod_1.z.number(),
+    devLt: zod_1.z.number(),
+    devLtf: zod_1.z.number(),
+    ecTdsLowSwitchEc: zod_1.z.number(),
+    ecTdsLowSwitchTds: zod_1.z.number(),
+    ecTdsLowValueEcUs: zod_1.z.number(),
+    ecTdsLowValueTdsPpm: zod_1.z.number(),
+    isOpenAutomation: zod_1.z.number(),
+    modeType: zod_1.z.number(),
+    moistureLowSwitch: zod_1.z.number(),
+    moistureLowValue: zod_1.z.number(),
+    onlyUpdateSpeed: zod_1.z.number(),
+    phHighSwitch: zod_1.z.number(),
+    phHighValue: zod_1.z.number(),
+    phLowSwitch: zod_1.z.number(),
+    phLowValue: zod_1.z.number(),
+    schedEndtTime: zod_1.z.number(),
+    schedStartTime: zod_1.z.number(),
+    surplus: zod_1.z.number().nullable(),
+    targetHumi: zod_1.z.number(),
+    targetHumiSwitch: zod_1.z.number(),
+    targetTSwitch: zod_1.z.number(),
+    targetTemp: zod_1.z.number(),
+    targetTempF: zod_1.z.number(),
+    targetVpd: zod_1.z.number(),
+    targetVpdSwitch: zod_1.z.number(),
+    waterLevelLowSwitch: zod_1.z.number(),
+    waterTempHighSwitch: zod_1.z.number(),
+    waterTempHighValue: zod_1.z.number(),
+    waterTempHighValueF: zod_1.z.number(),
+    waterTempLowSwitch: zod_1.z.number(),
+    waterTempLowValue: zod_1.z.number(),
+    waterTempLowValueF: zod_1.z.number(),
+}).transform((v) => ({
+    ...transformDeviceBase(v),
+}));
+function encodeDeviceModeSettings(settings) {
+    return {
+        onSpead: settings.levelWhileOn,
+    };
+}

package/build/src/types/User.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const UserSchema: z.ZodPipe<z.ZodObject<{
+    appId: z.ZodString;
+    nickName: z.ZodString;
+    appEmail: z.ZodEmail;
+}, z.core.$strip>, z.ZodTransform<{
+    id: string;
+    username: string;
+    email: string;
+}, {
+    appId: string;
+    nickName: string;
+    appEmail: string;
+}>>;
+export type User = z.infer<typeof UserSchema>;
+//# sourceMappingURL=User.d.ts.map

package/build/src/types/User.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"User.d.ts","sourceRoot":"","sources":["../../../src/types/User.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;;;;;;;GAUlB,CAAC;AAEN,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/build/src/types/User.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSchema = void 0;
+const zod_1 = require("zod");
+exports.UserSchema = zod_1.z
+    .object({
+    appId: zod_1.z.string(),
+    nickName: zod_1.z.string(),
+    appEmail: zod_1.z.email(),
+})
+    .transform(({ appId, nickName, appEmail }) => ({
+    id: appId,
+    username: nickName,
+    email: appEmail,
+}));

package/build/src/types/index.d.ts

@@ -0,0 +1,7 @@
+export type { Controller, ControllerDeviceInfo, ControllerPort } from './Controller';
+export { ControllerDeviceType, ControllerSchema } from './Controller';
+export type { DeviceModeSettings, DeviceModeSettingsInput, DeviceSettings } from './Device';
+export { DeviceMode, DeviceModeSettingsSchema, DeviceSettingsSchema, DeviceType, encodeDeviceModeSettings } from './Device';
+export type { User } from './User';
+export { UserSchema } from './User';
+//# sourceMappingURL=index.d.ts.map

package/build/src/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACtE,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,UAAU,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAC5H,YAAY,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC"}

package/build/src/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSchema = exports.encodeDeviceModeSettings = exports.DeviceType = exports.DeviceSettingsSchema = exports.DeviceModeSettingsSchema = exports.DeviceMode = exports.ControllerSchema = exports.ControllerDeviceType = void 0;
+var Controller_1 = require("./Controller");
+Object.defineProperty(exports, "ControllerDeviceType", { enumerable: true, get: function () { return Controller_1.ControllerDeviceType; } });
+Object.defineProperty(exports, "ControllerSchema", { enumerable: true, get: function () { return Controller_1.ControllerSchema; } });
+var Device_1 = require("./Device");
+Object.defineProperty(exports, "DeviceMode", { enumerable: true, get: function () { return Device_1.DeviceMode; } });
+Object.defineProperty(exports, "DeviceModeSettingsSchema", { enumerable: true, get: function () { return Device_1.DeviceModeSettingsSchema; } });
+Object.defineProperty(exports, "DeviceSettingsSchema", { enumerable: true, get: function () { return Device_1.DeviceSettingsSchema; } });
+Object.defineProperty(exports, "DeviceType", { enumerable: true, get: function () { return Device_1.DeviceType; } });
+Object.defineProperty(exports, "encodeDeviceModeSettings", { enumerable: true, get: function () { return Device_1.encodeDeviceModeSettings; } });
+var User_1 = require("./User");
+Object.defineProperty(exports, "UserSchema", { enumerable: true, get: function () { return User_1.UserSchema; } });

package/package.json

@@ -1,32 +1,37 @@
 {
   "name": "@jakobgoerke/ac-infinity-client",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "main": "./build/src",
   "types": "./build/src/index.d.ts",
   "repository": "git@github.com:jakobgoerke/ac-infinity-client.git",
   "author": "revdev <mail@revdev.me>",
   "license": "GPL-3.0-or-later",
-  "dependencies": {
-    "axios": "1.7.7",
-    "rimraf": "6.0.1",
-    "zod": "3.23.8"
-  },
   "files": [
     "package.json",
     "build/src/**"
   ],
+  "dependencies": {
+    "axios": "1.13.5",
+    "zod": "4.3.6"
+  },
   "devDependencies": {
-    "@jest/globals": "29.7.0",
-    "@tsconfig/node22": "22.0.0",
-    "@types/jest": "29.5.13",
-    "jest": "29.7.0",
-    "ts-jest": "29.2.5",
-    "typescript": "5.6.2"
+    "@biomejs/biome": "2.4.4",
+    "@jest/globals": "30.2.0",
+    "@tsconfig/node24": "24.0.4",
+    "@types/jest": "30.0.0",
+    "@types/node": "25.3.0",
+    "jest": "30.2.0",
+    "rimraf": "6.1.3",
+    "ts-jest": "29.4.6",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3"
   },
   "scripts": {
     "build": "rimraf build && tsc -p .",
     "watch": "tsc -p . --watch",
     "test": "jest",
-    "coverage": "jest --coverage"
-  }
-}
+    "coverage": "jest --coverage",
+    "lint": "biome check"
+  },
+  "packageManager": "yarn@4.12.0"
+}