@buildplease/core 1.0.0

package/dist/src/index.d.cts

@@ -0,0 +1,2296 @@
+import "reflect-metadata";
+import { Container, Container as Container$1 } from "inversify";
+import { Duration, FormatOptions, FromUnixTimeOptions } from "date-fns";
+import { FormatOptionsWithTZ } from "date-fns-tz";
+import { E_ALREADY_LOCKED, E_CANCELED, E_TIMEOUT, Mutex, MutexInterface, Semaphore, SemaphoreInterface, tryAcquire, withTimeout } from "async-mutex";
+import { z } from "zod";
+export * from "date-fns";
+//#region src/di/symbols.d.ts
+declare const CoreSymbols: {
+  DI: {
+    Formatter: {
+      UnitController: symbol;
+    };
+    Logger: symbol;
+  };
+};
+//#endregion
+//#region src/di/assembly.d.ts
+type AssemblyContainer = Container$1;
+interface Assembly {
+  assemble(container: AssemblyContainer): void;
+}
+//#endregion
+//#region src/di/scope-controller.d.ts
+declare class ScopeController {
+  private _container;
+  constructor();
+  get container(): Container$1;
+  getInstance<T>(serviceIdentifier: symbol): T;
+  registerAssemblies(assemblies: Assembly[]): Promise<void>;
+}
+//#endregion
+//#region src/converter/async-converter.d.ts
+/**
+ * Base class for asynchronous data conversion between two types.
+ *
+ * @template Input - The source data type.
+ * @template Output - The target data type.
+ */
+declare abstract class AsyncConverter<Input, Output> {
+  /**
+   * Converts a single input into the target output type asynchronously.
+   *
+   * @param input - The input data to convert.
+   * @returns A promise resolving to the converted output.
+   */
+  abstract convert(input: Input): Promise<Output>;
+  /**
+   * Converts an array of inputs into outputs asynchronously.
+   *
+   * @param inputs - An array of input data.
+   * @returns A promise resolving to an array of converted outputs.
+   */
+  convertArray(inputs: Input[]): Promise<Output[]>;
+  /**
+   * Converts an array of inputs, skipping invalid entries asynchronously.
+   *
+   * @param inputs - An array of input data.
+   * @returns A promise resolving to an array of valid outputs, ignoring errors.
+   */
+  convertArrayIgnoreInvalid(inputs: Input[]): Promise<Output[]>;
+}
+//#endregion
+//#region src/converter/converter.d.ts
+/**
+ * Base class for synchronous data conversion between two types.
+ *
+ * @template Input - The source data type.
+ * @template Output - The target data type.
+ */
+declare abstract class Converter<Input, Output> {
+  /**
+   * Converts a single input into the target output type.
+   *
+   * @param input - The input data to convert.
+   * @returns The converted output.
+   */
+  abstract convert(input: Input): Output;
+  /**
+   * Converts an array of inputs into outputs.
+   *
+   * @param inputs - An array of input data.
+   * @returns An array of converted outputs.
+   */
+  convertArray(inputs: Input[]): Output[];
+  /**
+   * Converts an array of inputs, skipping invalid entries.
+   *
+   * @param inputs - An array of input data.
+   * @returns An array of valid outputs, ignoring errors.
+   */
+  convertArrayIgnoreInvalid(inputs: Input[]): Output[];
+}
+//#endregion
+//#region src/device/device-type.d.ts
+declare enum DeviceType {
+  MOBILE = "MOBILE",
+  DESKTOP = "DESKTOP",
+  WEB = "WEB",
+  TABLET = "TABLET"
+}
+//#endregion
+//#region src/device/os-type.d.ts
+declare enum OSType {
+  IOS = "IOS",
+  ANDROID = "ANDROID",
+  WINDOWS = "WINDOWS",
+  MACOS = "MACOS",
+  LINUX = "LINUX"
+}
+//#endregion
+//#region src/device/push-notification-status.d.ts
+declare enum PushNotificationStatus {
+  UNKNOWN = "UNKNOWN",
+  ON = "ON",
+  OFF = "OFF"
+}
+//#endregion
+//#region src/error/canceled-error.d.ts
+declare class CanceledError extends Error {
+  readonly code = "CANCELED";
+  constructor(opts?: {
+    message?: string;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/error/conversion-error.d.ts
+declare class ConversionError extends Error {
+  readonly code = "MALFORMED_DATA";
+  readonly field?: string;
+  constructor(opts?: {
+    message?: string;
+    field?: string;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/error/network-error.d.ts
+declare class NetworkError extends Error {
+  readonly code = "NETWORK_ERROR";
+  constructor(opts?: {
+    message?: string;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/error/timeout-error.d.ts
+declare class TimeoutError extends Error {
+  readonly code = "TIMEOUT";
+  constructor(opts?: {
+    message?: string;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/error/unknown-error.d.ts
+declare class UnknownError extends Error {
+  readonly code = "UNKNOWN";
+  constructor(opts?: {
+    message?: string;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/utils/application/enum-utils.d.ts
+/**
+ * Try to map any input into one of the values of a TS enum.
+ *
+ * - Supports string and numeric enums.
+ * - Compares against both the enum’s KEY and VALUE (after normalization).
+ * - Skips the reverse-mapping keys TS emits for numeric enums (e.g. "0").
+ *
+ * @param input   Anything; only strings/numbers are considered (others → null).
+ * @param enumObj The enum object to map into.
+ * @param options.normalize  Optional normalizer (default: trim + uppercase).
+ * @returns       One of the enum’s values (E[keyof E]) or null if no match.
+ */
+declare function mapToEnum<E extends Record<string, string | number>>(input: unknown, enumObj: E, options?: {
+  normalize?: (s: string) => string;
+}): E[keyof E] | null;
+//#endregion
+//#region src/utils/application/error-utils.d.ts
+/**
+ * Checks if a value is an Error instance.
+ *
+ * @param value - Value to check.
+ * @returns True if the value is an Error.
+ */
+declare function isError(value: unknown): value is Error;
+//#endregion
+//#region src/utils/application/object-utils.d.ts
+interface ObjectFilterOptions {
+  filterNull?: boolean;
+  filterUndefined?: boolean;
+  filterEmptyString?: boolean;
+  filterEmptyObject?: boolean;
+  filterEmptyArray?: boolean;
+}
+/**
+ * Recursively filters properties from an object based on the provided options.
+ *
+ * @template T - The type of the object to filter.
+ * @param {T} obj - The object to filter.
+ * @param {ObjectFilterOptions} [options={}] - Options that determine which properties to filter out.
+ * @param {boolean} [options.filterNull=true] - If true, properties with null values will be filtered out.
+ * @param {boolean} [options.filterUndefined=true] - If true, properties with undefined values will be filtered out.
+ * @param {boolean} [options.filterEmptyString=false] - If true, properties with empty string values will be filtered out.
+ * @param {boolean} [options.filterEmptyObject=false] - If true, properties with empty object values will be filtered out.
+ * @param {boolean} [options.filterEmptyArray=false] - If true, properties with empty array values will be filtered out.
+ * @returns {Partial<T>} - A new object with the filtered properties.
+ */
+declare function filterObject<T extends object | null | undefined>(obj: T, options?: ObjectFilterOptions): Partial<T>;
+/**
+ * Checks if a value is an object.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is object} - True if the value is an object, false otherwise.
+ */
+declare function isObject(value: unknown): value is object;
+/**
+ * Checks if a value is an empty object.
+ * This checks if the object is null, undefined, or an empty object and returns a type guard.
+ *
+ * @param {T | null | undefined} value - The value to check.
+ * @returns {value is T} - True if the value is an empty object, false otherwise.
+ */
+declare function isEmptyObject<T extends object>(value: T | null | undefined): value is T;
+/**
+ * Checks if a value is a non-empty object, ensuring it is not null, undefined, or empty.
+ * This acts as a type guard.
+ *
+ * @param {T | null | undefined} value - The value to check.
+ * @returns {value is T} - True if the value is a non-empty object, false otherwise.
+ */
+declare function isNonEmptyObject<T extends object>(value: T | null | undefined): value is T;
+/**
+ * Checks if a value is a plain object (not a class instance or built-in object).
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is Record<string, any>} - True if the value is a plain object, false otherwise.
+ */
+declare function isPlainObject(value: unknown): value is Record<string, any>;
+//#endregion
+//#region src/utils/application/optional-utils.d.ts
+/**
+ * Excludes `undefined` from the given type `T`.
+ *
+ * @template T - The type to evaluate.
+ * @example
+ * type A = NonUndefined<string | undefined>; // string
+ * type B = NonUndefined<number | null | undefined>; // number | null
+ * type C = NonUndefined<undefined>; // never
+ */
+type NonUndefined<T> = T extends undefined ? never : T;
+/**
+ * A type that represents a value that can be null or undefined.
+ *
+ * @template T
+ */
+type OptionalValue<T> = T | null | undefined;
+/**
+ * Wraps a value to provide optional-aware operations.
+ *
+ * @template T
+ */
+declare class Optional<T> {
+  private readonly value;
+  constructor(value: T | null | undefined);
+  /**
+   * Checks if the value is `null` or `undefined`.
+   *
+   * @returns {boolean}
+   *   True if the contained value is `null` or `undefined`.
+   */
+  get isNil(): boolean;
+  /**
+   * Applies a transformation if the value is present.
+   *
+   * @param {(value: T) => U} transform
+   *   A function to apply to the contained value.
+   * @template U
+   * @returns {Optional<U>}
+   *   A new Optional wrapping the transformed value, or `Optional<null>` if absent.
+   */
+  map<U>(transform: (value: T) => U): Optional<U>;
+  /**
+   * Applies a transformation and expects an Optional as the result.
+   * Useful for chaining nested Optionals.
+   *
+   * @param {(value: T) => Optional<U>} transform
+   *   A function returning an Optional.
+   * @template U
+   * @returns {Optional<U>}
+   *   The result of the transformation, or `Optional<null>` if absent.
+   */
+  flatMap<U>(transform: (value: T) => Optional<U>): Optional<U>;
+  /**
+   * Returns the contained value if not null or undefined, or the result of the provided closure otherwise.
+   *
+   * @param {() => T} closure
+   *   A function that returns a default value.
+   * @returns {T}
+   *   The contained value if present, or the result of `closure()`.
+   */
+  or(closure: () => T): T;
+  /**
+   * Returns the contained value if not null or undefined, otherwise throws the specified error.
+   * If no error is provided, throws a default `Error('Conversion Error')`.
+   *
+   * @param {Error} [error]
+   *   Optional error to throw if the value is absent.
+   * @returns {T}
+   *   The contained value if present.
+   * @throws {Error}
+   *   The provided error, or `Error('Conversion Error')` if none provided.
+   */
+  orThrow(error?: Error): T;
+  /**
+   * Returns the contained value if not null or undefined, or the provided default value otherwise.
+   * Allows `null` as a default only if `T | null` is assignable to the expected type.
+   *
+   * @param {U} defaultValue
+   *   A default value to return if the contained value is absent.
+   * @template U
+   * @returns {T | U}
+   *   The contained value if present, or `defaultValue` otherwise.
+   */
+  orDefault<U>(defaultValue: U): T | U;
+  /**
+   * If the value is present, applies the provided function to it.
+   *
+   * @param {(value: T) => void} closure
+   *   A function to execute if the value is present.
+   * @returns {this}
+   *   The current Optional instance for chaining.
+   */
+  ifPresent(closure: (value: T) => void): this;
+  /**
+   * If the value is absent (`null` or `undefined`), executes the provided function.
+   *
+   * @param {() => void} closure
+   *   A function to execute if the value is absent.
+   * @returns {this}
+   *   The current Optional instance for chaining.
+   */
+  ifAbsent(closure: () => void): this;
+}
+/**
+ * Wraps a value in an `Optional` instance.
+ *
+ * @param {T | null | undefined} value
+ *   The value to wrap.
+ * @template T
+ * @returns {Optional<T>}
+ *   An instance of `Optional` containing the given value.
+ */
+declare function optional<T>(value: T | null | undefined): Optional<T>;
+/**
+ * Checks if a value is defined (not `undefined`).
+ *
+ * @param {OptionalValue<T>} value
+ *   The value to check.
+ * @template T
+ * @returns {boolean}
+ *   True if the value is not `undefined`.
+ */
+declare function isDefined<T>(value: OptionalValue<T>): value is NonUndefined<T>;
+/**
+ * Checks if a value is not `null`.
+ *
+ * @param {OptionalValue<T>} value
+ *   The value to check.
+ * @template T
+ * @returns {boolean}
+ *   True if the value is not `null`.
+ */
+declare function isNotNull<T>(value: OptionalValue<T>): value is NonNullable<T>;
+/**
+ * Checks if a value is defined (not `undefined`) and not `null`.
+ *
+ * @param {OptionalValue<T>} value
+ *   The value to check.
+ * @template T
+ * @returns {boolean}
+ *   True if the value is neither `undefined` nor `null`.
+ */
+declare function isDefinedAndNotNull<T>(value: OptionalValue<T>): value is NonNullable<T>;
+/**
+ * Executes a function and wraps the result in an Optional.
+ * If the function throws, returns an Optional with `null` value.
+ *
+ * @param fn - The function to execute.
+ * @template T
+ * @returns An Optional wrapping the function result, or `Optional<null>` if an error occurs.
+ *
+ * @example
+ * // A) single-expression sync (no braces, no return)
+ * const optA = ignoreError(() => JSON.parse('{ bad json }'));
+ * // optA.isNil === true
+ *
+ * @example
+ * // B) block-body sync (braces, implicit return via function result)
+ * const optB = ignoreError(() => {
+ *   // might throw
+ *   return JSON.parse('{"ok":true}');
+ * });
+ * // optB.or(() => ({ ok: false })) === { ok: true }
+ *
+ * @example
+ * // C) throwing sync
+ * const optC = ignoreError(() => { throw new Error('ouch'); });
+ * // optC.isNil === true
+ */
+declare function ignoreError<T>(fn: () => T): Optional<T>;
+/**
+ * Executes the provided function and suppresses any errors.
+ * Supports both synchronous and asynchronous bodies.
+ * Optionally handles any error via `onError`.
+ *
+ * @param fn
+ *   A function that can return a value or a Promise.
+ * @param onError
+ *   Optional function that handles the error.
+ * @returns Promise that always resolves to void.
+ *
+ * @example
+ * // A) single-expression async return
+ * await ignoreErrorAsync(() => cleanupTempFiles());
+ *
+ * @example
+ * // B) block-body sync (fn returns void)
+ * await ignoreErrorAsync(() => {
+ *   console.log('might throw');
+ *   // no return needed
+ * });
+ *
+ * @example
+ * // C) block-body returning a Promise
+ * await ignoreErrorAsync(() => {
+ *   return fetch('/api/data');
+ * }, err => {
+ *   console.warn('fetch failed:', err);
+ * });
+ *
+ * @example
+ * // D) async wrapper (can use await inside)
+ * await ignoreErrorAsync(async () => {
+ *   await cleanupTempFiles();
+ *   await notifyAdmin();
+ * }, err => {
+ *   console.error('cleanup+notify failed:', err);
+ * });
+ */
+declare function ignoreErrorAsync(fn: () => any | Promise<any>, onError?: (error: any) => void): Promise<void>;
+/**
+ * Executes an async function and wraps the result in an Optional.
+ * If the function throws, returns an Optional with `null` value.
+ *
+ * @param fn - The async function to execute.
+ * @param onError - Optional handler for any thrown error.
+ * @template T
+ * @returns Promise<Optional<T>> wrapping the result or null.
+ *
+ * @example
+ * // A) simple async call
+ * const optA = await ignoreErrorOptionalAsync(() => fetchJson('/user'));
+ * // optA.ifPresent(data => console.log(data))
+ *
+ * @example
+ * // B) block-body async with error callback
+ * const optB = await ignoreErrorOptionalAsync(async () => {
+ *   const resp = await fetch('/user');
+ *   return resp.json();
+ * }, err => {
+ *   console.error('load user failed:', err);
+ * });
+ *
+ * @example
+ * // C) explicit return of promise
+ * const optC = await ignoreErrorOptionalAsync(() => fetchJson('/settings'));
+ */
+declare function ignoreErrorOptionalAsync<T>(fn: () => Promise<T>, onError?: (error: unknown) => void): Promise<Optional<T>>;
+//#endregion
+//#region src/utils/application/promise-utils.d.ts
+type Awaitable<T> = T | Promise<T>;
+declare function delay(ms: number): Promise<void>;
+//#endregion
+//#region src/utils/application/string-utils.d.ts
+/**
+ * Checks if the value is a string and non-empty after trimming.
+ *
+ * @param value The value to check.
+ * @returns True if value is a non-empty string.
+ */
+declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Checks if the value is null, undefined, or an empty string after trimming.
+ *
+ * @param value The value to check.
+ * @returns True if value is null, undefined, or empty string.
+ */
+declare function isNullOrEmpty(value: unknown): value is null | undefined | '';
+/**
+ * Transforms an empty string or undefined to `null`. Otherwise, returns the string as is.
+ */
+declare function emptyOrUndefinedStringToNull(value: unknown): string | null;
+/**
+ * Capitalizes the first character of a string.
+ * Returns `null` if the input is not a valid non-empty string.
+ */
+declare function capitalized(value: unknown): string | null;
+//#endregion
+//#region src/utils/domain/empty.d.ts
+type Empty = Record<string, never>;
+//#endregion
+//#region src/utils/domain/json-serializable.d.ts
+/**
+ * JSON primitive.
+ *
+ * @remarks Valid JSON primitive types are: string, number, boolean, null.
+ */
+type JSONPrimitive = string | number | boolean | null;
+/**
+ * JSON object (string keys, JSON values).
+ *
+ * @remarks Keys must be strings. Values must be valid {@link JSONValue}.
+ */
+type JSONObject = {
+  [key: string]: JSONValue;
+};
+/**
+ * Any JSON value.
+ *
+ * @remarks Safe to pass to `JSON.stringify` and read back with `JSON.parse`.
+ */
+type JSONValue = JSONPrimitive | JSONObject | ReadonlyArray<JSONValue>;
+/**
+ * Implemented by types that can serialize themselves to JSON.
+ */
+interface JSONSerializable {
+  /**
+   * Convert this instance to a JSON value.
+   *
+   * @returns A {@link JSONValue} suitable for `JSON.stringify`.
+   */
+  toJSON(): JSONValue;
+}
+/**
+ * Checks whether a value is a JSON primitive.
+ *
+ * @param value - Input value to test.
+ * @returns `true` if `value` is a JSON primitive (`string | number | boolean | null`), otherwise `false`.
+ */
+declare function isJSONPrimitive(value: unknown): value is JSONPrimitive;
+/**
+ * Checks whether a value implements {@link JSONSerializable}.
+ *
+ * @param value - Input value to test.
+ * @returns `true` if `value` is a non-null object with a `toJSON()` function, otherwise `false`.
+ */
+declare function isJSONSerializable(value: unknown): value is JSONSerializable;
+//#endregion
+//#region src/utils/domain/partial.d.ts
+/**
+ * Recursively makes all properties of an object type optional, including nested objects.
+ *
+ * This is useful when you want to construct partial configuration or input objects,
+ * where any depth of nesting may be optionally provided.
+ *
+ * @template T The object type to transform.
+ *
+ * @example
+ * type User = {
+ *   name: string;
+ *   profile: {
+ *     age: number;
+ *     location: string;
+ *   };
+ * };
+ *
+ * type PartialUser = DeepPartial<User>;
+ * // Equivalent to:
+ * // {
+ * //   name?: string;
+ * //   profile?: {
+ * //     age?: number;
+ * //     location?: string;
+ * //   };
+ * // }
+ */
+type DeepPartial<T> = { [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]; };
+/**
+ * Makes only the leaf (non-object) properties of a type optional,
+ * while preserving the required structure of nested objects.
+ *
+ * Special handling for `Date`: it is treated as a leaf and made optional.
+ *
+ * @template T The object type to transform.
+ *
+ * @example
+ * type User = {
+ *   name: string;
+ *   profile: {
+ *     age: number;
+ *     location: string;
+ *     createdAt: Date;
+ *   };
+ * };
+ *
+ * type OptionalUser = OptionalPartial<User>;
+ * // Equivalent to:
+ * // {
+ * //   name?: string;
+ * //   profile: {
+ * //     age?: number;
+ * //     location?: string;
+ * //     createdAt?: Date;
+ * //   };
+ * // }
+ */
+type OptionalPartial<T> = { [K in keyof T]: T[K] extends object ? T[K] extends Date ? T[K] | undefined : OptionalPartial<T[K]> : T[K] | undefined; };
+//#endregion
+//#region src/utils/domain/primitive.d.ts
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Checks if a value is a JavaScript primitive.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a primitive.
+ */
+declare function isPrimitive(value: unknown): value is Primitive;
+//#endregion
+//#region src/utils/domain/query.d.ts
+type Query<T> = { [P in keyof T]?: T[P]; };
+//#endregion
+//#region src/utils/domain/required.d.ts
+/**
+ * Deeply marks all properties as required (including nested objects and arrays).
+ * @template T
+ */
+type DeepRequired<T> = T extends ((...args: unknown[]) => unknown) ? T : T extends Primitive ? T : T extends Array<infer U> ? Array<DeepRequired<U>> : T extends Array<infer U> ? Array<DeepRequired<U>> : { [K in keyof T]-?: DeepRequired<NonNullable<T[K]>>; };
+//#endregion
+//#region src/utils/extensions/array-extensions.d.ts
+declare global {
+  interface Array<T> {
+    /**
+     * Checks if the array is empty or undefined or null.
+     * @returns `true` if the array is empty, undefined, or null; otherwise `false`.
+     */
+    isEmpty(): boolean;
+  }
+}
+//#endregion
+//#region src/utils/extensions/string-extensions.d.ts
+declare global {
+  interface String {
+    capitalized(): string;
+  }
+}
+//#endregion
+//#region src/model/address.d.ts
+declare class Address implements JSONSerializable {
+  streetLine1: string;
+  streetLine2?: string | null;
+  postalCode?: string | null;
+  state?: string | null;
+  city?: string | null;
+  country: string;
+  countryCode?: string | null;
+  constructor(input: {
+    streetLine1: string;
+    streetLine2?: string | null;
+    postalCode?: string | null;
+    state?: string | null;
+    city?: string | null;
+    country: string;
+    countryCode?: string | null;
+  });
+  toJSON(): any;
+  formatted(): string;
+}
+//#endregion
+//#region src/model/contacts.d.ts
+declare class Contacts implements JSONSerializable {
+  email?: string | null;
+  fb?: string | null;
+  ig?: string | null;
+  phone?: string | null;
+  web?: string | null;
+  constructor({ email, fb, ig, phone, web }: {
+    email?: string | null;
+    fb?: string | null;
+    ig?: string | null;
+    phone?: string | null;
+    web?: string | null;
+  });
+  toJSON(): any;
+}
+//#endregion
+//#region src/model/date-time.d.ts
+/**
+ * A date-and-time utility class offering parsing, formatting, and arithmetic.
+ *
+ * - Instantiate with no arguments for current date/time.
+ * - Instantiate with a `Date` or ISO-format string.
+ *
+ * @throws {Error} If the provided date input is invalid.
+ *
+ * @example
+ * const now = new DateTime();
+ * const fromDate = new DateTime(new Date('2022-12-12'));
+ * const fromIso  = new DateTime('2022-12-12T00:00:00Z');
+ */
+declare class DateTime implements JSONSerializable {
+  private readonly date;
+  /**
+   * @param {Date | string} [input]
+   *   A Date object or ISO-format date string. Omit to use current date/time.
+   * @throws {Error}
+   *   If `input` is neither a valid Date nor a parseable string.
+   */
+  constructor(input?: Date | string);
+  /**
+   * Static method to create a DateTime from a Unix timestamp (seconds).
+   * @param {number} unixTimestamp - The Unix timestamp in seconds.
+   * @param {FromUnixTimeOptions} options
+   * @returns {DateTime}
+   */
+  static fromUnixTimestamp(unixTimestamp: number, options?: FromUnixTimeOptions): DateTime;
+  /** @returns The current moment as a DateTime. */
+  static now(): DateTime;
+  /**
+   * JSON.stringify will look for `toJSON()` first, so
+   * we emit an ISO string by default.
+   */
+  toJSON(): string;
+  /** @returns The wrapped JavaScript Date. */
+  toDate(): Date;
+  /** @returns The Unix timestamp in seconds. */
+  toUnixTimestamp(): number;
+  /**
+   * Returns the time value in milliseconds (similar to getTime() method of Date).
+   * @returns {number} The time in milliseconds.
+   */
+  getTime(): number;
+  /** @returns An ISO‐8601 string. */
+  toISOString(): string;
+  /**
+   * Formats this DateTime using the given pattern.
+   *
+   * @param pattern
+   *   A format string (for example, one of the `DateFormat` values or
+   *   any custom string).
+   * @param options
+   *   Optional `{ locale?: Locale }` for localized month/day names.
+   * @returns
+   *   The formatted date string.
+   *
+   * @example
+   * ```ts
+   * const dt = new DateTime('2025-06-05T14:30:00Z');
+   * console.log(dt.format(DateFormat.ISO_DATETIME));  // "2025-06-05T14:30:00+00:00"
+   * console.log(dt.format(DateFormat.MM_DD_YYYY));    // "06/05/2025"
+   * console.log(dt.format(DateFormat.RSS));           // "Fri, 05 Jun 2025 14:30:00 +0000"
+   * console.log(dt.format('yyyy/MM/dd HH:mm:ss'));    // "2025/06/05 14:30:00"
+   * ```
+   */
+  format(pattern: DateFormat | string, options?: FormatOptions): string;
+  addingDuration(duration: Duration): DateTime;
+  addingMilliseconds(msCount: number): DateTime;
+  addingSeconds(sec: number): DateTime;
+  addingMinutes(min: number): DateTime;
+  addingHours(hr: number): DateTime;
+  addingDays(d: number): DateTime;
+  addingWeeks(w: number): DateTime;
+  addingMonths(m: number): DateTime;
+  addingYears(y: number): DateTime;
+  subtractingDuration(duration: Duration): DateTime;
+  subtractingMilliseconds(msCount: number): DateTime;
+  subtractingSeconds(sec: number): DateTime;
+  subtractingMinutes(min: number): DateTime;
+  subtractingHours(hr: number): DateTime;
+  subtractingDays(d: number): DateTime;
+  subtractingWeeks(w: number): DateTime;
+  subtractingMonths(m: number): DateTime;
+  subtractingYears(y: number): DateTime;
+  differenceInMilliseconds(other: DateTime): number;
+  differenceInSeconds(other: DateTime): number;
+  differenceInMinutes(other: DateTime): number;
+  differenceInHours(other: DateTime): number;
+  differenceInDays(other: DateTime): number;
+  differenceInWeeks(other: DateTime): number;
+  differenceInMonths(other: DateTime): number;
+  differenceInYears(other: DateTime): number;
+  isEqualTo(other: DateTime): boolean;
+  isBefore(other: DateTime): boolean;
+  isAfter(other: DateTime): boolean;
+  compareTo(other: DateTime): number;
+  isSameDayAs(other: DateTime): boolean;
+  startOfDay(): DateTime;
+  endOfDay(): DateTime;
+  startOfWeek(): DateTime;
+  endOfWeek(): DateTime;
+  startOfMonth(): DateTime;
+  endOfMonth(): DateTime;
+  startOfYear(): DateTime;
+  endOfYear(): DateTime;
+  /** Day of month (1–31). */
+  get dayOfMonth(): number;
+  /** Day of week (0–6, 0 = Sunday). */
+  get dayOfWeek(): number;
+  /** Month (0–11). */
+  get month(): number;
+  /** Year. */
+  get year(): number;
+  /** Hours (0–23). */
+  get hours(): number;
+  /** Minutes (0–59). */
+  get minutes(): number;
+  /** Seconds (0–59). */
+  get seconds(): number;
+  /**
+   * Sets the day of the month.
+   *
+   * @param day  Day of the month (1–31).
+   * @returns {DateTime}
+   */
+  settingDayOfMonth(day: number): DateTime;
+  /**
+   * Sets the day of the week.
+   *
+   * @param day  Day of the week (0–6, 0 = Sunday).
+   * @returns {DateTime}
+   */
+  settingDayOfWeek(day: number): DateTime;
+  /**
+   * Sets the month.
+   *
+   * @param month  Month (0–11).
+   * @returns {DateTime}
+   */
+  settingMonth(month: number): DateTime;
+  /**
+   * Sets the year.
+   *
+   * @param year  Year.
+   * @returns {DateTime}
+   */
+  settingYear(year: number): DateTime;
+  /**
+   * Sets the hours.
+   *
+   * @param hours  Hours (0–23).
+   * @returns {DateTime}
+   */
+  settingHours(hours: number): DateTime;
+  /**
+   * Sets the minutes.
+   *
+   * @param minutes  Minutes (0–59).
+   * @returns {DateTime}
+   */
+  settingMinutes(minutes: number): DateTime;
+  /**
+   * Sets the seconds.
+   *
+   * @param seconds  Seconds (0–59).
+   * @returns {DateTime}
+   */
+  settingSeconds(seconds: number): DateTime;
+}
+declare enum DateFormat {
+  /** ISO date only (yyyy-MM-dd), e.g. "2025-06-05" */
+  ISO_DATE = "yyyy-MM-dd",
+  /** ISO date + time with offset, e.g. "2025-06-05T13:24:00+00:00" */
+  ISO_DATETIME = "yyyy-MM-dd'T'HH:mm:ssXXX",
+  /** Month/day/year, e.g. "06/05/2025" */
+  MM_DD_YYYY = "MM/dd/yyyy",
+  /** Full month name + day + year, e.g. "June 5, 2025" */
+  FULL_MONTH_DAY_YEAR = "MMMM d, yyyy",
+  /** Abbreviated month + day + year, e.g. "Jun 5, 2025" */
+  ABBR_MONTH_DAY_YEAR = "MMM d, yyyy",
+  /** RFC-3339 with milliseconds, e.g. "2025-06-05T13:24:00.000Z" */
+  RFC_3339 = "yyyy-MM-dd'T'HH:mm:ss.SSSxxx",
+  /** Alternative RSS date, e.g. "09 Sep 2011 15:26:08 +0200" */
+  ALT_RSS = "d MMM yyyy HH:mm:ss ZZZ",
+  /** Standard RSS date, e.g. "Fri, 09 Sep 2011 15:26:08 +0200" */
+  RSS = "EEE, d MMM yyyy HH:mm:ss ZZZ",
+  /** HTTP header date, e.g. "Tue, 15 Nov 1994 12:45:26 GMT" */
+  HTTP_HEADER = "EEE, dd MMM yyyy HH:mm:ss zzz",
+  /** Generic standard format, e.g. "Fri Sep 09 15:26:08 +0000 2011" */
+  STANDARD = "EEE MMM dd HH:mm:ss Z yyyy",
+  /** Extended format, e.g. "Fri 09-Sep-2011 AD 15:26:08.000 UTC" */
+  EXTENDED = "eee dd-MMM-yyyy GG HH:mm:ss.SSS zzz"
+}
+//#endregion
+//#region src/model/zoned-date-time.d.ts
+/**
+ * A UTC instant paired with an IANA time zone for formatting and conversions.
+ *
+ * @example
+ * const zoned = ZonedDateTime.fromUtc(new Date(), 'Europe/Bratislava')
+ * zoned.toLocalIsoMinutes()
+ */
+declare class ZonedDateTime {
+  /**
+   * UTC instant (truth).
+   *
+   * @default new Date()
+   * @output Date
+   */
+  readonly utc: Date;
+  /**
+   * IANA time zone identifier.
+   *
+   * @output string
+   * @example "Europe/Bratislava"
+   */
+  readonly timeZone: string;
+  /**
+   * @input timeZone IANA time zone identifier.
+   * @input utc UTC instant. Defaults to `new Date()`.
+   * @output ZonedDateTime
+   * @example new ZonedDateTime('Europe/Bratislava', new Date('2025-12-31T23:30:00.000Z'))
+   */
+  constructor(timeZone: string, utc?: Date);
+  /**
+   * Create from a UTC instant.
+   *
+   * @input utc UTC instant.
+   * @input timeZone IANA time zone identifier.
+   * @output ZonedDateTime
+   * @example ZonedDateTime.fromUtc(new Date('2025-12-31T23:30:00.000Z'), 'Europe/Bratislava')
+   */
+  static fromUtc(utc: Date, timeZone: string): ZonedDateTime;
+  /**
+   * Create from a local wall-clock time interpreted in the provided time zone.
+   *
+   * @input localIso Local date-time without offset: "YYYY-MM-DDTHH:mm" (or with seconds).
+   * @input timeZone IANA time zone identifier.
+   * @output ZonedDateTime
+   * @example ZonedDateTime.fromLocalIso('2026-01-01T18:00', 'Europe/Bratislava').toISOString()
+   */
+  static fromLocalIso(localIso: string, timeZone: string): ZonedDateTime;
+  /**
+   * Format this instant in the configured time zone.
+   *
+   * @input pattern date-fns format pattern.
+   * @input options date-fns-tz format options (locale, weekStartsOn, etc).
+   * @output string
+   * @example zoned.format("yyyy-MM-dd'T'HH:mm")
+   */
+  format(pattern: string, options?: FormatOptionsWithTZ): string;
+  /**
+   * Local ISO string without offset, minute precision.
+   *
+   * @output string
+   * @example zoned.toLocalIsoMinutes()
+   */
+  toLocalIsoMinutes(options?: FormatOptionsWithTZ): string;
+  /**
+   * Local ISO string without offset, second precision.
+   *
+   * @output string
+   * @example zoned.toLocalIsoSeconds()
+   */
+  toLocalIsoSeconds(options?: FormatOptionsWithTZ): string;
+  /**
+   * UTC ISO string (always Z).
+   *
+   * @output string
+   * @example zoned.toISOString()
+   */
+  toISOString(): string;
+  /**
+   * Unix timestamp in seconds.
+   *
+   * @output number
+   * @example zoned.toUnixTimestamp()
+   */
+  toUnixTimestamp(): number;
+  /**
+   * Date that formats to the local time of `timeZone` (useful for date pickers).
+   *
+   * @output Date
+   * @example const pickerDate = zoned.toZonedDate()
+   */
+  toZonedDate(): Date;
+  /**
+   * Offset in milliseconds between the configured time zone and UTC at the given instant.
+   *
+   * @input atUtc UTC instant to evaluate offset at. Defaults to this.utc.
+   * @output number
+   * @example zoned.timezoneOffsetMs()
+   */
+  timezoneOffsetMs(atUtc?: Date): number;
+}
+//#endregion
+//#region src/model/geojson.d.ts
+/**
+ * Represents a coordinate pair.
+ *
+ * @property {number} longitude  The longitude value (−180 to 180).
+ * @property {number} latitude   The latitude value (−90 to 90).
+ *
+ * @throws {Error} If longitude or latitude are out of range.
+ */
+declare class Coordinates implements JSONSerializable {
+  readonly value: [number, number];
+  constructor([longitude, latitude]: [number, number]);
+  /**
+   * @returns {number} The longitude.
+   */
+  get longitude(): number;
+  /**
+   * @returns {number} The latitude.
+   */
+  get latitude(): number;
+  /**
+   * Custom JSON serialization.
+   *
+   * @returns {[number, number]} Plain tuple [lon, lat]
+   */
+  toJSON(): [number, number];
+}
+/**
+ * Base GeoJSON object.
+ *
+ * @property {GeoJsonTypes} type  The GeoJSON object type.
+ * @property {BBox} [bbox]       Optional bounding box array.
+ */
+interface GeoJsonObject {
+  type: GeoJsonTypes;
+  bbox?: BBox;
+}
+/**
+ * Point geometry.
+ *
+ * @property {'Point'} type
+ * @property {Coordinates} coordinates  The coordinate pair.
+ * @property {BBox} [bbox]              Optional bounding box.
+ */
+declare class Point implements GeoJsonObject, JSONSerializable {
+  readonly type = GeoJsonType.Point;
+  coordinates: Coordinates;
+  bbox?: BBox;
+  constructor(coordinates: Coordinates, bbox?: BBox);
+  toJSON(): any;
+}
+/**
+ * MultiPoint geometry.
+ *
+ * @property {'MultiPoint'} type
+ * @property {Coordinates[]} coordinates  Array of coordinate pairs.
+ * @property {BBox} [bbox]                Optional bounding box.
+ */
+declare class MultiPoint implements GeoJsonObject, JSONSerializable {
+  readonly type = GeoJsonType.MultiPoint;
+  coordinates: Coordinates[];
+  bbox?: BBox;
+  constructor(coordinates: Coordinates[], bbox?: BBox);
+  toJSON(): any;
+}
+/**
+ * LineString geometry.
+ *
+ * @property {'LineString'} type
+ * @property {Coordinates[]} coordinates  Array of coordinate pairs.
+ * @property {BBox} [bbox]                Optional bounding box.
+ */
+declare class LineString implements GeoJsonObject, JSONSerializable {
+  readonly type = GeoJsonType.LineString;
+  coordinates: Coordinates[];
+  bbox?: BBox;
+  constructor(coordinates: Coordinates[], bbox?: BBox);
+  toJSON(): any;
+}
+/**
+ * MultiLineString geometry.
+ *
+ * @property {'MultiLineString'} type
+ * @property {Coordinates[][]} coordinates  Array of LineStrings (arrays of Coordinates).
+ * @property {BBox} [bbox]                   Optional bounding box.
+ */
+declare class MultiLineString implements GeoJsonObject, JSONSerializable {
+  readonly type = GeoJsonType.MultiLineString;
+  coordinates: Coordinates[][];
+  bbox?: BBox;
+  constructor(coordinates: Coordinates[][], bbox?: BBox);
+  toJSON(): any;
+}
+/**
+ * Polygon geometry.
+ *
+ * @property {'Polygon'} type
+ * @property {Coordinates[][]} coordinates  Array of linear rings (arrays of Coordinates).
+ * @property {BBox} [bbox]                    Optional bounding box.
+ */
+declare class Polygon implements GeoJsonObject, JSONSerializable {
+  readonly type = GeoJsonType.Polygon;
+  coordinates: Coordinates[][];
+  bbox?: BBox;
+  constructor(coordinates: Coordinates[][], bbox?: BBox);
+  toJSON(): any;
+}
+/**
+ * MultiPolygon geometry.
+ *
+ * @property {'MultiPolygon'} type
+ * @property {Coordinates[][][]} coordinates  Array of Polygons (arrays of rings of Coordinates).
+ * @property {BBox} [bbox]                       Optional bounding box.
+ */
+declare class MultiPolygon implements GeoJsonObject, JSONSerializable {
+  readonly type = GeoJsonType.MultiPolygon;
+  coordinates: Coordinates[][][];
+  bbox?: BBox;
+  constructor(coordinates: Coordinates[][][], bbox?: BBox);
+  toJSON(): any;
+}
+/**
+ * Bounding box for GeoJSON geometries.
+ *
+ * - [minX, minY, maxX, maxY] or
+ * - [minX, minY, minZ, maxX, maxY, maxZ].
+ */
+type BBox = [number, number, number, number] | [number, number, number, number, number, number];
+/**
+ * Union of all geometry types.
+ */
+type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon;
+/**
+ * Valid GeoJSON types, based on geometry classes.
+ */
+type GeoJsonTypes = `${GeoJsonType}`;
+declare enum GeoJsonType {
+  Point = "Point",
+  MultiPoint = "MultiPoint",
+  LineString = "LineString",
+  MultiLineString = "MultiLineString",
+  Polygon = "Polygon",
+  MultiPolygon = "MultiPolygon"
+}
+//#endregion
+//#region src/model/object-id.d.ts
+/**
+ * Immutable identifier value object.
+ *
+ * Stores a non-empty string and provides value-based equality, ordering,
+ * hashing, and JSON serialization.
+ */
+declare class ObjectId implements JSONSerializable {
+  /**
+   * Canonical identifier value.
+   */
+  readonly value: string;
+  /**
+   * Creates a new {@link ObjectId}.
+   *
+   * @param input Raw identifier value.
+   * @throws {Error} If `input` is `null`, `undefined`, or an empty/whitespace-only string.
+   *
+   * @example
+   * ```ts
+   * const id = new ObjectId("507f1f77bcf86cd799439011");
+   * ```
+   */
+  constructor(input: string | null | undefined);
+  /**
+   * Shorthand alias for {@link ObjectId.value}.
+   *
+   * Value as string semantic clarity.
+   *
+   * @returns Raw id string.
+   *
+   * @example
+   * ```ts
+   * const id = new ObjectId("abc");
+   * id.asString; // "abc"
+   * ```
+   */
+  get asString(): string;
+  /**
+   * Checks value equality.
+   *
+   * @param other Another id or raw string.
+   * @returns `true` if both values match.
+   *
+   * @example
+   * ```ts
+   * id.equals("abc");
+   * id.equals(new ObjectId("abc"));
+   * ```
+   */
+  equals(other: ObjectId | string): boolean;
+  /**
+   * Compares two ids lexicographically.
+   *
+   * @param other Another id or raw string.
+   * @returns -1 if less, 0 if equal, 1 if greater.
+   *
+   * @example
+   * ```ts
+   * ids.sort((a, b) => a.compare(b));
+   * ```
+   */
+  compare(other: ObjectId | string): -1 | 0 | 1;
+  /**
+   * Returns a stable hash key for Maps/Sets.
+   *
+   * @returns String hash key.
+   *
+   * @example
+   * ```ts
+   * const map = new Map<string, number>();
+   * map.set(id.hash(), 1);
+   * ```
+   */
+  hash(): string;
+  /**
+   * Serializes to JSON as the raw identifier string.
+   *
+   * @returns Raw id value.
+   */
+  toJSON(): string;
+  /**
+   * Converts to string.
+   *
+   * @returns Raw id value.
+   */
+  toString(): string;
+  /**
+   * Coerces to a primitive string (e.g., template literals).
+   *
+   * @returns Raw id value.
+   *
+   * @example
+   * ```ts
+   * `${id}`;
+   * ```
+   */
+  [Symbol.toPrimitive](): string;
+  /**
+   * Normalizes an id-like value into an {@link ObjectId}.
+   *
+   * @param value Raw string or {@link ObjectId}.
+   * @returns Normalized {@link ObjectId} instance.
+   *
+   * @example
+   * ```ts
+   * const id = ObjectId.from("abc");
+   * ```
+   */
+  static from(value: ObjectId | string): ObjectId;
+  /**
+   * Checks if a value can be used to construct an {@link ObjectId}.
+   *
+   * @param value Value to check.
+   * @returns `true` if it is a non-empty string.
+   */
+  static isValid(value: unknown): value is string;
+  /**
+   * Creates a value-based set of unique id strings.
+   *
+   * Useful when you need deduplication independent of object identity.
+   *
+   * @param values Iterable of id-like values.
+   * @returns Set of unique raw id strings.
+   *
+   * @example
+   * ```ts
+   * const unique = ObjectId.toValueSet([new ObjectId("a"), "a", "b"]);
+   * unique.has("a"); // true
+   * unique.size; // 2
+   * ```
+   */
+  static toValueSet(values: Iterable<ObjectId | string>): Set<string>;
+}
+//#endregion
+//#region src/model/opening-hour.d.ts
+type OpeningHourInterval = {
+  open: string;
+  close: string;
+};
+declare class OpeningHour implements JSONSerializable {
+  day: number;
+  intervals: OpeningHourInterval[];
+  constructor(day: number, intervals: OpeningHourInterval[]);
+  toJSON(): any;
+}
+//#endregion
+//#region src/model/time-interval.d.ts
+/**
+ * Represents a time interval in milliseconds, with helper methods for common time units.
+ *
+ * @param interval
+ *   A number (milliseconds), a string in ms format (e.g. "2d", "10h", "30m"),
+ *   or null/undefined (throws at runtime).
+ *
+ * @param options
+ *   Options passed directly to `ms()` when producing a string:
+ *   • `{ long: true }` produces a verbose form (e.g. "1 hour 30 minutes").
+ *
+ * @throws {Error}
+ *   If `interval` is null/undefined, or if a provided string cannot be parsed by `ms()`.
+ *
+ * @example
+ * const t1 = new TimeInterval("2h");
+ * console.log(t1.milliseconds); // 7200000
+ * console.log(t1.hours);        // 2
+ * console.log(t1.formatted);    // "2h"
+ * console.log(t1.toString());   // "2h"
+ *
+ * @example
+ * const t2 = new TimeInterval(15000, { long: true });
+ * console.log(t2.seconds);      // 15
+ * console.log(t2.toString());   // "15 seconds"
+ *
+ * @example
+ * try {
+ *   new TimeInterval("invalid");
+ * } catch (err) {
+ *   console.error(err.message); // "Invalid interval format: invalid"
+ * }
+ *
+ * @example
+ * try {
+ *   new TimeInterval(null);
+ * } catch (err) {
+ *   console.error(err.message); // "Invalid interval format: null"
+ * }
+ */
+declare class TimeInterval {
+  private readonly _milliseconds;
+  private readonly _long;
+  constructor(interval: string | number | null | undefined, options?: {
+    long: boolean;
+  });
+  /**
+   * @returns The interval duration in milliseconds.
+   */
+  get milliseconds(): number;
+  /**
+   * @returns The interval duration in seconds.
+   */
+  get seconds(): number;
+  /**
+   * @returns The interval duration in minutes.
+   */
+  get minutes(): number;
+  /**
+   * @returns The interval duration in hours.
+   */
+  get hours(): number;
+  /**
+   * @returns The interval duration in days.
+   */
+  get days(): number;
+  /**
+   * @returns The interval duration in weeks.
+   */
+  get weeks(): number;
+  /**
+   * @returns A compact, formatted string (e.g. "1h 30m", "45s").
+   */
+  get formatted(): string;
+  /**
+   * @returns A string representation of the interval.
+   *   If `{ long: true }` was passed, returns a verbose form (e.g. "1 hour 30 minutes");
+   *   otherwise, returns a compact form (e.g. "1h 30m").
+   */
+  toString(): string;
+  /**
+   * @returns An object with all time units for programmatic use.
+   */
+  toObject(): {
+    milliseconds: number;
+    seconds: number;
+    minutes: number;
+    hours: number;
+    days: number;
+    weeks: number;
+  };
+}
+//#endregion
+//#region src/model/unit.d.ts
+declare enum ByteUnit {
+  Byte = "B",
+  Kilobyte = "KB",
+  Megabyte = "MB",
+  Gigabyte = "GB",
+  Terabyte = "TB"
+}
+declare enum DistanceUnit {
+  Millimeter = "mm",
+  Centimeter = "cm",
+  Meter = "m",
+  Kilometer = "km"
+}
+declare enum WeightUnit {
+  Milligram = "mg",
+  Gram = "g",
+  Kilogram = "kg",
+  Tonne = "t"
+}
+//#endregion
+//#region src/formatter/format-bytes-options.d.ts
+interface FormatBytesOptions {
+  inputUnit?: ByteUnit;
+  outputUnit?: ByteUnit | 'auto';
+  decimals?: number;
+}
+interface FormattedBytes {
+  value: number;
+  unit: ByteUnit;
+  bytes: number;
+}
+//#endregion
+//#region src/formatter/unit-formatter-controller.d.ts
+interface UnitFormatterController {
+  /**
+   * Formats a byte size into a human-readable value and unit.
+   *
+   * @param size
+   *   Size expressed in the given input unit (or bytes by default).
+   *
+   * @param [options]
+   *   Optional formatting options.
+   *
+   * @param [options.inputUnit]
+   *   Unit of the input size.
+   *   @default ByteUnit.Byte
+   *
+   * @param [options.outputUnit]
+   *   Target unit. When 'auto', picks the largest unit with value ≥ 1.
+   *   @default 'auto'
+   *
+   * @param [options.decimals]
+   *   Number of decimal places to keep in the formatted value.
+   *   @default 1
+   *
+   * @returns
+   *   Formatted value with unit and the original size in bytes.
+   *
+   * @example
+   *   // 1.0 MB
+   *   formatter.formatBytes(1048576);
+   *
+   * @example
+   *   // 512.00 KB
+   *   formatter.formatBytes(512, {
+   *     inputUnit: ByteUnit.Kilobyte,
+   *     outputUnit: ByteUnit.Kilobyte,
+   *     decimals: 2,
+   *   });
+   */
+  formatBytes(size: number, options?: FormatBytesOptions): FormattedBytes;
+}
+declare class UnitFormatterControllerImpl implements UnitFormatterController {
+  formatBytes(size: number, options?: FormatBytesOptions): FormattedBytes;
+}
+//#endregion
+//#region src/l10n/l10n.d.ts
+type L10nResources = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+//#endregion
+//#region src/l10n/define-l10n-resource.d.ts
+type L10nDeepMerge<TLeft, TRight> = TLeft extends Record<string, unknown> ? TRight extends Record<string, unknown> ? { readonly [TKey in keyof TLeft | keyof TRight]: TKey extends keyof TRight ? TKey extends keyof TLeft ? L10nDeepMerge<TLeft[TKey], TRight[TKey]> : TRight[TKey] : TKey extends keyof TLeft ? TLeft[TKey] : never; } : TRight : TRight;
+declare class L10nResource<TResources extends L10nResources> {
+  readonly resources: TResources;
+  constructor(resources: TResources);
+  extend<const TExtension extends L10nResources>(options: {
+    resources: TExtension;
+  }): L10nResource<L10nDeepMerge<TResources, TExtension>>;
+}
+declare function defineL10nResource<const TResources extends L10nResources>(options: {
+  resources: TResources;
+}): L10nResource<TResources>;
+//#endregion
+//#region src/l10n/resources.d.ts
+declare const CoreL10nResource: L10nResource<{
+  readonly en: {
+    readonly core: {
+      common: {
+        actions: {
+          save: string;
+          cancel: string;
+          delete: string;
+          confirm: string;
+          close: string;
+          back: string;
+          next: string;
+        };
+        date_time: {
+          relative: {
+            today: string;
+            tomorrow: string;
+            yesterday: string;
+          };
+          interval: {
+            second: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            minute: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            hour: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            day: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            week: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            month: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            year: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+          };
+          weekday: {
+            monday: string;
+            tuesday: string;
+            wednesday: string;
+            thursday: string;
+            friday: string;
+            saturday: string;
+            sunday: string;
+          };
+          month: {
+            january: string;
+            february: string;
+            march: string;
+            april: string;
+            may: string;
+            june: string;
+            july: string;
+            august: string;
+            september: string;
+            october: string;
+            november: string;
+            december: string;
+          };
+        };
+        validation: {
+          opening_hours: {
+            time_required: string;
+            time_range_incomplete: string;
+          };
+        };
+      };
+    };
+  };
+  readonly sk: {
+    readonly core: {
+      common: {
+        actions: {
+          save: string;
+          cancel: string;
+          delete: string;
+          confirm: string;
+          close: string;
+          back: string;
+          next: string;
+        };
+        date_time: {
+          relative: {
+            today: string;
+            tomorrow: string;
+            yesterday: string;
+          };
+          interval: {
+            second: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            minute: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            hour: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            day: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            week: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            month: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            year: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+          };
+          weekday: {
+            monday: string;
+            tuesday: string;
+            wednesday: string;
+            thursday: string;
+            friday: string;
+            saturday: string;
+            sunday: string;
+          };
+          month: {
+            january: string;
+            february: string;
+            march: string;
+            april: string;
+            may: string;
+            june: string;
+            july: string;
+            august: string;
+            september: string;
+            october: string;
+            november: string;
+            december: string;
+          };
+        };
+        validation: {
+          opening_hours: {
+            time_required: string;
+            time_range_incomplete: string;
+          };
+        };
+      };
+    };
+  };
+  readonly cs: {
+    readonly core: {
+      common: {
+        actions: {
+          save: string;
+          cancel: string;
+          delete: string;
+          confirm: string;
+          close: string;
+          back: string;
+          next: string;
+        };
+        date_time: {
+          relative: {
+            today: string;
+            tomorrow: string;
+            yesterday: string;
+          };
+          interval: {
+            second: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            minute: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            hour: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            day: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            week: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            month: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            year: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+          };
+          weekday: {
+            monday: string;
+            tuesday: string;
+            wednesday: string;
+            thursday: string;
+            friday: string;
+            saturday: string;
+            sunday: string;
+          };
+          month: {
+            january: string;
+            february: string;
+            march: string;
+            april: string;
+            may: string;
+            june: string;
+            july: string;
+            august: string;
+            september: string;
+            october: string;
+            november: string;
+            december: string;
+          };
+        };
+        validation: {
+          opening_hours: {
+            time_required: string;
+            time_range_incomplete: string;
+          };
+        };
+      };
+    };
+  };
+}>;
+declare const CoreL10n: {
+  readonly Core: {
+    readonly Common: {
+      readonly Actions: {
+        readonly Close: "core.common.actions.close";
+        readonly Save: "core.common.actions.save";
+        readonly Cancel: "core.common.actions.cancel";
+        readonly Delete: "core.common.actions.delete";
+        readonly Confirm: "core.common.actions.confirm";
+        readonly Back: "core.common.actions.back";
+        readonly Next: "core.common.actions.next";
+      };
+      readonly DateTime: {
+        readonly Month: {
+          readonly January: "core.common.date_time.month.january";
+          readonly February: "core.common.date_time.month.february";
+          readonly March: "core.common.date_time.month.march";
+          readonly April: "core.common.date_time.month.april";
+          readonly May: "core.common.date_time.month.may";
+          readonly June: "core.common.date_time.month.june";
+          readonly July: "core.common.date_time.month.july";
+          readonly August: "core.common.date_time.month.august";
+          readonly September: "core.common.date_time.month.september";
+          readonly October: "core.common.date_time.month.october";
+          readonly November: "core.common.date_time.month.november";
+          readonly December: "core.common.date_time.month.december";
+        };
+        readonly Relative: {
+          readonly Today: "core.common.date_time.relative.today";
+          readonly Tomorrow: "core.common.date_time.relative.tomorrow";
+          readonly Yesterday: "core.common.date_time.relative.yesterday";
+        };
+        readonly Interval: {
+          readonly Day: {
+            readonly One: "core.common.date_time.interval.day.one";
+            readonly Few: "core.common.date_time.interval.day.few";
+            readonly Many: "core.common.date_time.interval.day.many";
+            readonly Other: "core.common.date_time.interval.day.other";
+          };
+          readonly Second: {
+            readonly One: "core.common.date_time.interval.second.one";
+            readonly Few: "core.common.date_time.interval.second.few";
+            readonly Many: "core.common.date_time.interval.second.many";
+            readonly Other: "core.common.date_time.interval.second.other";
+          };
+          readonly Minute: {
+            readonly One: "core.common.date_time.interval.minute.one";
+            readonly Few: "core.common.date_time.interval.minute.few";
+            readonly Many: "core.common.date_time.interval.minute.many";
+            readonly Other: "core.common.date_time.interval.minute.other";
+          };
+          readonly Hour: {
+            readonly One: "core.common.date_time.interval.hour.one";
+            readonly Few: "core.common.date_time.interval.hour.few";
+            readonly Many: "core.common.date_time.interval.hour.many";
+            readonly Other: "core.common.date_time.interval.hour.other";
+          };
+          readonly Week: {
+            readonly One: "core.common.date_time.interval.week.one";
+            readonly Few: "core.common.date_time.interval.week.few";
+            readonly Many: "core.common.date_time.interval.week.many";
+            readonly Other: "core.common.date_time.interval.week.other";
+          };
+          readonly Month: {
+            readonly One: "core.common.date_time.interval.month.one";
+            readonly Few: "core.common.date_time.interval.month.few";
+            readonly Many: "core.common.date_time.interval.month.many";
+            readonly Other: "core.common.date_time.interval.month.other";
+          };
+          readonly Year: {
+            readonly One: "core.common.date_time.interval.year.one";
+            readonly Few: "core.common.date_time.interval.year.few";
+            readonly Many: "core.common.date_time.interval.year.many";
+            readonly Other: "core.common.date_time.interval.year.other";
+          };
+        };
+        readonly Weekday: {
+          readonly Monday: "core.common.date_time.weekday.monday";
+          readonly Tuesday: "core.common.date_time.weekday.tuesday";
+          readonly Wednesday: "core.common.date_time.weekday.wednesday";
+          readonly Thursday: "core.common.date_time.weekday.thursday";
+          readonly Friday: "core.common.date_time.weekday.friday";
+          readonly Saturday: "core.common.date_time.weekday.saturday";
+          readonly Sunday: "core.common.date_time.weekday.sunday";
+        };
+      };
+      readonly Validation: {
+        readonly OpeningHours: {
+          readonly TimeRequired: "core.common.validation.opening_hours.time_required";
+          readonly TimeRangeIncomplete: "core.common.validation.opening_hours.time_range_incomplete";
+        };
+      };
+    };
+  };
+};
+//#endregion
+//#region src/l10n/define-l10n.d.ts
+type L10nLocaleResource = Readonly<Record<string, unknown>>;
+type L10nUnionKeys<TValue> = TValue extends TValue ? keyof TValue : never;
+type L10nUnionValue<TValue, TKey extends PropertyKey> = TValue extends TValue ? TKey extends keyof TValue ? TValue[TKey] : never : never;
+type L10nChildResource<TResource, TKey extends PropertyKey> = Extract<L10nUnionValue<TResource, TKey>, L10nLocaleResource>;
+type L10nKeyTree<TResource, TPrefix extends string = ''> = { readonly [TKey in L10nUnionKeys<TResource> & string as L10nPascalCase<TKey>]: [L10nChildResource<TResource, TKey>] extends [never] ? L10nJoin<TPrefix, TKey> : L10nKeyTree<L10nChildResource<TResource, TKey>, L10nJoin<TPrefix, TKey>>; };
+type L10nJoin<TPrefix extends string, TKey extends string> = TPrefix extends '' ? TKey : `${TPrefix}.${TKey}`;
+type L10nPascalCase<TValue extends string, TCapitalizeNext extends boolean = true> = TValue extends `${infer TCharacter}${infer TRest}` ? TCharacter extends '_' | '-' | ' ' ? L10nPascalCase<TRest, true> : `${TCapitalizeNext extends true ? Uppercase<TCharacter> : TCharacter}${L10nPascalCase<TRest, false>}` : '';
+declare function defineL10n<const TResources extends L10nResources>(resource: L10nResource<TResources>): L10nKeyTree<TResources[keyof TResources]>;
+//#endregion
+//#region src/foundation/identity.d.ts
+type Identity = string | number | symbol;
+//#endregion
+//#region src/foundation/equatable.d.ts
+interface Equatable {
+  equals(other: unknown): boolean;
+}
+//#endregion
+//#region src/foundation/hashable.d.ts
+interface Hashable {
+  hash(): Identity;
+}
+//#endregion
+//#region src/localization/localizable-text.d.ts
+declare class LocalizableText implements JSONSerializable {
+  values: {
+    [lang: string]: string;
+  };
+  constructor(LocalizableTexts: {
+    [lang: string]: string;
+  });
+  getLocalized(lang: string): string | null;
+  toJSON(): any;
+}
+//#endregion
+//#region src/operation/async-operation.d.ts
+interface AsyncOperation<Input, Output, Options = undefined> {
+  execute(input: Input, options?: Options): Promise<Output>;
+}
+//#endregion
+//#region src/operation/operation.d.ts
+interface Operation<Input, Output, Options = undefined> {
+  execute(input: Input, options?: Options): Output;
+}
+//#endregion
+//#region src/security/hash.d.ts
+/**
+ * Generates a hash for a given input string.
+ *
+ * @param input - The input string to hash.
+ * @param salt - The number of salt rounds to use. Default is 10.
+ * @returns A promise that resolves to the hashed string.
+ */
+declare function makeHash(input: string, salt?: number): Promise<string>;
+/**
+ * Compares a candidate string with a hashed string.
+ *
+ * @param candidate - The candidate string to compare.
+ * @param hashed - The hashed string to compare against.
+ * @returns A promise that resolves to a boolean indicating if the candidate matches the hash.
+ */
+declare function compareHash(candidate: string, hashed: string): Promise<boolean>;
+//#endregion
+//#region src/validation/validation-schema-i18n-params.d.ts
+type ValidationSchemaI18nParams = {
+  i18n: {
+    key: string;
+    values?: Record<string, unknown>;
+  };
+};
+//#endregion
+//#region src/validation/validation-schemas.d.ts
+declare const UUIDSchema: z.ZodUUID;
+declare const DateTimeSchema: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<DateTime, string>>;
+declare const ObjectIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<ObjectId, string>>;
+type UUIDDto = z.input<typeof UUIDSchema>;
+type DateTimeDto = z.input<typeof DateTimeSchema>;
+type ObjectIdDto = z.input<typeof ObjectIdSchema>;
+declare const LongitudeSchema: z.ZodNumber;
+declare const LatitudeSchema: z.ZodNumber;
+type LongitudeDto = z.input<typeof LongitudeSchema>;
+type LatitudeDto = z.input<typeof LatitudeSchema>;
+declare const CoordinatesSchema: z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>;
+type CoordinatesDto = z.input<typeof CoordinatesSchema>;
+declare const BBoxSchema: z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>;
+type BBoxDto = z.input<typeof BBoxSchema>;
+declare const PointGeometrySchema: z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"Point">;
+  coordinates: z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<Point, {
+  type: "Point";
+  coordinates: Coordinates;
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>;
+type PointGeometryDto = z.input<typeof PointGeometrySchema>;
+declare const MultiPointGeometrySchema: z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"MultiPoint">;
+  coordinates: z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<MultiPoint, {
+  type: "MultiPoint";
+  coordinates: Coordinates[];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>;
+type MultiPointGeometryDto = z.input<typeof MultiPointGeometrySchema>;
+declare const LineStringGeometrySchema: z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"LineString">;
+  coordinates: z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<LineString, {
+  type: "LineString";
+  coordinates: Coordinates[];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>;
+type LineStringGeometryDto = z.input<typeof LineStringGeometrySchema>;
+declare const MultiLineStringGeometrySchema: z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"MultiLineString">;
+  coordinates: z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<MultiLineString, {
+  type: "MultiLineString";
+  coordinates: Coordinates[][];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>;
+type MultiLineStringGeometryDto = z.input<typeof MultiLineStringGeometrySchema>;
+declare const PolygonGeometrySchema: z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"Polygon">;
+  coordinates: z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<Polygon, {
+  type: "Polygon";
+  coordinates: Coordinates[][];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>;
+type PolygonGeometryDto = z.input<typeof PolygonGeometrySchema>;
+declare const MultiPolygonGeometrySchema: z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"MultiPolygon">;
+  coordinates: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<MultiPolygon, {
+  type: "MultiPolygon";
+  coordinates: Coordinates[][][];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>;
+type MultiPolygonGeometryDto = z.input<typeof MultiPolygonGeometrySchema>;
+declare const GeometrySchema: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"Point">;
+  coordinates: z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<Point, {
+  type: "Point";
+  coordinates: Coordinates;
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>, z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"MultiPoint">;
+  coordinates: z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<MultiPoint, {
+  type: "MultiPoint";
+  coordinates: Coordinates[];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>, z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"LineString">;
+  coordinates: z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<LineString, {
+  type: "LineString";
+  coordinates: Coordinates[];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>, z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"MultiLineString">;
+  coordinates: z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<MultiLineString, {
+  type: "MultiLineString";
+  coordinates: Coordinates[][];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>, z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"Polygon">;
+  coordinates: z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<Polygon, {
+  type: "Polygon";
+  coordinates: Coordinates[][];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>, z.ZodPipe<z.ZodObject<{
+  type: z.ZodLiteral<"MultiPolygon">;
+  coordinates: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>>;
+  bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strip>, z.ZodTransform<MultiPolygon, {
+  type: "MultiPolygon";
+  coordinates: Coordinates[][][];
+  bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+}>>]>;
+type GeometryDto = z.input<typeof GeometrySchema>;
+declare const OpeningHourIntervalSchema: z.ZodObject<{
+  open: z.ZodString;
+  close: z.ZodString;
+}, z.core.$strip>;
+declare const OpeningHourSchema: z.ZodPipe<z.ZodObject<{
+  day: z.ZodNumber;
+  intervals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    open: z.ZodString;
+    close: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodTransform<OpeningHour, {
+  day: number;
+  intervals: {
+    open: string;
+    close: string;
+  }[];
+}>>;
+declare const OpeningHoursSchema: z.ZodArray<z.ZodPipe<z.ZodObject<{
+  day: z.ZodNumber;
+  intervals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    open: z.ZodString;
+    close: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodTransform<OpeningHour, {
+  day: number;
+  intervals: {
+    open: string;
+    close: string;
+  }[];
+}>>>;
+type OpeningHourIntervalDto = z.input<typeof OpeningHourIntervalSchema>;
+type OpeningHourDto = z.input<typeof OpeningHourSchema>;
+type OpeningHoursDto = z.input<typeof OpeningHoursSchema>;
+declare const ContactsSchema: z.ZodPipe<z.ZodObject<{
+  email: z.ZodNullable<z.ZodOptional<z.ZodEmail>>;
+  fb: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  ig: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  phone: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  web: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<Contacts, {
+  email?: string | null | undefined;
+  fb?: string | null | undefined;
+  ig?: string | null | undefined;
+  phone?: string | null | undefined;
+  web?: string | null | undefined;
+}>>;
+type ContactsDto = z.input<typeof ContactsSchema>;
+declare const AddressSchema: z.ZodPipe<z.ZodObject<{
+  streetLine1: z.ZodString;
+  streetLine2: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  postalCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  city: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  state: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  country: z.ZodString;
+  countryCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<Address, {
+  streetLine1: string;
+  country: string;
+  streetLine2?: string | null | undefined;
+  postalCode?: string | null | undefined;
+  city?: string | null | undefined;
+  state?: string | null | undefined;
+  countryCode?: string | null | undefined;
+}>>;
+type AddressDto = z.input<typeof AddressSchema>;
+declare const ValidationSchemas: {
+  UUID: z.ZodUUID;
+  DateTime: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<DateTime, string>>;
+  ObjectId: z.ZodPipe<z.ZodString, z.ZodTransform<ObjectId, string>>;
+  Longitude: z.ZodNumber;
+  Latitude: z.ZodNumber;
+  Coordinates: z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>;
+  BBox: z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>;
+  PointGeometry: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"Point">;
+    coordinates: z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<Point, {
+    type: "Point";
+    coordinates: Coordinates;
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>;
+  MultiPointGeometry: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"MultiPoint">;
+    coordinates: z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<MultiPoint, {
+    type: "MultiPoint";
+    coordinates: Coordinates[];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>;
+  LineStringGeometry: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"LineString">;
+    coordinates: z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<LineString, {
+    type: "LineString";
+    coordinates: Coordinates[];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>;
+  MultiLineStringGeometry: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"MultiLineString">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<MultiLineString, {
+    type: "MultiLineString";
+    coordinates: Coordinates[][];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>;
+  PolygonGeometry: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<Polygon, {
+    type: "Polygon";
+    coordinates: Coordinates[][];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>;
+  MultiPolygonGeometry: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"MultiPolygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<MultiPolygon, {
+    type: "MultiPolygon";
+    coordinates: Coordinates[][][];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>;
+  Geometry: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"Point">;
+    coordinates: z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<Point, {
+    type: "Point";
+    coordinates: Coordinates;
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"MultiPoint">;
+    coordinates: z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<MultiPoint, {
+    type: "MultiPoint";
+    coordinates: Coordinates[];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"LineString">;
+    coordinates: z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<LineString, {
+    type: "LineString";
+    coordinates: Coordinates[];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"MultiLineString">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<MultiLineString, {
+    type: "MultiLineString";
+    coordinates: Coordinates[][];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<Polygon, {
+    type: "Polygon";
+    coordinates: Coordinates[][];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"MultiPolygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodPipe<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTransform<Coordinates, [number, number]>>>>>;
+    bbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+  }, z.core.$strip>, z.ZodTransform<MultiPolygon, {
+    type: "MultiPolygon";
+    coordinates: Coordinates[][][];
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number] | undefined;
+  }>>]>;
+  OpeningHour: z.ZodPipe<z.ZodObject<{
+    day: z.ZodNumber;
+    intervals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      open: z.ZodString;
+      close: z.ZodString;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>, z.ZodTransform<OpeningHour, {
+    day: number;
+    intervals: {
+      open: string;
+      close: string;
+    }[];
+  }>>;
+  OpeningHours: z.ZodArray<z.ZodPipe<z.ZodObject<{
+    day: z.ZodNumber;
+    intervals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      open: z.ZodString;
+      close: z.ZodString;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>, z.ZodTransform<OpeningHour, {
+    day: number;
+    intervals: {
+      open: string;
+      close: string;
+    }[];
+  }>>>;
+  Contacts: z.ZodPipe<z.ZodObject<{
+    email: z.ZodNullable<z.ZodOptional<z.ZodEmail>>;
+    fb: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    ig: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    phone: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    web: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>, z.ZodTransform<Contacts, {
+    email?: string | null | undefined;
+    fb?: string | null | undefined;
+    ig?: string | null | undefined;
+    phone?: string | null | undefined;
+    web?: string | null | undefined;
+  }>>;
+  Address: z.ZodPipe<z.ZodObject<{
+    streetLine1: z.ZodString;
+    streetLine2: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    postalCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    city: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    state: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    country: z.ZodString;
+    countryCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>, z.ZodTransform<Address, {
+    streetLine1: string;
+    country: string;
+    streetLine2?: string | null | undefined;
+    postalCode?: string | null | undefined;
+    city?: string | null | undefined;
+    state?: string | null | undefined;
+    countryCode?: string | null | undefined;
+  }>>;
+};
+//#endregion
+//#region src/index.d.ts
+declare function coreAssembly(): Assembly[];
+//#endregion
+export { Address, AddressDto, Assembly, AssemblyContainer, AsyncConverter, AsyncOperation, Awaitable, BBox, BBoxDto, ByteUnit, CanceledError, Contacts, ContactsDto, type Container, ConversionError, Converter, Coordinates, CoordinatesDto, CoreL10n, CoreL10nResource, CoreSymbols, DateFormat, DateTime, DateTimeDto, DeepPartial, DeepRequired, DeviceType, DistanceUnit, type E_ALREADY_LOCKED, type E_CANCELED, type E_TIMEOUT, Empty, Equatable, FormatBytesOptions, FormattedBytes, GeoJsonObject, GeoJsonType, GeoJsonTypes, Geometry, GeometryDto, Hashable, Identity, JSONObject, JSONPrimitive, JSONSerializable, JSONValue, L10nResource, L10nResources, LatitudeDto, LineString, LineStringGeometryDto, LocalizableText, LongitudeDto, MultiLineString, MultiLineStringGeometryDto, MultiPoint, MultiPointGeometryDto, MultiPolygon, MultiPolygonGeometryDto, Mutex, type MutexInterface, NetworkError, NonUndefined, OSType, ObjectFilterOptions, ObjectId, ObjectIdDto, OpeningHour, OpeningHourDto, OpeningHourInterval, OpeningHourIntervalDto, OpeningHoursDto, Operation, Optional, OptionalPartial, OptionalValue, Point, PointGeometryDto, Polygon, PolygonGeometryDto, Primitive, PushNotificationStatus, Query, ScopeController, Semaphore, type SemaphoreInterface, TimeInterval, TimeoutError, UUIDDto, UnitFormatterController, UnitFormatterControllerImpl, UnknownError, ValidationSchemaI18nParams, ValidationSchemas, WeightUnit, ZonedDateTime, capitalized, compareHash, coreAssembly, defineL10n, defineL10nResource, delay, emptyOrUndefinedStringToNull, filterObject, ignoreError, ignoreErrorAsync, ignoreErrorOptionalAsync, isDefined, isDefinedAndNotNull, isEmptyObject, isError, isJSONPrimitive, isJSONSerializable, isNonEmptyObject, isNonEmptyString, isNotNull, isNullOrEmpty, isObject, isPlainObject, isPrimitive, makeHash, mapToEnum, optional, tryAcquire, withTimeout };