@kohost/api-client 3.0.0-beta.7 → 3.0.0-beta.71

package/dist/esm/Commands.js

@@ -9,6 +9,9 @@ var __commonJS = (cb, mod) => function __require() {
 var require_Command = __commonJS({
   "src/Commands/Command.js"(exports, module) {
     var Command = class {
+      static {
+        __name(this, "Command");
+      }
       constructor(data) {
         this.data = {};
         if (!data)
@@ -31,23 +34,44 @@ var require_Command = __commonJS({
       get exchange() {
         return "Commands";
       }
-      get replyTo() {
-        return "amq.rabbitmq.reply-to";
-      }
       build() {
         return { data: { ...this.data } };
       }
     };
-    __name(Command, "Command");
     module.exports = Command;
   }
 });
 
+// src/Commands/SetSceneCommand.js
+var require_SetSceneCommand = __commonJS({
+  "src/Commands/SetSceneCommand.js"(exports, module) {
+    var Command = require_Command();
+    var SetSceneCommand = class extends Command {
+      static {
+        __name(this, "SetSceneCommand");
+      }
+      constructor({ id, devices, ...rest }) {
+        super({ id, devices, ...rest });
+      }
+      get name() {
+        return "SetScene";
+      }
+      get routingKey() {
+        return `scene.${this.data.id}.set`;
+      }
+    };
+    module.exports = SetSceneCommand;
+  }
+});
+
 // src/Commands/SetAlarmCommand.js
 var require_SetAlarmCommand = __commonJS({
   "src/Commands/SetAlarmCommand.js"(exports, module) {
     var Command = require_Command();
     var SetAlarmCommand = class extends Command {
+      static {
+        __name(this, "SetAlarmCommand");
+      }
       constructor({ id, zones, areas }) {
         super({ id, zones, areas });
       }
@@ -57,11 +81,7 @@ var require_SetAlarmCommand = __commonJS({
       get routingKey() {
         return `alarm.${this.data.id}.set`;
       }
-      get replyTo() {
-        return "system.response.devices";
-      }
     };
-    __name(SetAlarmCommand, "SetAlarmCommand");
     module.exports = SetAlarmCommand;
   }
 });
@@ -71,6 +91,9 @@ var require_SetDimmerCommand = __commonJS({
   "src/Commands/SetDimmerCommand.js"(exports, module) {
     var Command = require_Command();
     var SetDimmerCommand = class extends Command {
+      static {
+        __name(this, "SetDimmerCommand");
+      }
       constructor({ id, level }) {
         super({ id, level });
       }
@@ -80,11 +103,7 @@ var require_SetDimmerCommand = __commonJS({
       get routingKey() {
         return `dimmer.${this.data.id}.set`;
       }
-      get replyTo() {
-        return "system.response.devices";
-      }
     };
-    __name(SetDimmerCommand, "SetDimmerCommand");
     module.exports = SetDimmerCommand;
   }
 });
@@ -94,6 +113,9 @@ var require_SetSwitchCommand = __commonJS({
   "src/Commands/SetSwitchCommand.js"(exports, module) {
     var Command = require_Command();
     var SetSwitchCommand = class extends Command {
+      static {
+        __name(this, "SetSwitchCommand");
+      }
       constructor({ id, state }) {
         super({ id, state });
       }
@@ -103,11 +125,7 @@ var require_SetSwitchCommand = __commonJS({
       get routingKey() {
         return `switch.${this.data.id}.set`;
       }
-      get replyTo() {
-        return "system.response.devices";
-      }
     };
-    __name(SetSwitchCommand, "SetSwitchCommand");
     module.exports = SetSwitchCommand;
   }
 });
@@ -117,6 +135,9 @@ var require_SetThermostatCommand = __commonJS({
   "src/Commands/SetThermostatCommand.js"(exports, module) {
     var Command = require_Command();
     var SetThermostatCommand = class extends Command {
+      static {
+        __name(this, "SetThermostatCommand");
+      }
       constructor({ id, setpoints, hvacMode, fanMode }) {
         super({ id, setpoints, hvacMode, fanMode });
       }
@@ -126,11 +147,7 @@ var require_SetThermostatCommand = __commonJS({
       get routingKey() {
         return `thermostat.${this.data.id}.set`;
       }
-      get replyTo() {
-        return "system.response.devices";
-      }
     };
-    __name(SetThermostatCommand, "SetThermostatCommand");
     module.exports = SetThermostatCommand;
   }
 });
@@ -140,6 +157,9 @@ var require_SetLockCommand = __commonJS({
   "src/Commands/SetLockCommand.js"(exports, module) {
     var Command = require_Command();
     var SetLockCommand = class extends Command {
+      static {
+        __name(this, "SetLockCommand");
+      }
       constructor({ id, state }) {
         super({ id, state });
       }
@@ -149,43 +169,19 @@ var require_SetLockCommand = __commonJS({
       get routingKey() {
         return `lock.${this.data.id}.set`;
       }
-      get replyTo() {
-        return "system.response.devices";
-      }
     };
-    __name(SetLockCommand, "SetLockCommand");
     module.exports = SetLockCommand;
   }
 });
 
-// src/Commands/SetSceneControllerCommand.js
-var require_SetSceneControllerCommand = __commonJS({
-  "src/Commands/SetSceneControllerCommand.js"(exports, module) {
-    var Command = require_Command();
-    var SetSceneControllerCommand = class extends Command {
-      constructor({ id, scene }) {
-        super({ id, scene });
-      }
-      get name() {
-        return "SetSceneController";
-      }
-      get routingKey() {
-        return `sceneController.${this.data.id}.set`;
-      }
-      get replyTo() {
-        return "system.response.devices";
-      }
-    };
-    __name(SetSceneControllerCommand, "SetSceneControllerCommand");
-    module.exports = SetSceneControllerCommand;
-  }
-});
-
 // src/Commands/SetWindowCoveringCommand.js
 var require_SetWindowCoveringCommand = __commonJS({
   "src/Commands/SetWindowCoveringCommand.js"(exports, module) {
     var Command = require_Command();
     var SetWindowCoveringCommand = class extends Command {
+      static {
+        __name(this, "SetWindowCoveringCommand");
+      }
       constructor({ id, position }) {
         super({ id, position });
       }
@@ -195,11 +191,7 @@ var require_SetWindowCoveringCommand = __commonJS({
       get routingKey() {
         return `windowCovering.${this.data.id}.set`;
       }
-      get replyTo() {
-        return "system.response.devices";
-      }
     };
-    __name(SetWindowCoveringCommand, "SetWindowCoveringCommand");
     module.exports = SetWindowCoveringCommand;
   }
 });
@@ -209,6 +201,9 @@ var require_SetCourtesyCommand = __commonJS({
   "src/Commands/SetCourtesyCommand.js"(exports, module) {
     var Command = require_Command();
     var SetCourtesyCommand = class extends Command {
+      static {
+        __name(this, "SetCourtesyCommand");
+      }
       constructor({ id, state }) {
         super({ id, state });
       }
@@ -218,34 +213,55 @@ var require_SetCourtesyCommand = __commonJS({
       get routingKey() {
         return `courtesy.${this.data.id}.set`;
       }
-      get replyTo() {
-        return "system.response.devices";
-      }
     };
-    __name(SetCourtesyCommand, "SetCourtesyCommand");
     module.exports = SetCourtesyCommand;
   }
 });
 
+// src/Commands/SetMediaCommand.js
+var require_SetMediaCommand = __commonJS({
+  "src/Commands/SetMediaCommand.js"(exports, module) {
+    var Command = require_Command();
+    var SetMediaCommand = class extends Command {
+      static {
+        __name(this, "SetMediaCommand");
+      }
+      constructor({ id, command, ...rest }) {
+        super({ id, command, ...rest });
+      }
+      get name() {
+        return "SetMedia";
+      }
+      get routingKey() {
+        return `mediaSource.${this.data.id}.set`;
+      }
+    };
+    module.exports = SetMediaCommand;
+  }
+});
+
 // src/Commands/DiscoverUsersCommand.js
 var require_DiscoverUsersCommand = __commonJS({
   "src/Commands/DiscoverUsersCommand.js"(exports, module) {
     var Command = require_Command();
     var DiscoverUsersCommand = class extends Command {
-      constructor({ id }) {
-        super({ id });
+      static {
+        __name(this, "DiscoverUsersCommand");
+      }
+      constructor({ id, ...rest }) {
+        super({ id, ...rest });
       }
       get name() {
         return "DiscoverUsers";
       }
       get routingKey() {
-        return `users.${this.data.id}.get`;
-      }
-      get replyTo() {
-        return "system.response.users";
+        if (typeof this.data.id === "string")
+          return `users.${this.data.id}.get`;
+        if (Array.isArray(this.data.id))
+          return "users.batch.get";
+        return "users.get";
       }
     };
-    __name(DiscoverUsersCommand, "DiscoverUsersCommand");
     module.exports = DiscoverUsersCommand;
   }
 });
@@ -253,14 +269,17 @@ var require_DiscoverUsersCommand = __commonJS({
 // src/Errors/AppError.js
 var require_AppError = __commonJS({
   "src/Errors/AppError.js"(exports, module) {
-    module.exports = /* @__PURE__ */ __name(class AppError extends Error {
+    module.exports = class AppError extends Error {
+      static {
+        __name(this, "AppError");
+      }
       constructor(message = "Internal Server Error", options) {
         super(message, options);
         this.type = this.constructor.name;
         this.statusCode = 500;
         Object.setPrototypeOf(this, AppError.prototype);
       }
-    }, "AppError");
+    };
   }
 });
 
@@ -268,13 +287,16 @@ var require_AppError = __commonJS({
 var require_RequestError = __commonJS({
   "src/Errors/RequestError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class RequestError extends AppError {
+    module.exports = class RequestError extends AppError {
+      static {
+        __name(this, "RequestError");
+      }
       constructor(message = "Bad Request", options = {}) {
         super(message, options);
         this.statusCode = 400;
         Object.setPrototypeOf(this, RequestError.prototype);
       }
-    }, "RequestError");
+    };
   }
 });
 
@@ -284,9 +306,10 @@ var require_OCRDocumentCommand = __commonJS({
     var Command = require_Command();
     var RequestError = require_RequestError();
     var OCRDocumentCommand = class extends Command {
+      static {
+        __name(this, "OCRDocumentCommand");
+      }
       constructor({ type, image }) {
-        if (!type)
-          throw new RequestError("document type is required");
         if (!image)
           throw new RequestError("document image is required");
         super({ type, image });
@@ -294,11 +317,7 @@ var require_OCRDocumentCommand = __commonJS({
       get name() {
         return "OCRDocument";
       }
-      get routingKey() {
-        return `document.${this.data.type}.ocr`;
-      }
     };
-    __name(OCRDocumentCommand, "OCRDocumentCommand");
     module.exports = OCRDocumentCommand;
   }
 });
@@ -309,6 +328,9 @@ var require_CheckInReservationCommand = __commonJS({
     var Command = require_Command();
     var RequestError = require_RequestError();
     var CheckInReservationCommand = class extends Command {
+      static {
+        __name(this, "CheckInReservationCommand");
+      }
       constructor({ id }) {
         if (!id)
           throw new RequestError("document type is required");
@@ -320,29 +342,59 @@ var require_CheckInReservationCommand = __commonJS({
       get routingKey() {
         return `reservation.${this.data.id}.checkin`;
       }
-      get replyTo() {
-        return "system.response.reservations";
-      }
     };
-    __name(CheckInReservationCommand, "CheckInReservationCommand");
     module.exports = CheckInReservationCommand;
   }
 });
 
+// src/Commands/SendEmailCommand.js
+var require_SendEmailCommand = __commonJS({
+  "src/Commands/SendEmailCommand.js"(exports, module) {
+    var Command = require_Command();
+    var RequestError = require_RequestError();
+    var SendEmailCommand = class extends Command {
+      static {
+        __name(this, "SendEmailCommand");
+      }
+      constructor({ text, html, to, from, subject, ...rest }) {
+        if (!to)
+          throw new RequestError("email to is required");
+        if (!from)
+          throw new RequestError("email from is required");
+        if (!subject)
+          throw new RequestError("email subject is required");
+        if (!text && !html)
+          throw new RequestError("email text or html is required");
+        super({ text, html, to, from, subject, ...rest });
+      }
+      get name() {
+        return "SendEmail";
+      }
+      get routingKey() {
+        return "comm.email.send";
+      }
+    };
+    module.exports = SendEmailCommand;
+  }
+});
+
 // src/Commands/SendSMSCommand.js
 var require_SendSMSCommand = __commonJS({
   "src/Commands/SendSMSCommand.js"(exports, module) {
     var Command = require_Command();
     var RequestError = require_RequestError();
     var SendSMSCommand = class extends Command {
-      constructor({ body, to, from, metaData }) {
+      static {
+        __name(this, "SendSMSCommand");
+      }
+      constructor({ id, body, to, from, ...rest }) {
         if (!body)
           throw new RequestError("sms body is required");
         if (!to)
           throw new RequestError("sms to is required");
         if (!from)
           throw new RequestError("sms from is required");
-        super({ body, to, from, metaData });
+        super({ id, body, to, from, ...rest });
       }
       get name() {
         return "SendSMS";
@@ -351,7 +403,6 @@ var require_SendSMSCommand = __commonJS({
         return "comm.sms.send";
       }
     };
-    __name(SendSMSCommand, "SendSMSCommand");
     module.exports = SendSMSCommand;
   }
 });
@@ -360,13 +411,16 @@ var require_SendSMSCommand = __commonJS({
 var require_AuthenticationError = __commonJS({
   "src/Errors/AuthenticationError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class AuthenticationError extends AppError {
+    module.exports = class AuthenticationError extends AppError {
+      static {
+        __name(this, "AuthenticationError");
+      }
       constructor(message = "Authentication Error", options = {}) {
         super(message, options);
         this.statusCode = 401;
         Object.setPrototypeOf(this, AuthenticationError.prototype);
       }
-    }, "AuthenticationError");
+    };
   }
 });
 
@@ -374,13 +428,33 @@ var require_AuthenticationError = __commonJS({
 var require_AuthorizationError = __commonJS({
   "src/Errors/AuthorizationError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class AuthorizationError extends AppError {
+    module.exports = class AuthorizationError extends AppError {
+      static {
+        __name(this, "AuthorizationError");
+      }
       constructor(message = "Authorization Error", options = {}) {
         super(message, options);
         this.statusCode = 403;
         Object.setPrototypeOf(this, AuthorizationError.prototype);
       }
-    }, "AuthorizationError");
+    };
+  }
+});
+
+// src/Errors/ConflictError.js
+var require_ConflictError = __commonJS({
+  "src/Errors/ConflictError.js"(exports, module) {
+    var AppError = require_AppError();
+    module.exports = class ConflictError extends AppError {
+      static {
+        __name(this, "ConflictError");
+      }
+      constructor(message = "Bad Request", options = {}) {
+        super(message, options);
+        this.statusCode = 409;
+        Object.setPrototypeOf(this, ConflictError.prototype);
+      }
+    };
   }
 });
 
@@ -388,13 +462,16 @@ var require_AuthorizationError = __commonJS({
 var require_DeviceCommError = __commonJS({
   "src/Errors/DeviceCommError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class DeviceCommError extends AppError {
+    module.exports = class DeviceCommError extends AppError {
+      static {
+        __name(this, "DeviceCommError");
+      }
       constructor(message = "Device Communication Error", options = {}) {
         super(message, options);
         this.statusCode = 503;
         Object.setPrototypeOf(this, DeviceCommError.prototype);
       }
-    }, "DeviceCommError");
+    };
   }
 });
 
@@ -402,13 +479,16 @@ var require_DeviceCommError = __commonJS({
 var require_LoginError = __commonJS({
   "src/Errors/LoginError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class LoginError extends AppError {
+    module.exports = class LoginError extends AppError {
+      static {
+        __name(this, "LoginError");
+      }
       constructor(message = "Invalid Login information provided", options = {}) {
         super(message, options);
         this.statusCode = 401;
         Object.setPrototypeOf(this, LoginError.prototype);
       }
-    }, "LoginError");
+    };
   }
 });
 
@@ -416,13 +496,16 @@ var require_LoginError = __commonJS({
 var require_NotFoundError = __commonJS({
   "src/Errors/NotFoundError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class NotFoundError extends AppError {
+    module.exports = class NotFoundError extends AppError {
+      static {
+        __name(this, "NotFoundError");
+      }
       constructor(message = "Resource Not Found", options = {}) {
         super(message, options);
         this.statusCode = 404;
         Object.setPrototypeOf(this, NotFoundError.prototype);
       }
-    }, "NotFoundError");
+    };
   }
 });
 
@@ -430,13 +513,16 @@ var require_NotFoundError = __commonJS({
 var require_SystemCommError = __commonJS({
   "src/Errors/SystemCommError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class SystemCommError extends AppError {
+    module.exports = class SystemCommError extends AppError {
+      static {
+        __name(this, "SystemCommError");
+      }
       constructor(message = "System Communication Error", options = {}) {
         super(message, options);
         this.statusCode = 503;
         Object.setPrototypeOf(this, SystemCommError.prototype);
       }
-    }, "SystemCommError");
+    };
   }
 });
 
@@ -444,13 +530,16 @@ var require_SystemCommError = __commonJS({
 var require_TokenExpiredError = __commonJS({
   "src/Errors/TokenExpiredError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class TokenExpiredError extends AppError {
+    module.exports = class TokenExpiredError extends AppError {
+      static {
+        __name(this, "TokenExpiredError");
+      }
       constructor(message = "Token Expired", options = {}) {
         super(message, options);
         this.statusCode = 401;
         Object.setPrototypeOf(this, TokenExpiredError.prototype);
       }
-    }, "TokenExpiredError");
+    };
   }
 });
 
@@ -458,13 +547,16 @@ var require_TokenExpiredError = __commonJS({
 var require_UnprocessableRequestError = __commonJS({
   "src/Errors/UnprocessableRequestError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class UnprocessableRequestError extends AppError {
+    module.exports = class UnprocessableRequestError extends AppError {
+      static {
+        __name(this, "UnprocessableRequestError");
+      }
       constructor(message = "Unprocessable Request Error", options = {}) {
         super(message, options);
         this.statusCode = 422;
         Object.setPrototypeOf(this, UnprocessableRequestError.prototype);
       }
-    }, "UnprocessableRequestError");
+    };
   }
 });
 
@@ -472,13 +564,16 @@ var require_UnprocessableRequestError = __commonJS({
 var require_ValidationError = __commonJS({
   "src/Errors/ValidationError.js"(exports, module) {
     var AppError = require_AppError();
-    module.exports = /* @__PURE__ */ __name(class ValidationError extends AppError {
+    module.exports = class ValidationError extends AppError {
+      static {
+        __name(this, "ValidationError");
+      }
       constructor(message = "Validation Error", options = {}) {
         super(message, options);
         this.statusCode = 400;
         Object.setPrototypeOf(this, ValidationError.prototype);
       }
-    }, "ValidationError");
+    };
   }
 });
 
@@ -489,6 +584,7 @@ var require_Errors = __commonJS({
       AppError: require_AppError(),
       AuthenticationError: require_AuthenticationError(),
       AuthorizationError: require_AuthorizationError(),
+      ConflictError: require_ConflictError(),
       DeviceCommError: require_DeviceCommError(),
       LoginError: require_LoginError(),
       NotFoundError: require_NotFoundError(),
@@ -508,11 +604,14 @@ var require_DiscoverReservationsCommand = __commonJS({
     var { RequestError } = require_Errors();
     var Command = require_Command();
     var DiscoverReservationsCommand = class extends Command {
+      static {
+        __name(this, "DiscoverReservationsCommand");
+      }
       constructor(options) {
         if (!options)
           throw new RequestError("options are required");
-        const { id, startDate, endDate, status } = options;
-        super({ id, startDate, endDate, status });
+        const { id, startDate, endDate, status, ...rest } = options;
+        super({ id, startDate, endDate, status, ...rest });
       }
       get name() {
         return "DiscoverReservations";
@@ -520,70 +619,379 @@ var require_DiscoverReservationsCommand = __commonJS({
       get routingKey() {
         return "reservation.discover";
       }
-      get replyTo() {
-        return "system.response.reservations";
-      }
     };
-    __name(DiscoverReservationsCommand, "DiscoverReservationsCommand");
     module.exports = DiscoverReservationsCommand;
   }
 });
 
+// src/Commands/DiscoverReservationSpaceCategoryAvailabilitiesCommand.js
+var require_DiscoverReservationSpaceCategoryAvailabilitiesCommand = __commonJS({
+  "src/Commands/DiscoverReservationSpaceCategoryAvailabilitiesCommand.js"(exports, module) {
+    var { RequestError } = require_Errors();
+    var Command = require_Command();
+    var DiscoverReservationSpaceCategoryAvailabilitiesCommand = class extends Command {
+      static {
+        __name(this, "DiscoverReservationSpaceCategoryAvailabilitiesCommand");
+      }
+      constructor(options) {
+        if (!options)
+          throw new RequestError("options are required");
+        const { id, ...rest } = options;
+        super({ id, ...rest });
+      }
+      get name() {
+        return "DiscoverReservationSpaceCategoryAvailabilities";
+      }
+      get routingKey() {
+        return "reservation.discoverRoomUpsells";
+      }
+    };
+    module.exports = DiscoverReservationSpaceCategoryAvailabilitiesCommand;
+  }
+});
+
 // src/Commands/DiscoverRoomsCommand.js
 var require_DiscoverRoomsCommand = __commonJS({
   "src/Commands/DiscoverRoomsCommand.js"(exports, module) {
     var Command = require_Command();
     var DiscoverRoomsCommand = class extends Command {
-      constructor({ id }) {
-        super({ id });
+      static {
+        __name(this, "DiscoverRoomsCommand");
+      }
+      constructor({
+        id,
+        types,
+        categories,
+        startDate,
+        endDate,
+        serviceStatus,
+        housekeepingStatus,
+        ...rest
+      }) {
+        super({
+          id,
+          types,
+          categories,
+          startDate,
+          endDate,
+          serviceStatus,
+          housekeepingStatus,
+          ...rest
+        });
       }
       get name() {
         return "DiscoverRooms";
       }
       get routingKey() {
-        return `rooms.${this.data.id}.get`;
-      }
-      get replyTo() {
-        return "system.response.users";
+        if (typeof this.data.id === "string")
+          return `rooms.${this.data.id}.get`;
+        if (Array.isArray(this.data.id))
+          return "rooms.batch.get";
+        return "rooms.get";
       }
     };
-    __name(DiscoverRoomsCommand, "DiscoverRoomsCommand");
     module.exports = DiscoverRoomsCommand;
   }
 });
 
+// src/Commands/DiscoverCategoriesCommand.js
+var require_DiscoverCategoriesCommand = __commonJS({
+  "src/Commands/DiscoverCategoriesCommand.js"(exports, module) {
+    var Command = require_Command();
+    var DiscoverCategoriesCommand = class extends Command {
+      static {
+        __name(this, "DiscoverCategoriesCommand");
+      }
+      constructor({ id, ...rest }) {
+        super({ id, ...rest });
+      }
+      get name() {
+        return "DiscoverCategories";
+      }
+      get routingKey() {
+        if (typeof this.data.id === "string")
+          return `categories.${this.data.id}.get`;
+        if (Array.isArray(this.data.id))
+          return "categories.batch.get";
+        return "categories.get";
+      }
+    };
+    module.exports = DiscoverCategoriesCommand;
+  }
+});
+
+// src/Commands/CreateShortLinkCommand.js
+var require_CreateShortLinkCommand = __commonJS({
+  "src/Commands/CreateShortLinkCommand.js"(exports, module) {
+    var Command = require_Command();
+    var RequestError = require_RequestError();
+    var CreateShortLinkCommand = class extends Command {
+      static {
+        __name(this, "CreateShortLinkCommand");
+      }
+      constructor({ title, destination }) {
+        if (!title)
+          throw new RequestError("title is required");
+        if (!destination)
+          throw new RequestError("destination to is required");
+        super({ title, destination });
+      }
+      get name() {
+        return "CreateShortLink";
+      }
+      get routingKey() {
+        return "comm.shortlink.create";
+      }
+    };
+    module.exports = CreateShortLinkCommand;
+  }
+});
+
+// src/Commands/UpdateReservationCommand.js
+var require_UpdateReservationCommand = __commonJS({
+  "src/Commands/UpdateReservationCommand.js"(exports, module) {
+    var Command = require_Command();
+    var RequestError = require_RequestError();
+    var UpdateReservationCommand = class extends Command {
+      static {
+        __name(this, "UpdateReservationCommand");
+      }
+      constructor({ id, ...rest }) {
+        if (!id)
+          throw new RequestError("document type is required");
+        super({ id, ...rest });
+      }
+      get name() {
+        return "UpdateReservation";
+      }
+      get routingKey() {
+        return `reservation.${this.data.id}.update`;
+      }
+    };
+    module.exports = UpdateReservationCommand;
+  }
+});
+
+// src/Commands/UpdateUserCommand.js
+var require_UpdateUserCommand = __commonJS({
+  "src/Commands/UpdateUserCommand.js"(exports, module) {
+    var Command = require_Command();
+    var RequestError = require_RequestError();
+    var UpdateUserCommand = class extends Command {
+      static {
+        __name(this, "UpdateUserCommand");
+      }
+      constructor({
+        id,
+        email,
+        phone,
+        identification,
+        address,
+        note,
+        nationality,
+        file,
+        payment,
+        ...rest
+      }) {
+        if (!id)
+          throw new RequestError("document type is required");
+        super({
+          id,
+          email,
+          phone,
+          identification,
+          address,
+          note,
+          nationality,
+          file,
+          payment,
+          ...rest
+        });
+      }
+      get name() {
+        return "UpdateUser";
+      }
+      get routingKey() {
+        return `user.${this.data.id}.update`;
+      }
+    };
+    module.exports = UpdateUserCommand;
+  }
+});
+
+// src/Commands/GetMobileKeyCommand.js
+var require_GetMobileKeyCommand = __commonJS({
+  "src/Commands/GetMobileKeyCommand.js"(exports, module) {
+    var Command = require_Command();
+    var GetMobileKeyCommand = class extends Command {
+      static {
+        __name(this, "GetMobileKeyCommand");
+      }
+      constructor({
+        id,
+        phone,
+        beginDateTime,
+        endDateTime,
+        keyToReplace,
+        ...rest
+      }) {
+        super({ id, phone, beginDateTime, endDateTime, keyToReplace, ...rest });
+      }
+      get name() {
+        return "GetMobileKey";
+      }
+      get routingKey() {
+        return `lock.${this.data.id}.set`;
+      }
+    };
+    module.exports = GetMobileKeyCommand;
+  }
+});
+
+// src/Commands/CreateImageUploadEndpointCommand.js
+var require_CreateImageUploadEndpointCommand = __commonJS({
+  "src/Commands/CreateImageUploadEndpointCommand.js"(exports, module) {
+    var Command = require_Command();
+    var CreateImageUploadEndpointCommand = class extends Command {
+      static {
+        __name(this, "CreateImageUploadEndpointCommand");
+      }
+      constructor({ id, expires, ...rest }) {
+        super({ id, expires, ...rest });
+      }
+      get name() {
+        return "CreateImageUploadEndpoint";
+      }
+      get routingKey() {
+        return "image.createUploadEndpoint";
+      }
+    };
+    module.exports = CreateImageUploadEndpointCommand;
+  }
+});
+
+// src/Commands/UploadImageCommand.js
+var require_UploadImageCommand = __commonJS({
+  "src/Commands/UploadImageCommand.js"(exports, module) {
+    var Command = require_Command();
+    var UploadImageCommand = class extends Command {
+      static {
+        __name(this, "UploadImageCommand");
+      }
+      constructor({ id, url, file, ...rest }) {
+        super({ id, url, file, ...rest });
+      }
+      get name() {
+        return "UploadImage";
+      }
+      get routingKey() {
+        return `image.${this.data.id}.upload`;
+      }
+    };
+    module.exports = UploadImageCommand;
+  }
+});
+
+// src/Commands/GetProductsCommand.js
+var require_GetProductsCommand = __commonJS({
+  "src/Commands/GetProductsCommand.js"(exports, module) {
+    var Command = require_Command();
+    var GetProductsCommand = class extends Command {
+      static {
+        __name(this, "GetProductsCommand");
+      }
+      constructor({ id, externalSystemId, ...rest }) {
+        super({ id, externalSystemId, ...rest });
+      }
+      get name() {
+        return "GetProducts";
+      }
+      get routingKey() {
+        return `product.${this.data.id}.get`;
+      }
+    };
+    module.exports = GetProductsCommand;
+  }
+});
+
+// src/Commands/SellProductsCommand.js
+var require_SellProductsCommand = __commonJS({
+  "src/Commands/SellProductsCommand.js"(exports, module) {
+    var Command = require_Command();
+    var SellProductsCommand = class extends Command {
+      static {
+        __name(this, "SellProductsCommand");
+      }
+      constructor({ reservationId, userId, products, ...rest }) {
+        super({ reservationId, userId, products, ...rest });
+      }
+      get name() {
+        return "SellProducts";
+      }
+      get routingKey() {
+        return `product.${this.data.id}.sell`;
+      }
+    };
+    module.exports = SellProductsCommand;
+  }
+});
+
 // src/Commands/index.js
 var require_Commands = __commonJS({
   "src/Commands/index.js"(exports, module) {
+    var SetSceneCommand = require_SetSceneCommand();
     var SetAlarmCommand = require_SetAlarmCommand();
     var SetDimmerCommand = require_SetDimmerCommand();
     var SetSwitchCommand = require_SetSwitchCommand();
     var SetThermostatCommand = require_SetThermostatCommand();
     var SetLockCommand = require_SetLockCommand();
-    var SetSceneControllerCommand = require_SetSceneControllerCommand();
     var SetWindowCoveringCommand = require_SetWindowCoveringCommand();
     var SetCourtesyCommand = require_SetCourtesyCommand();
+    var SetMediaCommand = require_SetMediaCommand();
     var DiscoverUsersCommand = require_DiscoverUsersCommand();
     var OCRDocumentCommand = require_OCRDocumentCommand();
     var CheckInReservationCommand = require_CheckInReservationCommand();
+    var SendEmailCommand = require_SendEmailCommand();
     var SendSMSCommand = require_SendSMSCommand();
     var DiscoverReservationsCommand = require_DiscoverReservationsCommand();
+    var DiscoverReservationSpaceCategoryAvailabilitiesCommand = require_DiscoverReservationSpaceCategoryAvailabilitiesCommand();
     var DiscoverRoomsCommand = require_DiscoverRoomsCommand();
+    var DiscoverCategoriesCommand = require_DiscoverCategoriesCommand();
+    var CreateShortLinkCommand = require_CreateShortLinkCommand();
+    var UpdateReservationCommand = require_UpdateReservationCommand();
+    var UpdateUserCommand = require_UpdateUserCommand();
+    var GetMobileKeyCommand = require_GetMobileKeyCommand();
+    var CreateImageUploadEndpointCommand = require_CreateImageUploadEndpointCommand();
+    var UploadImageCommand = require_UploadImageCommand();
+    var GetProductsCommand = require_GetProductsCommand();
+    var SellProductsCommand = require_SellProductsCommand();
     module.exports = {
+      SetSceneCommand,
       SetAlarmCommand,
       SetDimmerCommand,
       SetSwitchCommand,
       SetThermostatCommand,
       SetLockCommand,
-      SetSceneControllerCommand,
       SetWindowCoveringCommand,
       SetCourtesyCommand,
+      SetMediaCommand,
       OCRDocumentCommand,
       DiscoverUsersCommand,
       CheckInReservationCommand,
       SendSMSCommand,
+      SendEmailCommand,
       DiscoverReservationsCommand,
-      DiscoverRoomsCommand
+      DiscoverReservationSpaceCategoryAvailabilitiesCommand,
+      DiscoverRoomsCommand,
+      DiscoverCategoriesCommand,
+      CreateShortLinkCommand,
+      UpdateReservationCommand,
+      UpdateUserCommand,
+      GetMobileKeyCommand,
+      CreateImageUploadEndpointCommand,
+      UploadImageCommand,
+      GetProductsCommand,
+      SellProductsCommand
     };
   }
 });