@freshpointcz/fresh-core 0.0.19 → 0.0.20

package/dist/index.js

@@ -428,32 +428,73 @@ __export(index_exports, {
   AMOUNT_UNIT: () => AMOUNT_UNIT,
   ActionCommandCode: () => ActionCommandCode,
   ApiError: () => ApiError,
+  BadGatewayError: () => BadGatewayError,
+  BadRequestError: () => BadRequestError,
   BaseEntityChangeSubscriber: () => BaseEntityChangeSubscriber,
   BusinessWarning: () => BusinessWarning,
   Category: () => Category,
+  ConflictError: () => ConflictError,
   DEFAULT_PAGINATION_PARAMS: () => DEFAULT_PAGINATION_PARAMS,
   DataHelper: () => DataHelper,
   DateUtils: () => DateUtils,
   DepotPoolStatus: () => DepotPoolStatus,
   Device: () => Device,
+  ExpectationFailedError: () => ExpectationFailedError,
+  FailedDependencyError: () => FailedDependencyError,
+  ForbiddenError: () => ForbiddenError,
   FreshDao: () => FreshDao,
   FreshEntity: () => FreshEntity,
+  FreshError: () => FreshError,
   FreshHyperEntity: () => FreshHyperEntity,
   FreshJob: () => FreshJob,
   FreshTranslationBase: () => FreshTranslationBase,
+  GatewayTimeoutError: () => GatewayTimeoutError,
+  GoneError: () => GoneError,
   HttpStatus: () => HttpStatus,
+  HttpVersionNotSupportedError: () => HttpVersionNotSupportedError,
+  ImATeapotError: () => ImATeapotError,
+  InsufficientStorageError: () => InsufficientStorageError,
+  InternalServerError: () => InternalServerError,
   LanguageCode: () => LanguageCode,
+  LengthRequiredError: () => LengthRequiredError,
+  LockedError: () => LockedError,
+  LoopDetectedError: () => LoopDetectedError,
   Manufacturer: () => Manufacturer,
+  MethodNotAllowedError: () => MethodNotAllowedError,
+  MisdirectedRequestError: () => MisdirectedRequestError,
+  NetworkAuthenticationRequiredError: () => NetworkAuthenticationRequiredError,
+  NotAcceptableError: () => NotAcceptableError,
+  NotExtendedError: () => NotExtendedError,
+  NotFoundError: () => NotFoundError,
+  NotImplementedError: () => NotImplementedError,
+  PayloadTooLargeError: () => PayloadTooLargeError,
   PaymentMethod: () => PaymentMethod,
+  PaymentRequiredError: () => PaymentRequiredError,
   PgDataSourceOptions: () => datasource_default,
+  PreconditionFailedError: () => PreconditionFailedError,
+  PreconditionRequiredError: () => PreconditionRequiredError,
   Product: () => Product,
+  ProxyAuthenticationRequiredError: () => ProxyAuthenticationRequiredError,
+  RangeNotSatisfiableError: () => RangeNotSatisfiableError,
+  RequestHeaderFieldsTooLargeError: () => RequestHeaderFieldsTooLargeError,
+  RequestTimeoutError: () => RequestTimeoutError,
+  ServiceUnavailableError: () => ServiceUnavailableError,
   SinglePromiseWaiter: () => SinglePromiseWaiter,
   Singleton: () => Singleton,
   StatusDto: () => StatusDto,
   Subcategory: () => Subcategory,
   TO_BINARY_FLAG: () => TO_BINARY_FLAG,
   TimestampColumn: () => TimestampColumn,
+  TooEarlyError: () => TooEarlyError,
+  TooManyRequestsError: () => TooManyRequestsError,
   TransactionType: () => TransactionType,
+  UnauthorizedError: () => UnauthorizedError,
+  UnavailableForLegalReasonsError: () => UnavailableForLegalReasonsError,
+  UnprocessableEntityError: () => UnprocessableEntityError,
+  UnsupportedMediaTypeError: () => UnsupportedMediaTypeError,
+  UpgradeRequiredError: () => UpgradeRequiredError,
+  UriTooLongError: () => UriTooLongError,
+  VariantAlsoNegotiatesError: () => VariantAlsoNegotiatesError,
   buildPatch: () => buildPatch,
   constructTypeormPagination: () => constructTypeormPagination,
   createDeferred: () => createDeferred,
@@ -472,11 +513,44 @@ __export(index_exports, {
   isValidCron: () => isValidCron,
   listAll: () => listAll,
   parsePaginationFromURL: () => parsePaginationFromURL,
+  resolvePathParameterId: () => resolvePathParameterId,
   runWithConcurrency: () => runWithConcurrency,
   toDecimal: () => toDecimal
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/common/constants/amount-unit.ts
+var AMOUNT_UNIT = {
+  1: {
+    symbol: "g",
+    translations: {
+      en: "gram",
+      cs: "gram"
+    }
+  },
+  2: {
+    symbol: "kg",
+    translations: {
+      en: "kilogram",
+      cs: "kilogram"
+    }
+  },
+  3: {
+    symbol: "ml",
+    translations: {
+      en: "milliliter",
+      cs: "mililitr"
+    }
+  },
+  4: {
+    symbol: "l",
+    translations: {
+      en: "liter",
+      cs: "litr"
+    }
+  }
+};
+
 // src/common/date-utils.ts
 var import_dayjs = __toESM(require("dayjs"));
 var import_utc = __toESM(require("dayjs/plugin/utc"));
@@ -657,114 +731,6 @@ __publicField(_DateUtils, "HOLIDAYS", _DateUtils.HOLIDAYS_STR.map((h) => {
 }));
 var DateUtils = _DateUtils;
 
-// src/common/promise-magic/deferred.ts
-function createDeferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    promise,
-    resolve,
-    reject
-  };
-}
-__name(createDeferred, "createDeferred");
-
-// src/common/promise-magic/single-promise-waiter.ts
-var _SinglePromiseWaiter = class _SinglePromiseWaiter {
-  constructor() {
-    __publicField(this, "_promise", null);
-  }
-  static getInstance() {
-    if (!_SinglePromiseWaiter._instance) {
-      _SinglePromiseWaiter._instance = new _SinglePromiseWaiter();
-    }
-    return _SinglePromiseWaiter._instance;
-  }
-  get promise() {
-    return this._promise;
-  }
-  set promise(promise) {
-    if (promise !== null) {
-      this._promise = promise;
-      this._promise.finally(() => {
-        this._promise = null;
-      });
-    }
-  }
-  get hasPromise() {
-    return this._promise !== null;
-  }
-};
-__name(_SinglePromiseWaiter, "SinglePromiseWaiter");
-__publicField(_SinglePromiseWaiter, "_instance");
-var SinglePromiseWaiter = _SinglePromiseWaiter;
-
-// src/common/utils/is-cron-valid.ts
-function isValidCron(expr) {
-  const parts = expr.trim().split(/\s+/);
-  if (parts.length < 5 || parts.length > 6) {
-    return false;
-  }
-  const cronPart = /^(\*|\d+|\d+\-\d+|\d+\/\d+|\*\/\d+)(,\d+)*$/;
-  return parts.every((part) => cronPart.test(part));
-}
-__name(isValidCron, "isValidCron");
-
-// src/common/patterns/singleton.ts
-var _Singleton = class _Singleton {
-  /**
-   * Creates or returns the singleton instance for the subclass.
-   *
-   * If an instance already exists for the subclass, that instance is
-   * returned instead of creating a new one.
-   *
-   * @param callOnInit - Whether to call {@link onInit} for a newly
-   * created instance. Ignored if the instance already exists.
-   */
-  constructor(callOnInit = true) {
-    const ctor = this.constructor;
-    const existing = _Singleton.instances.get(ctor);
-    if (existing) {
-      return existing;
-    }
-    _Singleton.instances.set(ctor, this);
-    if (callOnInit) {
-      void this.onInit();
-    }
-  }
-  /**
-   * Retrieves the singleton instance for the calling subclass.
-   *
-   * If no instance exists, a new one is created using the provided
-   * constructor arguments.
-   *
-   * Intended to be used by subclasses as a protected factory method.
-   *
-   * @typeParam T - The concrete subclass type.
-   * @param args - Arguments forwarded to the subclass constructor.
-   * @returns The singleton instance of the subclass.
-   */
-  static getInstance(...args) {
-    let instance = _Singleton.instances.get(this);
-    if (!instance) {
-      instance = new this(...args);
-      _Singleton.instances.set(this, instance);
-    }
-    return instance;
-  }
-};
-__name(_Singleton, "Singleton");
-/**
- * Internal registry of singleton instances.
- * One instance per subclass constructor.
- */
-__publicField(_Singleton, "instances", /* @__PURE__ */ new Map());
-var Singleton = _Singleton;
-
 // src/common/dto/status-dto.ts
 var _StatusDto = class _StatusDto {
   constructor(status, details, timestamp) {
@@ -854,37 +820,102 @@ async function listAll(fetchPage, batchSize = 1e3) {
 }
 __name(listAll, "listAll");
 
-// src/common/constants/amount-unit.ts
-var AMOUNT_UNIT = {
-  1: {
-    symbol: "g",
-    translations: {
-      en: "gram",
-      cs: "gram"
+// src/common/patterns/singleton.ts
+var _Singleton = class _Singleton {
+  /**
+   * Creates or returns the singleton instance for the subclass.
+   *
+   * If an instance already exists for the subclass, that instance is
+   * returned instead of creating a new one.
+   *
+   * @param callOnInit - Whether to call {@link onInit} for a newly
+   * created instance. Ignored if the instance already exists.
+   */
+  constructor(callOnInit = true) {
+    const ctor = this.constructor;
+    const existing = _Singleton.instances.get(ctor);
+    if (existing) {
+      return existing;
     }
-  },
-  2: {
-    symbol: "kg",
-    translations: {
-      en: "kilogram",
-      cs: "kilogram"
+    _Singleton.instances.set(ctor, this);
+    if (callOnInit) {
+      void this.onInit();
     }
-  },
-  3: {
-    symbol: "ml",
-    translations: {
-      en: "milliliter",
-      cs: "mililitr"
+  }
+  /**
+   * Retrieves the singleton instance for the calling subclass.
+   *
+   * If no instance exists, a new one is created using the provided
+   * constructor arguments.
+   *
+   * Intended to be used by subclasses as a protected factory method.
+   *
+   * @typeParam T - The concrete subclass type.
+   * @param args - Arguments forwarded to the subclass constructor.
+   * @returns The singleton instance of the subclass.
+   */
+  static getInstance(...args) {
+    let instance = _Singleton.instances.get(this);
+    if (!instance) {
+      instance = new this(...args);
+      _Singleton.instances.set(this, instance);
     }
-  },
-  4: {
-    symbol: "l",
-    translations: {
-      en: "liter",
-      cs: "litr"
+    return instance;
+  }
+};
+__name(_Singleton, "Singleton");
+/**
+ * Internal registry of singleton instances.
+ * One instance per subclass constructor.
+ */
+__publicField(_Singleton, "instances", /* @__PURE__ */ new Map());
+var Singleton = _Singleton;
+
+// src/common/promise-magic/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+__name(createDeferred, "createDeferred");
+
+// src/common/promise-magic/single-promise-waiter.ts
+var _SinglePromiseWaiter = class _SinglePromiseWaiter {
+  constructor() {
+    __publicField(this, "_promise", null);
+  }
+  static getInstance() {
+    if (!_SinglePromiseWaiter._instance) {
+      _SinglePromiseWaiter._instance = new _SinglePromiseWaiter();
+    }
+    return _SinglePromiseWaiter._instance;
+  }
+  get promise() {
+    return this._promise;
+  }
+  set promise(promise) {
+    if (promise !== null) {
+      this._promise = promise;
+      this._promise.finally(() => {
+        this._promise = null;
+      });
     }
   }
+  get hasPromise() {
+    return this._promise !== null;
+  }
 };
+__name(_SinglePromiseWaiter, "SinglePromiseWaiter");
+__publicField(_SinglePromiseWaiter, "_instance");
+var SinglePromiseWaiter = _SinglePromiseWaiter;
 
 // src/common/schema/entities/category.entity.ts
 var import_typeorm5 = require("typeorm");
@@ -1523,6 +1554,23 @@ async function runWithConcurrency(items, concurrency, worker) {
 }
 __name(runWithConcurrency, "runWithConcurrency");
 
+// src/common/utils/id-path-param-resolver.utils.ts
+function resolvePathParameterId(id) {
+  return /^\d+$/.test(id) ? parseInt(id, 10) : id;
+}
+__name(resolvePathParameterId, "resolvePathParameterId");
+
+// src/common/utils/is-cron-valid.ts
+function isValidCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length < 5 || parts.length > 6) {
+    return false;
+  }
+  const cronPart = /^(\*|\d+|\d+\-\d+|\d+\/\d+|\*\/\d+)(,\d+)*$/;
+  return parts.every((part) => cronPart.test(part));
+}
+__name(isValidCron, "isValidCron");
+
 // src/common/utils/patch.utils.ts
 function buildPatch(data, keys, transforms) {
   const patch = {};
@@ -1537,43 +1585,6 @@ function buildPatch(data, keys, transforms) {
 }
 __name(buildPatch, "buildPatch");
 
-// src/core/data-helper.ts
-var _DataHelper = class _DataHelper {
-  constructor(startDataRetrieve = true, deviceIds) {
-    __publicField(this, "_data");
-    __publicField(this, "_dataPromise", null);
-    __publicField(this, "deviceIds");
-    this.deviceIds = deviceIds;
-    if (startDataRetrieve) {
-      this._dataPromise = this.startDataRetrieval();
-    }
-  }
-  get data() {
-    return this._data;
-  }
-  set data(value) {
-    this._data = value;
-  }
-  get dataPromise() {
-    return this._dataPromise;
-  }
-  set dataPromise(value) {
-    this._dataPromise = value;
-  }
-  async getData() {
-    if (this._dataPromise) {
-      return await this._dataPromise;
-    }
-    if (this._data === void 0) {
-      this._dataPromise = this.startDataRetrieval();
-      return this._dataPromise;
-    }
-    return this._data;
-  }
-};
-__name(_DataHelper, "DataHelper");
-var DataHelper = _DataHelper;
-
 // src/core/class/fresh-job.ts
 var import_node_schedule = require("node-schedule");
 var _FreshJob = class _FreshJob extends Singleton {
@@ -1722,6 +1733,346 @@ var _BusinessWarning = class _BusinessWarning extends Error {
 __name(_BusinessWarning, "BusinessWarning");
 var BusinessWarning = _BusinessWarning;
 
+// src/core/errors/fresh-error.ts
+var _FreshError = class _FreshError extends Error {
+  constructor(statusCode, status, detail, options) {
+    super(detail != null ? detail : status);
+    /** HTTP status code sent in the response. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    __publicField(this, "statusCode");
+    /** Structured response body describing the error. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    __publicField(this, "statusDto");
+    this.name = this.constructor.name;
+    if ((options == null ? void 0 : options.cause) !== void 0) {
+      this.cause = options.cause;
+    }
+    this.statusCode = statusCode;
+    this.statusDto = new StatusDto(status, detail);
+  }
+};
+__name(_FreshError, "FreshError");
+var FreshError = _FreshError;
+
+// src/core/errors/errors.ts
+var _BadRequestError = class _BadRequestError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.BAD_REQUEST, "validation-error", detail, options);
+  }
+};
+__name(_BadRequestError, "BadRequestError");
+var BadRequestError = _BadRequestError;
+var _UnauthorizedError = class _UnauthorizedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.UNAUTHORIZED, "not-authenticated", detail, options);
+  }
+};
+__name(_UnauthorizedError, "UnauthorizedError");
+var UnauthorizedError = _UnauthorizedError;
+var _PaymentRequiredError = class _PaymentRequiredError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.PAYMENT_REQUIRED, "error", detail, options);
+  }
+};
+__name(_PaymentRequiredError, "PaymentRequiredError");
+var PaymentRequiredError = _PaymentRequiredError;
+var _ForbiddenError = class _ForbiddenError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.FORBIDDEN, "not-authorized", detail, options);
+  }
+};
+__name(_ForbiddenError, "ForbiddenError");
+var ForbiddenError = _ForbiddenError;
+var _NotFoundError = class _NotFoundError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.NOT_FOUND, "error", detail, options);
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _MethodNotAllowedError = class _MethodNotAllowedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.METHOD_NOT_ALLOWED, "error", detail, options);
+  }
+};
+__name(_MethodNotAllowedError, "MethodNotAllowedError");
+var MethodNotAllowedError = _MethodNotAllowedError;
+var _NotAcceptableError = class _NotAcceptableError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.NOT_ACCEPTABLE, "error", detail, options);
+  }
+};
+__name(_NotAcceptableError, "NotAcceptableError");
+var NotAcceptableError = _NotAcceptableError;
+var _ProxyAuthenticationRequiredError = class _ProxyAuthenticationRequiredError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.PROXY_AUTHENTICATION_REQUIRED, "not-authenticated", detail, options);
+  }
+};
+__name(_ProxyAuthenticationRequiredError, "ProxyAuthenticationRequiredError");
+var ProxyAuthenticationRequiredError = _ProxyAuthenticationRequiredError;
+var _RequestTimeoutError = class _RequestTimeoutError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.REQUEST_TIMEOUT, "error", detail, options);
+  }
+};
+__name(_RequestTimeoutError, "RequestTimeoutError");
+var RequestTimeoutError = _RequestTimeoutError;
+var _ConflictError = class _ConflictError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.CONFLICT, "error", detail, options);
+  }
+};
+__name(_ConflictError, "ConflictError");
+var ConflictError = _ConflictError;
+var _GoneError = class _GoneError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.GONE, "error", detail, options);
+  }
+};
+__name(_GoneError, "GoneError");
+var GoneError = _GoneError;
+var _LengthRequiredError = class _LengthRequiredError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.LENGTH_REQUIRED, "error", detail, options);
+  }
+};
+__name(_LengthRequiredError, "LengthRequiredError");
+var LengthRequiredError = _LengthRequiredError;
+var _PreconditionFailedError = class _PreconditionFailedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.PRECONDITION_FAILED, "error", detail, options);
+  }
+};
+__name(_PreconditionFailedError, "PreconditionFailedError");
+var PreconditionFailedError = _PreconditionFailedError;
+var _PayloadTooLargeError = class _PayloadTooLargeError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.PAYLOAD_TOO_LARGE, "error", detail, options);
+  }
+};
+__name(_PayloadTooLargeError, "PayloadTooLargeError");
+var PayloadTooLargeError = _PayloadTooLargeError;
+var _UriTooLongError = class _UriTooLongError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.URI_TOO_LONG, "error", detail, options);
+  }
+};
+__name(_UriTooLongError, "UriTooLongError");
+var UriTooLongError = _UriTooLongError;
+var _UnsupportedMediaTypeError = class _UnsupportedMediaTypeError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "error", detail, options);
+  }
+};
+__name(_UnsupportedMediaTypeError, "UnsupportedMediaTypeError");
+var UnsupportedMediaTypeError = _UnsupportedMediaTypeError;
+var _RangeNotSatisfiableError = class _RangeNotSatisfiableError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.RANGE_NOT_SATISFIABLE, "error", detail, options);
+  }
+};
+__name(_RangeNotSatisfiableError, "RangeNotSatisfiableError");
+var RangeNotSatisfiableError = _RangeNotSatisfiableError;
+var _ExpectationFailedError = class _ExpectationFailedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.EXPECTATION_FAILED, "error", detail, options);
+  }
+};
+__name(_ExpectationFailedError, "ExpectationFailedError");
+var ExpectationFailedError = _ExpectationFailedError;
+var _ImATeapotError = class _ImATeapotError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.IM_A_TEAPOT, "error", detail, options);
+  }
+};
+__name(_ImATeapotError, "ImATeapotError");
+var ImATeapotError = _ImATeapotError;
+var _MisdirectedRequestError = class _MisdirectedRequestError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.MISDIRECTED_REQUEST, "error", detail, options);
+  }
+};
+__name(_MisdirectedRequestError, "MisdirectedRequestError");
+var MisdirectedRequestError = _MisdirectedRequestError;
+var _UnprocessableEntityError = class _UnprocessableEntityError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.UNPROCESSABLE_ENTITY, "validation-error", detail, options);
+  }
+};
+__name(_UnprocessableEntityError, "UnprocessableEntityError");
+var UnprocessableEntityError = _UnprocessableEntityError;
+var _LockedError = class _LockedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.LOCKED, "error", detail, options);
+  }
+};
+__name(_LockedError, "LockedError");
+var LockedError = _LockedError;
+var _FailedDependencyError = class _FailedDependencyError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.FAILED_DEPENDENCY, "error", detail, options);
+  }
+};
+__name(_FailedDependencyError, "FailedDependencyError");
+var FailedDependencyError = _FailedDependencyError;
+var _TooEarlyError = class _TooEarlyError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.TOO_EARLY, "error", detail, options);
+  }
+};
+__name(_TooEarlyError, "TooEarlyError");
+var TooEarlyError = _TooEarlyError;
+var _UpgradeRequiredError = class _UpgradeRequiredError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.UPGRADE_REQUIRED, "error", detail, options);
+  }
+};
+__name(_UpgradeRequiredError, "UpgradeRequiredError");
+var UpgradeRequiredError = _UpgradeRequiredError;
+var _PreconditionRequiredError = class _PreconditionRequiredError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.PRECONDITION_REQUIRED, "error", detail, options);
+  }
+};
+__name(_PreconditionRequiredError, "PreconditionRequiredError");
+var PreconditionRequiredError = _PreconditionRequiredError;
+var _TooManyRequestsError = class _TooManyRequestsError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.TOO_MANY_REQUESTS, "error", detail, options);
+  }
+};
+__name(_TooManyRequestsError, "TooManyRequestsError");
+var TooManyRequestsError = _TooManyRequestsError;
+var _RequestHeaderFieldsTooLargeError = class _RequestHeaderFieldsTooLargeError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.REQUEST_HEADER_FIELDS_TOO_LARGE, "error", detail, options);
+  }
+};
+__name(_RequestHeaderFieldsTooLargeError, "RequestHeaderFieldsTooLargeError");
+var RequestHeaderFieldsTooLargeError = _RequestHeaderFieldsTooLargeError;
+var _UnavailableForLegalReasonsError = class _UnavailableForLegalReasonsError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.UNAVAILABLE_FOR_LEGAL_REASONS, "error", detail, options);
+  }
+};
+__name(_UnavailableForLegalReasonsError, "UnavailableForLegalReasonsError");
+var UnavailableForLegalReasonsError = _UnavailableForLegalReasonsError;
+var _InternalServerError = class _InternalServerError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.INTERNAL_SERVER_ERROR, "internal-server-error", detail, options);
+  }
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+var _NotImplementedError = class _NotImplementedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.NOT_IMPLEMENTED, "internal-server-error", detail, options);
+  }
+};
+__name(_NotImplementedError, "NotImplementedError");
+var NotImplementedError = _NotImplementedError;
+var _BadGatewayError = class _BadGatewayError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.BAD_GATEWAY, "internal-server-error", detail, options);
+  }
+};
+__name(_BadGatewayError, "BadGatewayError");
+var BadGatewayError = _BadGatewayError;
+var _ServiceUnavailableError = class _ServiceUnavailableError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.SERVICE_UNAVAILABLE, "internal-server-error", detail, options);
+  }
+};
+__name(_ServiceUnavailableError, "ServiceUnavailableError");
+var ServiceUnavailableError = _ServiceUnavailableError;
+var _GatewayTimeoutError = class _GatewayTimeoutError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.GATEWAY_TIMEOUT, "internal-server-error", detail, options);
+  }
+};
+__name(_GatewayTimeoutError, "GatewayTimeoutError");
+var GatewayTimeoutError = _GatewayTimeoutError;
+var _HttpVersionNotSupportedError = class _HttpVersionNotSupportedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.HTTP_VERSION_NOT_SUPPORTED, "internal-server-error", detail, options);
+  }
+};
+__name(_HttpVersionNotSupportedError, "HttpVersionNotSupportedError");
+var HttpVersionNotSupportedError = _HttpVersionNotSupportedError;
+var _VariantAlsoNegotiatesError = class _VariantAlsoNegotiatesError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.VARIANT_ALSO_NEGOTIATES, "internal-server-error", detail, options);
+  }
+};
+__name(_VariantAlsoNegotiatesError, "VariantAlsoNegotiatesError");
+var VariantAlsoNegotiatesError = _VariantAlsoNegotiatesError;
+var _InsufficientStorageError = class _InsufficientStorageError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.INSUFFICIENT_STORAGE, "internal-server-error", detail, options);
+  }
+};
+__name(_InsufficientStorageError, "InsufficientStorageError");
+var InsufficientStorageError = _InsufficientStorageError;
+var _LoopDetectedError = class _LoopDetectedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.LOOP_DETECTED, "internal-server-error", detail, options);
+  }
+};
+__name(_LoopDetectedError, "LoopDetectedError");
+var LoopDetectedError = _LoopDetectedError;
+var _NotExtendedError = class _NotExtendedError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.NOT_EXTENDED, "internal-server-error", detail, options);
+  }
+};
+__name(_NotExtendedError, "NotExtendedError");
+var NotExtendedError = _NotExtendedError;
+var _NetworkAuthenticationRequiredError = class _NetworkAuthenticationRequiredError extends FreshError {
+  constructor(detail, options) {
+    super(HttpStatus.NETWORK_AUTHENTICATION_REQUIRED, "internal-server-error", detail, options);
+  }
+};
+__name(_NetworkAuthenticationRequiredError, "NetworkAuthenticationRequiredError");
+var NetworkAuthenticationRequiredError = _NetworkAuthenticationRequiredError;
+
+// src/core/data-helper.ts
+var _DataHelper = class _DataHelper {
+  constructor(startDataRetrieve = true, deviceIds) {
+    __publicField(this, "_data");
+    __publicField(this, "_dataPromise", null);
+    __publicField(this, "deviceIds");
+    this.deviceIds = deviceIds;
+    if (startDataRetrieve) {
+      this._dataPromise = this.startDataRetrieval();
+    }
+  }
+  get data() {
+    return this._data;
+  }
+  set data(value) {
+    this._data = value;
+  }
+  get dataPromise() {
+    return this._dataPromise;
+  }
+  set dataPromise(value) {
+    this._dataPromise = value;
+  }
+  async getData() {
+    if (this._dataPromise) {
+      return await this._dataPromise;
+    }
+    if (this._data === void 0) {
+      this._dataPromise = this.startDataRetrieval();
+      return this._dataPromise;
+    }
+    return this._data;
+  }
+};
+__name(_DataHelper, "DataHelper");
+var DataHelper = _DataHelper;
+
 // src/types/maybe-type.ts
 function isMaybe(v, inner) {
   return v === null || inner(v);
@@ -1915,32 +2266,73 @@ var datasource_default = PG_DATA_SOURCE_OPTIONS;
   AMOUNT_UNIT,
   ActionCommandCode,
   ApiError,
+  BadGatewayError,
+  BadRequestError,
   BaseEntityChangeSubscriber,
   BusinessWarning,
   Category,
+  ConflictError,
   DEFAULT_PAGINATION_PARAMS,
   DataHelper,
   DateUtils,
   DepotPoolStatus,
   Device,
+  ExpectationFailedError,
+  FailedDependencyError,
+  ForbiddenError,
   FreshDao,
   FreshEntity,
+  FreshError,
   FreshHyperEntity,
   FreshJob,
   FreshTranslationBase,
+  GatewayTimeoutError,
+  GoneError,
   HttpStatus,
+  HttpVersionNotSupportedError,
+  ImATeapotError,
+  InsufficientStorageError,
+  InternalServerError,
   LanguageCode,
+  LengthRequiredError,
+  LockedError,
+  LoopDetectedError,
   Manufacturer,
+  MethodNotAllowedError,
+  MisdirectedRequestError,
+  NetworkAuthenticationRequiredError,
+  NotAcceptableError,
+  NotExtendedError,
+  NotFoundError,
+  NotImplementedError,
+  PayloadTooLargeError,
   PaymentMethod,
+  PaymentRequiredError,
   PgDataSourceOptions,
+  PreconditionFailedError,
+  PreconditionRequiredError,
   Product,
+  ProxyAuthenticationRequiredError,
+  RangeNotSatisfiableError,
+  RequestHeaderFieldsTooLargeError,
+  RequestTimeoutError,
+  ServiceUnavailableError,
   SinglePromiseWaiter,
   Singleton,
   StatusDto,
   Subcategory,
   TO_BINARY_FLAG,
   TimestampColumn,
+  TooEarlyError,
+  TooManyRequestsError,
   TransactionType,
+  UnauthorizedError,
+  UnavailableForLegalReasonsError,
+  UnprocessableEntityError,
+  UnsupportedMediaTypeError,
+  UpgradeRequiredError,
+  UriTooLongError,
+  VariantAlsoNegotiatesError,
   buildPatch,
   constructTypeormPagination,
   createDeferred,
@@ -1959,6 +2351,7 @@ var datasource_default = PG_DATA_SOURCE_OPTIONS;
   isValidCron,
   listAll,
   parsePaginationFromURL,
+  resolvePathParameterId,
   runWithConcurrency,
   toDecimal
 });