@freshpointcz/fresh-core 0.0.19 → 0.0.20

package/dist/index.d.mts

@@ -1,117 +1,39 @@
-import dayjs, { Dayjs } from 'dayjs';
 import { BaseEntity, ColumnOptions, Repository, EntityTarget, EntityManager, ObjectLiteral, EntitySubscriberInterface, InsertEvent, UpdateEvent, SoftRemoveEvent, TransactionCommitEvent, DataSourceOptions } from 'typeorm';
+import dayjs, { Dayjs } from 'dayjs';
 import { Job } from 'node-schedule';
 import * as _eslint_core from '@eslint/core';
 import * as typescript_eslint_dist_compatibility_types from 'typescript-eslint/dist/compatibility-types';
 
-/**
- * Static DateUtils class
- */
-declare class DateUtils {
-    /** Holidays 2025-2030 as YYYY-MM-DD strings */
-    static HOLIDAYS_STR: readonly string[];
-    /** Holidays 2025-2030 as UTC timestamps */
-    static HOLIDAYS: readonly number[];
-    static fromISOtoSQLtimestamp(ts?: string): string;
-    static toSQLtimestamp(ts: Dayjs): string;
-    static fromSQLtimestamp(mysqlDate: string): Dayjs;
-    static getSqlTimestampFromNowCzech(): string;
-    static fromISO(isoDate: string): Dayjs;
-    static getDate(ts: string): dayjs.Dayjs;
-    static getNow(): Dayjs;
-    static getNowCzech(): Dayjs;
-    static clone(ts: Dayjs): Dayjs;
-    static getLastSunday(weeksOffset?: number): Dayjs;
-    static dayInWeek(ts?: Dayjs): 1 | 2 | 3 | 4 | 5 | 6 | 7;
-    static isWorkdayDay(ts: Dayjs): boolean;
-    static getDiffInMinutesWithNow(inputTime: Dayjs): number;
-    static isInLastDays(numOfDays: number, timestampInput: string | Dayjs): boolean;
-}
-
-type Deferred<T> = {
-    promise: Promise<T>;
-    resolve: (value: T) => void;
-    reject: (err: any) => void;
+declare const AMOUNT_UNIT: {
+    readonly 1: {
+        readonly symbol: "g";
+        readonly translations: {
+            readonly en: "gram";
+            readonly cs: "gram";
+        };
+    };
+    readonly 2: {
+        readonly symbol: "kg";
+        readonly translations: {
+            readonly en: "kilogram";
+            readonly cs: "kilogram";
+        };
+    };
+    readonly 3: {
+        readonly symbol: "ml";
+        readonly translations: {
+            readonly en: "milliliter";
+            readonly cs: "mililitr";
+        };
+    };
+    readonly 4: {
+        readonly symbol: "l";
+        readonly translations: {
+            readonly en: "liter";
+            readonly cs: "litr";
+        };
+    };
 };
-/**
- * Deferred promise is like "fake" which is used to manually resolve/reject later on with different promise
- * With resolve and reject outside for easier change of promise
- * is used as placeholder untill real promise is assigned
- */
-declare function createDeferred<T>(): Deferred<T>;
-
-/**
- * Experimental class to maintain just one promise for some process flow.
- * Currently is in singleton design, so can be used only in one proces. (currently: all-product-availability-per-day)
- */
-declare class SinglePromiseWaiter<T = any> {
-    private static _instance;
-    static getInstance<T = any>(): SinglePromiseWaiter<any>;
-    private _promise;
-    get promise(): Promise<T> | null;
-    set promise(promise: Promise<T> | null);
-    get hasPromise(): boolean;
-}
-
-declare function isValidCron(expr: string): boolean;
-
-/**
- * Abstract base class implementing a per-subclass Singleton pattern.
- *
- * Each subclass of `Singleton` can have exactly one instance.
- * Instantiation is guarded at runtime: calling `new` multiple times
- * will always return the first created instance for that subclass.
- *
- * Instances are stored internally in a static map keyed by constructor
- * function, allowing independent singleton instances per subclass.
- *
- * ⚠️ Important:
- * - Subclasses MUST NOT override the constructor unless they fully
- *   understand the consequences.
- * - Initialization logic must be placed in {@link onInit}, not the constructor.
- * - The constructor may return an existing instance, which is legal in JS
- *   but mildly unsettling.
- */
-declare abstract class Singleton {
-    /**
-     * Internal registry of singleton instances.
-     * One instance per subclass constructor.
-     */
-    private static instances;
-    /**
-     * 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?: boolean);
-    /**
-     * 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.
-     */
-    protected static getInstance<T>(this: new (...args: any[]) => T, ...args: ConstructorParameters<any>): T;
-    /**
-     * Lifecycle hook called once when the singleton instance is first created.
-     *
-     * Subclasses must implement this method instead of relying on the
-     * constructor for initialization logic.
-     *
-     * This method is guaranteed to be called at most once per subclass
-     * instance.
-     */
-    protected abstract onInit(): void | Promise<void>;
-}
 
 type Status = "ok" | "error" | "not-authorized" | "not-authenticated" | "internal-server-error" | "validation-error";
 
@@ -362,36 +284,88 @@ interface PaginatedList<T> {
  */
 declare function listAll<T>(fetchPage: (pagination: PaginationParams) => Promise<PaginatedList<T>>, batchSize?: number): Promise<T[]>;
 
-declare const AMOUNT_UNIT: {
-    readonly 1: {
-        readonly symbol: "g";
-        readonly translations: {
-            readonly en: "gram";
-            readonly cs: "gram";
-        };
-    };
-    readonly 2: {
-        readonly symbol: "kg";
-        readonly translations: {
-            readonly en: "kilogram";
-            readonly cs: "kilogram";
-        };
-    };
-    readonly 3: {
-        readonly symbol: "ml";
-        readonly translations: {
-            readonly en: "milliliter";
-            readonly cs: "mililitr";
-        };
-    };
-    readonly 4: {
-        readonly symbol: "l";
-        readonly translations: {
-            readonly en: "liter";
-            readonly cs: "litr";
-        };
-    };
+/**
+ * Abstract base class implementing a per-subclass Singleton pattern.
+ *
+ * Each subclass of `Singleton` can have exactly one instance.
+ * Instantiation is guarded at runtime: calling `new` multiple times
+ * will always return the first created instance for that subclass.
+ *
+ * Instances are stored internally in a static map keyed by constructor
+ * function, allowing independent singleton instances per subclass.
+ *
+ * ⚠️ Important:
+ * - Subclasses MUST NOT override the constructor unless they fully
+ *   understand the consequences.
+ * - Initialization logic must be placed in {@link onInit}, not the constructor.
+ * - The constructor may return an existing instance, which is legal in JS
+ *   but mildly unsettling.
+ */
+declare abstract class Singleton {
+    /**
+     * Internal registry of singleton instances.
+     * One instance per subclass constructor.
+     */
+    private static instances;
+    /**
+     * 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?: boolean);
+    /**
+     * 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.
+     */
+    protected static getInstance<T>(this: new (...args: any[]) => T, ...args: ConstructorParameters<any>): T;
+    /**
+     * Lifecycle hook called once when the singleton instance is first created.
+     *
+     * Subclasses must implement this method instead of relying on the
+     * constructor for initialization logic.
+     *
+     * This method is guaranteed to be called at most once per subclass
+     * instance.
+     */
+    protected abstract onInit(): void | Promise<void>;
+}
+
+type Deferred<T> = {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (err: any) => void;
 };
+/**
+ * Deferred promise is like "fake" which is used to manually resolve/reject later on with different promise
+ * With resolve and reject outside for easier change of promise
+ * is used as placeholder untill real promise is assigned
+ */
+declare function createDeferred<T>(): Deferred<T>;
+
+/**
+ * Experimental class to maintain just one promise for some process flow.
+ * Currently is in singleton design, so can be used only in one proces. (currently: all-product-availability-per-day)
+ */
+declare class SinglePromiseWaiter<T = any> {
+    private static _instance;
+    static getInstance<T = any>(): SinglePromiseWaiter<any>;
+    private _promise;
+    get promise(): Promise<T> | null;
+    set promise(promise: Promise<T> | null);
+    get hasPromise(): boolean;
+}
 
 /**
  * Default Entity with needed columns for every basic entity `id`, `uuid`, `created_at`, `updated_at` and `deleted_at`;
@@ -864,6 +838,29 @@ declare const TO_BINARY_FLAG: (v: number | boolean | null | undefined) => Binary
  */
 declare function runWithConcurrency<T>(items: T[], concurrency: number, worker: (item: T) => Promise<void>): Promise<void>;
 
+/**
+ * Resolves a path parameter ID string to either a numeric ID or a UUID (any version).
+ *
+ * tsoa always provides path parameters as strings, so this utility determines
+ * the intended type by checking whether the value is purely numeric.
+ *
+ * @param id - Raw path parameter string
+ * @returns Parsed `number` if the value is numeric, otherwise the original `string`.
+ *
+ * @example
+ * resolvePathParameterId("42")                                   // → 42
+ * resolvePathParameterId("550e8400-e29b-41d4-a716-446655440000") // → "550e8400-..."
+ *
+ * // Typical tsoa usage:
+ * \@Get("{id}")
+ * public async getUserById(\@Request() req: ExRequest, \@Path() id: string) {
+ *     const userId = resolvePathParameterId(id); // number | string
+ * }
+ */
+declare function resolvePathParameterId(id: string): string | number;
+
+declare function isValidCron(expr: string): boolean;
+
 type TransformMap<TIn, TOut, K extends keyof TIn & keyof TOut> = Partial<{
     [P in K]: (val: TIn[P]) => TOut[P];
 }>;
@@ -876,34 +873,28 @@ type TransformMap<TIn, TOut, K extends keyof TIn & keyof TOut> = Partial<{
  */
 declare function buildPatch<TOut extends Record<string, any>, TIn extends Record<string, any>, K extends keyof TIn & keyof TOut = keyof TIn & keyof TOut>(data: Partial<TIn>, keys: readonly K[], transforms?: TransformMap<TIn, TOut, K>): Partial<Pick<TOut, K>>;
 
-type Maybe<T> = T | null;
 /**
- * Validates a value that may be `null` or given type
- *
- * WARNING:
- * `undefined` is NOT accepted by this function.
- * If you need `undefined` support, it must be handled
- * before calling this guard or explicitly allowed elsewhere.
- *
- * @typeParam T - The underlying non-nullable type
- * @param v - Value to validate
- * @param inner - Typeguard function for the underlying type `T`
- *
- * @returns `true` if the value is `null` or satisfies the inner typeguard
+ * Static DateUtils class
  */
-declare function isMaybe<T>(v: unknown, inner: (x: unknown) => x is T): v is Maybe<T>;
-
-declare abstract class DataHelper<T> {
-    private _data?;
-    private _dataPromise;
-    protected deviceIds: Promise<number[]>;
-    constructor(startDataRetrieve: boolean | undefined, deviceIds: Promise<number[]>);
-    protected get data(): Maybe<T> | undefined;
-    protected set data(value: Maybe<T>);
-    protected get dataPromise(): Maybe<Promise<Maybe<T>>>;
-    protected set dataPromise(value: Maybe<Promise<Maybe<T>>>);
-    getData(): Promise<Maybe<T>>;
-    abstract startDataRetrieval(): Promise<Maybe<T>>;
+declare class DateUtils {
+    /** Holidays 2025-2030 as YYYY-MM-DD strings */
+    static HOLIDAYS_STR: readonly string[];
+    /** Holidays 2025-2030 as UTC timestamps */
+    static HOLIDAYS: readonly number[];
+    static fromISOtoSQLtimestamp(ts?: string): string;
+    static toSQLtimestamp(ts: Dayjs): string;
+    static fromSQLtimestamp(mysqlDate: string): Dayjs;
+    static getSqlTimestampFromNowCzech(): string;
+    static fromISO(isoDate: string): Dayjs;
+    static getDate(ts: string): dayjs.Dayjs;
+    static getNow(): Dayjs;
+    static getNowCzech(): Dayjs;
+    static clone(ts: Dayjs): Dayjs;
+    static getLastSunday(weeksOffset?: number): Dayjs;
+    static dayInWeek(ts?: Dayjs): 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    static isWorkdayDay(ts: Dayjs): boolean;
+    static getDiffInMinutesWithNow(inputTime: Dayjs): number;
+    static isInLastDays(numOfDays: number, timestampInput: string | Dayjs): boolean;
 }
 
 /**
@@ -996,8 +987,26 @@ declare abstract class FreshJob<T = void> extends Singleton {
     abstract invoke(): T | Promise<T>;
 }
 
+type Maybe<T> = T | null;
+/**
+ * Validates a value that may be `null` or given type
+ *
+ * WARNING:
+ * `undefined` is NOT accepted by this function.
+ * If you need `undefined` support, it must be handled
+ * before calling this guard or explicitly allowed elsewhere.
+ *
+ * @typeParam T - The underlying non-nullable type
+ * @param v - Value to validate
+ * @param inner - Typeguard function for the underlying type `T`
+ *
+ * @returns `true` if the value is `null` or satisfies the inner typeguard
+ */
+declare function isMaybe<T>(v: unknown, inner: (x: unknown) => x is T): v is Maybe<T>;
+
 type CardNumber = `${number}${number}${number}${number}`;
 
+/** @deprecated use {@link FreshError} instead */
 declare class ApiError extends Error {
     private _statusCode;
     get statusCode(): number;
@@ -1018,6 +1027,219 @@ declare class BusinessWarning extends Error {
     constructor(code: string, message: string);
 }
 
+/**
+ * Options for {@link FreshError} and its subclasses.
+ */
+interface FreshErrorOptions {
+    /**
+     * The original error that caused this one.
+     * Preserved for error chaining and accessible via `error.cause`.
+     */
+    cause?: unknown;
+}
+/**
+ * Base class for all application HTTP errors.
+ *
+ * Extend this class to create typed, status-specific errors with a hardcoded
+ * HTTP status code and status string. Direct instantiation is allowed but
+ * subclasses are preferred for consistent error identity.
+ *
+ * `error.name` is automatically set to the subclass name, so stack traces
+ * and logs show `UnauthorizedError` instead of the generic `Error`.
+ *
+ * @example
+ * // Without cause
+ * throw new FreshError(HttpStatus.NOT_FOUND, "error", "User not found");
+ *
+ * // With cause — preserves the original error for logging/debugging
+ * try {
+ *     await db.findUser(id);
+ * } catch (err) {
+ *     throw new FreshError(HttpStatus.INTERNAL_SERVER_ERROR, "internal-server-error", "DB query failed", { cause: err });
+ * }
+ */
+declare class FreshError extends Error {
+    /** HTTP status code sent in the response. */
+    readonly statusCode: number;
+    /** Structured response body describing the error. */
+    readonly statusDto: StatusDto;
+    constructor(statusCode: HttpStatus, status: Status, detail?: string, options?: FreshErrorOptions);
+}
+
+/** 400 — The request is malformed or contains invalid parameters. */
+declare class BadRequestError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 401 — Authentication is required or the provided credentials are invalid. */
+declare class UnauthorizedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 402 — Payment is required to access the requested resource. */
+declare class PaymentRequiredError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 403 — The caller is authenticated but lacks permission to access the resource. */
+declare class ForbiddenError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 404 — The requested resource does not exist. */
+declare class NotFoundError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 405 — The HTTP method is not supported for this endpoint. */
+declare class MethodNotAllowedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 406 — The server cannot produce a response matching the client's `Accept` headers. */
+declare class NotAcceptableError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 407 — Authentication with the proxy is required before the request can proceed. */
+declare class ProxyAuthenticationRequiredError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 408 — The server timed out waiting for the client to complete the request. */
+declare class RequestTimeoutError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 409 — The request conflicts with the current state of the resource. */
+declare class ConflictError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 410 — The resource has been permanently removed and will not return. */
+declare class GoneError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 411 — The request must include a `Content-Length` header. */
+declare class LengthRequiredError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 412 — A precondition in the request headers was not met. */
+declare class PreconditionFailedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 413 — The request body exceeds the server's size limit. */
+declare class PayloadTooLargeError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 414 — The request URI is longer than the server is willing to process. */
+declare class UriTooLongError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 415 — The request's `Content-Type` is not supported by the server. */
+declare class UnsupportedMediaTypeError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 416 — The `Range` header in the request cannot be satisfied by the resource. */
+declare class RangeNotSatisfiableError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 417 — The expectation in the `Expect` request header could not be met. */
+declare class ExpectationFailedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 418 — The server refuses to brew coffee because it is, permanently, a teapot. */
+declare class ImATeapotError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 421 — The request was directed at a server that cannot produce a response. */
+declare class MisdirectedRequestError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 422 — The request is well-formed but contains semantic errors. */
+declare class UnprocessableEntityError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 423 — The resource is locked and cannot be accessed. */
+declare class LockedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 424 — The request failed because a dependency it relies on also failed. */
+declare class FailedDependencyError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 425 — The server is unwilling to process a request that may be replayed. */
+declare class TooEarlyError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 426 — The client must switch to a different protocol to proceed. */
+declare class UpgradeRequiredError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 428 — The request must be conditional (e.g. missing `If-Match` header). */
+declare class PreconditionRequiredError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 429 — The client has sent too many requests in a given time window. */
+declare class TooManyRequestsError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 431 — The request headers are too large for the server to process. */
+declare class RequestHeaderFieldsTooLargeError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 451 — The resource is unavailable due to legal restrictions. */
+declare class UnavailableForLegalReasonsError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 500 — The server encountered an unexpected condition. */
+declare class InternalServerError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 501 — The server does not support the functionality required to fulfil the request. */
+declare class NotImplementedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 502 — The upstream server returned an invalid response. */
+declare class BadGatewayError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 503 — The server is temporarily unavailable, usually due to maintenance or overload. */
+declare class ServiceUnavailableError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 504 — The upstream server did not respond in time. */
+declare class GatewayTimeoutError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 505 — The HTTP version used in the request is not supported by the server. */
+declare class HttpVersionNotSupportedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 506 — The server has a configuration error resulting in circular content negotiation. */
+declare class VariantAlsoNegotiatesError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 507 — The server cannot store the representation needed to complete the request. */
+declare class InsufficientStorageError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 508 — The server detected an infinite loop while processing the request. */
+declare class LoopDetectedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 510 — Further extensions to the request are required for the server to fulfil it. */
+declare class NotExtendedError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+/** 511 — The client must authenticate to gain network access (e.g. captive portal). */
+declare class NetworkAuthenticationRequiredError extends FreshError {
+    constructor(detail?: string, options?: FreshErrorOptions);
+}
+
+declare abstract class DataHelper<T> {
+    private _data?;
+    private _dataPromise;
+    protected deviceIds: Promise<number[]>;
+    constructor(startDataRetrieve: boolean | undefined, deviceIds: Promise<number[]>);
+    protected get data(): Maybe<T> | undefined;
+    protected set data(value: Maybe<T>);
+    protected get dataPromise(): Maybe<Promise<Maybe<T>>>;
+    protected set dataPromise(value: Maybe<Promise<Maybe<T>>>);
+    getData(): Promise<Maybe<T>>;
+    abstract startDataRetrieval(): Promise<Maybe<T>>;
+}
+
 declare const FRESH_ESLINT_CONFIG: {
     files: string[];
     ignores: string[];
@@ -1095,4 +1317,4 @@ interface HealthCheckResult {
     };
 }
 
-export { AMOUNT_UNIT, ActionCommandCode, ApiError, BaseEntityChangeSubscriber, type BinaryFlag, BusinessWarning, type CardNumber, Category, DEFAULT_PAGINATION_PARAMS, DataHelper, DateUtils, type Deferred, DepotPoolStatus, Device, type EntityChangeEvent, FreshDao, FreshEntity, FreshHyperEntity, FreshJob, FreshTranslationBase, type HealthCheckResult, HttpStatus, type IsDecimalOptions, LanguageCode, Manufacturer, type Maybe, type PaginatedList, type PaginationMeta, type PaginationParams, PaymentMethod, PG_DATA_SOURCE_OPTIONS as PgDataSourceOptions, Product, SinglePromiseWaiter, Singleton, type Status, StatusDto, Subcategory, TO_BINARY_FLAG, TimestampColumn, TransactionType, buildPatch, constructTypeormPagination, createDeferred, FRESH_ESLINT_CONFIG as freshEslintConfig, getPaginationMeta, getPaginationParams, hasOwn, isDecimal, isEnumValue, isFlag01, isMaybe, isNumber, isNumberInRange, isObject, isString, isValidCron, listAll, parsePaginationFromURL, runWithConcurrency, toDecimal };
+export { AMOUNT_UNIT, ActionCommandCode, ApiError, BadGatewayError, BadRequestError, BaseEntityChangeSubscriber, type BinaryFlag, BusinessWarning, type CardNumber, Category, ConflictError, DEFAULT_PAGINATION_PARAMS, DataHelper, DateUtils, type Deferred, DepotPoolStatus, Device, type EntityChangeEvent, ExpectationFailedError, FailedDependencyError, ForbiddenError, FreshDao, FreshEntity, FreshError, type FreshErrorOptions, FreshHyperEntity, FreshJob, FreshTranslationBase, GatewayTimeoutError, GoneError, type HealthCheckResult, HttpStatus, HttpVersionNotSupportedError, ImATeapotError, InsufficientStorageError, InternalServerError, type IsDecimalOptions, LanguageCode, LengthRequiredError, LockedError, LoopDetectedError, Manufacturer, type Maybe, MethodNotAllowedError, MisdirectedRequestError, NetworkAuthenticationRequiredError, NotAcceptableError, NotExtendedError, NotFoundError, NotImplementedError, type PaginatedList, type PaginationMeta, type PaginationParams, PayloadTooLargeError, PaymentMethod, PaymentRequiredError, PG_DATA_SOURCE_OPTIONS as PgDataSourceOptions, PreconditionFailedError, PreconditionRequiredError, Product, ProxyAuthenticationRequiredError, RangeNotSatisfiableError, RequestHeaderFieldsTooLargeError, RequestTimeoutError, ServiceUnavailableError, SinglePromiseWaiter, Singleton, type Status, StatusDto, Subcategory, TO_BINARY_FLAG, TimestampColumn, TooEarlyError, TooManyRequestsError, TransactionType, UnauthorizedError, UnavailableForLegalReasonsError, UnprocessableEntityError, UnsupportedMediaTypeError, UpgradeRequiredError, UriTooLongError, VariantAlsoNegotiatesError, buildPatch, constructTypeormPagination, createDeferred, FRESH_ESLINT_CONFIG as freshEslintConfig, getPaginationMeta, getPaginationParams, hasOwn, isDecimal, isEnumValue, isFlag01, isMaybe, isNumber, isNumberInRange, isObject, isString, isValidCron, listAll, parsePaginationFromURL, resolvePathParameterId, runWithConcurrency, toDecimal };