@freshpointcz/fresh-core 0.0.18 → 0.0.20

package/dist/index.mjs

@@ -422,6 +422,38 @@ var require_main = __commonJS({
   }
 });
 
+// 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
 import dayjs from "dayjs";
 import utc from "dayjs/plugin/utc";
@@ -602,62 +634,94 @@ __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;
-  });
+// src/common/dto/status-dto.ts
+var _StatusDto = class _StatusDto {
+  constructor(status, details, timestamp) {
+    /**
+     * Call result status
+     */
+    __publicField(this, "status");
+    /**
+     * UTC Timestamp
+     * @example "2021-12-01T13:23:39.305Z"
+     */
+    __publicField(this, "timestamp");
+    /**
+     * Details (optional)
+     */
+    __publicField(this, "details");
+    this.status = status;
+    this.details = details;
+    this.timestamp = timestamp != null ? timestamp : DateUtils.getNowCzech().toISOString();
+  }
+};
+__name(_StatusDto, "StatusDto");
+var StatusDto = _StatusDto;
+
+// src/common/pagination/constructors.ts
+function constructTypeormPagination(params) {
   return {
-    promise,
-    resolve,
-    reject
+    take: params.limit,
+    skip: params.skip
   };
 }
-__name(createDeferred, "createDeferred");
+__name(constructTypeormPagination, "constructTypeormPagination");
+function parsePaginationFromURL(searchParams) {
+  var _a, _b;
+  const page = Math.max(1, parseInt((_a = searchParams.get("page")) != null ? _a : "1", 10));
+  const limit = Math.min(100, Math.max(1, parseInt((_b = searchParams.get("limit")) != null ? _b : "20", 10)));
+  return {
+    page,
+    limit,
+    skip: (page - 1) * limit
+  };
+}
+__name(parsePaginationFromURL, "parsePaginationFromURL");
 
-// 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;
-  }
+// src/common/pagination/pagination-meta.ts
+function getPaginationMeta(total, page, limit) {
+  return {
+    total,
+    page,
+    limit,
+    totalPages: Math.ceil(total / limit)
+  };
+}
+__name(getPaginationMeta, "getPaginationMeta");
+
+// src/common/pagination/pagination-params.ts
+function getPaginationParams(params) {
+  return {
+    ...DEFAULT_PAGINATION_PARAMS,
+    ...params
+  };
+}
+__name(getPaginationParams, "getPaginationParams");
+var DEFAULT_PAGINATION_PARAMS = {
+  page: 1,
+  limit: 1e3,
+  skip: 0
 };
-__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;
+// src/common/pagination/scrapper.ts
+async function listAll(fetchPage, batchSize = 1e3) {
+  const results = [];
+  let page = 1;
+  while (true) {
+    const { data, meta } = await fetchPage({
+      page,
+      limit: batchSize,
+      skip: (page - 1) * batchSize
+    });
+    results.push(...data);
+    if (page >= meta.totalPages) {
+      break;
+    }
+    page++;
   }
-  const cronPart = /^(\*|\d+|\d+\-\d+|\d+\/\d+|\*\/\d+)(,\d+)*$/;
-  return parts.every((part) => cronPart.test(part));
+  return results;
 }
-__name(isValidCron, "isValidCron");
+__name(listAll, "listAll");
 
 // src/common/patterns/singleton.ts
 var _Singleton = class _Singleton {
@@ -710,61 +774,51 @@ __name(_Singleton, "Singleton");
 __publicField(_Singleton, "instances", /* @__PURE__ */ new Map());
 var Singleton = _Singleton;
 
-// src/common/dto/status-dto.ts
-var _StatusDto = class _StatusDto {
-  constructor(status, details, timestamp) {
-    /**
-     * Call result status
-     */
-    __publicField(this, "status");
-    /**
-     * UTC Timestamp
-     * @example "2021-12-01T13:23:39.305Z"
-     */
-    __publicField(this, "timestamp");
-    /**
-     * Details (optional)
-     */
-    __publicField(this, "details");
-    this.status = status;
-    this.details = details;
-    this.timestamp = timestamp != null ? timestamp : DateUtils.getNowCzech().toISOString();
-  }
-};
-__name(_StatusDto, "StatusDto");
-var StatusDto = _StatusDto;
+// 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/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"
+// 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();
     }
-  },
-  4: {
-    symbol: "l",
-    translations: {
-      en: "liter",
-      cs: "litr"
+    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
 import { Entity } from "typeorm";
@@ -1282,6 +1336,57 @@ Subcategory = _ts_decorate8([
   Entity5()
 ], Subcategory);
 
+// src/common/typeguards/decimal.ts
+function toDecimal(num, precision = 9, scale = 2) {
+  const limit = Math.pow(10, precision - scale);
+  if (Math.abs(num) >= limit) {
+    throw new Error(`Value ${num} exceeds the allowed precision of ${precision} and scale of ${scale}.`);
+  }
+  return num.toFixed(scale);
+}
+__name(toDecimal, "toDecimal");
+function isDecimal(v, options) {
+  var _a, _b, _c;
+  const type = typeof v;
+  if ((options == null ? void 0 : options.allowedType) !== void 0 && type !== options.allowedType) {
+    return false;
+  }
+  if (type !== "number" && type !== "string") {
+    return false;
+  }
+  const sep = (_a = options == null ? void 0 : options.decimalPoint) != null ? _a : ".";
+  let intPart;
+  let fracPart;
+  if (type === "number") {
+    const n = v;
+    if (!Number.isFinite(n)) {
+      return false;
+    }
+    const str = n.toString();
+    if (str.includes("e") || str.includes("E")) {
+      return false;
+    }
+    const parts = str.replace("-", "").split(".");
+    intPart = parts[0];
+    fracPart = (_b = parts[1]) != null ? _b : "";
+  } else {
+    const s = v;
+    const escapedSep = sep === "." ? "\\." : ",";
+    const pattern = new RegExp(`^-?\\d+(?:${escapedSep}\\d+)?$`);
+    if (!pattern.test(s)) {
+      return false;
+    }
+    const parts = s.replace("-", "").split(sep);
+    intPart = parts[0];
+    fracPart = (_c = parts[1]) != null ? _c : "";
+  }
+  if ((options == null ? void 0 : options.scale) !== void 0 && fracPart.length > options.scale) {
+    return false;
+  }
+  return (options == null ? void 0 : options.precision) === void 0 || intPart.length + fracPart.length <= options.precision;
+}
+__name(isDecimal, "isDecimal");
+
 // src/common/typeguards/enums.ts
 function isEnumValue(enumObj, v) {
   if (!enumObj) {
@@ -1352,6 +1457,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 = {};
@@ -1366,43 +1488,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
 import { scheduleJob } from "node-schedule";
 var _FreshJob = class _FreshJob extends Singleton {
@@ -1551,6 +1636,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);
@@ -1743,35 +2168,81 @@ export {
   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,
   datasource_default as 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,
   eslint_config_default as freshEslintConfig,
+  getPaginationMeta,
+  getPaginationParams,
   hasOwn,
+  isDecimal,
   isEnumValue,
   isFlag01,
   isMaybe,
@@ -1780,6 +2251,10 @@ export {
   isObject,
   isString,
   isValidCron,
-  runWithConcurrency
+  listAll,
+  parsePaginationFromURL,
+  resolvePathParameterId,
+  runWithConcurrency,
+  toDecimal
 };
 //# sourceMappingURL=index.mjs.map