@thisisagile/easy 15.26.2 → 15.27.0

package/dist/index.js

@@ -1,45 +1,4808 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// src/index.ts
 var src_exports = {};
+__export(src_exports, {
+  Address: () => Address,
+  Api: () => Api,
+  ApiGateway: () => ApiGateway,
+  App: () => App,
+  Audit: () => Audit,
+  AxiosProvider: () => AxiosProvider,
+  BaseContext: () => BaseContext,
+  BaseRequestContext: () => BaseRequestContext,
+  Box: () => Box,
+  CacheControl: () => CacheControl,
+  Child: () => Child,
+  Clause: () => Clause,
+  Column: () => Column,
+  Condition: () => Condition,
+  ContentType: () => ContentType,
+  Context: () => Context,
+  Convert: () => Convert,
+  Country: () => Country,
+  Currency: () => Currency,
+  Database: () => Database,
+  DateTime: () => DateTime,
+  DefaultProvider: () => DefaultProvider,
+  Delete: () => Delete,
+  Dimension: () => Dimension,
+  DotEnvContext: () => DotEnvContext,
+  EAN: () => EAN,
+  EasyUri: () => EasyUri,
+  Email: () => Email,
+  Entity: () => Entity,
+  Enum: () => Enum,
+  Environment: () => Environment,
+  Exception: () => Exception,
+  Field: () => Field,
+  Gateway: () => Gateway,
+  HealthResource: () => HealthResource,
+  HealthUri: () => HealthUri,
+  HttpHeader: () => HttpHeader,
+  HttpStatus: () => HttpStatus,
+  HttpVerb: () => HttpVerb,
+  IBAN: () => IBAN,
+  InMemoryGateway: () => InMemoryGateway,
+  Insert: () => Insert,
+  Join: () => Join2,
+  Jwt: () => Jwt,
+  List: () => List6,
+  Locale: () => Locale,
+  LogicalCondition: () => LogicalCondition,
+  Manage: () => Manage,
+  MappedRouteGateway: () => MappedRouteGateway,
+  Mapper: () => Mapper,
+  Money: () => Money,
+  Name: () => Name,
+  OrderColumn: () => OrderColumn,
+  OriginatedError: () => OriginatedError,
+  PageList: () => PageList2,
+  ParathesizedClause: () => ParathesizedClause,
+  Parser: () => Parser,
+  PatternColumn: () => PatternColumn,
+  PostalCode: () => PostalCode,
+  Property: () => Property,
+  Repo: () => Repo,
+  Repository: () => Repository,
+  Req: () => Req,
+  RequestOptions: () => RequestOptions,
+  Requires: () => Requires,
+  Results: () => Results4,
+  RouteGateway: () => RouteGateway,
+  Scope: () => Scope,
+  Search: () => Search,
+  Select: () => Select,
+  Sentence: () => Sentence,
+  Service: () => Service,
+  Slug: () => Slug,
+  SortCondition: () => SortCondition,
+  SqlQuery: () => SqlQuery,
+  State: () => State,
+  Struct: () => Struct,
+  Table: () => Table2,
+  TableGateway: () => TableGateway,
+  Template: () => Template,
+  ToText: () => ToText2,
+  Try: () => Try,
+  Typo: () => Typo,
+  UnitOfMeasurement: () => UnitOfMeasurement,
+  UnitOfWeight: () => UnitOfWeight,
+  Update: () => Update,
+  Url: () => Url,
+  UseCase: () => UseCase,
+  Value: () => Value,
+  View: () => View,
+  ViewRouteGateway: () => ViewRouteGateway,
+  Wait: () => Wait,
+  Weight: () => Weight,
+  When: () => When,
+  any: () => any,
+  api: () => api,
+  array: () => array,
+  asJson: () => asJson,
+  asList: () => asList,
+  asNumber: () => asNumber,
+  asPageList: () => asPageList,
+  asResults: () => asResults,
+  asString: () => asString,
+  asc: () => asc,
+  base64: () => base64,
+  build: () => build,
+  cache: () => cache,
+  cacheAge: () => cacheAge,
+  choose: () => choose,
+  constraint: () => constraint,
+  convert: () => convert,
+  ctx: () => ctx,
+  days: () => days,
+  defined: () => defined,
+  del: () => del,
+  desc: () => desc,
+  dir: () => dir,
+  dt: () => dt,
+  email: () => email,
+  entries: () => entries,
+  future: () => future,
+  get: () => get,
+  gt: () => gt,
+  gte: () => gte,
+  ifA: () => ifA,
+  ifDefined: () => ifDefined,
+  ifFalse: () => ifFalse,
+  ifGet: () => ifGet,
+  ifNotEmpty: () => ifNotEmpty,
+  ifTrue: () => ifTrue,
+  inFuture: () => inFuture,
+  inList: () => inList,
+  inOptionalList: () => inOptionalList,
+  inPast: () => inPast,
+  includes: () => includes,
+  isA: () => isA,
+  isAddress: () => isAddress,
+  isAn: () => isAn,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isClause: () => isClause,
+  isConstructor: () => isConstructor,
+  isDate: () => isDate,
+  isDateTime: () => isDateTime,
+  isDefined: () => isDefined,
+  isDoesNotExist: () => isDoesNotExist,
+  isEAN: () => isEAN,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  isEmptyObject: () => isEmptyObject,
+  isEnum: () => isEnum,
+  isEqual: () => isEqual,
+  isError: () => isError,
+  isException: () => isException,
+  isFalsy: () => isFalsy,
+  isField: () => isField,
+  isFunc: () => isFunc,
+  isFunction: () => isFunction,
+  isHttpStatus: () => isHttpStatus,
+  isIBAN: () => isIBAN,
+  isIn: () => isIn,
+  isInstance: () => isInstance,
+  isIntersecting: () => isIntersecting,
+  isIsoDateString: () => isIsoDateString,
+  isJson: () => isJson,
+  isList: () => isList,
+  isLoading: () => isLoading,
+  isMapping: () => isMapping,
+  isMoney: () => isMoney,
+  isNotEmpty: () => isNotEmpty,
+  isNotPresent: () => isNotPresent,
+  isNullish: () => isNullish,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isOriginatedError: () => isOriginatedError,
+  isPageList: () => isPageList,
+  isPresent: () => isPresent,
+  isPrimitive: () => isPrimitive,
+  isRequestOptions: () => isRequestOptions,
+  isResponse: () => isResponse,
+  isRestResult: () => isRestResult,
+  isResult: () => isResult,
+  isResults: () => isResults,
+  isSimpleView: () => isSimpleView,
+  isSortCondition: () => isSortCondition,
+  isString: () => isString,
+  isStruct: () => isStruct,
+  isText: () => isText,
+  isTrue: () => isTrue,
+  isTruthy: () => isTruthy,
+  isUndefined: () => isUndefined,
+  isUrl: () => isUrl,
+  isUuid: () => isUuid,
+  isValid: () => isValid,
+  isValidatable: () => isValidatable,
+  isValue: () => isValue,
+  json: () => json,
+  kebab: () => kebab,
+  log: () => log,
+  lt: () => lt,
+  lte: () => lte,
+  mappings: () => mappings,
+  maxLength: () => maxLength,
+  maxValue: () => maxValue,
+  meta: () => meta,
+  minLength: () => minLength,
+  minValue: () => minValue,
+  money: () => money,
+  name: () => name,
+  notEmpty: () => notEmpty,
+  ofConstruct: () => ofConstruct,
+  ofGet: () => ofGet,
+  ofMessage: () => ofMessage,
+  ofProperty: () => ofProperty,
+  on: () => on,
+  optional: () => optional2,
+  past: () => past,
+  patch: () => patch,
+  post: () => post,
+  postalCode: () => postalCode,
+  put: () => put,
+  quote: () => quote,
+  reject: () => reject,
+  replaceAll: () => replaceAll,
+  required: () => required,
+  requires: () => requires,
+  resolve: () => resolve,
+  rest: () => rest,
+  route: () => route,
+  routes: () => routes,
+  rule: () => rule,
+  search: () => search,
+  searchable: () => searchable,
+  singleton: () => singleton,
+  stream: () => stream,
+  tag: () => tag,
+  template: () => template,
+  text: () => text,
+  toArray: () => toArray,
+  toCacheOptions: () => toCacheOptions,
+  toClause: () => toClause,
+  toCondition: () => toCondition,
+  toFilter: () => toFilter,
+  toHttpStatus: () => toHttpStatus,
+  toId: () => toId,
+  toJson: () => toJson,
+  toList: () => toList,
+  toName: () => toName,
+  toObject: () => toObject,
+  toOriginatedError: () => toOriginatedError,
+  toPageList: () => toPageList,
+  toPageOptions: () => toPageOptions,
+  toReq: () => toReq,
+  toResponse: () => toResponse,
+  toResult: () => toResult,
+  toResults: () => toResults,
+  toSegment: () => toSegment,
+  toShortFilter: () => toShortFilter,
+  toSlug: () => toSlug,
+  toUuid: () => toUuid,
+  toVerbOptions: () => toVerbOptions,
+  toViewer: () => toViewer,
+  toWords: () => toWords,
+  traverse: () => traverse,
+  tryTo: () => tryTo,
+  tuple: () => tuple,
+  tuple2: () => tuple2,
+  tuple3: () => tuple3,
+  tuple4: () => tuple4,
+  tuple5: () => tuple5,
+  uri: () => uri,
+  url: () => url,
+  use: () => use,
+  valid: () => valid,
+  validate: () => validate,
+  validateReject: () => validateReject,
+  view: () => view,
+  views: () => views,
+  wait: () => wait,
+  we: () => we,
+  weight: () => weight,
+  when: () => when
+});
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./data"), module.exports);
-__reExport(src_exports, require("./domain"), module.exports);
-__reExport(src_exports, require("./http"), module.exports);
-__reExport(src_exports, require("./health"), module.exports);
-__reExport(src_exports, require("./process"), module.exports);
-__reExport(src_exports, require("./resources"), module.exports);
-__reExport(src_exports, require("./services"), module.exports);
-__reExport(src_exports, require("./security"), module.exports);
-__reExport(src_exports, require("./sql"), module.exports);
-__reExport(src_exports, require("./types"), module.exports);
-__reExport(src_exports, require("./utils"), module.exports);
-__reExport(src_exports, require("./validation"), module.exports);
+
+// src/types/Is.ts
+var isDefined = (o) => o !== void 0 && o !== null;
+var isUndefined = (v) => v === void 0 || v === null;
+var isEmpty = (o) => o === "" || o === null || o === void 0 || isArray(o) && o.length === 0;
+var isNotEmpty = (o) => o !== "" && o !== null && o !== void 0 && (!isArray(o) || o.length > 0);
+var isString = (o) => o instanceof String || typeof o === "string";
+var isIsoDateString = (o) => isString(o) && /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)$/.test(o);
+var isBoolean = (o) => isDefined(o) && typeof o === "boolean";
+var isTrue = (o) => isFunction(o) ? isTrue(o()) : isBoolean(o) ? o : !!o;
+var isNumber = (o) => isDefined(o) && typeof o === "number" && !Number.isNaN(o);
+var isObject = (o) => o != null && typeof o === "object" && !isArray(o);
+var isEmptyObject = (o) => isObject(o) && Object.getOwnPropertyNames(o).length === 0;
+var isFunction = (o) => isDefined(o) && typeof o === "function";
+var isArray = (o) => isDefined(o) && o instanceof Array;
+var isInstance = (ctor, o) => isFunction(ctor) && o instanceof ctor;
+var isIn = (o, values) => isArray(values) && values.some((v) => v === o);
+var isIntersecting = (o, values) => isArray(o) && isArray(values) && o.some((ov) => isIn(ov, values));
+var isError = (e) => isDefined(e) && e instanceof Error;
+var isNotPresent = (...os) => os.some(
+  (o) => o === null || o === void 0 || o === "" || o instanceof Array && o.length === 0 || typeof o === "object" && Object.getOwnPropertyNames(o).length === 0
+);
+var isPresent = (...os) => !isNotPresent(...os);
+
+// src/types/Func.ts
+var isFunc = (o) => !!o && typeof o === "function";
+
+// src/types/Primitive.ts
+var isPrimitive = (v) => {
+  return v === null || v === void 0 || isIn(typeof v, ["string", "number", "bigint", "boolean", "symbol"]);
+};
+
+// src/types/Constructor.ts
+var isConstructor = (c) => (isDefined(c) && isFunc(c) && c.prototype && c.prototype.constructor) === c;
+var ofConstruct = (c, ...args) => isConstructor(c) ? new c(...args) : isFunc(c) ? c(...args) : c;
+var toName = (subject, postfix = "") => subject?.constructor?.name?.replace(postfix, "").toLowerCase() ?? "";
+var on = (t, f) => {
+  f(t);
+  return t;
+};
+var use = (t, f) => f(t);
+var ifA = (c, t, alt) => !isPrimitive(t) && t instanceof c ? t : alt ? ifA(c, alt) : void 0;
+
+// src/types/Array.ts
+var toArray = (...items) => items.length > 1 ? items : isArray(items[0]) ? items[0] : isDefined(items[0]) ? [items[0]] : [];
+var toObject = (key, ...items) => toArray(...items).reduce((o, i) => {
+  o[i[key]] = i;
+  return o;
+}, {});
+var array = {
+  merge: (first = [], second = [], firstKey = "id", secondKey = "id") => first.map((f) => ({
+    ...f,
+    ...second.find((s) => isDefined(s[secondKey]) && isDefined(f[firstKey]) && s[secondKey] === f[firstKey])
+  })),
+  switch: (items = [], item) => use([...items], (res) => {
+    on(res.indexOf(item), (i) => i !== -1 ? res.splice(i, 1) : res.push(item));
+    return res;
+  }),
+  splitIn: (items = [], length = 2) => {
+    const res = Array.from({ length }, () => []);
+    items.forEach((i, index) => res[index % length].push(i));
+    return res;
+  }
+};
+
+// src/types/Meta.ts
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/types/IsA.ts
+var isA = (t, ...properties) => !isPrimitive(t) && properties.every((p) => p.toString() in t);
+var isAn = isA;
+
+// src/types/Get.ts
+var ofGet = (g, ...args) => isFunc(g) ? g(...args) : g;
+var ifGet = (pred, valid2, invalid) => ofGet(pred) ? ofGet(valid2) : ofGet(invalid);
+var ofProperty = (t, p) => isFunc(p) ? p(t) : t[p];
+
+// src/utils/Base64.ts
+var base64 = {
+  decode: (data) => Buffer.from(data, "base64").toString("utf-8"),
+  encode: (data) => Buffer.from(data, "utf-8").toString("base64"),
+  toJson: (data) => JSON.parse(base64.decode(data))
+};
+
+// src/utils/Convert.ts
+var Convert = class {
+  constructor(from, to) {
+    this.from = from;
+    this.to = to;
+  }
+};
+var convert = {
+  default: new Convert(
+    (a) => a,
+    (a) => a
+  ),
+  ignore: new Convert(
+    () => void 0,
+    () => void 0
+  ),
+  toBool: {
+    fromNumber: new Convert(
+      (b) => b ? 1 : 0,
+      (n) => n !== 0
+    ),
+    fromString: new Convert(
+      (b) => b ? "true" : "false",
+      (s) => s === "true"
+    )
+  },
+  toDate: {
+    fromString: new Convert(
+      (s) => new Date(s).toISOString(),
+      (s) => s
+    )
+  },
+  toNumber: {
+    fromString: new Convert(
+      (n) => asString(n),
+      (s) => parseInt(s)
+    )
+  }
+};
+
+// src/utils/If.ts
+function ifTrue(o, f, alt) {
+  return isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+function ifFalse(o, f, alt) {
+  return !isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+function ifDefined(o, f, alt) {
+  return isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt);
+}
+function ifNotEmpty(o, f = (o2) => o2, alt) {
+  return isNotEmpty(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+
+// src/utils/Loading.ts
+var isLoading = (...targets) => isNotPresent(...targets);
+
+// src/utils/Log.ts
+function log(labelOrT, t) {
+  if (t) {
+    console.log(labelOrT, t);
+    return t;
+  } else {
+    console.log(labelOrT);
+    return labelOrT;
+  }
+}
+function dir(t) {
+  console.dir(t, { depth: 200 });
+  return t;
+}
+
+// src/utils/Property.ts
+var Property = class {
+  constructor(property, options) {
+    this.property = property;
+    this.options = options;
+    this.options = { ...options, convert: options?.convert ?? convert.default };
+  }
+  in = (source = {}) => this.options?.convert?.to(source[this.property] ?? ofGet(this.options?.dflt));
+  out = (source = {}, key = "") => this.options?.convert?.from(source[key]);
+  toString() {
+    return this.property;
+  }
+};
+
+// src/utils/State.ts
+var State = class {
+  constructor(state = {}) {
+    this.state = state;
+  }
+  get = (key, alt) => this.state[key] ?? (this.state[key] = ofConstruct(alt));
+  set = (key, value) => this.get(key, value);
+};
+
+// src/utils/Mapper.ts
+var isMapping = (m) => isA(m, "in", "out");
+var Mapper = class extends State {
+  constructor(options = { startFrom: "scratch" }, property = "") {
+    super();
+    this.options = options;
+    this.property = property;
+  }
+  map = mappings;
+  // All properties that are a mapping
+  get properties() {
+    return this.get(
+      "props",
+      () => meta(this).entries().filter(([, v]) => isMapping(v))
+    );
+  }
+  // All names of properties (in target) that have a Mapping
+  get keys() {
+    return this.get("keys", () => this.properties.map(([k]) => k));
+  }
+  // All names of properties (in source) that are named in a Mapping
+  get columns() {
+    return this.get("columns", () => this.properties.mapDefined(([, p]) => ifNotEmpty(p.property, p.property))).distinct();
+  }
+  // All names of properties (in source) that are NOT properties in target
+  get droppedIn() {
+    return this.get("droppedIn", () => this.columns.filter((c) => !this.keys.some((k) => k === c)));
+  }
+  // All names op properties (in target) that are NOT properties in source
+  get droppedOut() {
+    return this.get("droppedOut", () => this.properties.filter(([, p]) => !this.keys.some((k) => k === p.property)).map(([k]) => k));
+  }
+  in(from = {}) {
+    return json.omit(
+      this.properties.reduce((a, [k, p]) => json.merge(a, { [k]: p.in({ ...a, ...from }) }), this.options.startFrom === "source" ? from : {}),
+      ...this.droppedIn
+    );
+  }
+  out(to = {}) {
+    return json.omit(
+      this.properties.reduce(
+        (a, [k, p]) => json.merge(a, isEmpty(p.property) ? p.out(to, k) : { [p.property ?? ""]: p.out({ ...a, ...to }, k) }),
+        this.options.startFrom === "source" ? to : {}
+      ),
+      ...this.droppedOut
+    );
+  }
+  toString() {
+    return this.constructor.name;
+  }
+};
+var mappings = {
+  item: (property, options) => new Property(property, options),
+  ignore: (property = "") => ({
+    property,
+    in: () => void 0,
+    out: () => void 0
+  }),
+  skipIn: (property) => ({
+    property,
+    in: () => void 0,
+    out: (source = {}) => source[property]
+  }),
+  skipOut: (property) => ({
+    property,
+    in: (source = {}) => source[property],
+    out: () => void 0
+  }),
+  func: (property, funcIn, funcOut) => ({
+    property,
+    in: (source = {}) => ofGet(funcIn, source),
+    out: (source = {}) => ofGet(funcOut, source)
+  }),
+  add: (funcIn) => ({
+    property: "",
+    in: (source = {}) => ofGet(funcIn, source),
+    out: () => void 0
+  }),
+  map: (mapper, property = "") => ({
+    property,
+    in: (source = {}) => ofConstruct(mapper).in(isEmpty(property) ? source : source[property]),
+    out: (source = {}, key = "") => ofConstruct(mapper).out(isEmpty(key) ? source : source[key])
+  }),
+  propsToList: (...maps) => ({
+    property: "",
+    in: (source = {}) => toList(maps.map((m) => ofConstruct(m).in(source))).toJSON(),
+    out: (source = {}, key = "") => maps.reduce((a, m, i) => {
+      const res = toList(source[key])[i];
+      const out = m.out(res);
+      return { ...a, [m.property]: out ?? {} };
+    }, {})
+  }),
+  list: (mapper, property) => ({
+    property,
+    in: (source = {}) => toList(source[property]).map((v) => mapper.in(v)).toJSON(),
+    out: (source = {}, key = "") => toList(isEmpty(key) ? source : source[key]).map((v) => mapper.out(v)).toJSON()
+  })
+};
+
+// src/utils/Promise.ts
+var resolve = (subject) => Promise.resolve(subject);
+var reject = (e) => Promise.reject(e);
+var tuple = {
+  2: (first, second) => Promise.all([first, second]),
+  3: (first, second, third) => Promise.all([first, second, third]),
+  4: (first, second, third, forth) => Promise.all([first, second, third, forth]),
+  5: (first, second, third, forth, fifth) => Promise.all([first, second, third, forth, fifth]),
+  all: (first, second) => Promise.all([first, Promise.all(second)]),
+  spread: (first, ...second) => Promise.all([first, Promise.all(toArray(second))]),
+  list: (list) => Promise.all([...list]).then(toList)
+};
+var tuple2 = tuple[2];
+var tuple3 = tuple[3];
+var tuple4 = tuple[4];
+var tuple5 = tuple[5];
+
+// src/utils/Sentence.ts
+var Sentence = class {
+  constructor(word, pre, sentence = (pre?.sentence ?? []).concat(word)) {
+    this.sentence = sentence;
+  }
+  toString() {
+    return text(this.sentence.join(" ")).sentence.toString();
+  }
+};
+var Topic = class extends Sentence {
+  it = new Sentence("it", this);
+  anything = new Sentence("anything", this);
+  id = (id) => new Sentence(`id '${id}'`, this);
+  your = (subject) => new Sentence(`your ${subject ?? "item"}`, this);
+  a = (subject) => new Sentence(subject ? `a ${subject}` : "an item", this);
+  an = (subject) => new Sentence(`an ${subject ?? "item"}`, this);
+  any = (subjects) => new Sentence(`any ${subjects ?? "items"}`, this);
+};
+var Verb = class extends Sentence {
+  add = new Topic("add", this);
+  check = new Topic("check", this);
+  fetch = new Topic("fetch", this);
+  find = new Topic("find", this);
+  like = new Topic("like", this);
+  process = new Topic("process", this);
+  remove = new Topic("remove", this);
+  translate = new Topic("translate", this);
+  update = new Topic("update", this);
+  validate = new Topic("validate", this);
+};
+var Not = class extends Verb {
+};
+var SupportVerb = class extends Verb {
+  not = new Not("not", this);
+};
+var We = class extends Sentence {
+  could = new SupportVerb("could", this);
+  did = new SupportVerb("did", this);
+  added = new Topic("added", this);
+  checked = new Topic("checked", this);
+  fetched = new Topic("fetched", this);
+  found = new Topic("found", this);
+  liked = new Topic("liked", this);
+  processed = new Topic("processed", this);
+  removed = new Topic("removed", this);
+  translated = new Topic("translated", this);
+  updated = new Topic("updated", this);
+  validated = new Topic("validated", this);
+};
+var we = new We("we");
+
+// src/utils/Traverse.ts
+var traverse = (subject = {}, property = "") => {
+  const props = property.split(".");
+  const p = props.shift();
+  return props.length === 0 ? subject[p] : traverse(subject[p], props.join("."));
+};
+
+// src/utils/View.ts
+var ignore = Symbol("view.ignore");
+var keep = Symbol("view.keep");
+var toViewer = (key, value) => choose(value).is.not.defined((v) => v, { key, f: () => void 0 }).type(isBoolean, (b) => ({ key, f: () => b })).equals(ignore, { key, f: () => void 0 }).equals(keep, { key, f: (a) => traverse(a, key) }).type(isString, (s) => ({ key, f: (a) => traverse(a, s) })).type(isConstructor, (c) => ({
+  key,
+  f: (a, key2) => use(traverse(a, key2), (v) => isArray(v) ? v.map((i) => optional(c, i)) : optional(c, v))
+})).type(isSimpleView, (f) => ({ key, f: (a) => f.from(traverse(a, key)) })).type(isFunction, (f) => ({ key, f })).else((v) => ({ key, f: () => v }));
+var optional = (c, v) => ifDefined(
+  v,
+  (i) => new c(i),
+  () => v
+);
+var toViewers = (views2) => meta(views2).entries().map(([k, v]) => toViewer(k, v));
+var View = class _View {
+  constructor(views2 = {}, startsFrom = "scratch", viewers = toViewers(views2)) {
+    this.views = views2;
+    this.startsFrom = startsFrom;
+    this.viewers = viewers;
+  }
+  get fromSource() {
+    return new _View(this.views, "source", this.viewers);
+  }
+  from(source) {
+    if (isPageList(source))
+      return toPageList(
+        source.map((s) => this.reduce(s)),
+        source
+      );
+    if (isArray(source))
+      return source.map((s) => this.reduce(s));
+    return this.reduce(source);
+  }
+  same = (one, another) => isEqual(this.from(one), this.from(another));
+  reduce = (source) => use(asJson(source), (src) => this.viewers.reduce((acc, v) => json.set(acc, v.key, v.f(src, v.key)), this.startsFrom === "scratch" ? {} : src));
+};
+var isSimpleView = (a) => a instanceof View;
+var view = (views2) => new View(views2);
+var views = {
+  ignore,
+  keep,
+  skip: ignore,
+  value: (value) => () => value,
+  or: {
+    key: (altKey) => (a, key) => traverse(a, key) ?? traverse(a, altKey),
+    value: (altValue) => (a, key) => traverse(a, key) ?? altValue,
+    func: (altFunc) => (a, key) => traverse(a, key) ?? altFunc(a, key)
+  }
+};
+
+// src/utils/Wait.ts
+var Wait = class {
+  static wait(ms = 0) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+  static seconds(s = 0) {
+    return this.wait(s * 1e3);
+  }
+};
+var wait = (millis) => Wait.wait(millis);
+
+// src/types/Json.ts
+var isJson = (subject) => isA(subject, "toJSON");
+var json = {
+  parse: (subject) => JSON.parse(JSON.stringify(subject ?? {})),
+  merge: (...subjects) => json.parse(subjects.map((s) => asJson(s, (s2) => json.parse(s2))).reduce((js, j) => ({ ...js, ...j }), {})),
+  delete: (subject, key) => {
+    ifDefined(subject, () => delete subject[key]);
+    return subject;
+  },
+  set: (subject, key = "", value) => isEmpty(key) ? subject : value !== void 0 ? { ...subject, ...{ [key]: value } } : json.delete(subject, key),
+  omit: (subject, ...keys) => keys.reduce((js, k) => json.delete(js, k), json.parse(subject)),
+  defaults: (options = {}, defaults = {}) => json.merge(defaults, options)
+};
+var toJson = json.merge;
+var asJson = (j, alt = {}) => isJson(j) ? j.toJSON() : isObject(j) ? j : ofGet(alt, j);
+var Any = class {
+  constructor(value) {
+    this.value = value;
+  }
+  merge = (...subjects) => any(json.merge(this.value, ...subjects));
+  delete = (key) => any(json.delete(this.value, key));
+  omit = (...keys) => any(json.omit(this.value, ...keys));
+  set = (key, value) => any(json.set(this.value, key, value));
+  toJSON() {
+    return this.value;
+  }
+};
+var any = (value) => new Any(value);
+
+// src/validation/When.ts
+var When = class _When {
+  constructor(subject, valid2 = true, results) {
+    this.subject = subject;
+    this.valid = valid2;
+    this.results = results;
+  }
+  get not() {
+    return this.clone(!this.valid);
+  }
+  get and() {
+    return this.clone(this.valid);
+  }
+  get isDefined() {
+    return this.clone(this.valid === isDefined(this.subject));
+  }
+  get isEmpty() {
+    return this.clone(this.valid === isEmpty(this.subject));
+  }
+  get isTrue() {
+    return this.clone(this.valid === !!this.subject);
+  }
+  get isValid() {
+    this.results = validate(this.subject);
+    return this.clone(this.valid === this.results.isValid);
+  }
+  isInstance = (c) => this.clone(this.valid === this.subject instanceof c);
+  with = (pred) => this.clone(this.valid === ofGet(pred, this.subject));
+  contains = (property) => this.clone(this.valid === isDefined(ofGet(property, this.subject)));
+  in = (...items) => this.clone(this.valid === isIn(this.subject, toArray(...items)));
+  is = (item) => this.clone(this.valid === (this.subject === item));
+  reject = (error) => !this.valid ? resolve(this.subject) : reject(ofGet(error, this.subject) ?? this.results ?? Exception.Unknown);
+  recover = (f) => resolve(!this.valid ? this.subject : f(this.subject));
+  clone = (result = true) => new _When(this.subject, result, this.results);
+};
+var when = (subject) => new When(subject);
+
+// src/validation/Validate.ts
+var asResults = (subject, template2, options = {}) => toResults(toResult(text(template2).parse(subject, options), toName(subject)));
+var validators = (subject) => meta(subject).keys("constraint").reduce((list, vs) => list.add(vs), toList());
+var runValidator = (v, subject) => tryTo(() => isFunction(subject[v.property]) ? subject[v.property]() : subject[v.property]).map((actual) => [actual, v.constraint(actual)]).map(([actual, res]) => isResults(res) ? res : !res ? asResults(subject, v.text, { ...v, actual }) : toResults()).recover((e) => asResults(subject, asString(e))).value;
+var constraints = (subject) => tryTo(() => validators(subject)).map((vs) => vs.mapDefined((v) => runValidator(v, subject))).map((res) => res.reduce((rs, r) => rs.add(...r.results), toResults())).value;
+var validate = (subject) => choose(subject).is.not.defined(
+  (s) => s,
+  () => toResults("Subject is not defined.")
+).type(isEnum, (e) => e.isValid ? toResults() : asResults(e, "This is not a valid {type}.")).type(isValue, (v) => v.isValid ? toResults() : asResults(v, "This is not a valid {type}.")).type(isArray, (a) => a.map((i) => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults())).type(isValidatable, (v) => constraints(v)).else(toResults());
+var validateReject = (subject) => when(subject).not.isValid.reject();
+var isValid = (t) => validate(t).isValid;
+
+// src/validation/Contraints.ts
+var constraint = (c, message) => (subject, property) => {
+  const cs = meta(subject).property(property).get("constraint") ?? toList();
+  meta(subject).property(property).set("constraint", cs.add({ property, constraint: c, text: message }));
+};
+var defined = (message) => constraint((v) => isDefined(v), message ?? "Property {property} must be defined.");
+var required = (message) => constraint((v) => isNotEmpty(v), message ?? "Property {property} is required, and may not be empty.");
+var notEmpty = (message) => constraint((v) => isNotEmpty(v), message ?? "Property {property} may not be empty.");
+var valid = () => constraint((v) => validate(v), "");
+var optional2 = () => constraint((v) => !isDefined(v) || validate(v), "");
+var includes = (sub, message) => constraint((s) => isDefined(s) && isString(s) && s.includes(sub), message ?? `Value {actual} must include '${sub}'.`);
+var inList = (values, message) => constraint((v) => isDefined(v) && isIn(v, values), message ?? "Value {actual} must appear in list.");
+var inOptionalList = (values, message) => constraint((v) => !isDefined(v) || isIn(v, values), message ?? "Value {actual} must appear in list.");
+var gt = (limit, message) => constraint((v) => v > limit, message ?? `Value {actual} must be larger than '${limit}'.`);
+var gte = (limit, message) => constraint((v) => v >= limit, message ?? `Value {actual} must be larger than or equal to ${limit}.`);
+var lt = (limit, message) => constraint((v) => v < limit, message ?? `Value {actual} must be smaller than ${limit}.`);
+var lte = (limit, message) => constraint((v) => v <= limit, message ?? `Value {actual} must be smaller than or equal to ${limit}.`);
+var past = (message) => constraint((v) => inPast(v), message ?? "Value {actual} must lay in the past.");
+var future = (message) => constraint((v) => inFuture(v), message ?? "Value {actual} must lay in the future.");
+var minLength = (length, message) => constraint(
+  (v) => tryTo(() => v).is.defined().map((v2) => text(v2).toString().length >= length).orElse(true),
+  message ?? `Value {actual} must be at least '${length}' characters long.`
+);
+var maxLength = (length, message) => constraint(
+  (v) => tryTo(() => v).is.defined().map((v2) => text(v2).toString().length <= length).orElse(true),
+  message ?? `Value {actual} cannot be longer than '${length}' characters.`
+);
+var rule = (message) => constraint((v) => isFunction(v) ? v() : isBoolean(v) ? v : false, message ?? `Value {actual} must be true`);
+
+// src/types/Try.ts
+var Try = class _Try {
+  is = {
+    defined: (prop) => this.filter((v) => isDefined(prop ? prop(v) : v)),
+    empty: (prop) => this.filter((v) => isEmpty(prop ? prop(v) : v)),
+    valid: (prop) => this.filter((v) => validate(prop ? prop(v) : v).isValid),
+    true: (prop) => this.filter((v) => isTrue(prop ? prop(v) : v)),
+    false: (prop) => this.filter((v) => !isTrue(prop ? prop(v) : v)),
+    not: {
+      defined: (prop) => this.filter((v) => !isDefined(prop ? prop(v) : v)),
+      empty: (prop) => this.filter((v) => !isEmpty(prop ? prop(v) : v)),
+      valid: (prop) => this.filter((v) => !validate(prop ? prop(v) : v).isValid)
+    }
+  };
+  if = this.is;
+  static of = (c, ...args) => {
+    try {
+      const out = ofGet(c, ...args);
+      return new Success(out instanceof _Try ? out.value : out);
+    } catch (e) {
+      return new Failure(e);
+    }
+  };
+};
+var Success = class extends Try {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  get error() {
+    throw new Error("No error found");
+  }
+  get isValid() {
+    return true;
+  }
+  map(f) {
+    return tryTo(f, this.value);
+  }
+  recover(f) {
+    return this;
+  }
+  recoverFrom(type, f) {
+    return this;
+  }
+  accept(f) {
+    return tryTo(() => {
+      f(this.value);
+      return this;
+    });
+  }
+  filter(predicate) {
+    return tryTo(() => {
+      if (predicate(this.value))
+        return this;
+      throw new Error(`Applying filter(${predicate.toString()}) failed.`);
+    });
+  }
+  or(value) {
+    return this.value;
+  }
+  orElse(value) {
+    return this.value;
+  }
+  orThrow(_error) {
+    return this.value;
+  }
+};
+var Failure = class _Failure extends Try {
+  constructor(error) {
+    super();
+    this.error = error;
+  }
+  get value() {
+    throw this.error;
+  }
+  get isValid() {
+    return false;
+  }
+  map(f) {
+    return new _Failure(this.error);
+  }
+  recover(f) {
+    return tryTo(f, this.error);
+  }
+  recoverFrom(type, f) {
+    return tryTo(() => this.error instanceof type ? this.recover(f) : this);
+  }
+  accept(f) {
+    return this;
+  }
+  filter(predicate) {
+    return this;
+  }
+  or(value) {
+    return ofGet(value);
+  }
+  orElse(value) {
+    return ofGet(value);
+  }
+  orThrow(error) {
+    throw ofConstruct(error);
+  }
+};
+var tryTo = (c, ...args) => Try.of(c, ...args);
+
+// src/types/List.ts
+var List6 = class extends Array {
+  asc(p) {
+    return this.sort((e1, e2) => ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1);
+  }
+  desc(p) {
+    return this.sort((e1, e2) => ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1);
+  }
+  first(p, params) {
+    return p ? this.find(p, params) : this[0];
+  }
+  firstValue(f, alt) {
+    return tryTo(() => this.first((t) => !!f(t))).map((i) => i ? f(i) : ofGet(alt, i)).value;
+  }
+  isFirst(value) {
+    return value === this.first();
+  }
+  next(p, params) {
+    return p ? this[this.findIndex(p, params) + 1] : this[0];
+  }
+  prev(p, params) {
+    return p ? this[this.findIndex(p, params) - 1] : this[0];
+  }
+  last(p, params) {
+    return p ? this.filter(p, params).last() : this[this.length - 1];
+  }
+  isLast(value) {
+    return value === this.last();
+  }
+  overlaps(...items) {
+    return toList(...items).some((i) => this.some((t) => i === t));
+  }
+  diff(others) {
+    return this.filter((i) => !others.includes(i));
+  }
+  diffByKey(others, key) {
+    return this.filter((i) => !others.some((o) => o[key] === i[key]));
+  }
+  symmetricDiff(others) {
+    return this.diff(others).concat(toList(...others).diff(this));
+  }
+  symmetricDiffByKey(others, key) {
+    return this.diffByKey(others, key).concat(toList(...others).diffByKey(this, key));
+  }
+  intersect(others) {
+    return this.filter((i) => others.includes(i));
+  }
+  intersectByKey(others, key) {
+    return this.filter((i) => others.some((o) => o[key] === i[key]));
+  }
+  toJSON() {
+    return this.reduce((a, i) => {
+      a.push(json.parse(i));
+      return a;
+    }, new Array());
+  }
+  map(f, params) {
+    return toList(super.map(f, params));
+  }
+  flatMap(f, params) {
+    return toList(super.flatMap(f, params));
+  }
+  mapDefined(f, params) {
+    return this.map(f, params).defined();
+  }
+  mapAsync(f) {
+    return Promise.all(super.map((e) => f(e))).then((a) => toList(a));
+  }
+  distinct() {
+    return this.filter((i, index) => this.indexOf(i) === index);
+  }
+  distinctByKey(key) {
+    return meta(this.toObject(key)).values();
+  }
+  filter(p, params) {
+    return toList(super.filter(p, params));
+  }
+  sum(p) {
+    return this.reduce((sum, i) => sum + p(i), 0);
+  }
+  max(key) {
+    return this.desc(key).first();
+  }
+  min(key) {
+    return this.asc(key).first();
+  }
+  byId(id) {
+    return this.first((i) => asString(i.id) === asString(id));
+  }
+  add(...items) {
+    super.push(...toArray(...items));
+    return this;
+  }
+  concat(...items) {
+    return toList(super.concat(...items));
+  }
+  reverse() {
+    return toList(super.reverse());
+  }
+  splice(start, deleteCount, ...items) {
+    return toList(super.splice(start, deleteCount, ...items));
+  }
+  remove(item) {
+    const index = this.indexOf(item);
+    if (index > -1) {
+      this.splice(index, 1);
+    }
+    return this;
+  }
+  replace(key, item) {
+    tryTo(() => item[key]).map((k) => this.findIndex((i) => i[key] === k)).filter((i) => i > -1).map((i) => this[i] = item);
+    return this;
+  }
+  switch(item) {
+    return this.includes(item) ? this.remove(item) : this.add(item);
+  }
+  defined() {
+    return this.reduce((l, v) => isDefined(v) ? l.add(v) : l, toList());
+  }
+  toObject(key, options = {}) {
+    return this.reduce((o, i) => {
+      o[i[key]] = i;
+      if (options.deleteKey)
+        delete o[i[key]][key];
+      return o;
+    }, {});
+  }
+  toObjectList(key) {
+    return this.reduce(
+      (a, t) => {
+        const k = t[key];
+        a[k] = a[k] ?? toList();
+        a[k].push(t);
+        return a;
+      },
+      {}
+    );
+  }
+  orElse(...alt) {
+    return !isEmpty(this) ? this : !isEmpty(...alt) ? toList(...alt) : void 0;
+  }
+  weave(insertFrom, interval) {
+    for (let i = interval, n = 0; i <= this.length && n < insertFrom.length; i += interval + 1) {
+      this.splice(i, 0, insertFrom[n++]);
+    }
+    return this;
+  }
+  slice(start, end) {
+    return toList(super.slice(start, end));
+  }
+  none(p) {
+    return !this.some(p);
+  }
+  chunk(chunkSize) {
+    return this.reduce((acc, _, index) => index % chunkSize === 0 ? on(acc, (a) => a.push(this.slice(index, index + chunkSize))) : acc, toList());
+  }
+};
+var toList = (...items) => new List6().add(...items);
+var isList = (l) => isDefined(l) && isArray(l) && isA(l, "first", "last", "asc", "desc");
+var asList = (c, items = []) => toList(toArray(items).map((i) => new c(i)));
+var maxValue = (l, key) => l.desc(key).first()?.[key];
+var minValue = (l, key) => l.asc(key).first()?.[key];
+
+// src/types/Meta.ts
+var ClassMeta = class {
+  constructor(subject, data = (subject.prototype ?? subject).constructor) {
+    this.subject = subject;
+    this.data = data;
+  }
+  get = (key) => Reflect.getMetadata(key, this.data);
+  set = (key, value) => {
+    Reflect.defineMetadata(key, value, this.data);
+    return value;
+  };
+  entries = () => toList([...Object.entries(this.subject), ...Object.entries(Object.getPrototypeOf(this.subject))]);
+  parse = (f, options = {}) => {
+    const { initial = {}, skipUndefined = false } = options;
+    return this.entries().reduce((a, [k, val]) => use(f(val), (v) => isDefined(v) || !skipUndefined ? on(a, (a2) => a2[k] = v) : a), initial);
+  };
+  properties = (key) => toList([...Object.getOwnPropertyNames(this.subject), ...Object.getOwnPropertyNames(Object.getPrototypeOf(this.subject))]).map((p) => this.property(p)).filter((p) => key ? p.get(key) : p);
+  keys = (key) => this.properties().map((p) => p.get(key)).reduce((list, u) => u ? list.add(u) : list, toList());
+  values = () => toList([...Object.values(this.subject), ...Object.values(Object.getPrototypeOf(this.subject))]);
+  property = (property) => new PropertyMeta(this.subject, property);
+};
+var PropertyMeta = class {
+  constructor(subject, property, data = Reflect.getMetadata(property, subject)) {
+    this.subject = subject;
+    this.property = property;
+    this.data = data;
+  }
+  get value() {
+    return this.subject[this.property];
+  }
+  get = (key) => isDefined(this.data) && isDefined(this.data[key]) ? this.data[key] : void 0;
+  set = (key, value) => {
+    Reflect.defineMetadata(this.property, { ...this.data, [key]: value }, this.subject);
+    return value;
+  };
+};
+var meta = (subject) => new ClassMeta(subject ?? {});
+var entries = (subject) => meta(subject).entries();
+
+// src/types/Template.ts
+var Template = class {
+  constructor(template2, subject = {}, options = {}) {
+    this.template = template2;
+    this.subject = subject;
+    this.options = options;
+  }
+  toString = () => {
+    return meta(this.options).entries().reduce((t, [k]) => this.option(t, k), this.object()).replace("  ", " ");
+  };
+  value = (subject, prop) => tryTo(() => prop.split(".")).map((p) => [p, p.splice(1)]).map(([p, ps]) => ps.reduce((t, s) => t[s], text(subject[p[0]]))).map((p) => p.toString()).value;
+  props = (tmpl, key, result = toList()) => {
+    const i1 = tmpl.indexOf(`{${key}`);
+    if (i1 < 0) {
+      return result;
+    }
+    const i2 = tmpl.indexOf("}", i1);
+    return this.props(tmpl.slice(i2 + 1), key, result.add(tmpl.substring(i1 + 1, i2)));
+  };
+  object = () => {
+    return this.props(this.template, "this").reduce((t, p) => t.replace(`{${p}}`, this.value(this.subject, p.replace("this.", ""))), this.template);
+  };
+  option = (tmpl, prop) => {
+    return this.props(tmpl, prop).reduce((t, p) => t.replace(`{${p}}`, this.value(this.options, p)), tmpl);
+  };
+};
+var template = (tmpl, subject, options = {}) => new Template(asString(tmpl), subject, {
+  type: toName(subject),
+  subject: text(JSON.stringify(subject)),
+  ...options
+});
+
+// src/types/Text.ts
+var isText = (t) => isDefined(t) && isFunc(t.toString);
+var asString = (t, alt = "") => (isText(t) ? t : ofGet(alt)).toString();
+var replaceAll = (origin, search2, replace = "") => asString(origin).split(asString(search2)).join(asString(replace));
+var toWords = (input) => {
+  return asString(input).replace(/(\p{Lower})(\p{Upper})/gu, "$1 $2").replace(/(\p{Upper})(\p{Upper}\p{Lower})/gu, "$1 $2").split(/[_\W]+/g).filter(Boolean);
+};
+var kebab = (s = "") => toWords(s).join("-").toLowerCase();
+var ToText2 = class {
+  constructor(subject) {
+    this.subject = subject;
+  }
+  get cap() {
+    return this.map((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase());
+  }
+  get title() {
+    return this.map(
+      (s) => s.split(" ").map((w) => text(w).cap).join(" ")
+    );
+  }
+  get pascal() {
+    return this.title.replace(" ", "");
+  }
+  get lower() {
+    return this.map((s) => s.toLowerCase());
+  }
+  get upper() {
+    return this.map((s) => s.toUpperCase());
+  }
+  get camel() {
+    return this.title.trim.map((s) => `${s.charAt(0).toLowerCase()}${s.slice(1)}`);
+  }
+  get kebab() {
+    return this.lower.replace(" ", "-");
+  }
+  get strictKebab() {
+    return this.map((s) => s.replace(/[^a-z\d]+/gi, " ").trim()).kebab;
+  }
+  get slug() {
+    return this.map(
+      (s) => s.replace(/ß/g, "ss").normalize("NFKD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z\d]+/g, "-").replace(/(^-)|(-$)/g, "")
+    );
+  }
+  get snake() {
+    return this.upper.replace(" ", "_");
+  }
+  get plural() {
+    return this.ifLike("") ?? this.add("s");
+  }
+  get space() {
+    return this.map((s) => s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]/g, " "));
+  }
+  get sentence() {
+    return this.isEmpty ? this : this.map((s) => `${s.charAt(0).toUpperCase()}${s.slice(1)}.`);
+  }
+  get initials() {
+    return this.map(
+      (s) => s.split(" ").map((w) => w[0]).join("")
+    );
+  }
+  get trim() {
+    return this.map((s) => s.replace(/[- ,_#]/g, ""));
+  }
+  get isEmpty() {
+    return isEmpty(this.toString());
+  }
+  parse = (subject, options = {}) => text(template(this.subject, subject, { type: toName(subject), ...options }));
+  is = (...others) => others.some((o) => this.toString() === text(o).toString());
+  equals = this.is;
+  isLike = (...others) => others.some((o) => this.trim.lower.is(text(o).trim.lower));
+  ifLike = (...others) => this.isLike(...others) ? this : void 0;
+  endsWith = (end) => this.subject.endsWith(asString(end));
+  startsWith = (end) => this.subject.startsWith(asString(end));
+  first = (n) => this.map((s) => s.substring(0, n));
+  last = (n) => this.map((s) => s.substring(s.length - n));
+  map = (func) => text(ofGet(func, this.subject));
+  replace = (search2, replace) => this.map((s) => replaceAll(s, search2, replace));
+  add = (add, separator = "") => this.map((s) => isNotEmpty(add) ? `${s}${separator}${text(add)}` : s);
+  with = (separator, ...other) => this.map(
+    (s) => toList(s).add(...other.map((u) => text(u).toString())).filter((s2) => isNotEmpty(s2)).join(separator)
+  );
+  toString() {
+    return this.subject;
+  }
+  toJSON() {
+    return this.subject;
+  }
+};
+var text = (subject, alt = "") => {
+  const sub = subject ? asString(subject) : alt;
+  return new ToText2(sub !== "[object Object]" ? sub : "");
+};
+
+// src/types/Builder.ts
+var builder = class _builder {
+  static state = {};
+  static singleton = (ctr, ...args) => _builder.state[asString(ctr)] ?? (_builder.state[asString(ctr)] = new ctr(...args));
+  static reset = () => {
+    _builder.state = {};
+  };
+};
+var build = {
+  singleton: (ctr, ...args) => builder.singleton(ctr, ...args),
+  reset: () => builder.reset()
+};
+var singleton = (ctr, ...args) => build.singleton(ctr, ...args);
+
+// src/types/Cache.ts
+var toCacheOptions = (co) => ({
+  expiresIn: co.expiresIn ?? "5m",
+  store: co.store
+});
+var cache = (options) => (subject) => {
+  meta(subject).set("cache", toCacheOptions(options));
+};
+
+// src/types/CacheAge.ts
+var ageNumber = (s) => asNumber(s.replace(/[a-z]/g, ""));
+var cacheAge = {
+  toMilliseconds: (ca) => choose(asString(ca)).case(
+    (c) => c.endsWith("ms"),
+    (c) => ageNumber(c)
+  ).case(
+    (c) => c.endsWith("s"),
+    (c) => ageNumber(c) * 1e3
+  ).case(
+    (c) => c.endsWith("m"),
+    (c) => ageNumber(c) * 60 * 1e3
+  ).case(
+    (c) => c.endsWith("h"),
+    (c) => ageNumber(c) * 3600 * 1e3
+  ).case(
+    (c) => c.endsWith("d"),
+    (c) => ageNumber(c) * 24 * 3600 * 1e3
+  ).else(ca),
+  toSeconds: (ca) => choose(asString(ca)).case(
+    (c) => c.endsWith("ms"),
+    (c) => ageNumber(c) / 1e3
+  ).case(
+    (c) => c.endsWith("s"),
+    (c) => ageNumber(c)
+  ).case(
+    (c) => c.endsWith("m"),
+    (c) => ageNumber(c) * 60
+  ).case(
+    (c) => c.endsWith("h"),
+    (c) => ageNumber(c) * 3600
+  ).case(
+    (c) => c.endsWith("d"),
+    (c) => ageNumber(c) * 24 * 3600
+  ).else(ca)
+};
+
+// src/types/Case.ts
+var CaseBuilder = class {
+  constructor(v) {
+    this.v = v;
+  }
+  case(pred, out) {
+    return new Case(this.v).case(pred, out);
+  }
+  type(guard, out) {
+    return new Case(this.v).type(guard, out);
+  }
+  equals(value, out) {
+    return new Case(this.v).equals(value, out);
+  }
+  is = {
+    defined: (prop, out) => new Case(this.v).case(isDefined(prop(this.v)), out),
+    empty: (prop, out) => new Case(this.v).case(isEmpty(prop(this.v)), out),
+    valid: (prop, out) => new Case(this.v).case(validate(prop(this.v)).isValid, out),
+    not: {
+      defined: (prop, out) => new Case(this.v).case(!isDefined(prop(this.v)), out),
+      empty: (prop, out) => new Case(this.v).case(!isEmpty(prop(this.v)), out),
+      valid: (prop, out) => new Case(this.v).case(!validate(prop(this.v)).isValid, out)
+    }
+  };
+  if = this.is;
+};
+var Case = class _Case {
+  constructor(value, outcome) {
+    this.value = value;
+    this.outcome = outcome;
+  }
+  case(pred, out) {
+    return tryTo(pred, this.value).is.true().map(() => ofGet(out, this.value)).map((res) => new Found(this.value, res)).or(this);
+  }
+  type(guard, out) {
+    return tryTo(guard, this.value).is.true().map(() => out(this.value)).map((res) => new Found(this.value, res)).or(this);
+  }
+  equals(value, out) {
+    return this.case(this.value === value, out);
+  }
+  is = {
+    defined: (prop, out) => new _Case(this.value).case(isDefined(prop(this.value)), out),
+    empty: (prop, out) => new _Case(this.value).case(isEmpty(prop(this.value)), out),
+    valid: (prop, out) => new _Case(this.value).case(validate(prop(this.value)).isValid, out),
+    not: {
+      defined: (prop, out) => new _Case(this.value).case(!isDefined(prop(this.value)), out),
+      empty: (prop, out) => new _Case(this.value).case(!isEmpty(prop(this.value)), out),
+      valid: (prop, out) => new _Case(this.value).case(!validate(prop(this.value)).isValid, out)
+    }
+  };
+  if = this.is;
+  else(alt) {
+    return ofGet(alt, this.value);
+  }
+};
+var Found = class extends Case {
+  constructor(value, outcome) {
+    super(value, outcome);
+    this.value = value;
+    this.outcome = outcome;
+  }
+  case(pred, out) {
+    return this;
+  }
+  type(guard, out) {
+    return this;
+  }
+  equals(value, out) {
+    return this;
+  }
+  is = {
+    defined: (_prop, _out) => this,
+    empty: (_prop, _out) => this,
+    valid: (_prop, _out) => this,
+    not: {
+      defined: (_prop, _out) => this,
+      empty: (_prop, _out) => this,
+      valid: (_prop, _out) => this
+    }
+  };
+  if = this.is;
+  else(alt) {
+    return this.outcome;
+  }
+};
+var choose = (value) => new CaseBuilder(value);
+
+// src/types/Context.ts
+var DotEnvContext = class {
+  domain = process.env.DOMAIN ?? "easy";
+  name = process.env.ENVIRONMENT_NAME ?? "";
+  host = process.env.HOST ?? "";
+  port = Number.parseInt(process.env.PORT ?? "8080");
+  app = process.env.APP ?? "";
+  get = (key, alt) => tryTo(
+    () => text(key).map((k) => k.replace(/([a-z])([A-Z])/g, "$1 $2")).snake.toString()
+  ).map((k) => process.env[k] ?? alt).value;
+};
+var BaseRequestContext = class {
+  state = {};
+  get token() {
+    return this.get("token");
+  }
+  set token(token) {
+    this.set("token", token);
+  }
+  get identity() {
+    return this.token;
+  }
+  get jwt() {
+    return this.get("jwt");
+  }
+  set jwt(jwt) {
+    this.set("jwt", jwt);
+  }
+  get correlationId() {
+    return this.get("correlationId");
+  }
+  set correlationId(id) {
+    this.set("correlationId", id);
+  }
+  get lastError() {
+    return this.get("lastError");
+  }
+  set lastError(error) {
+    this.set("lastError", error);
+  }
+  get(key) {
+    return this.state[key];
+  }
+  set(key, value) {
+    return this.state[key] = value;
+  }
+  create = (f) => f();
+  wrap = (f) => f();
+};
+var BaseContext = class extends BaseRequestContext {
+};
+var Context = class {
+  constructor(state = {}) {
+    this.state = state;
+    this.state = {
+      ...{
+        env: new DotEnvContext(),
+        request: new BaseRequestContext(),
+        other: {}
+      },
+      ...this.state
+    };
+  }
+  get env() {
+    return this.state.env;
+  }
+  set env(env) {
+    this.state.env = env;
+  }
+  get request() {
+    return this.state.request;
+  }
+  set request(request) {
+    this.state.request = request;
+  }
+  get other() {
+    return this.state.other;
+  }
+};
+var ctx = new Context();
+
+// src/types/Enum.ts
+var Enum = class {
+  constructor(name2, id = name2.toLowerCase(), code = id.toString()) {
+    this.name = name2;
+    this.id = id;
+    this.code = code;
+  }
+  get isValid() {
+    return isDefined(this.id);
+  }
+  static all() {
+    return meta(this.allTuple()).values();
+  }
+  static allTuple() {
+    return meta(this).get(`all-${this.name}`) ?? meta(this).set(`all-${this.name}`, meta(this).values().filter(isEnum).toObject("id"));
+  }
+  static filter(p, params) {
+    return this.all().filter(p, params);
+  }
+  static first(p, params) {
+    return this.all().first(p, params);
+  }
+  static byIds(ids = []) {
+    return toList(ids).mapDefined((id) => this.byId(id)).distinct();
+  }
+  static byId(id, alt) {
+    return this.allTuple()[id] ?? ofGet(alt);
+  }
+  equals(other) {
+    return this.id === (isEnum(other) ? other.id : other);
+  }
+  isIn(...items) {
+    return items.some((i) => this.equals(i));
+  }
+  toJSON() {
+    return this.id;
+  }
+  toString() {
+    return this.id.toString();
+  }
+};
+var isEnum = (e) => isDefined(e) && e instanceof Enum && isAn(e, "name", "id", "code");
+
+// src/types/Exception.ts
+var Exception = class _Exception extends Enum {
+  constructor(message, id, reason) {
+    super(message, id ?? text(message).pascal.toString());
+    this.message = message;
+    this.reason = reason;
+  }
+  static AlreadyExists = new _Exception("Subject already exists");
+  static DoesNotExist = new _Exception("Does not exist");
+  static IsMissingId = new _Exception("Subject is missing an id");
+  static IsNotImplemented = new _Exception("Is not implemented");
+  static IsNotValid = new _Exception("Is not valid");
+  static Unknown = new _Exception("Unknown error");
+  static CouldNotExecute = (target) => new _Exception(`Could not execute ${target}.`, "CouldNotExecute");
+  static CouldNotValidate = (target) => new _Exception(`Could not validate ${target}.`, "CouldNotValidate");
+  static EnvironmentVariableNotFound = (variable) => new _Exception(`Environment variable ${text(variable).upper} could not be found.`, "EnvironmentVariableNotFound");
+  because = (reason) => new _Exception(this.message, this.id, reason);
+};
+var isException = (e, t) => e instanceof Exception && (isDefined(t) ? e.equals(asString(t)) : true);
+var isDoesNotExist = (e) => e instanceof Exception && Exception.DoesNotExist.equals(e);
+
+// src/types/Falsy.ts
+var isFalsy = (v) => !v;
+var isTruthy = (v) => !isFalsy(v);
+
+// src/types/Gateway.ts
+var Gateway = class {
+  all(options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  byId(id, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  by(_key, _value, _options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  byIds(..._ids) {
+    return reject(Exception.IsNotImplemented);
+  }
+  search(q, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  filter(options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  exists(id, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  add(item, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  update(item, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  remove(id, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+};
+
+// src/types/Uuid.ts
+var import_uuid = require("uuid");
+var isValidUuid = new RegExp(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i);
+var isUuid = (id) => isString(id) && isValidUuid.test(id);
+var toUuid = () => (0, import_uuid.v4)();
+
+// src/types/Id.ts
+var toId = () => toUuid();
+
+// src/types/IsDate.ts
+var isDate = (o) => o instanceof Date && !isNaN(o.getTime());
+var days = {
+  add: (date, days2) => {
+    date.setDate(date.getDate() + days2);
+    return date;
+  },
+  today: () => /* @__PURE__ */ new Date(),
+  yesterday: () => days.add(days.today(), -1),
+  tomorrow: () => days.add(days.today(), 1)
+};
+var inPast = (o) => isDate(o) && o <= days.today();
+var inFuture = (o) => isDate(o) && o > days.today();
+
+// src/types/IsEqual.ts
+var isEqualArray = (one, another) => choose([one, another]).case(([o, a]) => !isArray(o) || !isArray(a), false).case(([o, a]) => o?.length !== a?.length, false).else(([o, a]) => !o.some((v, i) => !isEqual(v, a[i])));
+var isEqualObject = (one, another) => choose([Object.keys(one), Object.keys(another)]).case(([keysO, keysA]) => keysO.length !== keysA.length, false).case(([keysO, keysA]) => keysO.some((k) => !keysA.includes(k)), false).case(([keysO]) => keysO.some((k) => !isEqual(one[k], another[k])), false).else(true);
+var isEqual = (one, another) => choose([one, another]).case(([o, a]) => o === a, true).case(
+  ([o, a]) => isArray(o) || isArray(a),
+  ([o, a]) => isEqualArray(o, a)
+).case(
+  ([o, a]) => o == null || a == null || !isObject(o) && !isObject(a),
+  ([o, a]) => o !== o && a !== a
+).else(([o, a]) => isEqualObject(o, a));
+
+// src/types/Message.ts
+var ofMessage = (g, ...params) => isFunc(g) ? g(...params) : g;
+
+// src/types/Nullish.ts
+var isNullish = (v) => v == null;
+
+// src/types/Number.ts
+var asNumber = (n, alt) => tryTo(() => asString(n)).map((s) => parseInt(s)).filter((n2) => isNumber(n2)).or(ofGet(alt) ?? NaN);
+
+// src/types/PageList.ts
+var toFilter = (field, value) => toShortFilter(field, field, value);
+var toShortFilter = (field, shortField, value) => ({
+  field,
+  shortField,
+  values: [{ value }]
+});
+var PageList2 = class extends List6 {
+  _options;
+  setPageOptions(options) {
+    this._options = options;
+    return this;
+  }
+  get take() {
+    return this._options?.take ?? 250;
+  }
+  get skip() {
+    return this._options?.skip ?? 0;
+  }
+  get total() {
+    return this._options?.total;
+  }
+  get sorts() {
+    return this._options?.sorts;
+  }
+  get filters() {
+    return this._options?.filters;
+  }
+  get meta() {
+    return {
+      take: this.take,
+      skip: this.skip,
+      total: this.total,
+      sorts: this.sorts,
+      filters: this.filters
+    };
+  }
+  get options() {
+    return this._options;
+  }
+  asc(p) {
+    return toPageList(super.asc(p), this);
+  }
+  desc(p) {
+    return toPageList(super.desc(p), this);
+  }
+  diff(others) {
+    return toPageList(super.diff(others), this);
+  }
+  diffByKey(others, key) {
+    return toPageList(super.diffByKey(others, key), this);
+  }
+  intersect(others) {
+    return toPageList(super.intersect(others), this);
+  }
+  intersectByKey(others, key) {
+    return toPageList(super.intersectByKey(others, key), this);
+  }
+  map(f, params) {
+    const items = super.map(f, params);
+    return toPageList(items, this);
+  }
+  flatMap(f, params) {
+    return toPageList(super.flatMap(f, params), this);
+  }
+  mapDefined(f, params) {
+    return toPageList(super.mapDefined(f, params), this);
+  }
+  mapAsync(f) {
+    return super.mapAsync(f).then((r) => toPageList(r, this));
+  }
+  distinct() {
+    return toPageList(super.distinct(), this);
+  }
+  distinctByKey(key) {
+    return toPageList(super.distinctByKey(key), this);
+  }
+  filter(p, params) {
+    return toPageList(super.filter(p, params), this);
+  }
+  concat(...items) {
+    return toPageList(super.concat(...items), this);
+  }
+  reverse() {
+    return toPageList(super.reverse(), this);
+  }
+  splice(start, deleteCount, ...items) {
+    return toPageList(super.splice(start, deleteCount, ...items), this);
+  }
+  remove(item) {
+    return toPageList(super.remove(item), this);
+  }
+  replace(key, item) {
+    return toPageList(super.replace(key, item), this);
+  }
+  switch(item) {
+    return toPageList(super.switch(item), this);
+  }
+  defined() {
+    return toPageList(super.defined(), this);
+  }
+  orElse(...alt) {
+    return toPageList(super.orElse(...alt), this);
+  }
+  slice(start, end) {
+    return toPageList(super.slice(start, end), this);
+  }
+};
+var isPageList = (l) => isList(l) && isA(l, "total");
+var toPageList = (items = [], options) => choose(items).case(
+  (i) => i.length === 1 && isNumber(i[0]),
+  (i) => new PageList2().add(...i)
+).else((i) => new PageList2(...i)).setPageOptions(options);
+var asPageList = (c, items = toPageList()) => items.map((i) => ofConstruct(c, i));
+
+// src/types/Parser.ts
+var Parser = class {
+  constructor(value, valid2 = true) {
+    this.value = value;
+    this.valid = valid2;
+  }
+  if = {
+    equals: (pred) => this.evaluate(isTrue, pred),
+    empty: (pred) => this.evaluate(isEmpty, pred),
+    defined: (pred) => this.evaluate(isDefined, pred),
+    valid: (pred) => this.evaluate(isValid, pred),
+    in: (...items) => this.evaluate(() => isIn(this.value, toArray(...items))),
+    is: {
+      object: (pred) => this.evaluate(isObject, pred),
+      string: (pred) => this.evaluate(isString, pred),
+      instance: (c, pred) => this.evaluate(() => this.value instanceof c, pred)
+    },
+    not: {
+      empty: (pred) => this.evaluateNot(isEmpty, pred),
+      defined: (pred) => this.evaluateNot(isDefined, pred),
+      valid: (pred) => this.evaluateNot(isValid, pred),
+      isObject: (pred) => this.evaluateNot(isObject, pred),
+      in: (...items) => this.evaluate(() => !isIn(this.value, toArray(...items))),
+      is: {
+        object: (pred) => this.evaluateNot(isObject, pred),
+        string: (pred) => this.evaluateNot(isString, pred),
+        instance: (c, pred) => this.evaluate(() => !(this.value instanceof c), pred)
+      }
+    }
+  };
+  evaluate(meta2, pred) {
+    return on(this, (t) => t.valid = ofGet(meta2, pred ? ofGet(pred, this.value) : this.value));
+  }
+  evaluateNot(meta2, pred) {
+    return on(this, (t) => t.valid = !ofGet(meta2, pred ? ofGet(pred, this.value) : this.value));
+  }
+};
+
+// src/types/Repository.ts
+var Repository = class {
+  all(options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  byId(id) {
+    return reject(Exception.IsNotImplemented);
+  }
+  byIds(...ids) {
+    return reject(Exception.IsNotImplemented);
+  }
+  byKey(key, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  by(key, value, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  search(q, options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  filter(options) {
+    return reject(Exception.IsNotImplemented);
+  }
+  exists(id) {
+    return reject(Exception.IsNotImplemented);
+  }
+  add(t) {
+    return reject(Exception.IsNotImplemented);
+  }
+  update(id, json2) {
+    return reject(Exception.IsNotImplemented);
+  }
+  remove(id) {
+    return reject(Exception.IsNotImplemented);
+  }
+  upsert(id, item) {
+    return reject(Exception.IsNotImplemented);
+  }
+};
+
+// src/types/Result.ts
+var toResult = (message, location, domain = ctx.env.domain) => ({
+  message: message.toString(),
+  location: location?.toString(),
+  domain: domain?.toString()
+});
+var isResult = (r) => isA(r, "message");
+
+// src/types/Results.ts
+var parse = (...rs) => toArray(...rs).map((r) => isResult(r) ? r : toResult(r));
+var Results4 = class {
+  results;
+  constructor(...rs) {
+    this.results = parse(...rs);
+  }
+  get length() {
+    return this.results.length;
+  }
+  get isValid() {
+    return this.results.length === 0;
+  }
+  add = (...rs) => toResults(...this.results, ...parse(...rs));
+};
+var toResults = (...r) => new Results4(...r);
+var isResults = (r) => isDefined(r) && r instanceof Results4;
+
+// src/types/Sort.ts
+var asc = 1;
+var desc = -1;
+
+// src/types/Tag.ts
+var tag = (name2) => (subject, property) => {
+  meta(subject).property(property).set(name2, property);
+};
+var searchable = () => tag(searchable.name);
+
+// src/types/Uri.ts
+var toSegment = (key, {
+  segment,
+  query
+} = {}) => ({
+  key,
+  segment,
+  query,
+  toString: () => asString(key)
+});
+var uri = {
+  host: (key) => toSegment(key, { segment: key ?? ctx.env.host ?? "$host" }),
+  resource: (resource) => toSegment(toName(resource, "Uri"), { segment: toName(resource, "Uri") }),
+  segment: (key) => toSegment(key, { segment: key }),
+  path: (key) => toSegment(key, { segment: `:${key}` }),
+  query: (key) => toSegment(key, {
+    query: (value) => tryTo(value).is.defined().map((v) => encodeURIComponent(asString(v))).map((v) => `${key}=${v}`).orElse("") ?? ""
+  }),
+  boolean: (key) => toSegment(key, { query: (value) => isTrue(value) ? `${key}` : "" })
+};
+var toRoute = (...segments) => toList(segments).mapDefined((s) => s.segment).join("/");
+var EasyUri = class _EasyUri {
+  constructor(segments = []) {
+    this.segments = segments;
+  }
+  static id = uri.path("id");
+  static ids = uri.query("ids");
+  static query = uri.query("q");
+  static sort = uri.query("s");
+  static skip = uri.query("skip");
+  static take = uri.query("take");
+  host = uri.host();
+  resource = uri.resource(this);
+  state = {};
+  get path() {
+    return toRoute(uri.segment(""), this.resource, ...this.segments);
+  }
+  get complete() {
+    return toRoute(this.host, this.resource, ...this.segments);
+  }
+  get isInternal() {
+    return toRoute(this.host) === (ctx.env.host ?? "$host");
+  }
+  get props() {
+    return meta(this.state).values();
+  }
+  route = (resource = this.resource.key) => toRoute(uri.segment(""), uri.segment(resource?.toLowerCase()), ...this.segments);
+  set = (segment, value) => {
+    tryTo(value).is.defined().accept((value2) => this.state[segment.key ?? ""] = { segment, value: value2 });
+    return this;
+  };
+  toString() {
+    return tryTo(() => this.props).map((ps) => ps.filter((p) => p.segment?.segment)).map((ps) => ps.reduce((r, p) => r.replace(asString(p.segment.segment), asString(p.value)), this.complete)).map((route2) => ({
+      route: route2,
+      query: this.props.mapDefined((p) => p.segment?.query ? p.segment?.query(p.value) : void 0)?.join("&")
+    })).map(({ route: route2, query }) => isNotEmpty(query) ? `${route2}?${query}` : route2).value;
+  }
+  id = (id) => this.set(_EasyUri.id, id);
+  ids = (ids) => this.set(_EasyUri.ids, toArray(ids).join(","));
+  query = (q) => this.set(_EasyUri.query, q);
+  sort = (s) => this.set(_EasyUri.sort, asString(s));
+  skip = (index) => this.set(_EasyUri.skip, index);
+  take = (items) => this.set(_EasyUri.take, items);
+  expand(props) {
+    return entries(props).filter(([_, v]) => isNotEmpty(v)).reduce((u, [k, v]) => isBoolean(v) ? u.set(uri.boolean(k), v) : u.set(uri.query(k), toArray(v).join(",")), this);
+  }
+};
+
+// src/types/Validatable.ts
+var isValidatable = (v) => isA(v, "isValid");
+
+// src/types/Value.ts
+var Value = class {
+  constructor(value) {
+    this.value = value;
+    this.value = value;
+  }
+  get isValid() {
+    return isDefined(this.value);
+  }
+  toJSON() {
+    return this.value;
+  }
+  toString() {
+    return asString(this.value);
+  }
+};
+var isValue = (v) => v instanceof Value;
+
+// src/data/Condition.ts
+var Condition = class {
+  constructor(key, operator, value) {
+    this.key = key;
+    this.operator = operator;
+    this.value = value;
+  }
+  and = (...others) => new LogicalCondition("and", [this, ...others]);
+  or = (...others) => new LogicalCondition("or", [this, ...others]);
+  toJSON() {
+    return { [this.key]: { [`$${this.operator}`]: json.parse(this.value) } };
+  }
+};
+var LogicalCondition = class {
+  constructor(operator, conditions) {
+    this.operator = operator;
+    this.conditions = conditions;
+  }
+  toJSON() {
+    return { [`$${this.operator}`]: this.conditions.map((c) => c.toJSON()) };
+  }
+};
+var SortCondition = class extends Condition {
+  constructor(key, value) {
+    super(key, "", value);
+    this.key = key;
+    this.value = value;
+  }
+  toJSON() {
+    return { [this.key]: this.value };
+  }
+};
+var toCondition = (field, operator, value, conv = convert.default) => new Condition(field, operator, conv.from(value));
+var isSortCondition = (s) => isDefined(s) && s instanceof SortCondition;
+
+// src/data/InMemoryGateway.ts
+var InMemoryGateway = class extends Gateway {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  all(options) {
+    return this.data.then((d) => toPageList(d, d));
+  }
+  byId(id) {
+    return this.data.then((d) => d.byId(id)).then((d) => d ? { ...d } : void 0);
+  }
+  by = (key, value) => {
+    return this.data.then((d) => d.filter((i) => i[key] === value));
+  };
+  exists(id) {
+    return this.byId(id).then((d) => isDefined(d));
+  }
+  add(item) {
+    return when(item).not.contains((i) => i.id).reject(Exception.IsMissingId).then((i) => this.exists(i.id)).then((ex) => when(ex).isTrue.reject(Exception.AlreadyExists)).then(() => this.data.then((d) => d.add(item))).then(() => ({ ...item }));
+  }
+  remove(id) {
+    return this.data.then(
+      (d) => when(d.findIndex((i) => i.id === id)).with((i) => i < 0).reject(Exception.DoesNotExist).then((i) => d.splice(i, 1))
+    ).then(() => true);
+  }
+  update(item) {
+    return when(item).not.contains((i) => i.id).reject(Exception.IsMissingId).then((i) => this.remove(i.id).then(() => this.add(i)));
+  }
+};
+
+// src/data/Database.ts
+var DefaultProvider = class {
+};
+var Database = class _Database extends Enum {
+  constructor(name2, provider, options) {
+    super(name2);
+    this.provider = provider;
+    this.options = options;
+  }
+  static Default = new _Database("Default", DefaultProvider);
+  provide = () => ofConstruct(this.provider, this);
+};
+
+// src/data/Field.ts
+var Field = class extends Property {
+  is = (value) => this.condition("eq", value);
+  isNot = (value) => this.condition("ne", value);
+  isIn = (...value) => this.condition("in", toArray(value));
+  notIn = (...value) => this.condition("nin", toArray(value));
+  exists = (does) => this.condition("exists", does);
+  greater = (value) => this.condition("gt", value);
+  greaterEqual = (value) => this.condition("gte", value);
+  less = (value) => this.condition("lt", value);
+  lessEqual = (value) => this.condition("lte", value);
+  asc = () => new SortCondition(this.property, 1);
+  desc = () => new SortCondition(this.property, -1);
+  condition = (operator, value) => toCondition(this.property, operator, value, this.options?.convert);
+};
+var isField = (f) => isDefined(f) && f instanceof Field;
+
+// src/domain/enums/Country.ts
+var Country = class _Country extends Enum {
+  constructor(name2, id, lower = text(id).lower.trim.toString()) {
+    super(name2, id);
+    this.lower = lower;
+  }
+  static AF = new _Country("Afghanistan", "AF");
+  static AX = new _Country("\xC5land Islands", "AX");
+  static AL = new _Country("Albania", "AL");
+  static DZ = new _Country("Algeria", "DZ");
+  static AS = new _Country("American Samoa", "AS");
+  static AD = new _Country("Andorra", "AD");
+  static AO = new _Country("Angola", "AO");
+  static AI = new _Country("Anguilla", "AI");
+  static AQ = new _Country("Antarctica", "AQ");
+  static AG = new _Country("Antigua & Barbuda", "AG");
+  static AR = new _Country("Argentina", "AR");
+  static AM = new _Country("Armenia", "AM");
+  static AW = new _Country("Aruba", "AW");
+  static AU = new _Country("Australia", "AU");
+  static AT = new _Country("Austria", "AT");
+  static AZ = new _Country("Azerbaijan", "AZ");
+  static BS = new _Country("Bahamas", "BS");
+  static BH = new _Country("Bahrain", "BH");
+  static BD = new _Country("Bangladesh", "BD");
+  static BB = new _Country("Barbados", "BB");
+  static BY = new _Country("Belarus", "BY");
+  static BE = new _Country("Belgium", "BE");
+  static BZ = new _Country("Belize", "BZ");
+  static BJ = new _Country("Benin", "BJ");
+  static BM = new _Country("Bermuda", "BM");
+  static BT = new _Country("Bhutan", "BT");
+  static BO = new _Country("Bolivia", "BO");
+  static BA = new _Country("Bosnia & Herzegovina", "BA");
+  static BW = new _Country("Botswana", "BW");
+  static BV = new _Country("Bouvet Island", "BV");
+  static BR = new _Country("Brazil", "BR");
+  static IO = new _Country("British Indian Ocean Territory", "IO");
+  static VG = new _Country("British Virgin Islands", "VG");
+  static BN = new _Country("Brunei", "BN");
+  static BG = new _Country("Bulgaria", "BG");
+  static BF = new _Country("Burkina Faso", "BF");
+  static BI = new _Country("Burundi", "BI");
+  static KH = new _Country("Cambodia", "KH");
+  static CM = new _Country("Cameroon", "CM");
+  static CA = new _Country("Canada", "CA");
+  static CV = new _Country("Cape Verde", "CV");
+  static BQ = new _Country("Caribbean Netherlands", "BQ");
+  static KY = new _Country("Cayman Islands", "KY");
+  static CF = new _Country("Central African Republic", "CF");
+  static TD = new _Country("Chad", "TD");
+  static CL = new _Country("Chile", "CL");
+  static CN = new _Country("China", "CN");
+  static CX = new _Country("Christmas Island", "CX");
+  static CC = new _Country("Cocos (Keeling) Islands", "CC");
+  static CO = new _Country("Colombia", "CO");
+  static KM = new _Country("Comoros", "KM");
+  static CG = new _Country("Congo - Brazzaville", "CG");
+  static CD = new _Country("Congo - Kinshasa", "CD");
+  static CK = new _Country("Cook Islands", "CK");
+  static CR = new _Country("Costa Rica", "CR");
+  static CI = new _Country("C\xF4te d\u2019Ivoire", "CI");
+  static HR = new _Country("Croatia", "HR");
+  static CU = new _Country("Cuba", "CU");
+  static CW = new _Country("Cura\xE7ao", "CW");
+  static CY = new _Country("Cyprus", "CY");
+  static CZ = new _Country("Czechia", "CZ");
+  static DK = new _Country("Denmark", "DK");
+  static DJ = new _Country("Djibouti", "DJ");
+  static DM = new _Country("Dominica", "DM");
+  static DO = new _Country("Dominican Republic", "DO");
+  static EC = new _Country("Ecuador", "EC");
+  static EG = new _Country("Egypt", "EG");
+  static SV = new _Country("El Salvador", "SV");
+  static GQ = new _Country("Equatorial Guinea", "GQ");
+  static ER = new _Country("Eritrea", "ER");
+  static EE = new _Country("Estonia", "EE");
+  static SZ = new _Country("Eswatini", "SZ");
+  static ET = new _Country("Ethiopia", "ET");
+  static FK = new _Country("Falkland Islands", "FK");
+  static FO = new _Country("Faroe Islands", "FO");
+  static FJ = new _Country("Fiji", "FJ");
+  static FI = new _Country("Finland", "FI");
+  static FR = new _Country("France", "FR");
+  static GF = new _Country("French Guiana", "GF");
+  static PF = new _Country("French Polynesia", "PF");
+  static TF = new _Country("French Southern Territories", "TF");
+  static GA = new _Country("Gabon", "GA");
+  static GM = new _Country("Gambia", "GM");
+  static GE = new _Country("Georgia", "GE");
+  static DE = new _Country("Germany", "DE");
+  static GH = new _Country("Ghana", "GH");
+  static GI = new _Country("Gibraltar", "GI");
+  static GR = new _Country("Greece", "GR");
+  static GL = new _Country("Greenland", "GL");
+  static GD = new _Country("Grenada", "GD");
+  static GP = new _Country("Guadeloupe", "GP");
+  static GU = new _Country("Guam", "GU");
+  static GT = new _Country("Guatemala", "GT");
+  static GG = new _Country("Guernsey", "GG");
+  static GN = new _Country("Guinea", "GN");
+  static GW = new _Country("Guinea-Bissau", "GW");
+  static GY = new _Country("Guyana", "GY");
+  static HT = new _Country("Haiti", "HT");
+  static HM = new _Country("Heard & McDonald Islands", "HM");
+  static HN = new _Country("Honduras", "HN");
+  static HK = new _Country("Hong Kong SAR China", "HK");
+  static HU = new _Country("Hungary", "HU");
+  static IS = new _Country("Iceland", "IS");
+  static IN = new _Country("India", "IN");
+  static ID = new _Country("Indonesia", "ID");
+  static IR = new _Country("Iran", "IR");
+  static IQ = new _Country("Iraq", "IQ");
+  static IE = new _Country("Ireland", "IE");
+  static IM = new _Country("Isle of Man", "IM");
+  static IL = new _Country("Israel", "IL");
+  static IT = new _Country("Italy", "IT");
+  static JM = new _Country("Jamaica", "JM");
+  static JP = new _Country("Japan", "JP");
+  static JE = new _Country("Jersey", "JE");
+  static JO = new _Country("Jordan", "JO");
+  static KZ = new _Country("Kazakhstan", "KZ");
+  static KE = new _Country("Kenya", "KE");
+  static KI = new _Country("Kiribati", "KI");
+  static KW = new _Country("Kuwait", "KW");
+  static KG = new _Country("Kyrgyzstan", "KG");
+  static LA = new _Country("Laos", "LA");
+  static LV = new _Country("Latvia", "LV");
+  static LB = new _Country("Lebanon", "LB");
+  static LS = new _Country("Lesotho", "LS");
+  static LR = new _Country("Liberia", "LR");
+  static LY = new _Country("Libya", "LY");
+  static LI = new _Country("Liechtenstein", "LI");
+  static LT = new _Country("Lithuania", "LT");
+  static LU = new _Country("Luxembourg", "LU");
+  static MO = new _Country("Macao SAR China", "MO");
+  static MG = new _Country("Madagascar", "MG");
+  static MW = new _Country("Malawi", "MW");
+  static MY = new _Country("Malaysia", "MY");
+  static MV = new _Country("Maldives", "MV");
+  static ML = new _Country("Mali", "ML");
+  static MT = new _Country("Malta", "MT");
+  static MH = new _Country("Marshall Islands", "MH");
+  static MQ = new _Country("Martinique", "MQ");
+  static MR = new _Country("Mauritania", "MR");
+  static MU = new _Country("Mauritius", "MU");
+  static YT = new _Country("Mayotte", "YT");
+  static MX = new _Country("Mexico", "MX");
+  static FM = new _Country("Micronesia", "FM");
+  static MD = new _Country("Moldova", "MD");
+  static MC = new _Country("Monaco", "MC");
+  static MN = new _Country("Mongolia", "MN");
+  static ME = new _Country("Montenegro", "ME");
+  static MS = new _Country("Montserrat", "MS");
+  static MA = new _Country("Morocco", "MA");
+  static MZ = new _Country("Mozambique", "MZ");
+  static MM = new _Country("Myanmar (Burma)", "MM");
+  static NA = new _Country("Namibia", "NA");
+  static NR = new _Country("Nauru", "NR");
+  static NP = new _Country("Nepal", "NP");
+  static NL = new _Country("Netherlands", "NL");
+  static NC = new _Country("New Caledonia", "NC");
+  static NZ = new _Country("New Zealand", "NZ");
+  static NI = new _Country("Nicaragua", "NI");
+  static NE = new _Country("Niger", "NE");
+  static NG = new _Country("Nigeria", "NG");
+  static NU = new _Country("Niue", "NU");
+  static NF = new _Country("Norfolk Island", "NF");
+  static KP = new _Country("North Korea", "KP");
+  static MK = new _Country("North Macedonia", "MK");
+  static MP = new _Country("Northern Mariana Islands", "MP");
+  static NO = new _Country("Norway", "NO");
+  static OM = new _Country("Oman", "OM");
+  static PK = new _Country("Pakistan", "PK");
+  static PW = new _Country("Palau", "PW");
+  static PS = new _Country("Palestinian Territories", "PS");
+  static PA = new _Country("Panama", "PA");
+  static PG = new _Country("Papua New Guinea", "PG");
+  static PY = new _Country("Paraguay", "PY");
+  static PE = new _Country("Peru", "PE");
+  static PH = new _Country("Philippines", "PH");
+  static PN = new _Country("Pitcairn Islands", "PN");
+  static PL = new _Country("Poland", "PL");
+  static PT = new _Country("Portugal", "PT");
+  static PR = new _Country("Puerto Rico", "PR");
+  static QA = new _Country("Qatar", "QA");
+  static RE = new _Country("R\xE9union", "RE");
+  static RO = new _Country("Romania", "RO");
+  static RU = new _Country("Russia", "RU");
+  static RW = new _Country("Rwanda", "RW");
+  static WS = new _Country("Samoa", "WS");
+  static SM = new _Country("San Marino", "SM");
+  static ST = new _Country("S\xE3o Tom\xE9 & Pr\xEDncipe", "ST");
+  static SA = new _Country("Saudi Arabia", "SA");
+  static SN = new _Country("Senegal", "SN");
+  static RS = new _Country("Serbia", "RS");
+  static SC = new _Country("Seychelles", "SC");
+  static SL = new _Country("Sierra Leone", "SL");
+  static SG = new _Country("Singapore", "SG");
+  static SX = new _Country("Sint Maarten", "SX");
+  static SK = new _Country("Slovakia", "SK");
+  static SI = new _Country("Slovenia", "SI");
+  static SB = new _Country("Solomon Islands", "SB");
+  static SO = new _Country("Somalia", "SO");
+  static ZA = new _Country("South Africa", "ZA");
+  static GS = new _Country("South Georgia & South Sandwich Islands", "GS");
+  static KR = new _Country("South Korea", "KR");
+  static SS = new _Country("South Sudan", "SS");
+  static ES = new _Country("Spain", "ES");
+  static LK = new _Country("Sri Lanka", "LK");
+  static BL = new _Country("St. Barth\xE9lemy", "BL");
+  static SH = new _Country("St. Helena", "SH");
+  static KN = new _Country("St. Kitts & Nevis", "KN");
+  static LC = new _Country("St. Lucia", "LC");
+  static MF = new _Country("St. Martin", "MF");
+  static PM = new _Country("St. Pierre & Miquelon", "PM");
+  static VC = new _Country("St. Vincent & Grenadines", "VC");
+  static SD = new _Country("Sudan", "SD");
+  static SR = new _Country("Suriname", "SR");
+  static SJ = new _Country("Svalbard & Jan Mayen", "SJ");
+  static SE = new _Country("Sweden", "SE");
+  static CH = new _Country("Switzerland", "CH");
+  static SY = new _Country("Syria", "SY");
+  static TW = new _Country("Taiwan", "TW");
+  static TJ = new _Country("Tajikistan", "TJ");
+  static TZ = new _Country("Tanzania", "TZ");
+  static TH = new _Country("Thailand", "TH");
+  static TL = new _Country("Timor-Leste", "TL");
+  static TG = new _Country("Togo", "TG");
+  static TK = new _Country("Tokelau", "TK");
+  static TO = new _Country("Tonga", "TO");
+  static TT = new _Country("Trinidad & Tobago", "TT");
+  static TN = new _Country("Tunisia", "TN");
+  static TR = new _Country("Turkey", "TR");
+  static TM = new _Country("Turkmenistan", "TM");
+  static TC = new _Country("Turks & Caicos Islands", "TC");
+  static TV = new _Country("Tuvalu", "TV");
+  static UM = new _Country("U.S. Outlying Islands", "UM");
+  static VI = new _Country("U.S. Virgin Islands", "VI");
+  static UG = new _Country("Uganda", "UG");
+  static UA = new _Country("Ukraine", "UA");
+  static AE = new _Country("United Arab Emirates", "AE");
+  static GB = new _Country("United Kingdom", "GB");
+  static US = new _Country("United States", "US");
+  static UY = new _Country("Uruguay", "UY");
+  static UZ = new _Country("Uzbekistan", "UZ");
+  static VU = new _Country("Vanuatu", "VU");
+  static VA = new _Country("Vatican City", "VA");
+  static VE = new _Country("Venezuela", "VE");
+  static VN = new _Country("Vietnam", "VN");
+  static WF = new _Country("Wallis & Futuna", "WF");
+  static EH = new _Country("Western Sahara", "EH");
+  static YE = new _Country("Yemen", "YE");
+  static ZM = new _Country("Zambia", "ZM");
+  static ZW = new _Country("Zimbabwe", "ZW");
+  static lookup(other) {
+    return this.all().first((l) => l.equals(other));
+  }
+  equals(other) {
+    return text(other).lower.trim.equals(this.lower);
+  }
+};
+
+// src/domain/Struct.ts
+var Struct = class {
+  constructor(state = {}) {
+    this.state = state;
+  }
+  get isValid() {
+    return validate(this).isValid;
+  }
+  toJSON() {
+    return json.delete(json.parse({ ...this }), "state");
+  }
+  toString() {
+    return this.constructor.name;
+  }
+  update(_add) {
+    return this;
+  }
+  merge(a) {
+    return json.merge(this, a);
+  }
+};
+function isStruct(s) {
+  return isDefined(s) && s instanceof Struct;
+}
+
+// src/domain/values/DateTime.ts
+var import_luxon = require("luxon");
+import_luxon.Settings.defaultZone = "utc";
+var DateTime = class _DateTime extends Value {
+  constructor(value, format) {
+    super(
+      choose(value).type(isString, (v) => format ? import_luxon.DateTime.fromFormat(v, format, { setZone: true }) : import_luxon.DateTime.fromISO(v, { setZone: true })).type(isNumber, (v) => import_luxon.DateTime.fromMillis(v)).type(isDate, (v) => import_luxon.DateTime.fromJSDate(v)).type(isDateTime, (v) => import_luxon.DateTime.fromISO(v.toString())).else(void 0)?.toISO()
+    );
+  }
+  static get now() {
+    return new _DateTime(import_luxon.DateTime.utc().toISO());
+  }
+  get isValid() {
+    return isDefined(this.value) && this.utc.isValid;
+  }
+  /**
+   * @deprecated Deprecated in favor for DateTime.from as that also accepts locales and another DateTime
+   */
+  get fromNow() {
+    return this.from();
+  }
+  get utc() {
+    return this.luxon.setZone("utc");
+  }
+  get luxon() {
+    return import_luxon.DateTime.fromISO(this.value, { setZone: true });
+  }
+  from(param, other) {
+    const date = isA(param) ? param : void 0;
+    const locale = (isString(param) ? param : void 0) ?? other ?? "en";
+    return ifDefined(
+      date,
+      (d) => this.utc.setLocale(locale).toRelative({ base: d.utc }),
+      () => this.utc.setLocale(locale).toRelative()
+    );
+  }
+  isAfter(dt2) {
+    return this.utc > dt2.utc;
+  }
+  isBefore(dt2) {
+    return this.utc < dt2.utc;
+  }
+  equals(dt2) {
+    return this.utc.hasSame(dt2.utc, "millisecond");
+  }
+  add(n, unit) {
+    return new _DateTime(this.luxon.plus(isNumber(n) ? { [unit ?? "day"]: n } : n).toISO());
+  }
+  subtract(n, unit) {
+    return new _DateTime(this.luxon.minus(isNumber(n) ? { [unit ?? "day"]: n } : n).toISO());
+  }
+  diff(other, unit = "day", opts) {
+    return Math[opts?.rounding ?? "floor"](this.utc.diff(other.utc).as(unit));
+  }
+  startOf(unit = "day") {
+    return new _DateTime(this.luxon.startOf(unit).toISO());
+  }
+  endOf(unit = "day") {
+    return new _DateTime(this.luxon.endOf(unit).toISO());
+  }
+  isWeekend() {
+    return this.luxon.isWeekend;
+  }
+  withZone(zone) {
+    return new _DateTime(this.utc.setZone(zone).toISO());
+  }
+  toString() {
+    return this.value ?? "";
+  }
+  toJSON() {
+    return this.utc.toISO();
+  }
+  toFormat(format) {
+    return this.luxon.toFormat(format);
+  }
+  toLocale(locale = "nl-NL", format = "D") {
+    return this.luxon.setLocale(locale).toFormat(format);
+  }
+  toFull(locale) {
+    return this.toLocale(locale, "DDD");
+  }
+  toDate() {
+    return this.isValid ? this.utc.toJSDate() : void 0;
+  }
+};
+var isDateTime = (dt2) => isDefined(dt2) && dt2 instanceof DateTime;
+var dt = (dt2) => isString(dt2) || isNumber(dt2) || dt2 instanceof Date ? new DateTime(dt2) : new DateTime();
+
+// src/domain/values/EAN.ts
+var import_isEAN = __toESM(require("validator/lib/isEAN"));
+var EAN = class extends Value {
+  get isValid() {
+    return isEAN(this.value);
+  }
+};
+var isEAN = (ean) => {
+  return !isEmpty(ean) && (0, import_isEAN.default)(asString(ean));
+};
+
+// src/domain/values/Email.ts
+var import_isEmail = __toESM(require("validator/lib/isEmail"));
+var Email = class extends Value {
+  constructor(email2) {
+    super(asString(email2).trim().toLowerCase());
+  }
+  get isValid() {
+    return isEmail(this.value);
+  }
+  get name() {
+    return text(this.value.split("@")[0]).replace(".", " ").title.toString();
+  }
+};
+var email = (email2) => new Email(email2);
+var isEmail = (e) => !isEmpty(e) && (0, import_isEmail.default)(asString(e));
+
+// src/domain/values/IBAN.ts
+var import_isIBAN = __toESM(require("validator/lib/isIBAN"));
+var IBAN = class extends Value {
+  get isValid() {
+    return isIBAN(this.value);
+  }
+};
+var isIBAN = (iban) => {
+  return !isEmpty(iban) && (0, import_isIBAN.default)(asString(iban));
+};
+
+// src/domain/values/PostalCode.ts
+var import_isPostalCode = __toESM(require("validator/lib/isPostalCode"));
+var PostalCode = class extends Value {
+  constructor(postalCode2, country = Country.NL) {
+    super(text(postalCode2).replace(" ", "").toString());
+    this.country = country;
+  }
+  get isValid() {
+    return (0, import_isPostalCode.default)(this.value, this.country instanceof Country ? this.country.id : text(this.country).upper);
+  }
+};
+var postalCode = (postalCode2, country = Country.NL) => new PostalCode(postalCode2, country);
+
+// src/domain/values/Slug.ts
+var import_validator = require("validator");
+var Slug = class extends Value {
+  constructor(slug) {
+    super(text(slug).slug.toString());
+  }
+  get isValid() {
+    return isNotEmpty(this.value) && (0, import_validator.isSlug)(this.value);
+  }
+};
+var toSlug = (slug) => new Slug(slug);
+
+// src/domain/values/Url.ts
+var import_isURL = __toESM(require("validator/lib/isURL"));
+var Url = class extends Value {
+  constructor(value, options) {
+    super(asString(value));
+    this.options = options;
+  }
+  get isValid() {
+    return isUrl(this.value, this.options);
+  }
+};
+var url = (url2, options) => new Url(url2, options);
+var isUrl = (url2, options) => {
+  return !isEmpty(url2) && (0, import_isURL.default)(asString(url2), options);
+};
+
+// src/domain/structs/Address.ts
+var Address = class extends Struct {
+  street = this.state.street;
+  houseNumber = this.state.houseNumber;
+  extension = this.state.extension;
+  postalCode = postalCode(this.state.postalCode, this.state.country);
+  city = this.state.city;
+  country = Country.byId(this.state.country);
+  toString() {
+    return text(this.street).with(" ", this.houseNumber, this.extension).with(", ", text(this.postalCode).with(" ", this.city, this.country?.name)).toString();
+  }
+};
+__decorateClass([
+  required()
+], Address.prototype, "street", 2);
+__decorateClass([
+  required()
+], Address.prototype, "houseNumber", 2);
+__decorateClass([
+  valid()
+], Address.prototype, "postalCode", 2);
+__decorateClass([
+  required()
+], Address.prototype, "city", 2);
+__decorateClass([
+  required()
+], Address.prototype, "country", 2);
+var isAddress = (a) => {
+  return !isEmpty(a) && a instanceof Address;
+};
+
+// src/domain/structs/Dimension.ts
+var _Dimension = class _Dimension extends Struct {
+  value = this.state.value;
+  uom = UnitOfMeasurement.byId(this.state.uom, UnitOfMeasurement.MM);
+  static with = (value, uom = UnitOfMeasurement.MM) => new _Dimension({ value, uom });
+  /**
+   @deprecated use inMilliMeters getter instead
+   */
+  sizeInMM() {
+    return this.inMilliMeters;
+  }
+  get inMilliMeters() {
+    return this.value * this.uom.mmMultiplier;
+  }
+  gte(dim) {
+    return this.inMilliMeters >= dim.inMilliMeters;
+  }
+};
+__decorateClass([
+  required()
+], _Dimension.prototype, "value", 2);
+var Dimension = _Dimension;
+
+// src/domain/structs/Box.ts
+var _Box = class _Box extends Struct {
+  l = new Dimension(this.state.l);
+  w = new Dimension(this.state.w);
+  h = new Dimension(this.state.h);
+  sorted = [this.l, this.w, this.h].sort((n1, n2) => n1.inMilliMeters - n2.inMilliMeters);
+  lowestDim = this.sorted[0];
+  medianDim = this.sorted[1];
+  maxDim = this.sorted[2];
+  get isValid() {
+    return super.isValid && this.l.isValid && this.w.isValid && this.h.isValid;
+  }
+  static with = (l, w, h) => new _Box({ l, w, h });
+  stack(qty) {
+    return _Box.with(this.maxDim, this.medianDim, Dimension.with(this.lowestDim.value * qty, this.lowestDim.uom));
+  }
+  fits(contents, qty = 1) {
+    const stackedContent = contents.stack(qty);
+    return this.lowestDim.gte(stackedContent.lowestDim) && this.medianDim.gte(stackedContent.medianDim) && this.maxDim.gte(stackedContent.maxDim);
+  }
+};
+__decorateClass([
+  required()
+], _Box.prototype, "l", 2);
+__decorateClass([
+  required()
+], _Box.prototype, "w", 2);
+__decorateClass([
+  required()
+], _Box.prototype, "h", 2);
+var Box = _Box;
+
+// src/domain/structs/Money.ts
+var Money = class extends Struct {
+  currency = Currency.byId(this.state.currency);
+  value = this.state.value;
+  add(amount) {
+    return money(this.currency, this.value + amount);
+  }
+  subtract(amount) {
+    return money(this.currency, this.value - amount);
+  }
+  times(n) {
+    return money(this.currency, this.value * n);
+  }
+  toString() {
+    return text(this.currency?.code).with(" ", this.value?.toFixed(this.currency?.digits ?? 2)).toString();
+  }
+};
+__decorateClass([
+  required()
+], Money.prototype, "currency", 2);
+__decorateClass([
+  required()
+], Money.prototype, "value", 2);
+var money = (currency, value) => new Money({ currency: currency.id, value });
+var isMoney = (m) => {
+  return !isEmpty(m) && m instanceof Money;
+};
+
+// src/domain/structs/Name.ts
+var Name = class extends Struct {
+  first = this.state.first;
+  middle = this.state.middle;
+  last = this.state.last;
+  toString() {
+    return text(this.first, "").add(this.middle, " ").add(this.last, " ").toString();
+  }
+};
+__decorateClass([
+  required()
+], Name.prototype, "first", 2);
+__decorateClass([
+  required()
+], Name.prototype, "last", 2);
+var name = (n) => new Name(n);
+
+// src/domain/structs/Weight.ts
+var Weight = class extends Struct {
+  value = this.state.value;
+  uow = UnitOfWeight.byId(this.state.uow, UnitOfWeight.G);
+  /**
+    @deprecated use inGrams getter instead
+   */
+  sizeInG() {
+    return this.inGrams;
+  }
+  get inGrams() {
+    return this.value * this.uow.gMultiplier;
+  }
+  gte(w) {
+    return this.inGrams >= w.inGrams;
+  }
+  lte(w) {
+    return this.inGrams <= w.inGrams;
+  }
+  between(lower, upper = weight(Number.MAX_VALUE, this.uow)) {
+    return this.gte(lower) && this.lte(upper);
+  }
+  sum(add) {
+    return weight((this.inGrams + add.inGrams) / this.uow.gMultiplier, this.uow);
+  }
+};
+__decorateClass([
+  required()
+], Weight.prototype, "value", 2);
+var weight = (value, uow) => new Weight({ value, uow });
+
+// src/domain/enums/Currency.ts
+var Currency = class _Currency extends Enum {
+  constructor(id, name2, digits, code) {
+    super(name2, id, code);
+    this.digits = digits;
+  }
+  static EUR = new _Currency("EUR", "Euro", 2, "\u20AC");
+  static USD = new _Currency("USD", "US Dollar", 2, "$");
+  static AED = new _Currency("AED", "United Arab Emirates Dirham", 2, "AED");
+  static AFN = new _Currency("AFN", "Afghan Afghani", 0, "Af");
+  static ALL = new _Currency("ALL", "Albanian Lek", 0, "ALL");
+  static AMD = new _Currency("AMD", "Armenian Dram", 0, "AMD");
+  static ARS = new _Currency("ARS", "Argentine Peso", 2, "AR$");
+  static AUD = new _Currency("AUD", "Australian Dollar", 2, "AU$");
+  static AZN = new _Currency("AZN", "Azerbaijani Manat", 2, "man.");
+  static BAM = new _Currency("BAM", "Bosnia-Herzegovina Convertible Mark", 2, "KM");
+  static BDT = new _Currency("BDT", "Bangladeshi Taka", 2, "Tk");
+  static BGN = new _Currency("BGN", "Bulgarian Lev", 2, "BGN");
+  static BHD = new _Currency("BHD", "Bahraini Dinar", 3, "BD");
+  static BIF = new _Currency("BIF", "Burundian Franc", 0, "FBu");
+  static BND = new _Currency("BND", "Brunei Dollar", 2, "BN$");
+  static BOB = new _Currency("BOB", "Bolivian Boliviano", 2, "Bs");
+  static BRL = new _Currency("BRL", "Brazilian Real", 2, "R$");
+  static BWP = new _Currency("BWP", "Botswanan Pula", 2, "BWP");
+  static BYN = new _Currency("BYN", "Belarusian Ruble", 2, "Br");
+  static BZD = new _Currency("BZD", "Belize Dollar", 2, "BZ$");
+  static CAD = new _Currency("CAD", "Canadian Dollar", 2, "CA$");
+  static CDF = new _Currency("CDF", "Congolese Franc", 2, "CDF");
+  static CHF = new _Currency("CHF", "Swiss Franc", 2, "CHF");
+  static CLP = new _Currency("CLP", "Chilean Peso", 0, "CL$");
+  static CNY = new _Currency("CNY", "Chinese Yuan", 2, "CN\xA5");
+  static COP = new _Currency("COP", "Colombian Peso", 0, "CO$");
+  static CRC = new _Currency("CRC", "Costa Rican Col\xF3n", 0, "\u20A1");
+  static CVE = new _Currency("CVE", "Cape Verdean Escudo", 2, "CV$");
+  static CZK = new _Currency("CZK", "Czech Republic Koruna", 2, "K\u010D");
+  static DJF = new _Currency("DJF", "Djiboutian Franc", 0, "Fdj");
+  static DKK = new _Currency("DKK", "Danish Krone", 2, "Dkr");
+  static DOP = new _Currency("DOP", "Dominican Peso", 2, "RD$");
+  static DZD = new _Currency("DZD", "Algerian Dinar", 2, "DA");
+  static EEK = new _Currency("EEK", "Estonian Kroon", 2, "Ekr");
+  static EGP = new _Currency("EGP", "Egyptian Pound", 2, "EGP");
+  static ERN = new _Currency("ERN", "Eritrean Nakfa", 2, "Nfk");
+  static ETB = new _Currency("ETB", "Ethiopian Birr", 2, "Br");
+  static GBP = new _Currency("GBP", "British Pound Sterling", 2, "\xA3");
+  static GEL = new _Currency("GEL", "Georgian Lari", 2, "GEL");
+  static GHS = new _Currency("GHS", "Ghanaian Cedi", 2, "GH\u20B5");
+  static GNF = new _Currency("GNF", "Guinean Franc", 0, "FG");
+  static GTQ = new _Currency("GTQ", "Guatemalan Quetzal", 2, "GTQ");
+  static HKD = new _Currency("HKD", "Hong Kong Dollar", 2, "HK$");
+  static HNL = new _Currency("HNL", "Honduran Lempira", 2, "HNL");
+  static HRK = new _Currency("HRK", "Croatian Kuna", 2, "kn");
+  static HUF = new _Currency("HUF", "Hungarian Forint", 0, "Ft");
+  static IDR = new _Currency("IDR", "Indonesian Rupiah", 0, "Rp");
+  static ILS = new _Currency("ILS", "Israeli New Sheqel", 2, "\u20AA");
+  static INR = new _Currency("INR", "Indian Rupee", 2, "Rs");
+  static IQD = new _Currency("IQD", "Iraqi Dinar", 0, "IQD");
+  static IRR = new _Currency("IRR", "Iranian Rial", 0, "IRR");
+  static ISK = new _Currency("ISK", "Icelandic Kr\xF3na", 0, "Ikr");
+  static JMD = new _Currency("JMD", "Jamaican Dollar", 2, "J$");
+  static JOD = new _Currency("JOD", "Jordanian Dinar", 3, "JD");
+  static JPY = new _Currency("JPY", "Japanese Yen", 0, "\xA5");
+  static KES = new _Currency("KES", "Kenyan Shilling", 2, "Ksh");
+  static KHR = new _Currency("KHR", "Cambodian Riel", 2, "KHR");
+  static KMF = new _Currency("KMF", "Comorian Franc", 0, "CF");
+  static KRW = new _Currency("KRW", "South Korean Won", 0, "\u20A9");
+  static KWD = new _Currency("KWD", "Kuwaiti Dinar", 3, "KD");
+  static KZT = new _Currency("KZT", "Kazakhstani Tenge", 2, "KZT");
+  static LBP = new _Currency("LBP", "Lebanese Pound", 0, "L.L.");
+  static LKR = new _Currency("LKR", "Sri Lankan Rupee", 2, "SLRs");
+  static LTL = new _Currency("LTL", "Lithuanian Litas", 2, "Lt");
+  static LVL = new _Currency("LVL", "Latvian Lats", 2, "Ls");
+  static LYD = new _Currency("LYD", "Libyan Dinar", 3, "LD");
+  static MAD = new _Currency("MAD", "Moroccan Dirham", 2, "MAD");
+  static MDL = new _Currency("MDL", "Moldovan Leu", 2, "MDL");
+  static MGA = new _Currency("MGA", "Malagasy Ariary", 0, "MGA");
+  static MKD = new _Currency("MKD", "Macedonian Denar", 2, "MKD");
+  static MMK = new _Currency("MMK", "Myanma Kyat", 0, "MMK");
+  static MOP = new _Currency("MOP", "Macanese Pataca", 2, "MOP$");
+  static MUR = new _Currency("MUR", "Mauritian Rupee", 0, "MURs");
+  static MXN = new _Currency("MXN", "Mexican Peso", 2, "MX$");
+  static MYR = new _Currency("MYR", "Malaysian Ringgit", 2, "RM");
+  static MZN = new _Currency("MZN", "Mozambican Metical", 2, "MTn");
+  static NAD = new _Currency("NAD", "Namibian Dollar", 2, "N$");
+  static NGN = new _Currency("NGN", "Nigerian Naira", 2, "\u20A6");
+  static NIO = new _Currency("NIO", "Nicaraguan C\xF3rdoba", 2, "C$");
+  static NOK = new _Currency("NOK", "Norwegian Krone", 2, "Nkr");
+  static NPR = new _Currency("NPR", "Nepalese Rupee", 2, "NPRs");
+  static NZD = new _Currency("NZD", "New Zealand Dollar", 2, "NZ$");
+  static OMR = new _Currency("OMR", "Omani Rial", 3, "OMR");
+  static PAB = new _Currency("PAB", "Panamanian Balboa", 2, "B/.");
+  static PEN = new _Currency("PEN", "Peruvian Nuevo Sol", 2, "S/.");
+  static PHP = new _Currency("PHP", "Philippine Peso", 2, "\u20B1");
+  static PKR = new _Currency("PKR", "Pakistani Rupee", 0, "PKRs");
+  static PLN = new _Currency("PLN", "Polish Zloty", 2, "z\u0142");
+  static PYG = new _Currency("PYG", "Paraguayan Guarani", 0, "\u20B2");
+  static QAR = new _Currency("QAR", "Qatari Rial", 2, "QR");
+  static RON = new _Currency("RON", "Romanian Leu", 2, "RON");
+  static RSD = new _Currency("RSD", "Serbian Dinar", 0, "din.");
+  static RUB = new _Currency("RUB", "Russian Ruble", 2, "RUB");
+  static RWF = new _Currency("RWF", "Rwandan Franc", 0, "RWF");
+  static SAR = new _Currency("SAR", "Saudi Riyal", 2, "SR");
+  static SDG = new _Currency("SDG", "Sudanese Pound", 2, "SDG");
+  static SEK = new _Currency("SEK", "Swedish Krona", 2, "Skr");
+  static SGD = new _Currency("SGD", "Singapore Dollar", 2, "S$");
+  static SOS = new _Currency("SOS", "Somali Shilling", 0, "Ssh");
+  static SYP = new _Currency("SYP", "Syrian Pound", 0, "SY\xA3");
+  static THB = new _Currency("THB", "Thai Baht", 2, "\u0E3F");
+  static TND = new _Currency("TND", "Tunisian Dinar", 3, "DT");
+  static TOP = new _Currency("TOP", "Tongan Pa\u02BBanga", 2, "T$");
+  static TRY = new _Currency("TRY", "Turkish Lira", 2, "TL");
+  static TTD = new _Currency("TTD", "Trinidad and Tobago Dollar", 2, "TT$");
+  static TWD = new _Currency("TWD", "New Taiwan Dollar", 2, "NT$");
+  static TZS = new _Currency("TZS", "Tanzanian Shilling", 0, "TSh");
+  static UAH = new _Currency("UAH", "Ukrainian Hryvnia", 2, "\u20B4");
+  static UGX = new _Currency("UGX", "Ugandan Shilling", 0, "USh");
+  static UYU = new _Currency("UYU", "Uruguayan Peso", 2, "$U");
+  static UZS = new _Currency("UZS", "Uzbekistan Som", 0, "UZS");
+  static VEF = new _Currency("VEF", "Venezuelan Bol\xEDvar", 2, "Bs.F.");
+  static VND = new _Currency("VND", "Vietnamese Dong", 0, "\u20AB");
+  static XAF = new _Currency("XAF", "CFA Franc BEAC", 0, "FCFA");
+  static XOF = new _Currency("XOF", "CFA Franc BCEAO", 0, "CFA");
+  static YER = new _Currency("YER", "Yemeni Rial", 0, "YR");
+  static ZAR = new _Currency("ZAR", "South African Rand", 2, "R");
+  static ZMK = new _Currency("ZMK", "Zambian Kwacha", 0, "ZK");
+  static ZWL = new _Currency("ZWL", "Zimbabwean Dollar", 0, "ZWL$");
+  amount = (amount = 0) => money(this, amount);
+  get zero() {
+    return this.amount();
+  }
+};
+
+// src/domain/enums/Environment.ts
+var Environment = class _Environment extends Enum {
+  static Dev = new _Environment("Development", "dev");
+  static Tst = new _Environment("Test", "tst");
+  static Acc = new _Environment("Acceptance", "acc");
+  static Prd = new _Environment("Production", "prd");
+};
+
+// src/domain/enums/Locale.ts
+var Locale = class _Locale extends Enum {
+  constructor(id, name2, country = text(id).lower.last(2).toString(), lower = text(id).lower.trim.toString()) {
+    super(name2, id);
+    this.country = country;
+    this.lower = lower;
+  }
+  static AF = new _Locale("af", "Afrikaans");
+  static AF_NA = new _Locale("af_NA", "Afrikaans (Namibia)");
+  static AF_ZA = new _Locale("af_ZA", "Afrikaans (South Africa)");
+  static AK = new _Locale("ak", "Akan");
+  static AK_GH = new _Locale("ak_GH", "Akan (Ghana)");
+  static SQ = new _Locale("sq", "Albanian");
+  static SQ_AL = new _Locale("sq_AL", "Albanian (Albania)");
+  static SQ_XK = new _Locale("sq_XK", "Albanian (Kosovo)");
+  static SQ_MK = new _Locale("sq_MK", "Albanian (Macedonia)");
+  static AM = new _Locale("am", "Amharic");
+  static AM_ET = new _Locale("am_ET", "Amharic (Ethiopia)");
+  static AR = new _Locale("ar", "Arabic");
+  static AR_DZ = new _Locale("ar_DZ", "Arabic (Algeria)");
+  static AR_BH = new _Locale("ar_BH", "Arabic (Bahrain)");
+  static AR_TD = new _Locale("ar_TD", "Arabic (Chad)");
+  static AR_KM = new _Locale("ar_KM", "Arabic (Comoros)");
+  static AR_DJ = new _Locale("ar_DJ", "Arabic (Djibouti)");
+  static AR_EG = new _Locale("ar_EG", "Arabic (Egypt)");
+  static AR_ER = new _Locale("ar_ER", "Arabic (Eritrea)");
+  static AR_IQ = new _Locale("ar_IQ", "Arabic (Iraq)");
+  static AR_IL = new _Locale("ar_IL", "Arabic (Israel)");
+  static AR_JO = new _Locale("ar_JO", "Arabic (Jordan)");
+  static AR_KW = new _Locale("ar_KW", "Arabic (Kuwait)");
+  static AR_LB = new _Locale("ar_LB", "Arabic (Lebanon)");
+  static AR_LY = new _Locale("ar_LY", "Arabic (Libya)");
+  static AR_MR = new _Locale("ar_MR", "Arabic (Mauritania)");
+  static AR_MA = new _Locale("ar_MA", "Arabic (Morocco)");
+  static AR_OM = new _Locale("ar_OM", "Arabic (Oman)");
+  static AR_PS = new _Locale("ar_PS", "Arabic (Palestinian Territories)");
+  static AR_QA = new _Locale("ar_QA", "Arabic (Qatar)");
+  static AR_SA = new _Locale("ar_SA", "Arabic (Saudi Arabia)");
+  static AR_SO = new _Locale("ar_SO", "Arabic (Somalia)");
+  static AR_SS = new _Locale("ar_SS", "Arabic (South Sudan)");
+  static AR_SD = new _Locale("ar_SD", "Arabic (Sudan)");
+  static AR_SY = new _Locale("ar_SY", "Arabic (Syria)");
+  static AR_TN = new _Locale("ar_TN", "Arabic (Tunisia)");
+  static AR_AE = new _Locale("ar_AE", "Arabic (United Arab Emirates)");
+  static AR_EH = new _Locale("ar_EH", "Arabic (Western Sahara)");
+  static AR_YE = new _Locale("ar_YE", "Arabic (Yemen)");
+  static HY = new _Locale("hy", "Armenian");
+  static HY_AM = new _Locale("hy_AM", "Armenian (Armenia)");
+  static AS = new _Locale("as", "Assamese");
+  static AS_IN = new _Locale("as_IN", "Assamese (India)");
+  static AZ = new _Locale("az", "Azerbaijani");
+  static AZ_AZ = new _Locale("az_AZ", "Azerbaijani (Azerbaijan)");
+  static AZ_CYRL_AZ = new _Locale("az_Cyrl_AZ", "Azerbaijani (Cyrillic, Azerbaijan)");
+  static AZ_CYRL = new _Locale("az_Cyrl", "Azerbaijani (Cyrillic)", "az");
+  static AZ_LATN_AZ = new _Locale("az_Latn_AZ", "Azerbaijani (Latin, Azerbaijan)");
+  static AZ_LATN = new _Locale("az_Latn", "Azerbaijani (Latin)", "az");
+  static BM = new _Locale("bm", "Bambara");
+  static BM_LATN_ML = new _Locale("bm_Latn_ML", "Bambara (Latin, Mali)");
+  static BM_LATN = new _Locale("bm_Latn", "Bambara (Latin)", "bm");
+  static EU = new _Locale("eu", "Basque");
+  static EU_ES = new _Locale("eu_ES", "Basque (Spain)");
+  static BE = new _Locale("be", "Belarusian");
+  static BE_BY = new _Locale("be_BY", "Belarusian (Belarus)");
+  static BN = new _Locale("bn", "Bengali");
+  static BN_BD = new _Locale("bn_BD", "Bengali (Bangladesh)");
+  static BN_IN = new _Locale("bn_IN", "Bengali (India)");
+  static BS = new _Locale("bs", "Bosnian");
+  static BS_BA = new _Locale("bs_BA", "Bosnian (Bosnia & Herzegovina)");
+  static BS_CYRL_BA = new _Locale("bs_Cyrl_BA", "Bosnian (Cyrillic, Bosnia & Herzegovina)");
+  static BS_CYRL = new _Locale("bs_Cyrl", "Bosnian (Cyrillic)", "bs");
+  static BS_LATN_BA = new _Locale("bs_Latn_BA", "Bosnian (Latin, Bosnia & Herzegovina)");
+  static BS_LATN = new _Locale("bs_Latn", "Bosnian (Latin)", "bs");
+  static BR = new _Locale("br", "Breton");
+  static BR_FR = new _Locale("br_FR", "Breton (France)");
+  static BG = new _Locale("bg", "Bulgarian");
+  static BG_BG = new _Locale("bg_BG", "Bulgarian (Bulgaria)");
+  static MY = new _Locale("my", "Burmese");
+  static MY_MM = new _Locale("my_MM", "Burmese (Myanmar (Burma))");
+  static CA = new _Locale("ca", "Catalan");
+  static CA_AD = new _Locale("ca_AD", "Catalan (Andorra)");
+  static CA_FR = new _Locale("ca_FR", "Catalan (France)");
+  static CA_IT = new _Locale("ca_IT", "Catalan (Italy)");
+  static CA_ES = new _Locale("ca_ES", "Catalan (Spain)");
+  static ZH = new _Locale("zh", "Chinese");
+  static ZH_CN = new _Locale("zh_CN", "Chinese (China)");
+  static ZH_HK = new _Locale("zh_HK", "Chinese (Hong Kong SAR China)");
+  static ZH_MO = new _Locale("zh_MO", "Chinese (Macau SAR China)");
+  static ZH_HANS_CN = new _Locale("zh_Hans_CN", "Chinese (Simplified, China)");
+  static ZH_HANS_HK = new _Locale("zh_Hans_HK", "Chinese (Simplified, Hong Kong SAR China)");
+  static ZH_HANS_MO = new _Locale("zh_Hans_MO", "Chinese (Simplified, Macau SAR China)");
+  static ZH_HANS_SG = new _Locale("zh_Hans_SG", "Chinese (Simplified, Singapore)");
+  static ZH_HANS = new _Locale("zh_Hans", "Chinese (Simplified)");
+  static ZH_SG = new _Locale("zh_SG", "Chinese (Singapore)");
+  static ZH_TW = new _Locale("zh_TW", "Chinese (Taiwan)");
+  static ZH_HANT_HK = new _Locale("zh_Hant_HK", "Chinese (Traditional, Hong Kong SAR China)");
+  static ZH_HANT_MO = new _Locale("zh_Hant_MO", "Chinese (Traditional, Macau SAR China)");
+  static ZH_HANT_TW = new _Locale("zh_Hant_TW", "Chinese (Traditional, Taiwan)");
+  static ZH_HANT = new _Locale("zh_Hant", "Chinese (Traditional)");
+  static KW = new _Locale("kw", "Cornish");
+  static KW_GB = new _Locale("kw_GB", "Cornish (United Kingdom)");
+  static HR = new _Locale("hr", "Croatian");
+  static HR_BA = new _Locale("hr_BA", "Croatian (Bosnia & Herzegovina)");
+  static HR_HR = new _Locale("hr_HR", "Croatian (Croatia)");
+  static CS = new _Locale("cs", "Czech");
+  static CS_CZ = new _Locale("cs_CZ", "Czech (Czech Republic)");
+  static DA = new _Locale("da", "Danish");
+  static DA_DK = new _Locale("da_DK", "Danish (Denmark)");
+  static DA_GL = new _Locale("da_GL", "Danish (Greenland)");
+  static NL = new _Locale("nl", "Dutch");
+  static NL_AW = new _Locale("nl_AW", "Dutch (Aruba)");
+  static NL_BE = new _Locale("nl_BE", "Dutch (Belgium)");
+  static NL_BQ = new _Locale("nl_BQ", "Dutch (Caribbean Netherlands)");
+  static NL_CW = new _Locale("nl_CW", "Dutch (Cura\xE7ao)");
+  static NL_NL = new _Locale("nl_NL", "Dutch (Netherlands)");
+  static NL_SX = new _Locale("nl_SX", "Dutch (Sint Maarten)");
+  static NL_SR = new _Locale("nl_SR", "Dutch (Suriname)");
+  static DZ = new _Locale("dz", "Dzongkha");
+  static DZ_BT = new _Locale("dz_BT", "Dzongkha (Bhutan)");
+  static EN = new _Locale("en", "English", "gb");
+  static EN_AS = new _Locale("en_AS", "English (American Samoa)");
+  static EN_AI = new _Locale("en_AI", "English (Anguilla)");
+  static EN_AG = new _Locale("en_AG", "English (Antigua & Barbuda)");
+  static EN_AU = new _Locale("en_AU", "English (Australia)");
+  static EN_BS = new _Locale("en_BS", "English (Bahamas)");
+  static EN_BB = new _Locale("en_BB", "English (Barbados)");
+  static EN_BE = new _Locale("en_BE", "English (Belgium)");
+  static EN_BZ = new _Locale("en_BZ", "English (Belize)");
+  static EN_BM = new _Locale("en_BM", "English (Bermuda)");
+  static EN_BW = new _Locale("en_BW", "English (Botswana)");
+  static EN_IO = new _Locale("en_IO", "English (British Indian Ocean Territory)");
+  static EN_VG = new _Locale("en_VG", "English (British Virgin Islands)");
+  static EN_CM = new _Locale("en_CM", "English (Cameroon)");
+  static EN_CA = new _Locale("en_CA", "English (Canada)");
+  static EN_KY = new _Locale("en_KY", "English (Cayman Islands)");
+  static EN_CX = new _Locale("en_CX", "English (Christmas Island)");
+  static EN_CC = new _Locale("en_CC", "English (Cocos (Keeling) Islands)");
+  static EN_CK = new _Locale("en_CK", "English (Cook Islands)");
+  static EN_DG = new _Locale("en_DG", "English (Diego Garcia)");
+  static EN_DM = new _Locale("en_DM", "English (Dominica)");
+  static EN_ER = new _Locale("en_ER", "English (Eritrea)");
+  static EN_FK = new _Locale("en_FK", "English (Falkland Islands)");
+  static EN_FJ = new _Locale("en_FJ", "English (Fiji)");
+  static EN_GM = new _Locale("en_GM", "English (Gambia)");
+  static EN_GH = new _Locale("en_GH", "English (Ghana)");
+  static EN_GI = new _Locale("en_GI", "English (Gibraltar)");
+  static EN_GD = new _Locale("en_GD", "English (Grenada)");
+  static EN_GU = new _Locale("en_GU", "English (Guam)");
+  static EN_GG = new _Locale("en_GG", "English (Guernsey)");
+  static EN_GY = new _Locale("en_GY", "English (Guyana)");
+  static EN_HK = new _Locale("en_HK", "English (Hong Kong SAR China)");
+  static EN_IN = new _Locale("en_IN", "English (India)");
+  static EN_IE = new _Locale("en_IE", "English (Ireland)");
+  static EN_IM = new _Locale("en_IM", "English (Isle of Man)");
+  static EN_JM = new _Locale("en_JM", "English (Jamaica)");
+  static EN_JE = new _Locale("en_JE", "English (Jersey)");
+  static EN_KE = new _Locale("en_KE", "English (Kenya)");
+  static EN_KI = new _Locale("en_KI", "English (Kiribati)");
+  static EN_LS = new _Locale("en_LS", "English (Lesotho)");
+  static EN_LR = new _Locale("en_LR", "English (Liberia)");
+  static EN_MO = new _Locale("en_MO", "English (Macau SAR China)");
+  static EN_MG = new _Locale("en_MG", "English (Madagascar)");
+  static EN_MW = new _Locale("en_MW", "English (Malawi)");
+  static EN_MY = new _Locale("en_MY", "English (Malaysia)");
+  static EN_MT = new _Locale("en_MT", "English (Malta)");
+  static EN_MH = new _Locale("en_MH", "English (Marshall Islands)");
+  static EN_MU = new _Locale("en_MU", "English (Mauritius)");
+  static EN_FM = new _Locale("en_FM", "English (Micronesia)");
+  static EN_MS = new _Locale("en_MS", "English (Montserrat)");
+  static EN_NA = new _Locale("en_NA", "English (Namibia)");
+  static EN_NR = new _Locale("en_NR", "English (Nauru)");
+  static EN_NZ = new _Locale("en_NZ", "English (New Zealand)");
+  static EN_NG = new _Locale("en_NG", "English (Nigeria)");
+  static EN_NU = new _Locale("en_NU", "English (Niue)");
+  static EN_NF = new _Locale("en_NF", "English (Norfolk Island)");
+  static EN_MP = new _Locale("en_MP", "English (Northern Mariana Islands)");
+  static EN_PK = new _Locale("en_PK", "English (Pakistan)");
+  static EN_PW = new _Locale("en_PW", "English (Palau)");
+  static EN_PG = new _Locale("en_PG", "English (Papua New Guinea)");
+  static EN_PH = new _Locale("en_PH", "English (Philippines)");
+  static EN_PN = new _Locale("en_PN", "English (Pitcairn Islands)");
+  static EN_PR = new _Locale("en_PR", "English (Puerto Rico)");
+  static EN_RW = new _Locale("en_RW", "English (Rwanda)");
+  static EN_WS = new _Locale("en_WS", "English (Samoa)");
+  static EN_SC = new _Locale("en_SC", "English (Seychelles)");
+  static EN_SL = new _Locale("en_SL", "English (Sierra Leone)");
+  static EN_SG = new _Locale("en_SG", "English (Singapore)");
+  static EN_SX = new _Locale("en_SX", "English (Sint Maarten)");
+  static EN_SB = new _Locale("en_SB", "English (Solomon Islands)");
+  static EN_ZA = new _Locale("en_ZA", "English (South Africa)");
+  static EN_SS = new _Locale("en_SS", "English (South Sudan)");
+  static EN_SH = new _Locale("en_SH", "English (St. Helena)");
+  static EN_KN = new _Locale("en_KN", "English (St. Kitts & Nevis)");
+  static EN_LC = new _Locale("en_LC", "English (St. Lucia)");
+  static EN_VC = new _Locale("en_VC", "English (St. Vincent & Grenadines)");
+  static EN_SD = new _Locale("en_SD", "English (Sudan)");
+  static EN_SZ = new _Locale("en_SZ", "English (Swaziland)");
+  static EN_TZ = new _Locale("en_TZ", "English (Tanzania)");
+  static EN_TK = new _Locale("en_TK", "English (Tokelau)");
+  static EN_TO = new _Locale("en_TO", "English (Tonga)");
+  static EN_TT = new _Locale("en_TT", "English (Trinidad & Tobago)");
+  static EN_TC = new _Locale("en_TC", "English (Turks & Caicos Islands)");
+  static EN_TV = new _Locale("en_TV", "English (Tuvalu)");
+  static EN_UM = new _Locale("en_UM", "English (U.S. Outlying Islands)");
+  static EN_VI = new _Locale("en_VI", "English (U.S. Virgin Islands)");
+  static EN_UG = new _Locale("en_UG", "English (Uganda)");
+  static EN_GB = new _Locale("en_GB", "English (United Kingdom)");
+  static EN_US = new _Locale("en_US", "English (United States)");
+  static EN_VU = new _Locale("en_VU", "English (Vanuatu)");
+  static EN_ZM = new _Locale("en_ZM", "English (Zambia)");
+  static EN_ZW = new _Locale("en_ZW", "English (Zimbabwe)");
+  static EO = new _Locale("eo", "Esperanto");
+  static ET = new _Locale("et", "Estonian");
+  static ET_EE = new _Locale("et_EE", "Estonian (Estonia)");
+  static EE = new _Locale("ee", "Ewe");
+  static EE_GH = new _Locale("ee_GH", "Ewe (Ghana)");
+  static EE_TG = new _Locale("ee_TG", "Ewe (Togo)");
+  static FO = new _Locale("fo", "Faroese");
+  static FO_FO = new _Locale("fo_FO", "Faroese (Faroe Islands)");
+  static FI = new _Locale("fi", "Finnish");
+  static FI_FI = new _Locale("fi_FI", "Finnish (Finland)");
+  static FR = new _Locale("fr", "French");
+  static FR_DZ = new _Locale("fr_DZ", "French (Algeria)");
+  static FR_BE = new _Locale("fr_BE", "French (Belgium)");
+  static FR_BJ = new _Locale("fr_BJ", "French (Benin)");
+  static FR_BF = new _Locale("fr_BF", "French (Burkina Faso)");
+  static FR_BI = new _Locale("fr_BI", "French (Burundi)");
+  static FR_CM = new _Locale("fr_CM", "French (Cameroon)");
+  static FR_CA = new _Locale("fr_CA", "French (Canada)");
+  static FR_CF = new _Locale("fr_CF", "French (Central African Republic)");
+  static FR_TD = new _Locale("fr_TD", "French (Chad)");
+  static FR_KM = new _Locale("fr_KM", "French (Comoros)");
+  static FR_CG = new _Locale("fr_CG", "French (Congo - Brazzaville)");
+  static FR_CD = new _Locale("fr_CD", "French (Congo - Kinshasa)");
+  static FR_CI = new _Locale("fr_CI", "French (C\xF4te d\u2019Ivoire)");
+  static FR_DJ = new _Locale("fr_DJ", "French (Djibouti)");
+  static FR_GQ = new _Locale("fr_GQ", "French (Equatorial Guinea)");
+  static FR_FR = new _Locale("fr_FR", "French (France)");
+  static FR_GF = new _Locale("fr_GF", "French (French Guiana)");
+  static FR_PF = new _Locale("fr_PF", "French (French Polynesia)");
+  static FR_GA = new _Locale("fr_GA", "French (Gabon)");
+  static FR_GP = new _Locale("fr_GP", "French (Guadeloupe)");
+  static FR_GN = new _Locale("fr_GN", "French (Guinea)");
+  static FR_HT = new _Locale("fr_HT", "French (Haiti)");
+  static FR_LU = new _Locale("fr_LU", "French (Luxembourg)");
+  static FR_MG = new _Locale("fr_MG", "French (Madagascar)");
+  static FR_ML = new _Locale("fr_ML", "French (Mali)");
+  static FR_MQ = new _Locale("fr_MQ", "French (Martinique)");
+  static FR_MR = new _Locale("fr_MR", "French (Mauritania)");
+  static FR_MU = new _Locale("fr_MU", "French (Mauritius)");
+  static FR_YT = new _Locale("fr_YT", "French (Mayotte)");
+  static FR_MC = new _Locale("fr_MC", "French (Monaco)");
+  static FR_MA = new _Locale("fr_MA", "French (Morocco)");
+  static FR_NC = new _Locale("fr_NC", "French (New Caledonia)");
+  static FR_NE = new _Locale("fr_NE", "French (Niger)");
+  static FR_RE = new _Locale("fr_RE", "French (R\xE9union)");
+  static FR_RW = new _Locale("fr_RW", "French (Rwanda)");
+  static FR_SN = new _Locale("fr_SN", "French (Senegal)");
+  static FR_SC = new _Locale("fr_SC", "French (Seychelles)");
+  static FR_BL = new _Locale("fr_BL", "French (St. Barth\xE9lemy)");
+  static FR_MF = new _Locale("fr_MF", "French (St. Martin)");
+  static FR_PM = new _Locale("fr_PM", "French (St. Pierre & Miquelon)");
+  static FR_CH = new _Locale("fr_CH", "French (Switzerland)");
+  static FR_SY = new _Locale("fr_SY", "French (Syria)");
+  static FR_TG = new _Locale("fr_TG", "French (Togo)");
+  static FR_TN = new _Locale("fr_TN", "French (Tunisia)");
+  static FR_VU = new _Locale("fr_VU", "French (Vanuatu)");
+  static FR_WF = new _Locale("fr_WF", "French (Wallis & Futuna)");
+  static FF = new _Locale("ff", "Fulah");
+  static FF_CM = new _Locale("ff_CM", "Fulah (Cameroon)");
+  static FF_GN = new _Locale("ff_GN", "Fulah (Guinea)");
+  static FF_MR = new _Locale("ff_MR", "Fulah (Mauritania)");
+  static FF_SN = new _Locale("ff_SN", "Fulah (Senegal)");
+  static GL = new _Locale("gl", "Galician");
+  static GL_ES = new _Locale("gl_ES", "Galician (Spain)");
+  static LG = new _Locale("lg", "Ganda");
+  static LG_UG = new _Locale("lg_UG", "Ganda (Uganda)");
+  static KA = new _Locale("ka", "Georgian");
+  static KA_GE = new _Locale("ka_GE", "Georgian (Georgia)");
+  static DE = new _Locale("de", "German");
+  static DE_AT = new _Locale("de_AT", "German (Austria)");
+  static DE_BE = new _Locale("de_BE", "German (Belgium)");
+  static DE_DE = new _Locale("de_DE", "German (Germany)");
+  static DE_LI = new _Locale("de_LI", "German (Liechtenstein)");
+  static DE_LU = new _Locale("de_LU", "German (Luxembourg)");
+  static DE_CH = new _Locale("de_CH", "German (Switzerland)");
+  static EL = new _Locale("el", "Greek");
+  static EL_CY = new _Locale("el_CY", "Greek (Cyprus)");
+  static EL_GR = new _Locale("el_GR", "Greek (Greece)");
+  static GU = new _Locale("gu", "Gujarati");
+  static GU_IN = new _Locale("gu_IN", "Gujarati (India)");
+  static HA = new _Locale("ha", "Hausa");
+  static HA_GH = new _Locale("ha_GH", "Hausa (Ghana)");
+  static HA_LATN_GH = new _Locale("ha_Latn_GH", "Hausa (Latin, Ghana)");
+  static HA_LATN_NE = new _Locale("ha_Latn_NE", "Hausa (Latin, Niger)");
+  static HA_LATN_NG = new _Locale("ha_Latn_NG", "Hausa (Latin, Nigeria)");
+  static HA_LATN = new _Locale("ha_Latn", "Hausa (Latin)");
+  static HA_NE = new _Locale("ha_NE", "Hausa (Niger)");
+  static HA_NG = new _Locale("ha_NG", "Hausa (Nigeria)");
+  static HE = new _Locale("he", "Hebrew");
+  static HE_IL = new _Locale("he_IL", "Hebrew (Israel)");
+  static HI = new _Locale("hi", "Hindi");
+  static HI_IN = new _Locale("hi_IN", "Hindi (India)");
+  static HU = new _Locale("hu", "Hungarian");
+  static HU_HU = new _Locale("hu_HU", "Hungarian (Hungary)");
+  static IS = new _Locale("is", "Icelandic");
+  static IS_IS = new _Locale("is_IS", "Icelandic (Iceland)");
+  static IG = new _Locale("ig", "Igbo");
+  static IG_NG = new _Locale("ig_NG", "Igbo (Nigeria)");
+  static ID = new _Locale("id", "Indonesian");
+  static ID_ID = new _Locale("id_ID", "Indonesian (Indonesia)");
+  static GA = new _Locale("ga", "Irish");
+  static GA_IE = new _Locale("ga_IE", "Irish (Ireland)");
+  static IT = new _Locale("it", "Italian");
+  static IT_IT = new _Locale("it_IT", "Italian (Italy)");
+  static IT_SM = new _Locale("it_SM", "Italian (San Marino)");
+  static IT_CH = new _Locale("it_CH", "Italian (Switzerland)");
+  static JA = new _Locale("ja", "Japanese");
+  static JA_JP = new _Locale("ja_JP", "Japanese (Japan)");
+  static KL = new _Locale("kl", "Kalaallisut");
+  static KL_GL = new _Locale("kl_GL", "Kalaallisut (Greenland)");
+  static KN = new _Locale("kn", "Kannada");
+  static KN_IN = new _Locale("kn_IN", "Kannada (India)");
+  static KS = new _Locale("ks", "Kashmiri");
+  static KS_ARAB_IN = new _Locale("ks_Arab_IN", "Kashmiri (Arabic, India)");
+  static KS_ARAB = new _Locale("ks_Arab", "Kashmiri (Arabic)", "ks");
+  static KS_IN = new _Locale("ks_IN", "Kashmiri (India)");
+  static KK = new _Locale("kk", "Kazakh");
+  static KK_CYRL_KZ = new _Locale("kk_Cyrl_KZ", "Kazakh (Cyrillic, Kazakhstan)");
+  static KK_CYRL = new _Locale("kk_Cyrl", "Kazakh (Cyrillic)", "kk");
+  static KK_KZ = new _Locale("kk_KZ", "Kazakh (Kazakhstan)");
+  static KM = new _Locale("km", "Khmer");
+  static KM_KH = new _Locale("km_KH", "Khmer (Cambodia)");
+  static KI = new _Locale("ki", "Kikuyu");
+  static KI_KE = new _Locale("ki_KE", "Kikuyu (Kenya)");
+  static RW = new _Locale("rw", "Kinyarwanda");
+  static RW_RW = new _Locale("rw_RW", "Kinyarwanda (Rwanda)");
+  static KO = new _Locale("ko", "Korean");
+  static KO_KP = new _Locale("ko_KP", "Korean (North Korea)");
+  static KO_KR = new _Locale("ko_KR", "Korean (South Korea)");
+  static KY = new _Locale("ky", "Kyrgyz");
+  static KY_CYRL_KG = new _Locale("ky_Cyrl_KG", "Kyrgyz (Cyrillic, Kyrgyzstan)");
+  static KY_CYRL = new _Locale("ky_Cyrl", "Kyrgyz (Cyrillic)", "ky");
+  static KY_KG = new _Locale("ky_KG", "Kyrgyz (Kyrgyzstan)");
+  static LO = new _Locale("lo", "Lao");
+  static LO_LA = new _Locale("lo_LA", "Lao (Laos)");
+  static LV = new _Locale("lv", "Latvian");
+  static LV_LV = new _Locale("lv_LV", "Latvian (Latvia)");
+  static LN = new _Locale("ln", "Lingala");
+  static LN_AO = new _Locale("ln_AO", "Lingala (Angola)");
+  static LN_CF = new _Locale("ln_CF", "Lingala (Central African Republic)");
+  static LN_CG = new _Locale("ln_CG", "Lingala (Congo - Brazzaville)");
+  static LN_CD = new _Locale("ln_CD", "Lingala (Congo - Kinshasa)");
+  static LT = new _Locale("lt", "Lithuanian");
+  static LT_LT = new _Locale("lt_LT", "Lithuanian (Lithuania)");
+  static LU = new _Locale("lu", "Luba-Katanga");
+  static LU_CD = new _Locale("lu_CD", "Luba-Katanga (Congo - Kinshasa)");
+  static LB = new _Locale("lb", "Luxembourgish");
+  static LB_LU = new _Locale("lb_LU", "Luxembourgish (Luxembourg)");
+  static MK = new _Locale("mk", "Macedonian");
+  static MK_MK = new _Locale("mk_MK", "Macedonian (Macedonia)");
+  static MG = new _Locale("mg", "Malagasy");
+  static MG_MG = new _Locale("mg_MG", "Malagasy (Madagascar)");
+  static MS = new _Locale("ms", "Malay");
+  static MS_BN = new _Locale("ms_BN", "Malay (Brunei)");
+  static MS_LATN_BN = new _Locale("ms_Latn_BN", "Malay (Latin, Brunei)");
+  static MS_LATN_MY = new _Locale("ms_Latn_MY", "Malay (Latin, Malaysia)");
+  static MS_LATN_SG = new _Locale("ms_Latn_SG", "Malay (Latin, Singapore)");
+  static MS_LATN = new _Locale("ms_Latn", "Malay (Latin)", "ms");
+  static MS_MY = new _Locale("ms_MY", "Malay (Malaysia)");
+  static MS_SG = new _Locale("ms_SG", "Malay (Singapore)");
+  static ML = new _Locale("ml", "Malayalam");
+  static ML_IN = new _Locale("ml_IN", "Malayalam (India)");
+  static MT = new _Locale("mt", "Maltese");
+  static MT_MT = new _Locale("mt_MT", "Maltese (Malta)");
+  static GV = new _Locale("gv", "Manx");
+  static GV_IM = new _Locale("gv_IM", "Manx (Isle of Man)");
+  static MR = new _Locale("mr", "Marathi");
+  static MR_IN = new _Locale("mr_IN", "Marathi (India)");
+  static MN = new _Locale("mn", "Mongolian");
+  static MN_CYRL_MN = new _Locale("mn_Cyrl_MN", "Mongolian (Cyrillic, Mongolia)");
+  static MN_CYRL = new _Locale("mn_Cyrl", "Mongolian (Cyrillic)", "mn");
+  static MN_MN = new _Locale("mn_MN", "Mongolian (Mongolia)");
+  static NE = new _Locale("ne", "Nepali");
+  static NE_IN = new _Locale("ne_IN", "Nepali (India)");
+  static NE_NP = new _Locale("ne_NP", "Nepali (Nepal)");
+  static ND = new _Locale("nd", "North Ndebele");
+  static ND_ZW = new _Locale("nd_ZW", "North Ndebele (Zimbabwe)");
+  static SE = new _Locale("se", "Northern Sami");
+  static SE_FI = new _Locale("se_FI", "Northern Sami (Finland)");
+  static SE_NO = new _Locale("se_NO", "Northern Sami (Norway)");
+  static SE_SE = new _Locale("se_SE", "Northern Sami (Sweden)");
+  static NO = new _Locale("no", "Norwegian");
+  static NO_NO = new _Locale("no_NO", "Norwegian (Norway)");
+  static NB = new _Locale("nb", "Norwegian Bokm\xE5l");
+  static NB_NO = new _Locale("nb_NO", "Norwegian Bokm\xE5l (Norway)");
+  static NB_SJ = new _Locale("nb_SJ", "Norwegian Bokm\xE5l (Svalbard & Jan Mayen)");
+  static NN = new _Locale("nn", "Norwegian Nynorsk");
+  static NN_NO = new _Locale("nn_NO", "Norwegian Nynorsk (Norway)");
+  static OR = new _Locale("or", "Oriya");
+  static OR_IN = new _Locale("or_IN", "Oriya (India)");
+  static OM = new _Locale("om", "Oromo");
+  static OM_ET = new _Locale("om_ET", "Oromo (Ethiopia)");
+  static OM_KE = new _Locale("om_KE", "Oromo (Kenya)");
+  static OS = new _Locale("os", "Ossetic");
+  static OS_GE = new _Locale("os_GE", "Ossetic (Georgia)");
+  static OS_RU = new _Locale("os_RU", "Ossetic (Russia)");
+  static PS = new _Locale("ps", "Pashto");
+  static PS_AF = new _Locale("ps_AF", "Pashto (Afghanistan)");
+  static FA = new _Locale("fa", "Persian");
+  static FA_AF = new _Locale("fa_AF", "Persian (Afghanistan)");
+  static FA_IR = new _Locale("fa_IR", "Persian (Iran)");
+  static PL = new _Locale("pl", "Polish");
+  static PL_PL = new _Locale("pl_PL", "Polish (Poland)");
+  static PT = new _Locale("pt", "Portuguese");
+  static PT_AO = new _Locale("pt_AO", "Portuguese (Angola)");
+  static PT_BR = new _Locale("pt_BR", "Portuguese (Brazil)");
+  static PT_CV = new _Locale("pt_CV", "Portuguese (Cape Verde)");
+  static PT_GW = new _Locale("pt_GW", "Portuguese (Guinea-Bissau)");
+  static PT_MO = new _Locale("pt_MO", "Portuguese (Macau SAR China)");
+  static PT_MZ = new _Locale("pt_MZ", "Portuguese (Mozambique)");
+  static PT_PT = new _Locale("pt_PT", "Portuguese (Portugal)");
+  static PT_ST = new _Locale("pt_ST", "Portuguese (S\xE3o Tom\xE9 & Pr\xEDncipe)");
+  static PT_TL = new _Locale("pt_TL", "Portuguese (Timor-Leste)");
+  static PA = new _Locale("pa", "Punjabi");
+  static PA_ARAB_PK = new _Locale("pa_Arab_PK", "Punjabi (Arabic, Pakistan)");
+  static PA_ARAB = new _Locale("pa_Arab", "Punjabi (Arabic)", "pa");
+  static PA_GURU_IN = new _Locale("pa_Guru_IN", "Punjabi (Gurmukhi, India)");
+  static PA_GURU = new _Locale("pa_Guru", "Punjabi (Gurmukhi)", "pa");
+  static PA_IN = new _Locale("pa_IN", "Punjabi (India)");
+  static PA_PK = new _Locale("pa_PK", "Punjabi (Pakistan)");
+  static QU = new _Locale("qu", "Quechua");
+  static QU_BO = new _Locale("qu_BO", "Quechua (Bolivia)");
+  static QU_EC = new _Locale("qu_EC", "Quechua (Ecuador)");
+  static QU_PE = new _Locale("qu_PE", "Quechua (Peru)");
+  static RO = new _Locale("ro", "Romanian");
+  static RO_MD = new _Locale("ro_MD", "Romanian (Moldova)");
+  static RO_RO = new _Locale("ro_RO", "Romanian (Romania)");
+  static RM = new _Locale("rm", "Romansh");
+  static RM_CH = new _Locale("rm_CH", "Romansh (Switzerland)");
+  static RN = new _Locale("rn", "Rundi");
+  static RN_BI = new _Locale("rn_BI", "Rundi (Burundi)");
+  static RU = new _Locale("ru", "Russian");
+  static RU_BY = new _Locale("ru_BY", "Russian (Belarus)");
+  static RU_KZ = new _Locale("ru_KZ", "Russian (Kazakhstan)");
+  static RU_KG = new _Locale("ru_KG", "Russian (Kyrgyzstan)");
+  static RU_MD = new _Locale("ru_MD", "Russian (Moldova)");
+  static RU_RU = new _Locale("ru_RU", "Russian (Russia)");
+  static RU_UA = new _Locale("ru_UA", "Russian (Ukraine)");
+  static SG = new _Locale("sg", "Sango");
+  static SG_CF = new _Locale("sg_CF", "Sango (Central African Republic)");
+  static GD = new _Locale("gd", "Scottish Gaelic");
+  static GD_GB = new _Locale("gd_GB", "Scottish Gaelic (United Kingdom)");
+  static SR = new _Locale("sr", "Serbian");
+  static SR_BA = new _Locale("sr_BA", "Serbian (Bosnia & Herzegovina)");
+  static SR_CYRL_BA = new _Locale("sr_Cyrl_BA", "Serbian (Cyrillic, Bosnia & Herzegovina)");
+  static SR_CYRL_XK = new _Locale("sr_Cyrl_XK", "Serbian (Cyrillic, Kosovo)");
+  static SR_CYRL_ME = new _Locale("sr_Cyrl_ME", "Serbian (Cyrillic, Montenegro)");
+  static SR_CYRL_RS = new _Locale("sr_Cyrl_RS", "Serbian (Cyrillic, Serbia)");
+  static SR_CYRL = new _Locale("sr_Cyrl", "Serbian (Cyrillic)", "sr");
+  static SR_XK = new _Locale("sr_XK", "Serbian (Kosovo)");
+  static SR_LATN_BA = new _Locale("sr_Latn_BA", "Serbian (Latin, Bosnia & Herzegovina)");
+  static SR_LATN_XK = new _Locale("sr_Latn_XK", "Serbian (Latin, Kosovo)");
+  static SR_LATN_ME = new _Locale("sr_Latn_ME", "Serbian (Latin, Montenegro)");
+  static SR_LATN_RS = new _Locale("sr_Latn_RS", "Serbian (Latin, Serbia)");
+  static SR_LATN = new _Locale("sr_Latn", "Serbian (Latin)", "sr");
+  static SR_ME = new _Locale("sr_ME", "Serbian (Montenegro)");
+  static SR_RS = new _Locale("sr_RS", "Serbian (Serbia)");
+  static SH = new _Locale("sh", "Serbo-Croatian");
+  static SH_BA = new _Locale("sh_BA", "Serbo-Croatian (Bosnia & Herzegovina)");
+  static SN = new _Locale("sn", "Shona");
+  static SN_ZW = new _Locale("sn_ZW", "Shona (Zimbabwe)");
+  static II = new _Locale("ii", "Sichuan Yi");
+  static II_CN = new _Locale("ii_CN", "Sichuan Yi (China)");
+  static SI = new _Locale("si", "Sinhala");
+  static SI_LK = new _Locale("si_LK", "Sinhala (Sri Lanka)");
+  static SK = new _Locale("sk", "Slovak");
+  static SK_SK = new _Locale("sk_SK", "Slovak (Slovakia)");
+  static SL = new _Locale("sl", "Slovenian");
+  static SL_SI = new _Locale("sl_SI", "Slovenian (Slovenia)");
+  static SO = new _Locale("so", "Somali");
+  static SO_DJ = new _Locale("so_DJ", "Somali (Djibouti)");
+  static SO_ET = new _Locale("so_ET", "Somali (Ethiopia)");
+  static SO_KE = new _Locale("so_KE", "Somali (Kenya)");
+  static SO_SO = new _Locale("so_SO", "Somali (Somalia)");
+  static ES = new _Locale("es", "Spanish");
+  static ES_AR = new _Locale("es_AR", "Spanish (Argentina)");
+  static ES_BO = new _Locale("es_BO", "Spanish (Bolivia)");
+  static ES_IC = new _Locale("es_IC", "Spanish (Canary Islands)");
+  static ES_EA = new _Locale("es_EA", "Spanish (Ceuta & Melilla)");
+  static ES_CL = new _Locale("es_CL", "Spanish (Chile)");
+  static ES_CO = new _Locale("es_CO", "Spanish (Colombia)");
+  static ES_CR = new _Locale("es_CR", "Spanish (Costa Rica)");
+  static ES_CU = new _Locale("es_CU", "Spanish (Cuba)");
+  static ES_DO = new _Locale("es_DO", "Spanish (Dominican Republic)");
+  static ES_EC = new _Locale("es_EC", "Spanish (Ecuador)");
+  static ES_SV = new _Locale("es_SV", "Spanish (El Salvador)");
+  static ES_GQ = new _Locale("es_GQ", "Spanish (Equatorial Guinea)");
+  static ES_GT = new _Locale("es_GT", "Spanish (Guatemala)");
+  static ES_HN = new _Locale("es_HN", "Spanish (Honduras)");
+  static ES_MX = new _Locale("es_MX", "Spanish (Mexico)");
+  static ES_NI = new _Locale("es_NI", "Spanish (Nicaragua)");
+  static ES_PA = new _Locale("es_PA", "Spanish (Panama)");
+  static ES_PY = new _Locale("es_PY", "Spanish (Paraguay)");
+  static ES_PE = new _Locale("es_PE", "Spanish (Peru)");
+  static ES_PH = new _Locale("es_PH", "Spanish (Philippines)");
+  static ES_PR = new _Locale("es_PR", "Spanish (Puerto Rico)");
+  static ES_ES = new _Locale("es_ES", "Spanish (Spain)");
+  static ES_US = new _Locale("es_US", "Spanish (United States)");
+  static ES_UY = new _Locale("es_UY", "Spanish (Uruguay)");
+  static ES_VE = new _Locale("es_VE", "Spanish (Venezuela)");
+  static SW = new _Locale("sw", "Swahili");
+  static SW_KE = new _Locale("sw_KE", "Swahili (Kenya)");
+  static SW_TZ = new _Locale("sw_TZ", "Swahili (Tanzania)");
+  static SW_UG = new _Locale("sw_UG", "Swahili (Uganda)");
+  static SV = new _Locale("sv", "Swedish");
+  static SV_AX = new _Locale("sv_AX", "Swedish (\xC5land Islands)");
+  static SV_FI = new _Locale("sv_FI", "Swedish (Finland)");
+  static SV_SE = new _Locale("sv_SE", "Swedish (Sweden)");
+  static TL = new _Locale("tl", "Tagalog");
+  static TL_PH = new _Locale("tl_PH", "Tagalog (Philippines)");
+  static TA = new _Locale("ta", "Tamil");
+  static TA_IN = new _Locale("ta_IN", "Tamil (India)");
+  static TA_MY = new _Locale("ta_MY", "Tamil (Malaysia)");
+  static TA_SG = new _Locale("ta_SG", "Tamil (Singapore)");
+  static TA_LK = new _Locale("ta_LK", "Tamil (Sri Lanka)");
+  static TE = new _Locale("te", "Telugu");
+  static TE_IN = new _Locale("te_IN", "Telugu (India)");
+  static TH = new _Locale("th", "Thai");
+  static TH_TH = new _Locale("th_TH", "Thai (Thailand)");
+  static BO = new _Locale("bo", "Tibetan");
+  static BO_CN = new _Locale("bo_CN", "Tibetan (China)");
+  static BO_IN = new _Locale("bo_IN", "Tibetan (India)");
+  static TI = new _Locale("ti", "Tigrinya");
+  static TI_ER = new _Locale("ti_ER", "Tigrinya (Eritrea)");
+  static TI_ET = new _Locale("ti_ET", "Tigrinya (Ethiopia)");
+  static TO = new _Locale("to", "Tongan");
+  static TO_TO = new _Locale("to_TO", "Tongan (Tonga)");
+  static TR = new _Locale("tr", "Turkish");
+  static TR_CY = new _Locale("tr_CY", "Turkish (Cyprus)");
+  static TR_TR = new _Locale("tr_TR", "Turkish (Turkey)");
+  static UK = new _Locale("uk", "Ukrainian");
+  static UK_UA = new _Locale("uk_UA", "Ukrainian (Ukraine)");
+  static UR = new _Locale("ur", "Urdu");
+  static UR_IN = new _Locale("ur_IN", "Urdu (India)");
+  static UR_PK = new _Locale("ur_PK", "Urdu (Pakistan)");
+  static UG = new _Locale("ug", "Uyghur");
+  static UG_ARAB_CN = new _Locale("ug_Arab_CN", "Uyghur (Arabic, China)");
+  static UG_ARAB = new _Locale("ug_Arab", "Uyghur (Arabic)");
+  static UG_CN = new _Locale("ug_CN", "Uyghur (China)");
+  static UZ = new _Locale("uz", "Uzbek");
+  static UZ_AF = new _Locale("uz_AF", "Uzbek (Afghanistan)");
+  static UZ_ARAB_AF = new _Locale("uz_Arab_AF", "Uzbek (Arabic, Afghanistan)");
+  static UZ_ARAB = new _Locale("uz_Arab", "Uzbek (Arabic)", "uz");
+  static UZ_CYRL_UZ = new _Locale("uz_Cyrl_UZ", "Uzbek (Cyrillic, Uzbekistan)");
+  static UZ_CYRL = new _Locale("uz_Cyrl", "Uzbek (Cyrillic)", "uz");
+  static UZ_LATN_UZ = new _Locale("uz_Latn_UZ", "Uzbek (Latin, Uzbekistan)");
+  static UZ_LATN = new _Locale("uz_Latn", "Uzbek (Latin)", "uz");
+  static UZ_UZ = new _Locale("uz_UZ", "Uzbek (Uzbekistan)");
+  static VI = new _Locale("vi", "Vietnamese");
+  static VI_VN = new _Locale("vi_VN", "Vietnamese (Vietnam)");
+  static CY = new _Locale("cy", "Welsh");
+  static CY_GB = new _Locale("cy_GB", "Welsh (United Kingdom)");
+  static FY = new _Locale("fy", "Western Frisian");
+  static FY_NL = new _Locale("fy_NL", "Western Frisian (Netherlands)");
+  static YI = new _Locale("yi", "Yiddish");
+  static YO = new _Locale("yo", "Yoruba");
+  static YO_BJ = new _Locale("yo_BJ", "Yoruba (Benin)");
+  static YO_NG = new _Locale("yo_NG", "Yoruba (Nigeria)");
+  static ZU = new _Locale("zu", "Zulu");
+  static ZU_ZA = new _Locale("zu_ZA", "Zulu (South Africa)");
+  static lookup(other) {
+    return this.all().first((l) => l.equals(other));
+  }
+  equals(other) {
+    return text(other).lower.trim.equals(this.lower);
+  }
+};
+
+// src/domain/enums/UnitOfMeasurement.ts
+var UnitOfMeasurement = class _UnitOfMeasurement extends Enum {
+  constructor(name2, id, mmMultiplier) {
+    super(name2, id);
+    this.mmMultiplier = mmMultiplier;
+  }
+  static MM = new _UnitOfMeasurement("Millimeter", "mm", 1);
+  static CM = new _UnitOfMeasurement("Centimeter", "cm", 10);
+  static DM = new _UnitOfMeasurement("Decimeter", "dm", 100);
+  static M = new _UnitOfMeasurement("Meter", "m", 1e3);
+  static KM = new _UnitOfMeasurement("Kilometer", "km", 1e6);
+};
+
+// src/domain/enums/UnitOfWeight.ts
+var UnitOfWeight = class _UnitOfWeight extends Enum {
+  constructor(name2, id, gMultiplier) {
+    super(name2, id);
+    this.gMultiplier = gMultiplier;
+  }
+  static MG = new _UnitOfWeight("MilliGram", "mg", 1e-3);
+  static G = new _UnitOfWeight("Gram", "g", 1);
+  static KG = new _UnitOfWeight("Kilogram", "kg", 1e3);
+};
+
+// src/domain/Audit.ts
+var Audit = class extends Struct {
+  by = { id: this.state.by.id, user: this.state.by.user };
+  when = new DateTime(this.state.when);
+  constructor(json2) {
+    super(
+      choose(json2).is.defined(
+        (j) => j,
+        (j) => j
+      ).else({ by: ctx.request?.identity ?? { id: 0, user: "easy" }, when: DateTime.now.toJSON() })
+    );
+  }
+};
+__decorateClass([
+  required()
+], Audit.prototype, "by", 2);
+__decorateClass([
+  valid()
+], Audit.prototype, "when", 2);
+
+// src/domain/Child.ts
+var Child = class extends Struct {
+  id = this.state.id ?? toId();
+  merge(a) {
+    return json.merge(this, a, { id: this.id });
+  }
+};
+__decorateClass([
+  required()
+], Child.prototype, "id", 2);
+
+// src/domain/Entity.ts
+var Entity = class extends Struct {
+  id = this.state.id ?? toId();
+  created = new Audit(this.state.created);
+  lastModified = new Audit(this.state.lastModified);
+  merge(a) {
+    return json.merge(this, a, {
+      id: this.id,
+      created: this.created,
+      lastModified: new Audit()
+    });
+  }
+};
+__decorateClass([
+  required()
+], Entity.prototype, "id", 2);
+__decorateClass([
+  required()
+], Entity.prototype, "created", 2);
+__decorateClass([
+  required()
+], Entity.prototype, "lastModified", 2);
+
+// src/domain/Repo.ts
+var Repo = class extends Repository {
+  constructor(ctor, gateway) {
+    super();
+    this.ctor = ctor;
+    this.gateway = gateway;
+  }
+  create = (item) => isValidatable(item) ? item : new this.ctor(item);
+  all(options) {
+    return this.gateway.all(options).then((js) => js.map((i) => new this.ctor(i)));
+  }
+  byId(id) {
+    return this.gateway.byId(id).then((j) => when(j).not.isDefined.reject(Exception.DoesNotExist)).then((j) => new this.ctor(j));
+  }
+  byIds(...ids) {
+    return this.gateway.byIds(...ids).then((j) => asList(this.ctor, j));
+  }
+  byKey(key, options) {
+    return this.gateway.by("key", key, options).then((js) => js.map((i) => new this.ctor(i)));
+  }
+  by(key, value, options) {
+    return this.gateway.by(key.toString(), value, options).then((js) => js.map((i) => new this.ctor(i)));
+  }
+  search(q, options) {
+    return this.gateway.search(q, options).then((js) => js.map((i) => new this.ctor(i)));
+  }
+  filter(options) {
+    return this.gateway.filter(options).then((js) => js.map((i) => new this.ctor(i)));
+  }
+  exists(id) {
+    return this.gateway.exists(id);
+  }
+  add(t) {
+    return this.extend(this.create(t), "add").then((i) => when(i).not.isValid.reject()).then((i) => this.validate(i, "add")).then((i) => this.gateway.add(toJson(i))).then((j) => new this.ctor(j));
+  }
+  update(id, json2) {
+    return this.gateway.byId(id).then((j) => when(j).not.isDefined.reject(Exception.DoesNotExist)).then((j) => new this.ctor(j).update(json2)).then((i) => this.extend(i, "update")).then((i) => when(i).not.isValid.reject()).then((i) => this.validate(i, "update")).then((i) => this.gateway.update(toJson(i))).then((j) => new this.ctor(j));
+  }
+  remove(id) {
+    return this.gateway.remove(id);
+  }
+  extend(item, _action) {
+    return resolve(item);
+  }
+  validate(item, _action) {
+    return resolve(item);
+  }
+  upsert(id, item) {
+    return this.update(id, item).catch((e) => Exception.DoesNotExist.equals(e) ? this.add(item) : reject(e));
+  }
+};
+
+// src/domain/Typo.ts
+var Typo = class extends Repository {
+  constructor(view2, gateway) {
+    super();
+    this.view = view2;
+    this.gateway = gateway;
+  }
+  create = (j) => this.view.from(j);
+  all(options) {
+    return this.gateway.all(options).then((js) => js.map(this.create));
+  }
+  byId(id) {
+    return this.gateway.byId(id).then((j) => when(j).not.isDefined.reject(Exception.DoesNotExist)).then((j) => this.create(j));
+  }
+  byIds(...ids) {
+    return this.gateway.byIds(...ids).then((js) => js.map(this.create));
+  }
+  byKey(key, options) {
+    return this.gateway.by("key", key, options).then((js) => js.map(this.create));
+  }
+  by(key, value, options) {
+    return this.gateway.by(key.toString(), value, options).then((js) => js.map(this.create));
+  }
+  search(q, options) {
+    return this.gateway.search(q, options).then((js) => js.map(this.create));
+  }
+  filter(options) {
+    return this.gateway.filter(options).then((js) => js.map((j) => this.create(j)));
+  }
+  exists(id) {
+    return this.gateway.exists(id);
+  }
+};
+
+// src/http/CacheControl.ts
+var CacheControl = class _CacheControl {
+  constructor(enabled = true, directives = {}) {
+    this.enabled = enabled;
+    this.directives = directives;
+  }
+  name = "Cache-Control";
+  static disabled = () => new _CacheControl(false);
+  static OneSecond = () => new _CacheControl().maxAge(1).staleWhileRevalidate(1);
+  static fiveSeconds = () => new _CacheControl().maxAge(5).staleWhileRevalidate(5);
+  static tenSeconds = () => new _CacheControl().maxAge(10).staleWhileRevalidate(10);
+  static thirtySeconds = () => new _CacheControl().maxAge(30).staleWhileRevalidate(30);
+  static sixtySeconds = () => new _CacheControl().maxAge(60).staleWhileRevalidate(60);
+  static custom = (maxAge, staleWhileRevalidate) => new _CacheControl().maxAge(maxAge).staleWhileRevalidate(staleWhileRevalidate);
+  maxAge = (ca) => on(this, (t) => t.directives["max-age"] = ca);
+  sharedMaxAge = (ca) => on(this, (t) => t.directives["s-maxage"] = ca);
+  noCache = (a) => on(this, (t) => t.directives["no-cache"] = a);
+  mustRevalidate = (a) => on(this, (t) => t.directives["must-revalidate"] = a);
+  private = (a) => on(this, (t) => t.directives["private"] = a);
+  public = (a) => on(this, (t) => t.directives["public"] = a);
+  immutable = (a) => on(this, (t) => t.directives["immutable"] = a);
+  staleWhileRevalidate = (ca) => on(this, (t) => t.directives["stale-while-revalidate"] = ca);
+  value = () => this.toString();
+  toString() {
+    return entries(this.directives).mapDefined(([k, v]) => ifDefined(v, isNumber(v) ? `${k}=${cacheAge.toSeconds(v)}` : k)).join(",");
+  }
+};
+
+// src/http/ContentType.ts
+var import_form_urlencoded = __toESM(require("form-urlencoded"));
+var ContentType = class _ContentType extends Enum {
+  constructor(name2, type, encoder = (b) => asString(b)) {
+    super(name2, type);
+    this.type = type;
+    this.encoder = encoder;
+  }
+  static Form = new _ContentType("form", "application/x-www-form-urlencoded", (b) => (0, import_form_urlencoded.default)(b));
+  static Json = new _ContentType("json", "application/json", (b) => b);
+  static Stream = new _ContentType("stream", "application/octet-stream");
+  static Text = new _ContentType("text", "text/plain");
+  static Xml = new _ContentType("xml", "application/xml");
+  encode = (body) => ofGet(this.encoder, body);
+};
+
+// src/http/HttpHeader.ts
+var HttpHeader = {
+  ContentType: "Content-Type",
+  Correlation: "X-Correlation-Id"
+};
+
+// src/http/HttpStatus.ts
+var HttpStatus = class _HttpStatus extends Enum {
+  static Continue = new _HttpStatus("Continue", 100);
+  static SwitchingProtocols = new _HttpStatus("Switching protocols", 101);
+  static Processing = new _HttpStatus("Processing", 102);
+  static EarlyHints = new _HttpStatus("Early hints", 103);
+  static Ok = new _HttpStatus("Ok", 200);
+  static Created = new _HttpStatus("Created", 201);
+  static Accepted = new _HttpStatus("Accepted", 202);
+  static NonAuthoritativeInformation = new _HttpStatus("Non-authoritative information", 203);
+  static NoContent = new _HttpStatus("No content", 204);
+  static ResetContent = new _HttpStatus("Reset content", 205);
+  static PartialContent = new _HttpStatus("Partial content", 206);
+  static MultiStatus = new _HttpStatus("Multi-status", 207);
+  static AlreadyReported = new _HttpStatus("Already reported", 208);
+  static ImUsed = new _HttpStatus("IM used", 226);
+  static MultipleChoices = new _HttpStatus("Multiple Choices", 300);
+  static MovedPermanently = new _HttpStatus("Moved Permanently", 301);
+  static Found = new _HttpStatus("Found", 302);
+  static SeeOther = new _HttpStatus("See other", 303);
+  static NotModified = new _HttpStatus("Not modified", 304);
+  static UseProxy = new _HttpStatus("Use proxy", 305);
+  static SwitchProxy = new _HttpStatus("Switch proxy", 306);
+  static TemporaryRedirect = new _HttpStatus("Temporary redirect", 307);
+  static PermanentRedirect = new _HttpStatus("Permanent redirect", 308);
+  static BadRequest = new _HttpStatus("Bad request", 400);
+  static NotAuthorized = new _HttpStatus("Not authorized", 401);
+  static PaymentRequired = new _HttpStatus("Payment required", 402);
+  static Forbidden = new _HttpStatus("Forbidden", 403);
+  static NotFound = new _HttpStatus("Not found", 404);
+  static MethodNotAllowed = new _HttpStatus("Method not allowed", 405);
+  static NotAcceptable = new _HttpStatus("Not acceptable", 406);
+  static ProxyAuthenticationRequired = new _HttpStatus("Proxy authentication required", 407);
+  static RequestTimeout = new _HttpStatus("Request timeout", 408);
+  static Conflict = new _HttpStatus("Conflict", 409);
+  static Gone = new _HttpStatus("Gone", 410);
+  static LengthRequired = new _HttpStatus("Length required", 411);
+  static PreconditionFailed = new _HttpStatus("Precondition failed", 412);
+  static PayloadTooLarge = new _HttpStatus("Payload too large", 413);
+  static UriTooLong = new _HttpStatus("URI too long", 414);
+  static UnsupportedMediaType = new _HttpStatus("Unsupported media type", 415);
+  static RangeNotSatisfiable = new _HttpStatus("Range not satisfiable", 416);
+  static ExpectationFailed = new _HttpStatus("Expectation failed", 417);
+  static ImATeapot = new _HttpStatus("I'm a teapot", 418);
+  static MisdirectedRequest = new _HttpStatus("Misdirected request", 421);
+  static UnprocessableEntity = new _HttpStatus("Unprocessable entity", 422);
+  static Locked = new _HttpStatus("Locked", 423);
+  static FailedDependency = new _HttpStatus("Failed dependency", 424);
+  static TooEarly = new _HttpStatus("Too early", 425);
+  static UpgradeRequired = new _HttpStatus("Upgrade required", 426);
+  static PreconditionRequired = new _HttpStatus("Precondition required", 428);
+  static TooManyRequests = new _HttpStatus("Too many requests", 429);
+  static RequestHeaderFieldsTooLarge = new _HttpStatus("Request header fields too large", 431);
+  static UnavailableForLegalReasons = new _HttpStatus("Unavailable for legal reasons", 451);
+  static InternalServerError = new _HttpStatus("Internal server error", 500);
+  static NotImplemented = new _HttpStatus("Not implemented", 501);
+  static BadGateway = new _HttpStatus("Bad gateway", 502);
+  static ServiceUnavailable = new _HttpStatus("Service unavailable", 503);
+  static GatewayTimeout = new _HttpStatus("Gateway timeout", 504);
+  static HTTPVersionNotSupported = new _HttpStatus("Http version not supported", 505);
+  static VariantAlsoNegotiates = new _HttpStatus("Variant also negotiates", 506);
+  static InsufficientStorage = new _HttpStatus("Insufficient storage", 507);
+  static LoopDetected = new _HttpStatus("Loop detected", 508);
+  static NotExtended = new _HttpStatus("Not extended", 510);
+  static NetworkAuthenticationRequired = new _HttpStatus("Network authentication required", 511);
+  get isError() {
+    return this.isClientError || this.isServerError;
+  }
+  get isClientError() {
+    return this.id >= 400 && this.id < 500;
+  }
+  get isServerError() {
+    return this.id >= 500 && this.id < 600;
+  }
+  get status() {
+    return this.id;
+  }
+};
+var isHttpStatus = (s) => isAn(s, "id", "status");
+var toHttpStatus = (s) => isHttpStatus(s) ? s : HttpStatus.byId(s);
+
+// src/http/HttpVerb.ts
+var HttpVerb = class _HttpVerb extends Enum {
+  static Get = new _HttpVerb("Get");
+  static Put = new _HttpVerb("Put");
+  static Patch = new _HttpVerb("Patch");
+  static Post = new _HttpVerb("Post");
+  static Delete = new _HttpVerb("Delete");
+  constructor(name2) {
+    super(name2, name2.toLowerCase(), name2.toUpperCase());
+  }
+};
+
+// src/http/OriginatedError.ts
+var OriginatedError = class extends Error {
+  constructor(origin, options) {
+    super();
+    this.origin = origin;
+    this.options = options;
+    if (isError(origin))
+      this.stack = origin.stack;
+  }
+};
+var isOriginatedError = (e) => isError(e) && e instanceof OriginatedError;
+var toOriginatedError = (e, options) => isOriginatedError(e) ? e : new OriginatedError(e, options);
+
+// src/http/RequestOptions.ts
+var toPageOptions = (options) => options instanceof RequestOptions ? options.pageOptions : options;
+var RequestOptions = class _RequestOptions extends Enum {
+  constructor(type = ContentType.Json, headers = {}, pageOptions) {
+    super(type.name);
+    this.type = type;
+    this.headers = headers;
+    this.pageOptions = pageOptions;
+    this.headers["Content-Type"] = type.id;
+    this.headers[HttpHeader.Correlation] = ctx.request.correlationId ?? toUuid();
+  }
+  requestOptions = {};
+  static get Form() {
+    return new _RequestOptions(ContentType.Form);
+  }
+  static get Json() {
+    return new _RequestOptions(ContentType.Json);
+  }
+  static get Stream() {
+    return new _RequestOptions(ContentType.Stream);
+  }
+  static get Text() {
+    return new _RequestOptions(ContentType.Text);
+  }
+  static get Xml() {
+    return new _RequestOptions(ContentType.Xml);
+  }
+  page = (options) => {
+    this.pageOptions = options;
+    return this;
+  };
+  authorization = (auth) => this.setHeader("Authorization", auth);
+  apiKey = (apiKey) => this.setHeader("apiKey", apiKey);
+  setHeader = (key, value) => on(this, (t) => t.headers[asString(key)] = value);
+  setHeaderUnlessPresent = (key, value) => value ? this.setHeader(key, this.headers[key] ?? value) : this;
+  accept = (type) => this.setHeader("Accept", type.id);
+  bearer = (jwt) => {
+    return isNotEmpty(jwt) ? this.authorization(`Bearer ${jwt}`) : this;
+  };
+  basic = (username, password) => {
+    const basicAuth = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
+    return this.authorization(`Basic ${basicAuth}`);
+  };
+  maxRedirects = (max) => {
+    this.requestOptions.maxRedirects = max;
+    return this;
+  };
+  validateStatus = (validate2) => {
+    this.requestOptions.validateStatus = validate2;
+    return this;
+  };
+  timeout = (t) => {
+    this.requestOptions.timeout = t;
+    return this;
+  };
+};
+var isRequestOptions = (o) => isDefined(o) && o instanceof RequestOptions;
+
+// src/http/RestResult.ts
+var hasErrors = (a) => isDefined(a?.error?.errors);
+var hasItems = (a) => isDefined(a?.data.items);
+var rest = {
+  toData: (status, items = [], totalItems, meta2) => ({
+    data: {
+      code: status.status,
+      items: toList(items),
+      itemCount: items.length,
+      totalItems,
+      meta: meta2
+    }
+  }),
+  toError: (status, errors = [toResult(status.name)]) => ({
+    error: {
+      code: status.status,
+      message: status.name ?? errors[0].message ?? "Unknown",
+      errors: toList(errors),
+      errorCount: errors.length
+    }
+  }),
+  to: (payload, status) => choose(payload).is.not.defined((p) => p, void 0).type(isHttpStatus, (h) => rest.toError(h ?? status ?? HttpStatus.InternalServerError, [toResult(h.name)])).type(isResult, (r) => rest.toError(status ?? HttpStatus.BadRequest, [r])).type(isError, (e) => rest.toError(status ?? HttpStatus.BadRequest, [e])).type(isResults, (r) => rest.toError(status ?? HttpStatus.BadRequest, r.results)).type(isResponse, (r) => rest.toError(status ?? HttpStatus.byId(r.body.error?.code), r.body.error?.errors)).type(hasErrors, (e) => rest.toError(status ?? HttpStatus.byId(e.error.code, HttpStatus.BadRequest), e.error.errors)).type(hasItems, (d) => rest.toData(status ?? HttpStatus.byId(d.data.code, HttpStatus.Ok), d.data.items, d.data.totalItems, d.data.meta)).else((p) => rest.toData(status ?? HttpStatus.Ok, toList(p)))
+};
+var isRestResult = (r) => isDefined(r) && (isDefined(r.data) || isDefined(r.error));
+
+// src/http/Response.ts
+var isResponse = (r) => isA(r, "status", "body");
+var toResponse = (status, body, headers) => ({
+  status: toHttpStatus(status),
+  headers,
+  body: rest.to(body)
+});
+
+// src/http/Verb.ts
+var toVerbOptions = (options) => ({
+  onOk: options?.onOk ?? HttpStatus.Ok,
+  onNotFound: options?.onNotFound ?? HttpStatus.NotFound,
+  onError: options?.onError ?? HttpStatus.BadRequest,
+  type: options?.type ?? ContentType.Json,
+  cache: options?.cache ?? CacheControl.disabled()
+});
+var toVerb = (verb, options) => (subject, property) => {
+  meta(subject).property(property).set("verb", { verb, options });
+};
+var get = (options) => toVerb(HttpVerb.Get, options);
+var search = (options) => toVerb(HttpVerb.Get, { onNotFound: HttpStatus.Ok, ...options });
+var put = (options) => toVerb(HttpVerb.Put, options);
+var patch = (options) => toVerb(HttpVerb.Patch, options);
+var post = (options) => toVerb(HttpVerb.Post, { onOk: HttpStatus.Created, ...options });
+var del = (options) => toVerb(HttpVerb.Delete, { onOk: HttpStatus.NoContent, ...options });
+var stream = (options) => toVerb(HttpVerb.Get, { type: ContentType.Stream, ...options });
+
+// src/health/HealthUri.ts
+var HealthUri = class _HealthUri extends EasyUri {
+  static health = uri.segment("health");
+  static Health = new _HealthUri([_HealthUri.health]);
+};
+
+// src/resources/Req.ts
+var Req = class {
+  constructor(path = {}, query = {}, body, headers) {
+    this.path = path;
+    this.query = query;
+    this.body = body;
+    this.headers = headers;
+    this.skip = ifDefined(query.skip, (s) => asNumber(s));
+    this.take = ifDefined(query.take, (t) => asNumber(t));
+  }
+  skip;
+  take;
+  get id() {
+    return this.get("id");
+  }
+  get q() {
+    return this.get("q");
+  }
+  get = (key) => this.path[key.toString()] ?? this.query[key.toString()];
+};
+function toReq(req) {
+  return new Req(req.params, req.query, req.body, req.headers);
+}
+
+// src/resources/Requires.ts
+var Requires = class {
+  labCoat = () => (subject, property) => {
+    meta(subject).property(property).set("labCoat", true);
+  };
+  token = () => (subject, property) => {
+    meta(subject).property(property).set("token", true);
+  };
+  scope = (scope) => (subject, property) => {
+    meta(subject).property(property).set("token", true);
+    meta(subject).property(property).set("scope", scope);
+  };
+  useCase = (uc) => (subject, property) => {
+    meta(subject).property(property).set("token", true);
+    meta(subject).property(property).set("uc", uc);
+  };
+};
+var requires = new Requires();
+
+// src/resources/Route.ts
+var route = (uri2) => (subject) => {
+  meta(subject).set("route", uri2);
+};
+var toRoute2 = (endpoint, requires2, verb, middleware) => tryTo(verb).is.defined().map((verb2) => ({ verb: verb2, endpoint, requires: requires2, middleware: middleware ?? [] })).orElse();
+var Router = class {
+  constructor(resource) {
+    this.resource = resource;
+  }
+  get route() {
+    return meta(this.resource).get("route");
+  }
+  get middleware() {
+    return meta(this.resource).get("middleware") ?? [];
+  }
+  get endpoints() {
+    return meta(this.resource).properties("verb").mapDefined(
+      (v) => toRoute2(
+        this.resource[v.property],
+        {
+          labCoat: v.get("labCoat") ?? false,
+          token: v.get("token") ?? false,
+          scope: v.get("scope"),
+          uc: v.get("uc")
+        },
+        v.get("verb"),
+        v.get("middleware")
+      )
+    );
+  }
+};
+var routes = (resource) => new Router(resource);
+
+// src/resources/Service.ts
+var Service = class extends Enum {
+  constructor(name2, app, resources = toList()) {
+    super(name2);
+    this.name = name2;
+    this.app = app;
+    this.resources = resources;
+  }
+  port = 8080;
+  pre = () => [];
+  post = () => [];
+  with(...resources) {
+    return tryTo(this).accept((t) => t.resources.add(resources.map((r) => new r()))).value;
+  }
+  atPort(port) {
+    return tryTo(this).accept((t) => t.port = port).value;
+  }
+  start(message = `Service ${this.name} listening on port ${this.port} with ${this.resources.length} resources.`) {
+    tryTo(this).accept((t) => t.pre().forEach((h) => this.app.use(h))).accept((t) => t.resources.forEach((r) => this.app.route(this, r))).accept((t) => t.post().forEach((h) => this.app.use(h))).accept((t) => t.app.listen(this.port, message));
+  }
+};
+
+// src/health/HealthResource.ts
+var HealthResource = class {
+  ok = () => resolve({ state: "Service is healthy." });
+};
+__decorateClass([
+  get()
+], HealthResource.prototype, "ok", 2);
+HealthResource = __decorateClass([
+  route(HealthUri.Health)
+], HealthResource);
+
+// src/process/Scope.ts
+var Scope = class _Scope extends Enum {
+  constructor(name2, id = text(name2).kebab, subs = toList()) {
+    super(name2, id.toString());
+    this.name = name2;
+    this.subs = subs;
+  }
+  for(item) {
+    return new _Scope(`${this.name} ${isString(item) ? text(item).title : item.name}`, kebab(`${this.id} ${isString(item) ? item : item.id}`));
+  }
+  combines(...scopes) {
+    this.subs.add(scopes);
+    return this;
+  }
+  expand() {
+    return this.subs.flatMap((s) => s.expand()).add(this).distinct();
+  }
+};
+
+// src/process/App.ts
+var App = class _App extends Scope {
+  constructor(name2) {
+    super(name2);
+  }
+  static Main = new _App("Main");
+};
+
+// src/process/Search.ts
+var Search = class {
+  constructor(repo) {
+    this.repo = repo;
+  }
+  all(options) {
+    return this.repo.all(options);
+  }
+  byId(id) {
+    return this.repo.byId(id);
+  }
+  byIds(...ids) {
+    return this.repo.byIds(...ids);
+  }
+  byKey(key, options) {
+    return this.repo.byKey(key, options);
+  }
+  query({ query, skip, take }) {
+    return this.search(query, { skip, take });
+  }
+  search(query, options) {
+    return choose(query).is.not.empty(
+      (q) => q,
+      (q) => this.repo.search(q, options)
+    ).else(() => resolve(toPageList()));
+  }
+  filter(options) {
+    return this.repo.filter(options);
+  }
+  exists(id) {
+    return this.repo.exists(id);
+  }
+};
+
+// src/process/Manage.ts
+var Manage = class extends Search {
+  add(json2) {
+    return this.repo.add(json2);
+  }
+  update(id, json2) {
+    return this.repo.update(id, json2);
+  }
+  upsert(id, json2) {
+    return this.repo.upsert(id, json2);
+  }
+  remove(id) {
+    return this.repo.remove(id);
+  }
+};
+
+// src/process/UseCase.ts
+var UseCase = class _UseCase extends Enum {
+  constructor(app, name2, id = text(name2).kebab, scopes = toList()) {
+    super(name2, id.toString());
+    this.app = app;
+    this.scopes = scopes;
+  }
+  with(...s) {
+    this.scopes.add(
+      ...toList(s).flatMap((s2) => s2.expand()).distinct()
+    );
+    return this;
+  }
+  for(item) {
+    return new _UseCase(this.app, `${this.name} ${isString(item) ? item : item?.name}`, kebab(`${this.id} ${isString(item) ? item : item.id}`)).with(
+      ...this.scopes.map((s) => s?.for(item))
+    );
+  }
+  static byScopes(...s) {
+    return this.filter((u) => u.scopes.some((us) => isIn(us, s)));
+  }
+};
+
+// src/services/AxiosProvider.ts
+var import_axios = __toESM(require("axios"));
+var isResponse2 = (a) => isDefined(a?.response);
+var isRequest = (a) => isDefined(a?.request);
+var asResponse = (uri2, verb, error) => choose(error).type(
+  isResponse2,
+  (r) => toResponse(r.response.status, isRestResult(r.response.data) ? r.response.data : toResult(r.response.statusText, uri2.path, uri2), r.response.headers)
+).type(isRequest, (r) => toResponse(r.request.status, toResult(r.request.message, uri2.path, uri2))).else((e) => toResponse(HttpStatus.InternalServerError, toResult(e.message, uri2.path, uri2)));
+var AxiosProvider = class {
+  constructor(ai = import_axios.default) {
+    this.ai = ai;
+  }
+  execute = ({ uri: uri2, verb, body, transform = (r) => r, transformError = (r) => r, options = RequestOptions.Json }) => this.ai.request({
+    url: uri2.toString(),
+    method: verb.toString(),
+    headers: uri2.isInternal && isEmpty(options.headers.Authorization) ? options.bearer(ctx.request.jwt).headers : options.headers,
+    data: options.type.encode(body),
+    maxRedirects: options.requestOptions.maxRedirects,
+    ...options.requestOptions.timeout && { timeout: cacheAge.toMilliseconds(options?.requestOptions.timeout) },
+    ...options.requestOptions.validateStatus && { validateStatus: options.requestOptions.validateStatus }
+  }).then((r) => toResponse(r.status, transform(r.data), r.headers)).catch((e) => Promise.reject(asResponse(uri2, verb, transformError(e))));
+};
+
+// src/services/Api.ts
+var Api = class {
+  constructor(provider = new AxiosProvider(), store) {
+    this.provider = provider;
+    this.store = store;
+  }
+  get(uri2, options, transform, transformError = (r) => r) {
+    return this.execute({
+      uri: uri2.skip(toPageOptions(options)?.skip).take(toPageOptions(options)?.take),
+      verb: HttpVerb.Get,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Get, options)
+    });
+  }
+  post(uri2, body, options = RequestOptions.Json, transform, transformError = (r) => r) {
+    return this.execute({
+      uri: uri2,
+      verb: HttpVerb.Post,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Post, options)
+    });
+  }
+  put(uri2, body, options = RequestOptions.Json, transform, transformError = (r) => r) {
+    return this.execute({
+      uri: uri2,
+      verb: HttpVerb.Put,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Put, options)
+    });
+  }
+  patch(uri2, body, options = RequestOptions.Json, transform, transformError = (r) => r) {
+    return this.execute({
+      uri: uri2,
+      verb: HttpVerb.Patch,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Patch, options)
+    });
+  }
+  delete(uri2, options = RequestOptions.Json, transform, transformError = (r) => r) {
+    return this.execute({
+      uri: uri2,
+      verb: HttpVerb.Delete,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Delete, options)
+    });
+  }
+  options(verb, options) {
+    return options instanceof RequestOptions ? options : RequestOptions.Json;
+  }
+  execute(req) {
+    return this.store ? this.store.execute(req, () => this.provider.execute(req)) : this.provider.execute(req);
+  }
+};
+var api = new Api();
+
+// src/services/ApiGateway.ts
+var ApiGateway = class extends Gateway {
+  constructor(api2 = new Api()) {
+    super();
+    this.api = api2;
+  }
+  get(uri2, options) {
+    return this.api.get(uri2, options).then((r) => use(r.body.data, (d) => toPageList(d?.items, { total: d?.totalItems, ...d?.meta })));
+  }
+  getOne(uri2, options) {
+    return this.get(uri2, options).then((r) => r.first());
+  }
+  post(uri2, item, options) {
+    return this.api.post(uri2, item, options).then((r) => r.body.data?.items.first() ?? {});
+  }
+  postSearch(uri2, options) {
+    return this.api.post(uri2, options).then((r) => use(r.body.data, (d) => toPageList(d?.items, { total: d?.totalItems, ...d?.meta })));
+  }
+  patch(uri2, item, options) {
+    return this.api.patch(uri2, item, options).then((r) => r.body.data?.items.first() ?? {});
+  }
+  put(uri2, item, options) {
+    return this.api.put(uri2, item, options).then((r) => r.body.data?.items.first() ?? {});
+  }
+  delete(uri2, options) {
+    return this.api.delete(uri2, options).then(() => true);
+  }
+};
+
+// src/services/RouteGateway.ts
+var RouteGateway = class extends ApiGateway {
+  constructor(route2, routeId, api2 = new Api()) {
+    super(api2);
+    this.route = route2;
+    this.routeId = routeId;
+    this.api = api2;
+  }
+  all(options) {
+    return this.get(this.route(), options);
+  }
+  byId(id, options) {
+    return this.getOne(this.routeId().id(id));
+  }
+  byIds(...ids) {
+    return this.get(this.route().ids(toArray(...ids)));
+  }
+  search(q, options) {
+    return this.get(this.route().query(q), options);
+  }
+  exists(id, options) {
+    return this.get(this.routeId().id(id)).then((r) => r.length === 1).catch((r) => HttpStatus.NotFound.equals(r.status) ? false : Promise.reject(r));
+  }
+  add(item, options) {
+    return this.post(this.route(), item, options);
+  }
+  filter(options) {
+    return this.postSearch(this.route(), options);
+  }
+  update(item, options) {
+    return this.patch(this.routeId().id(item.id), item, options);
+  }
+  upsert(item, options) {
+    return this.put(this.routeId().id(item.id), item, options);
+  }
+  remove(id, options) {
+    return this.delete(this.routeId().id(id), options);
+  }
+};
+
+// src/services/MappedRouteGateway.ts
+var MappedRouteGateway = class extends RouteGateway {
+  constructor(route2, routeId, map = new Mapper(), api2 = new Api()) {
+    super(route2, routeId, api2);
+    this.route = route2;
+    this.routeId = routeId;
+    this.map = map;
+    this.api = api2;
+  }
+  get(uri2, options) {
+    return super.get(uri2, options).then((is) => is.map((i) => this.map.in(i)));
+  }
+  getOne(uri2, options) {
+    return super.get(uri2, options).then((is) => is.first()).then((i) => this.map.in(i));
+  }
+  add(item) {
+    return super.add(this.map.out(item));
+  }
+  update(item) {
+    return super.update(this.map.out(item));
+  }
+};
+
+// src/services/ViewRouteGateway.ts
+var ViewRouteGateway = class extends RouteGateway {
+  constructor(route2, routeId, views2 = {
+    in: view({}).fromSource,
+    out: view({}).fromSource
+  }, api2 = new Api()) {
+    super(route2, routeId, api2);
+    this.route = route2;
+    this.routeId = routeId;
+    this.views = views2;
+    this.api = api2;
+  }
+  get(uri2, options) {
+    return super.get(uri2, options).then((is) => is.map((i) => this.views.in.from(i)));
+  }
+  getOne(uri2, options) {
+    return super.get(uri2, options).then((is) => is.first()).then((i) => this.views.in.from(i));
+  }
+  add(item) {
+    return super.add(this.views.out.from(item));
+  }
+  update(item) {
+    return super.update(this.views.out.from(item));
+  }
+};
+
+// src/security/Jwt.ts
+var import_jsonwebtoken = require("jsonwebtoken");
+var Jwt = class _Jwt extends Value {
+  get isValid() {
+    return tryTo(() => ctx.env.get("tokenPublicKey") ?? "").map((key) => (0, import_jsonwebtoken.verify)(this.value, key)).map(() => true).orElse() ?? false;
+  }
+  static sign = (token, options) => tryTo(() => ctx.env.get("tokenPrivateKey") ?? "").is.not.empty().map(
+    (key) => (0, import_jsonwebtoken.sign)(token, key, {
+      ...options,
+      expiresIn: ctx.env.get("tokenExpiresIn") ?? "1h",
+      keyid: ctx.env.get("tokenKeyid") ?? "easy",
+      algorithm: ctx.env.get("tokenAlgorithm", "RS256")
+    })
+  ).map((s) => new _Jwt(s)).value;
+  static of = (a) => new _Jwt(a.jwt);
+  decode = () => (0, import_jsonwebtoken.decode)(this.value);
+  toJSON() {
+    return { jwt: this.value };
+  }
+};
+
+// src/sql/Clause.ts
+var quote = (a) => isNumber(a) || isBoolean(a) || isClause(a) ? a.toString() : `'${a}'`;
+var Clause = class {
+  constructor(first, operator, second) {
+    this.first = first;
+    this.operator = operator;
+    this.second = second;
+  }
+  and = (other) => new ParathesizedClause(this, "AND", other);
+  or = (other) => new ParathesizedClause(this, "OR", other);
+  toString() {
+    return `${this.first} ${this.operator} ${quote(this.second)}`;
+  }
+};
+var ParathesizedClause = class extends Clause {
+  toString() {
+    return `(${this.first} ${this.operator} ${quote(this.second)})`;
+  }
+};
+var toClause = (first, operator, second, conv = convert.default) => new Clause(first, operator, conv.from(second));
+var isClause = (c) => isA(c, "and", "or");
+
+// src/sql/Column.ts
+var Column = class extends Property {
+  constructor(owner, property, options) {
+    super(property, options);
+    this.owner = owner;
+  }
+  get count() {
+    return this.function("COUNT");
+  }
+  get max() {
+    return this.function("MAX");
+  }
+  get min() {
+    return this.function("MIN");
+  }
+  get sum() {
+    return this.function("SUM");
+  }
+  get average() {
+    return this.function("AVG");
+  }
+  get length() {
+    return this.function("LEN");
+  }
+  get asc() {
+    return this.format("$col ASC");
+  }
+  get desc() {
+    return this.format("$col DESC");
+  }
+  in = (source = {}) => tryTo(source).map((s) => s[this.property] ?? ofGet(this.options?.dflt)).map((v) => this.options?.convert?.to(v)).orElse();
+  out = (source = {}, key = "") => tryTo(source).map((s) => this.options?.convert?.from(s[key])).orElse();
+  function = (func) => this.format(`${func}($name)`);
+  format = (pattern) => new PatternColumn(this, pattern);
+  is = (value) => this.clause("=", value);
+  not = (value) => this.clause("<>", value);
+  like = (value) => this.clause("LIKE", `%${value}%`);
+  startsLike = (value) => this.clause("LIKE", `${value}%`);
+  endsLike = (value) => this.clause("LIKE", `%${value}`);
+  unlike = (value) => this.clause("NOT LIKE", `%${value}%`);
+  less = (value) => this.clause("<", value);
+  lessEqual = (value) => this.clause("<=", value);
+  greater = (value) => this.clause(">", value);
+  greaterEqual = (value) => this.clause(">=", value);
+  as = (as) => this.format(`$col AS ${as}`);
+  toString() {
+    return `${this.owner}.${this.property}`;
+  }
+  clause = (operator, value) => toClause(this, operator, value, this?.options?.convert);
+};
+var PatternColumn = class extends Column {
+  constructor(col, pattern) {
+    super(col.owner, col.property);
+    this.col = col;
+    this.pattern = pattern;
+  }
+  toString() {
+    return this.pattern.replace("$col", this.col.toString()).replace("$table", this.col.owner.toString).replace("$name", this.col.property);
+  }
+};
+var OrderColumn = class extends PatternColumn {
+};
+
+// src/sql/SqlQuery.ts
+var SqlQuery = class {
+  constructor(table, clauses = toList()) {
+    this.table = table;
+    this.clauses = clauses;
+  }
+  where = (...clauses) => {
+    this.clauses.add(clauses);
+    return this;
+  };
+};
+
+// src/sql/Delete.ts
+var Delete = class extends SqlQuery {
+  toString() {
+    return `DELETE FROM ${this.table}` + ifGet(this.clauses.length, ` WHERE ${this.clauses.join(" AND ")};`, ";");
+  }
+};
+
+// src/sql/Insert.ts
+var Insert = class extends SqlQuery {
+  constructor(table, fields) {
+    super(table);
+    this.table = table;
+    this.fields = fields;
+  }
+  toString() {
+    return `INSERT INTO ${this.table} (${Object.keys(this.fields).join(", ")}) OUTPUT INSERTED.* VALUES (${Object.values(this.fields).map((v) => quote(v)).join(", ")});`;
+  }
+};
+
+// src/sql/Join.ts
+var Join2 = class {
+  constructor(first, second, c, c2) {
+    this.first = first;
+    this.second = second;
+    this.c = c;
+    this.c2 = c2;
+    this.db = this.first.db;
+  }
+  db;
+  on(c, c2) {
+    this.c = c;
+    this.c2 = c2;
+    return this;
+  }
+  toString() {
+    return `${this.first} JOIN ${this.second} ON ${this.c} = ${this.c2}`;
+  }
+};
+
+// src/sql/Select.ts
+var Select = class extends SqlQuery {
+  constructor(table, columns = toList()) {
+    super(table);
+    this.columns = columns;
+  }
+  ordered = toList();
+  grouped = toList();
+  _top = 0;
+  _limit = 0;
+  _offset = 0;
+  from(t) {
+    this.table = t ?? this.table;
+    return this;
+  }
+  orderBy = (...ordered) => {
+    this.ordered.add(ordered);
+    return this;
+  };
+  groupBy(...grouped) {
+    this.grouped.add(grouped);
+    return this;
+  }
+  top(t) {
+    this._top = t;
+    return this;
+  }
+  limit(l) {
+    this._limit = l;
+    return this;
+  }
+  offset(o) {
+    this._offset = o;
+    return this;
+  }
+  toString() {
+    return `SELECT ` + ifGet(this._top, `TOP ${this._top} `, "") + ifGet(this.columns.length, this.columns.join(", "), "*") + ` FROM ${this.table}` + ifGet(this.clauses.length, ` WHERE ${this.clauses.join(" AND ")}`, "") + ifGet(this.grouped.length, ` GROUP BY ${this.grouped.join(", ")}`, "") + ifGet(this.ordered.length, ` ORDERED BY ${this.ordered.join(", ")}`, "") + ifGet(this._limit, ` LIMIT ${this._limit}`, "") + ifGet(this._offset, ` OFFSET ${this._offset};`, ";");
+  }
+};
+
+// src/sql/Update.ts
+var Update = class extends SqlQuery {
+  constructor(table, fields) {
+    super(table);
+    this.table = table;
+    this.fields = fields;
+  }
+  toString() {
+    return `UPDATE ${this.table} SET ${Object.entries(this.fields).map(([k, v]) => toClause(k, "=", v)).join(", ")} OUTPUT INSERTED.*` + ifGet(this.clauses.length, ` WHERE ${this.clauses.join(" AND ")};`, ";");
+  }
+};
+
+// src/sql/Count.ts
+var Count = class extends Select {
+  toString() {
+    return `SELECT COUNT(*)` + ifGet(this._top, ` TOP ${this._top}`, "") + ` FROM ${this.table}` + ifGet(this.clauses.length, ` WHERE ${this.clauses.join(" AND ")}`, "") + ifGet(this.grouped.length, ` GROUP BY ${this.grouped.join(", ")}`, "") + ";";
+  }
+};
+
+// src/sql/Table.ts
+var Table2 = class extends Mapper {
+  map = {
+    ...mappings,
+    column: (name2, options) => new Column(this, name2, options)
+  };
+  id = this.map.column("", { dflt: toUuid });
+  constructor(options = { startFrom: "source" }) {
+    super(options);
+  }
+  get db() {
+    return Database.Default;
+  }
+  get count() {
+    return new Count(this);
+  }
+  /**
+   * @deprecated Deprecated since version 6.2. Please use map.column instead.
+   */
+  prop = (name2, options) => this.map.column(name2, options);
+  select = (...columns) => new Select(this, toList(columns));
+  insert = (fields) => new Insert(this, this.out(fields));
+  update = (fields) => new Update(this, this.out(fields));
+  delete = () => new Delete(this, toList());
+  join = (t) => new Join2(this, t);
+};
+
+// src/sql/TableGateway.ts
+var TableGateway = class extends Gateway {
+  constructor(table, provider = table.db.provide()) {
+    super();
+    this.table = table;
+    this.provider = provider;
+  }
+  provide = ({ provider } = {}) => provider ?? this.provider;
+  all(options) {
+    return this.provide(options).query(this.table.select()).then(
+      (js) => toPageList(
+        js.map((j) => this.table.in(j)),
+        options
+      )
+    );
+  }
+  byId(id, options) {
+    return this.provide(options).query(this.table.select().where(this.table.id.is(id))).then((js) => js.first()).then((j) => ifDefined(j, this.table.in(j)));
+  }
+  exists(id, options) {
+    return this.byId(id).then((j) => isDefined(j));
+  }
+  add(item, options) {
+    return this.provide(options).query(this.table.insert(item)).then((js) => when(js.first()).not.isDefined.reject(`Could not add items with id ${item.id}`)).then((j) => this.table.in(j));
+  }
+  remove(id, options) {
+    return this.provide(options).command(this.table.delete().where(this.table.id.is(id))).then(() => true);
+  }
+  update(item, options) {
+    return this.provide(options).query(this.table.update(item).where(this.table.id.is(item.id))).then((js) => when(js.first()).not.isDefined.reject(`Could not update item with id ${item.id}`)).then((j) => this.table.in(j));
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./data"),
-  ...require("./domain"),
-  ...require("./http"),
-  ...require("./health"),
-  ...require("./process"),
-  ...require("./resources"),
-  ...require("./services"),
-  ...require("./security"),
-  ...require("./sql"),
-  ...require("./types"),
-  ...require("./utils"),
-  ...require("./validation")
+  Address,
+  Api,
+  ApiGateway,
+  App,
+  Audit,
+  AxiosProvider,
+  BaseContext,
+  BaseRequestContext,
+  Box,
+  CacheControl,
+  Child,
+  Clause,
+  Column,
+  Condition,
+  ContentType,
+  Context,
+  Convert,
+  Country,
+  Currency,
+  Database,
+  DateTime,
+  DefaultProvider,
+  Delete,
+  Dimension,
+  DotEnvContext,
+  EAN,
+  EasyUri,
+  Email,
+  Entity,
+  Enum,
+  Environment,
+  Exception,
+  Field,
+  Gateway,
+  HealthResource,
+  HealthUri,
+  HttpHeader,
+  HttpStatus,
+  HttpVerb,
+  IBAN,
+  InMemoryGateway,
+  Insert,
+  Join,
+  Jwt,
+  List,
+  Locale,
+  LogicalCondition,
+  Manage,
+  MappedRouteGateway,
+  Mapper,
+  Money,
+  Name,
+  OrderColumn,
+  OriginatedError,
+  PageList,
+  ParathesizedClause,
+  Parser,
+  PatternColumn,
+  PostalCode,
+  Property,
+  Repo,
+  Repository,
+  Req,
+  RequestOptions,
+  Requires,
+  Results,
+  RouteGateway,
+  Scope,
+  Search,
+  Select,
+  Sentence,
+  Service,
+  Slug,
+  SortCondition,
+  SqlQuery,
+  State,
+  Struct,
+  Table,
+  TableGateway,
+  Template,
+  ToText,
+  Try,
+  Typo,
+  UnitOfMeasurement,
+  UnitOfWeight,
+  Update,
+  Url,
+  UseCase,
+  Value,
+  View,
+  ViewRouteGateway,
+  Wait,
+  Weight,
+  When,
+  any,
+  api,
+  array,
+  asJson,
+  asList,
+  asNumber,
+  asPageList,
+  asResults,
+  asString,
+  asc,
+  base64,
+  build,
+  cache,
+  cacheAge,
+  choose,
+  constraint,
+  convert,
+  ctx,
+  days,
+  defined,
+  del,
+  desc,
+  dir,
+  dt,
+  email,
+  entries,
+  future,
+  get,
+  gt,
+  gte,
+  ifA,
+  ifDefined,
+  ifFalse,
+  ifGet,
+  ifNotEmpty,
+  ifTrue,
+  inFuture,
+  inList,
+  inOptionalList,
+  inPast,
+  includes,
+  isA,
+  isAddress,
+  isAn,
+  isArray,
+  isBoolean,
+  isClause,
+  isConstructor,
+  isDate,
+  isDateTime,
+  isDefined,
+  isDoesNotExist,
+  isEAN,
+  isEmail,
+  isEmpty,
+  isEmptyObject,
+  isEnum,
+  isEqual,
+  isError,
+  isException,
+  isFalsy,
+  isField,
+  isFunc,
+  isFunction,
+  isHttpStatus,
+  isIBAN,
+  isIn,
+  isInstance,
+  isIntersecting,
+  isIsoDateString,
+  isJson,
+  isList,
+  isLoading,
+  isMapping,
+  isMoney,
+  isNotEmpty,
+  isNotPresent,
+  isNullish,
+  isNumber,
+  isObject,
+  isOriginatedError,
+  isPageList,
+  isPresent,
+  isPrimitive,
+  isRequestOptions,
+  isResponse,
+  isRestResult,
+  isResult,
+  isResults,
+  isSimpleView,
+  isSortCondition,
+  isString,
+  isStruct,
+  isText,
+  isTrue,
+  isTruthy,
+  isUndefined,
+  isUrl,
+  isUuid,
+  isValid,
+  isValidatable,
+  isValue,
+  json,
+  kebab,
+  log,
+  lt,
+  lte,
+  mappings,
+  maxLength,
+  maxValue,
+  meta,
+  minLength,
+  minValue,
+  money,
+  name,
+  notEmpty,
+  ofConstruct,
+  ofGet,
+  ofMessage,
+  ofProperty,
+  on,
+  optional,
+  past,
+  patch,
+  post,
+  postalCode,
+  put,
+  quote,
+  reject,
+  replaceAll,
+  required,
+  requires,
+  resolve,
+  rest,
+  route,
+  routes,
+  rule,
+  search,
+  searchable,
+  singleton,
+  stream,
+  tag,
+  template,
+  text,
+  toArray,
+  toCacheOptions,
+  toClause,
+  toCondition,
+  toFilter,
+  toHttpStatus,
+  toId,
+  toJson,
+  toList,
+  toName,
+  toObject,
+  toOriginatedError,
+  toPageList,
+  toPageOptions,
+  toReq,
+  toResponse,
+  toResult,
+  toResults,
+  toSegment,
+  toShortFilter,
+  toSlug,
+  toUuid,
+  toVerbOptions,
+  toViewer,
+  toWords,
+  traverse,
+  tryTo,
+  tuple,
+  tuple2,
+  tuple3,
+  tuple4,
+  tuple5,
+  uri,
+  url,
+  use,
+  valid,
+  validate,
+  validateReject,
+  view,
+  views,
+  wait,
+  we,
+  weight,
+  when
 });
 //# sourceMappingURL=index.js.map