@jakobgoerke/ac-infinity-client 0.1.0 → 0.1.1

package/build/src/AcInfinityClient.d.ts

@@ -0,0 +1,34 @@
+import { Controller, User, DeviceModeSettings, DeviceSettings } from './types';
+export declare enum Url {
+    AUTH = "/user/appUserLogin",
+    CONTROLLERS = "/user/devInfoListAll",
+    DEVICE_SETTINGS = "/dev/getDevSetting",
+    DEVICE_MODE_SETTINGS = "/dev/getdevModeSettingList"
+}
+export interface Response<T> {
+    code: number;
+    data: T;
+}
+export interface AuthParams {
+    email: string;
+    password: string;
+}
+interface GetDeviceParams {
+    deviceId: string;
+    port: number;
+}
+declare class AcInfinityClient {
+    constructor(args: AuthParams);
+    private api;
+    private token;
+    private email;
+    private password;
+    authenticate(): Promise<User>;
+    getControllers(): Promise<Controller[]>;
+    getDeviceSettings({ deviceId, port }: GetDeviceParams): Promise<DeviceSettings>;
+    getDeviceModeSettings({ deviceId, port }: GetDeviceParams): Promise<DeviceModeSettings>;
+    static build(args: AuthParams): Promise<AcInfinityClient>;
+}
+export { AcInfinityClient };
+export type { Controller, User, DeviceModeSettings, DeviceSettings };
+//# 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":"AAEA,OAAO,EACL,UAAU,EAEV,IAAI,EAGJ,kBAAkB,EAClB,cAAc,EAEf,MAAM,SAAS,CAAC;AAGjB,oBAAY,GAAG;IACb,IAAI,uBAAuB;IAC3B,WAAW,yBAAyB;IACpC,eAAe,uBAAuB;IACtC,oBAAoB,+BAA+B;CACpD;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,CAAC;CACT;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,eAAe;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;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;IAiB7B,cAAc,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAQvC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAS/E,qBAAqB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;WASvF,KAAK,CAAC,IAAI,EAAE,UAAU;CAKpC;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAC"}

package/build/src/AcInfinityClient.js

@@ -0,0 +1,74 @@
+"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 types_1 = require("./types");
+const errors_1 = require("./errors");
+var Url;
+(function (Url) {
+    Url["AUTH"] = "/user/appUserLogin";
+    Url["CONTROLLERS"] = "/user/devInfoListAll";
+    Url["DEVICE_SETTINGS"] = "/dev/getDevSetting";
+    Url["DEVICE_MODE_SETTINGS"] = "/dev/getdevModeSettingList";
+})(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.appId;
+        this.api.defaults.headers.common['token'] = user.appId;
+        return user;
+    }
+    async getControllers() {
+        const response = await this.api.post(Url.CONTROLLERS, {
+            userId: this.token,
+        });
+        return response.data.data.map((device) => types_1.ControllerSchema.parse(device));
+    }
+    async getDeviceSettings({ deviceId, port }) {
+        const response = await this.api.post(Url.DEVICE_SETTINGS, {
+            devId: deviceId,
+            port,
+        });
+        return types_1.DeviceSettingsSchema.parse(response.data.data);
+    }
+    async getDeviceModeSettings({ deviceId, port }) {
+        const response = await this.api.post(Url.DEVICE_MODE_SETTINGS, {
+            devId: deviceId,
+            port,
+        });
+        return types_1.DeviceModeSettingsSchema.parse(response.data.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,177 @@
+import { z } from 'zod';
+import { DeviceMode, DeviceType } from './Device';
+declare enum ControllerDeviceType {
+    UIS_CONTROLLER_69_PRO = 11,
+    UIS_CONTROLLER_69_PRO_PLUS = 10
+}
+export declare const ControllerPortSchema: z.ZodObject<{
+    loadType: z.ZodNativeEnum<typeof DeviceType>;
+    curMode: z.ZodNativeEnum<typeof DeviceMode>;
+    port: z.ZodNumber;
+    speak: z.ZodNumber;
+    portName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    loadType: DeviceType;
+    curMode: DeviceMode;
+    port: number;
+    speak: number;
+    portName: string;
+}, {
+    loadType: DeviceType;
+    curMode: DeviceMode;
+    port: number;
+    speak: number;
+    portName: string;
+}>;
+export type ControllerPort = z.infer<typeof ControllerPortSchema>;
+export declare const ControllerDeviceInfoSchema: z.ZodObject<{
+    temperature: z.ZodNumber;
+    humidity: z.ZodNumber;
+    ports: z.ZodArray<z.ZodObject<{
+        loadType: z.ZodNativeEnum<typeof DeviceType>;
+        curMode: z.ZodNativeEnum<typeof DeviceMode>;
+        port: z.ZodNumber;
+        speak: z.ZodNumber;
+        portName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        loadType: DeviceType;
+        curMode: DeviceMode;
+        port: number;
+        speak: number;
+        portName: string;
+    }, {
+        loadType: DeviceType;
+        curMode: DeviceMode;
+        port: number;
+        speak: number;
+        portName: string;
+    }>, "many">;
+    vpdnums: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    temperature: number;
+    humidity: number;
+    ports: {
+        loadType: DeviceType;
+        curMode: DeviceMode;
+        port: number;
+        speak: number;
+        portName: string;
+    }[];
+    vpdnums: number;
+}, {
+    temperature: number;
+    humidity: number;
+    ports: {
+        loadType: DeviceType;
+        curMode: DeviceMode;
+        port: number;
+        speak: number;
+        portName: string;
+    }[];
+    vpdnums: number;
+}>;
+export type ControllerDeviceInfo = z.infer<typeof ControllerDeviceInfoSchema>;
+export declare const ControllerSchema: z.ZodObject<{
+    devId: z.ZodString;
+    devCode: z.ZodString;
+    devName: z.ZodString;
+    devType: z.ZodNativeEnum<typeof ControllerDeviceType>;
+    devPortCount: z.ZodNumber;
+    devVersion: z.ZodNumber;
+    online: z.ZodBoolean;
+    firmwareVersion: z.ZodString;
+    hardwareVersion: z.ZodString;
+    deviceInfo: z.ZodObject<{
+        temperature: z.ZodNumber;
+        humidity: z.ZodNumber;
+        ports: z.ZodArray<z.ZodObject<{
+            loadType: z.ZodNativeEnum<typeof DeviceType>;
+            curMode: z.ZodNativeEnum<typeof DeviceMode>;
+            port: z.ZodNumber;
+            speak: z.ZodNumber;
+            portName: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            loadType: DeviceType;
+            curMode: DeviceMode;
+            port: number;
+            speak: number;
+            portName: string;
+        }, {
+            loadType: DeviceType;
+            curMode: DeviceMode;
+            port: number;
+            speak: number;
+            portName: string;
+        }>, "many">;
+        vpdnums: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        temperature: number;
+        humidity: number;
+        ports: {
+            loadType: DeviceType;
+            curMode: DeviceMode;
+            port: number;
+            speak: number;
+            portName: string;
+        }[];
+        vpdnums: number;
+    }, {
+        temperature: number;
+        humidity: number;
+        ports: {
+            loadType: DeviceType;
+            curMode: DeviceMode;
+            port: number;
+            speak: number;
+            portName: string;
+        }[];
+        vpdnums: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    devId: string;
+    devCode: string;
+    devName: string;
+    devType: ControllerDeviceType;
+    devPortCount: number;
+    devVersion: number;
+    online: boolean;
+    firmwareVersion: string;
+    hardwareVersion: string;
+    deviceInfo: {
+        temperature: number;
+        humidity: number;
+        ports: {
+            loadType: DeviceType;
+            curMode: DeviceMode;
+            port: number;
+            speak: number;
+            portName: string;
+        }[];
+        vpdnums: number;
+    };
+}, {
+    devId: string;
+    devCode: string;
+    devName: string;
+    devType: ControllerDeviceType;
+    devPortCount: number;
+    devVersion: number;
+    online: boolean;
+    firmwareVersion: string;
+    hardwareVersion: string;
+    deviceInfo: {
+        temperature: number;
+        humidity: number;
+        ports: {
+            loadType: DeviceType;
+            curMode: DeviceMode;
+            port: number;
+            speak: number;
+            portName: string;
+        }[];
+        vpdnums: number;
+    };
+}>;
+export type Controller = z.infer<typeof ControllerSchema>;
+export {};
+//# 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;AACxB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAElD,aAAK,oBAAoB;IACvB,qBAAqB,KAAK;IAC1B,0BAA0B,KAAK;CAChC;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/build/src/types/Controller.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerSchema = exports.ControllerDeviceInfoSchema = exports.ControllerPortSchema = 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 || (ControllerDeviceType = {}));
+exports.ControllerPortSchema = zod_1.z.object({
+    loadType: zod_1.z.nativeEnum(Device_1.DeviceType),
+    curMode: zod_1.z.nativeEnum(Device_1.DeviceMode),
+    port: zod_1.z.number().positive(),
+    speak: zod_1.z.number(),
+    portName: zod_1.z.string(),
+});
+exports.ControllerDeviceInfoSchema = zod_1.z.object({
+    temperature: zod_1.z.number(),
+    humidity: zod_1.z.number(),
+    ports: zod_1.z.array(exports.ControllerPortSchema),
+    vpdnums: zod_1.z.number(),
+});
+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.nativeEnum(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,
+});

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

@@ -0,0 +1,24 @@
+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.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type DeviceSettings = z.infer<typeof DeviceSettingsSchema>;
+export declare const DeviceModeSettingsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type DeviceModeSettings = z.infer<typeof DeviceModeSettingsSchema>;
+//# 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,YAAY,IAAI;IAChB,YAAY,IAAI;IAChB,cAAc,IAAI;IAClB,QAAQ,IAAI;IACZ,eAAe,IAAI;IACnB,KAAK,IAAI;CACV;AAED,oBAAY,UAAU;IACpB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,MAAM,IAAI;IACV,aAAa,IAAI;IACjB,cAAc,IAAI;IAClB,OAAO,IAAI;IACX,UAAU,IAAI;IACd,KAAK,IAAI;CACV;AAED,eAAO,MAAM,oBAAoB,gDAAe,CAAC;AACjD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,wBAAwB,gDAAe,CAAC;AACrD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/build/src/types/Device.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceModeSettingsSchema = exports.DeviceSettingsSchema = exports.DeviceMode = exports.DeviceType = void 0;
+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 = {}));
+exports.DeviceSettingsSchema = zod_1.z.object({});
+exports.DeviceModeSettingsSchema = zod_1.z.object({});

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const UserSchema: z.ZodObject<{
+    appId: z.ZodString;
+    nickName: z.ZodString;
+    appEmail: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appId: string;
+    nickName: string;
+    appEmail: 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;;;;;;;;;;;;EAIrB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/build/src/types/User.js

@@ -0,0 +1,9 @@
+"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.string().email(),
+});

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

@@ -0,0 +1,4 @@
+export * from './Controller';
+export * from './Device';
+export * 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,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC"}

package/build/src/types/index.js

@@ -0,0 +1,19 @@
+"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("./Controller"), exports);
+__exportStar(require("./Device"), exports);
+__exportStar(require("./User"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jakobgoerke/ac-infinity-client",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "main": "./build/src",
   "types": "./build/src/index.d.ts",
   "repository": "git@github.com:jakobgoerke/ac-infinity-client.git",