@kohost/api-client 3.0.0-beta.20 → 3.0.0-beta.22

package/dist/cjs/defs.js

@@ -14,11 +14,10 @@ var require_deviceTypes = __commonJS({
       "thermostat",
       "lock",
       "windowCovering",
-      "sceneController",
       "courtesy",
       "alarm",
       "camera",
-      "source",
+      "mediaSource",
       "motionSensor"
     ];
     module2.exports = types;
@@ -52,6 +51,7 @@ var require_Client = __commonJS({
       constructor(options = {
         url: "",
         propertyId: "",
+        organizationId: "",
         apiKey: "",
         headers: {}
       }) {
@@ -120,7 +120,7 @@ var require_Client = __commonJS({
             this._onLoginRequired();
             return Promise.reject(error);
           }
-          if (expectedError && errorMessage === "No token provided") {
+          if (expectedError && errorMessage === "No auth header or cookie provided") {
             this._onLoginRequired();
             return Promise.reject(error);
           }

package/dist/cjs/index.cjs.js

@@ -6,6 +6,7 @@ const defs = require("./defs");
 const utils = require("./utils");
 const Client = require("./Client");
 const SocketIoClient = require("./SocketIoClient");
+const AMQPClient = require("./AMQPClient");
 const Kohost = {
   Models,
   Errors,
@@ -13,6 +14,7 @@ const Kohost = {
   Events,
   Client,
   SocketIoClient,
+  AMQPClient,
   defs,
   utils
 };

package/dist/cjs/utils.js

@@ -25,11 +25,10 @@ var require_deviceTypes = __commonJS({
       "thermostat",
       "lock",
       "windowCovering",
-      "sceneController",
       "courtesy",
       "alarm",
       "camera",
-      "source",
+      "mediaSource",
       "motionSensor"
     ];
     module2.exports = types;
@@ -53,10 +52,13 @@ var require_common = __commonJS({
   "src/schemas/definitions/common.json"(exports2, module2) {
     module2.exports = {
       $schema: "http://json-schema.org/draft-07/schema",
-      $id: "https://api.kohost.app/schemas/v3/definitions/common.json",
+      $id: "https://api.kohost.io/schemas/v3/definitions/common.json",
       definitions: {
         id: {
-          type: "string"
+          type: "string",
+          not: {
+            enum: ["global", "system"]
+          }
         },
         systemData: {
           type: "object",
@@ -122,6 +124,28 @@ var require_common = __commonJS({
               maxLength: 2
             }
           }
+        },
+        driver: {
+          type: "string",
+          enum: [
+            "aws-kinesis",
+            "butler",
+            "crestron",
+            "ecobee",
+            "igor",
+            "kohost-k7",
+            "kohost-pms",
+            "lirc",
+            "mews",
+            "pelican-wireless",
+            "rebrandly",
+            "salto",
+            "salto-irn",
+            "se",
+            "sendgrid",
+            "stay-n-touch",
+            "twilio"
+          ]
         }
       }
     };
@@ -133,13 +157,13 @@ var require_device = __commonJS({
   "src/schemas/definitions/device.json"(exports2, module2) {
     module2.exports = {
       $schema: "http://json-schema.org/draft-07/schema",
-      $id: "https://api.kohost.app/schemas/v3/definitions/device.json",
+      $id: "https://api.kohost.io/schemas/v3/definitions/device.json",
       definitions: {
         id: {
-          $ref: "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/id"
+          $ref: "https://api.kohost.io/schemas/v3/definitions/common.json#/definitions/id"
         },
         systemData: {
-          $ref: "https://api.kohost.app/schemas/v3/definitions/common.json#/definitions/systemData"
+          $ref: "https://api.kohost.io/schemas/v3/definitions/common.json#/definitions/systemData"
         },
         type: {
           type: "string",
@@ -239,12 +263,223 @@ var require_schema = __commonJS({
   }
 });
 
+// src/Errors/AppError.js
+var require_AppError = __commonJS({
+  "src/Errors/AppError.js"(exports2, module2) {
+    module2.exports = /* @__PURE__ */ __name(class AppError extends Error {
+      constructor(message = "Internal Server Error", options) {
+        super(message, options);
+        this.type = this.constructor.name;
+        this.statusCode = 500;
+        Object.setPrototypeOf(this, AppError.prototype);
+      }
+    }, "AppError");
+  }
+});
+
+// src/Errors/AuthenticationError.js
+var require_AuthenticationError = __commonJS({
+  "src/Errors/AuthenticationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class AuthenticationError extends AppError {
+      constructor(message = "Authentication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+      }
+    }, "AuthenticationError");
+  }
+});
+
+// src/Errors/AuthorizationError.js
+var require_AuthorizationError = __commonJS({
+  "src/Errors/AuthorizationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class AuthorizationError extends AppError {
+      constructor(message = "Authorization Error", options = {}) {
+        super(message, options);
+        this.statusCode = 403;
+        Object.setPrototypeOf(this, AuthorizationError.prototype);
+      }
+    }, "AuthorizationError");
+  }
+});
+
+// src/Errors/DeviceCommError.js
+var require_DeviceCommError = __commonJS({
+  "src/Errors/DeviceCommError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class DeviceCommError extends AppError {
+      constructor(message = "Device Communication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 503;
+        Object.setPrototypeOf(this, DeviceCommError.prototype);
+      }
+    }, "DeviceCommError");
+  }
+});
+
+// src/Errors/LoginError.js
+var require_LoginError = __commonJS({
+  "src/Errors/LoginError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class LoginError extends AppError {
+      constructor(message = "Invalid Login information provided", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, LoginError.prototype);
+      }
+    }, "LoginError");
+  }
+});
+
+// src/Errors/NotFoundError.js
+var require_NotFoundError = __commonJS({
+  "src/Errors/NotFoundError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class NotFoundError extends AppError {
+      constructor(message = "Resource Not Found", options = {}) {
+        super(message, options);
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+      }
+    }, "NotFoundError");
+  }
+});
+
+// src/Errors/RequestError.js
+var require_RequestError = __commonJS({
+  "src/Errors/RequestError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class RequestError extends AppError {
+      constructor(message = "Bad Request", options = {}) {
+        super(message, options);
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, RequestError.prototype);
+      }
+    }, "RequestError");
+  }
+});
+
+// src/Errors/SystemCommError.js
+var require_SystemCommError = __commonJS({
+  "src/Errors/SystemCommError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class SystemCommError extends AppError {
+      constructor(message = "System Communication Error", options = {}) {
+        super(message, options);
+        this.statusCode = 503;
+        Object.setPrototypeOf(this, SystemCommError.prototype);
+      }
+    }, "SystemCommError");
+  }
+});
+
+// src/Errors/TokenExpiredError.js
+var require_TokenExpiredError = __commonJS({
+  "src/Errors/TokenExpiredError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class TokenExpiredError extends AppError {
+      constructor(message = "Token Expired", options = {}) {
+        super(message, options);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, TokenExpiredError.prototype);
+      }
+    }, "TokenExpiredError");
+  }
+});
+
+// src/Errors/UnprocessableRequestError.js
+var require_UnprocessableRequestError = __commonJS({
+  "src/Errors/UnprocessableRequestError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class UnprocessableRequestError extends AppError {
+      constructor(message = "Unprocessable Request Error", options = {}) {
+        super(message, options);
+        this.statusCode = 422;
+        Object.setPrototypeOf(this, UnprocessableRequestError.prototype);
+      }
+    }, "UnprocessableRequestError");
+  }
+});
+
+// src/Errors/ValidationError.js
+var require_ValidationError = __commonJS({
+  "src/Errors/ValidationError.js"(exports2, module2) {
+    var AppError = require_AppError();
+    module2.exports = /* @__PURE__ */ __name(class ValidationError extends AppError {
+      constructor(message = "Validation Error", options = {}) {
+        super(message, options);
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, ValidationError.prototype);
+      }
+    }, "ValidationError");
+  }
+});
+
+// src/Errors/index.js
+var require_Errors = __commonJS({
+  "src/Errors/index.js"(exports2, module2) {
+    var Errors = {
+      AppError: require_AppError(),
+      AuthenticationError: require_AuthenticationError(),
+      AuthorizationError: require_AuthorizationError(),
+      DeviceCommError: require_DeviceCommError(),
+      LoginError: require_LoginError(),
+      NotFoundError: require_NotFoundError(),
+      RequestError: require_RequestError(),
+      SystemCommError: require_SystemCommError(),
+      TokenExpiredError: require_TokenExpiredError(),
+      UnprocessableRequestError: require_UnprocessableRequestError(),
+      ValidationError: require_ValidationError()
+    };
+    module2.exports = Errors;
+  }
+});
+
+// src/utils/errorFactory.js
+var require_errorFactory = __commonJS({
+  "src/utils/errorFactory.js"(exports2, module2) {
+    var Errors = require_Errors();
+    module2.exports = /* @__PURE__ */ __name(function errorFactory2(err) {
+      switch (err.type) {
+        case "AppError":
+          return new Errors.AppError(err.message);
+        case "AuthenticationError":
+          return new Errors.AuthenticationError(err.message);
+        case "AuthorizationError":
+          return new Errors.AuthorizationError(err.message);
+        case "DeviceCommError":
+          return new Errors.DeviceCommError(err.message);
+        case "LoginError":
+          return new Errors.LoginError(err.message);
+        case "NotFoundError":
+          return new Errors.NotFoundError(err.message);
+        case "RequestError":
+          return new Errors.RequestError(err.message);
+        case "SystemCommError":
+          return new Errors.SystemCommError(err.message);
+        case "TokenExpiredError":
+          return new Errors.TokenExpiredError(err.message);
+        case "UnprocessableRequestError":
+          return new Errors.UnprocessableRequestError(err.message);
+        case "ValidationError":
+          return new Errors.ValidationError(err.message);
+        default:
+          return new Error(err.message);
+      }
+    }, "errorFactory");
+  }
+});
+
 // src/utils/index.js
 var getFormalDeviceType = require_getFormalDeviceType();
 var getDeviceTypes = require_getDeviceTypes();
 var schema = require_schema();
+var errorFactory = require_errorFactory();
 module.exports = {
   getFormalDeviceType,
   getDeviceTypes,
-  schema
+  schema,
+  errorFactory
 };

package/dist/esm/Client.js

@@ -5390,8 +5390,9 @@ var require_axios = __commonJS({
     var isFileList = kindOfTest("FileList");
     var isStream = /* @__PURE__ */ __name((val) => isObject(val) && isFunction(val.pipe), "isStream");
     var isFormData = /* @__PURE__ */ __name((thing) => {
-      const pattern = "[object FormData]";
-      return thing && (typeof FormData === "function" && thing instanceof FormData || toString.call(thing) === pattern || isFunction(thing.toString) && thing.toString() === pattern);
+      let kind;
+      return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || // detect form-data instance
+      kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]"));
     }, "isFormData");
     var isURLSearchParams = kindOfTest("URLSearchParams");
     var trim = /* @__PURE__ */ __name((str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ""), "trim");
@@ -6286,10 +6287,7 @@ var require_axios = __commonJS({
       return tokens;
     }
     __name(parseTokens, "parseTokens");
-    function isValidHeaderName(str) {
-      return /^[-_a-zA-Z]+$/.test(str.trim());
-    }
-    __name(isValidHeaderName, "isValidHeaderName");
+    var isValidHeaderName = /* @__PURE__ */ __name((str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim()), "isValidHeaderName");
     function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
       if (utils.isFunction(filter)) {
         return filter.call(this, value, header);
@@ -6995,7 +6993,7 @@ var require_axios = __commonJS({
       return config;
     }
     __name(mergeConfig, "mergeConfig");
-    var VERSION = "1.3.4";
+    var VERSION = "1.3.6";
     var validators$1 = {};
     ["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
       validators$1[type] = /* @__PURE__ */ __name(function validator2(thing) {
@@ -7087,11 +7085,17 @@ var require_axios = __commonJS({
             clarifyTimeoutError: validators.transitional(validators.boolean)
           }, false);
         }
-        if (paramsSerializer !== void 0) {
-          validator.assertOptions(paramsSerializer, {
-            encode: validators.function,
-            serialize: validators.function
-          }, true);
+        if (paramsSerializer != null) {
+          if (utils.isFunction(paramsSerializer)) {
+            config.paramsSerializer = {
+              serialize: paramsSerializer
+            };
+          } else {
+            validator.assertOptions(paramsSerializer, {
+              encode: validators.function,
+              serialize: validators.function
+            }, true);
+          }
         }
         config.method = (config.method || this.defaults.method || "get").toLowerCase();
         let contextHeaders;
@@ -7540,6 +7544,7 @@ var require_Client = __commonJS({
       constructor(options = {
         url: "",
         propertyId: "",
+        organizationId: "",
         apiKey: "",
         headers: {}
       }) {
@@ -7606,7 +7611,7 @@ var require_Client = __commonJS({
             this._onLoginRequired();
             return Promise.reject(error);
           }
-          if (expectedError && errorMessage === "No token provided") {
+          if (expectedError && errorMessage === "No auth header or cookie provided") {
             this._onLoginRequired();
             return Promise.reject(error);
           }