@thisisagile/easy 17.25.1 → 17.25.3

package/dist/index.mjs

@@ -1,116 +1,3477 @@
-export * from "./data/Condition";
-export * from "./data/InMemoryGateway";
-export * from "./data/Database";
-export * from "./data/DataProvider";
-export * from "./data/Field";
-export * from "./data/Query";
-export * from "./data/QueryProvider";
-export * from "./domain/Audit";
-export * from "./domain/Child";
-export * from "./domain/DateTime";
-export * from "./domain/Entity";
-export * from "./domain/Struct";
-export * from "./domain/Repo";
-export * from "./domain/Typo";
-export * from "./http/CacheControl";
-export * from "./http/ContentType";
-export * from "./http/HttpHeader";
-export * from "./http/HttpStatus";
-export * from "./http/HttpVerb";
-export * from "./http/Request";
-export * from "./http/RequestOptions";
-export * from "./http/RequestProvider";
-export * from "./http/Response";
-export * from "./http/RestResult";
-export * from "./http/toResponse";
-export * from "./process/App";
-export * from "./process/Manage";
-export * from "./process/Scope";
-export * from "./process/Search";
-export * from "./process/UseCase";
-export * from "./resources/Req";
-export * from "./security/Jwt";
-export * from "./services/Api";
-export * from "./services/ApiGateway";
-export * from "./services/AxiosProvider";
-export * from "./services/MappedRouteGateway";
-export * from "./services/RouteGateway";
-export * from "./services/ViewRouteGateway";
-export * from "./sql/Clause";
-export * from "./sql/Column";
-export * from "./sql/Delete";
-export * from "./sql/Insert";
-export * from "./sql/Join";
-export * from "./sql/SqlQuery";
-export * from "./sql/Select";
-export * from "./sql/Table";
-export * from "./sql/TableGateway";
-export * from "./sql/Update";
-export * from "./types/AnyKey";
-export * from "./types/Array";
-export * from "./types/Builder";
-export * from "./types/Cache";
-export * from "./types/CacheAge";
-export * from "./types/Case";
-export * from "./types/Constructor";
-export * from "./types/Context";
-export * from "./types/Currency";
-export * from "./types/Enum";
-export * from "./types/Environment";
-export * from "./types/ErrorOrigin";
-export * from "./types/Exception";
-export * from "./types/Falsy";
-export * from "./types/Func";
-export * from "./types/Gateway";
-export * from "./types/Get";
-export * from "./types/Id";
-export * from "./types/Identity";
-export * from "./types/IdName";
-export * from "./types/Indexed";
-export * from "./types/Is";
-export * from "./types/IsA";
-export * from "./types/IsDate";
-export * from "./types/IsEqual";
-export * from "./types/Json";
-export * from "./types/List";
-export * from "./types/Message";
-export * from "./types/Meta";
-export * from "./types/Nullish";
-export * from "./types/Number";
-export * from "./types/Object";
-export * from "./types/PageList";
-export * from "./types/Parser";
-export * from "./types/Primitive";
-export * from "./types/Repository";
-export * from "./types/Result";
-export * from "./types/Results";
-export * from "./types/Sort";
-export * from "./types/Tag";
-export * from "./types/Template";
-export * from "./types/Text";
-export * from "./types/Try";
-export * from "./types/TypeGuard";
-export * from "./types/Types";
-export * from "./types/Uri";
-export * from "./types/Uuid";
-export * from "./types/Validatable";
-export * from "./types/Value";
-export * from "./utils/Base64";
-export * from "./utils/Convert";
-export * from "./utils/If";
-export * from "./utils/Loading";
-export * from "./utils/Log";
-export * from "./utils/Mapper";
-export * from "./utils/Promise";
-export * from "./utils/Property";
-export * from "./utils/Seconds";
-export * from "./utils/State";
-export * from "./utils/Sentence";
-export * from "./utils/Traverse";
-export * from "./utils/View";
-export * from "./utils/Wait";
-export * from "./validation/Contraints";
-export * from "./validation/Validate";
-export * from "./validation/When";
-export * from "./types/ToText";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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/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 isIn = (o, values2) => isArray(values2) && values2.some((v) => v === o);
+var isIntersecting = (o, values2) => isArray(o) && isArray(values2) && o.some((ov) => isIn(ov, values2));
+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/Primitive.ts
+var isPrimitive = (v) => {
+  return v === null || v === void 0 || isIn(typeof v, ["string", "number", "bigint", "boolean", "symbol"]);
+};
+
+// src/types/Func.ts
+var isFunc = (o) => !!o && typeof o === "function";
+
+// src/types/Constructor.ts
+var isConstructor = (c) => (isDefined(c) && isFunc(c) && c.prototype && c.prototype.constructor) === c;
+var isInstance = (ctor, o) => isFunction(ctor) && o instanceof ctor;
+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 isPromise = (value) => {
+  return value instanceof Promise;
+};
+var on = (t, f) => {
+  const result = f(t);
+  return isPromise(result) ? result.then(() => t) : 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/IsA.ts
+var isA = (t, ...properties) => !isPrimitive(t) && properties.every((p) => p.toString() in t);
+var isAn = isA;
+var isIdentity = (by) => use(by, (b) => isObject(b) && isDefined(b.id));
+
+// 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/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;
+  },
+  chunk: (items = [], length = 2) => {
+    const chunks = Math.ceil(items.length / length);
+    const res = Array.from({ length: chunks }, () => []);
+    items.forEach((i, index) => res[Math.floor(index / chunks)].push(i));
+    return res;
+  }
+};
+
+// 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, search, replace = "") => asString(origin).split(asString(search)).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 capitalize = (s = "") => s.charAt(0).toUpperCase() + s.slice(1);
+
+// src/utils/Traverse.ts
+var traverse = (subject, property = "") => {
+  subject ??= {};
+  const props = property.split(".");
+  const p = props.shift();
+  return props.length === 0 ? subject[p] : traverse(subject[p], props.join("."));
+};
+var traverseSet = (subject, property, value) => {
+  const props = property.split(".");
+  const p = props.shift();
+  return {
+    ...subject,
+    [p]: props.length === 0 ? value : traverseSet(subject[p], props.join("."), value)
+  };
+};
+var accumulate = (items, ...keys2) => items.map((t, i, arr) => {
+  const acc = keys2.reduce(
+    (acc2, v) => traverseSet(acc2, v, i === 0 ? traverse(t, v) : traverse(arr[i - 1], v) + traverse(t, v)),
+    t
+  );
+  arr[i] = acc;
+  return acc;
+});
+
+// src/types/List.ts
+var List = class extends Array {
+  get ids() {
+    return this.mapDefined((i) => i.id);
+  }
+  get indexed() {
+    return this.map((v, index) => ({ ...v, index }));
+  }
+  isSubSetOf(...items) {
+    return this.diff(items).length === 0;
+  }
+  isSuperSetOf(...items) {
+    return this.length > items.length && toList(...items).isSubSetOf(...this);
+  }
+  isIntersectingWith(...items) {
+    return this.intersect(items).length > 0;
+  }
+  isDisjointWith(...items) {
+    return !this.isIntersectingWith(...items);
+  }
+  areEqual(...items) {
+    return this.isSubSetOf(...items) && toList(...items).isSubSetOf(...this);
+  }
+  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 ifDefined(
+      this.first((t) => !!f(t)),
+      f,
+      (v) => ofGet(alt, v)
+    );
+  }
+  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]));
+  }
+  intersectBy(others, f) {
+    return this.filter((i) => others.some((o) => f(i, o)));
+  }
+  accumulate(...keys2) {
+    return this.map((d, i, arr) => {
+      const acc = keys2.reduce((acc2, v) => {
+        acc2[v] = i === 0 ? d[v] : arr[i - 1][v] + d[v];
+        return acc2;
+      }, d);
+      arr[i] = acc;
+      return acc;
+    });
+  }
+  toJSON() {
+    return this.reduce((a, i) => {
+      a.push(JSON.parse(JSON.stringify(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));
+  }
+  mapSerial(f) {
+    return super.reduce((p, item) => p.then((results) => on(results, async (r) => r.push(await f(item)))), Promise.resolve(toList()));
+  }
+  distinct() {
+    return this.filter((i, index) => this.indexOf(i) === index);
+  }
+  distinctByKey(key) {
+    const seen = /* @__PURE__ */ new Set();
+    return this.filter((item) => !seen.has(item[key]) && seen.add(item[key]));
+  }
+  distinctByValue() {
+    const seen = /* @__PURE__ */ new Set();
+    return this.filter((item) => !seen.has(JSON.stringify(item)) && seen.add(JSON.stringify(item)));
+  }
+  filter(p, params) {
+    return toList(super.filter(p, params));
+  }
+  sum(p) {
+    return this.reduce((sum, i) => sum + p(i), 0);
+  }
+  max(p) {
+    return typeof p === "function" ? this.sort((e1, e2) => p(e1) < p(e2) ? 1 : -1).first() : this.desc(p).first();
+  }
+  min(p) {
+    return typeof p === "function" ? this.sort((e1, e2) => p(e1) > p(e2) ? 1 : -1).first() : this.asc(p).first();
+  }
+  byId(id) {
+    return this.first((i) => asString(i.id) === asString(id));
+  }
+  byKey(key, value) {
+    return this.first((i) => i[key] == value);
+  }
+  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) {
+    const index = this.findIndex((i) => i[key] === item?.[key]);
+    ifTrue(index != -1, () => this.splice(index, 1, item));
+    return this;
+  }
+  switch(item) {
+    return this.includes(item) ? this.remove(item) : this.add(item);
+  }
+  switchOn(item, on2) {
+    return use(
+      typeof on2 === "function" ? this.find(on2) : use(traverse(item, on2), (v) => this.find((i) => traverse(i, on2) === v)),
+      (i) => i ? this.remove(i) : 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());
+  }
+  //we needed to add U because of a Typescript issue with generics
+  update(p, val) {
+    return this.map((v, i, a) => p(v, i, a) ? ofGet(val, v, i, a) : v);
+  }
+  updateFirst(p, val) {
+    const index = this.findIndex(p);
+    return this.update((t, i) => p(t, i, this) && i == index, val);
+  }
+  updateFirstById(id, val) {
+    return this.updateFirst((i) => asString(i?.id) === asString(id), val);
+  }
+  updateById(id, val) {
+    return this.update((i) => asString(i?.id) === asString(id), val);
+  }
+};
+var toList = (...items) => new List().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/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);
+}
+function ifEither(os, f = (o) => o, alt) {
+  return use(
+    toList(os).first((o) => isPresent(o)),
+    (o) => isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt, o)
+  );
+}
+
+// src/types/Object.ts
+function entries(subject) {
+  return ifDefined(
+    subject,
+    () => toList([...Object.entries(subject), ...Object.entries(Object.getPrototypeOf(subject))]),
+    () => toList()
+  );
+}
+function values(subject) {
+  return toList([...Object.values(subject), ...Object.values(Object.getPrototypeOf(subject))]);
+}
+function keys(subject) {
+  return toList([...Object.keys(subject), ...Object.keys(Object.getPrototypeOf(subject))]);
+}
+function extractKeys(obj, keys2) {
+  return keys2.filter((k) => k in obj).reduce(
+    (acc, key) => {
+      acc.keys[key] = obj[key];
+      delete acc[key];
+      return acc;
+    },
+    { keys: {}, ...obj }
+  );
+}
+
+// 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, ...keys2) => keys2.reduce((js, k) => json.delete(js, k), json.parse(subject)),
+  pick: (subject, ...keys2) => keys2.reduce((js, k) => json.set(js, k, subject[k]), {}),
+  defaults: (options = {}, defaults = {}) => json.merge(defaults, options),
+  isSubset: (subject, subset) => !entries(subset).some(([k, v]) => subject[k] !== v),
+  split: (t, keys2, prop = "extracted") => {
+    const extracted = {};
+    const rest2 = { ...t };
+    keys2.forEach((key) => {
+      if (key in t) {
+        ifDefined(t[key], (v) => extracted[key] = v);
+        delete rest2[key];
+      }
+    });
+    return { [prop]: extracted, ...rest2 };
+  }
+};
+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 = (...keys2) => any(json.omit(this.value, ...keys2));
+  set = (key, value) => any(json.set(this.value, key, value));
+  toJSON() {
+    return this.value;
+  }
+};
+var takeFirstKey = (j, alt = "") => entries(asJson(j)).first(([, v]) => isDefined(v))?.[0] ?? alt;
+var any = (value) => new Any(value);
+
+// 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/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/types/Meta.ts
+import "reflect-metadata";
+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 = () => entries(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 = () => values(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 ?? {});
+
+// src/types/Enum.ts
+var isEnumConstructor = (c) => isFunction(c) && c.isEnum;
+var Enum = class {
+  constructor(name, id = name.toLowerCase(), code = id.toString()) {
+    this.name = name;
+    this.id = id;
+    this.code = code;
+  }
+  static isEnum = true;
+  get isValid() {
+    return isDefined(this.id);
+  }
+  static all() {
+    return meta(this.allTuple()).values();
+  }
+  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);
+  }
+  static allTuple() {
+    return meta(this).get(`all-${this.name}`) ?? meta(this).set(`all-${this.name}`, meta(this).values().filter(isEnum).toObject("id"));
+  }
+  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/Template.ts
+var Template = class {
+  constructor(template2, subject = {}, options = {}) {
+    this.template = template2;
+    this.subject = subject;
+    this.options = options;
+  }
+  toString = () => {
+    return entries(this.options).reduce((t, [k]) => this.option(t, k), this.object()).replace("  ", " ");
+  };
+  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}}`, textValue(this.subject, p.replace("this.", ""))), this.template);
+  };
+  option = (tmpl, prop) => {
+    return this.props(tmpl, prop).reduce((t, p) => t.replace(`{${p}}`, textValue(this.options, p)), tmpl);
+  };
+};
+function template(tmpl, subject, options = {}) {
+  return new Template(asString(tmpl), subject, {
+    type: toName(subject),
+    subject: text(JSON.stringify(subject)),
+    ...options
+  });
+}
+
+// src/types/ToText.ts
+var ToText = class {
+  constructor(subject) {
+    this.subject = subject;
+  }
+  get cap() {
+    return this.map((s) => capitalize(s?.toLowerCase()));
+  }
+  get capFirst() {
+    return this.map((s) => capitalize(s));
+  }
+  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 trimSentence() {
+    return this.map(
+      (s) => s.replace(/[\u200B-\u200D\uFEFF]/g, "").replace(/[\s\u00A0]+/g, " ").replace(/\s+([.,;:!?])/g, "$1").trim()
+    );
+  }
+  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 = (search, replace) => this.map((s) => replaceAll(s, search, 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)
+  );
+  split = (separator = " ") => toList(this.subject.split(separator));
+  toString() {
+    return this.subject;
+  }
+  toJSON() {
+    return this.subject;
+  }
+};
+function text(subject, alt = "") {
+  const sub = subject ? asString(subject) : alt;
+  return new ToText(sub !== "[object Object]" ? sub : "");
+}
+function textValue(subject, prop) {
+  const p = prop.split(".");
+  const root = subject?.[p[0]];
+  const initial = typeof root === "object" && root !== null ? root : text(root);
+  return p.splice(1).reduce((t, s) => t?.[s], initial)?.toString() ?? "";
+}
+
+// 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/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),
+  settled: (list) => Promise.allSettled([...list]).then((rs) => ({
+    fulfilled: toList(...rs.filter((r) => r.status === "fulfilled").map((r) => r.value)),
+    rejected: toList(...rs.filter((r) => r.status === "rejected").map((r) => asString(r.reason)))
+  })),
+  object: (obj) => use(keys(obj), (ks) => tuple.list(values(obj)).then((vs) => vs.reduce((acc, v, i) => on(acc, (a) => a[ks[i]] = v), {})))
+};
+var tuple2 = tuple[2];
+var tuple3 = tuple[3];
+var tuple4 = tuple[4];
+var tuple5 = tuple[5];
+var tupleO = tuple.object;
+var settled = tuple.settled;
+
+// 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/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/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) => {
+    const k = text(key).map((k2) => k2.replace(/([a-z])([A-Z])/g, "$1 $2")).snake.toString();
+    return process.env[k] ?? alt;
+  };
+};
+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/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 Results = 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 Results(...r);
+var isResults = (r) => isDefined(r) && r instanceof Results;
+
+// 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/types/Validatable.ts
+var isValidatable = (v) => isA(v, "isValid");
+
+// 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) => {
+  try {
+    const actual = isFunction(subject[v.property]) ? subject[v.property]() : subject[v.property];
+    const constraint2 = v.constraint(actual);
+    return isResults(constraint2) ? constraint2 : !constraint2 ? asResults(subject, v.text, {
+      ...v,
+      actual
+    }) : toResults();
+  } catch (e) {
+    return asResults(subject, asString(e));
+  }
+};
+var constraints = (subject) => validators(subject).map((vs) => runValidator(vs, subject)).reduce((rs, r) => rs.add(...r.results), toResults());
+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/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/Case.ts
+var CaseBuilder = class {
+  constructor(v) {
+    this.v = v;
+  }
+  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),
+    in: (prop, out) => new Case(this.v).case(ofGet(prop, this.v).includes(this.v), 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),
+      in: (prop, out) => new Case(this.v).case(!ofGet(prop, this.v).includes(this.v), out)
+    }
+  };
+  if = this.is;
+  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);
+  }
+};
+var Case = class _Case {
+  constructor(value, outcome) {
+    this.value = value;
+    this.outcome = outcome;
+  }
+  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),
+    in: (prop, out) => new _Case(this.value).case(ofGet(prop, this.value).includes(this.value), 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),
+      in: (prop, out) => new _Case(this.value).case(!ofGet(prop, this.value).includes(this.value), out)
+    }
+  };
+  if = this.is;
+  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);
+  }
+  else(alt) {
+    return ofGet(alt, this.value);
+  }
+};
+var Found = class extends Case {
+  constructor(value, outcome) {
+    super(value, outcome);
+    this.value = value;
+    this.outcome = outcome;
+  }
+  is = {
+    defined: (_prop, _out) => this,
+    empty: (_prop, _out) => this,
+    valid: (_prop, _out) => this,
+    in: (_prop, _out) => this,
+    not: {
+      defined: (_prop, _out) => this,
+      empty: (_prop, _out) => this,
+      valid: (_prop, _out) => this,
+      in: (_prop, _out) => this
+    }
+  };
+  if = this.is;
+  case(pred, out) {
+    return this;
+  }
+  type(guard, out) {
+    return this;
+  }
+  equals(value, out) {
+    return this;
+  }
+  else(alt) {
+    return this.outcome;
+  }
+};
+var choose = (value) => new CaseBuilder(value);
+
+// src/types/PageList.ts
+var toFilter = (field, value) => toShortFilter(field, field, value);
+var toShortFilter = (field, shortField, value) => ({
+  field,
+  shortField,
+  values: [{ value }]
+});
+var PageList = class extends List {
+  _options;
+  get options() {
+    return this._options;
+  }
+  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 ids() {
+    return this.mapDefined((i) => i.id);
+  }
+  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);
+  }
+  symmetricDiff(others) {
+    return toPageList(super.symmetricDiff(others), this);
+  }
+  symmetricDiffByKey(others, key) {
+    return toPageList(super.symmetricDiffByKey(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));
+  }
+  areEqual(...items) {
+    return this.isSubSetOf(...items) && toList(...items).isSubSetOf(...this);
+  }
+  distinct() {
+    return toPageList(super.distinct(), this);
+  }
+  distinctByKey(key) {
+    return toPageList(super.distinctByKey(key), this);
+  }
+  distinctByValue() {
+    return toPageList(super.distinctByValue(), this);
+  }
+  filter(p, params) {
+    return toPageList(super.filter(p, params), this);
+  }
+  accumulate(...keys2) {
+    return toPageList(super.accumulate(...keys2), 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);
+  }
+  //we needed to add U because of a Typescript issue with generics
+  update(p, val) {
+    return toPageList(super.update(p, val), this);
+  }
+  updateFirst(p, val) {
+    return toPageList(super.updateFirst(p, val), this);
+  }
+  updateFirstById(id, val) {
+    return toPageList(super.updateFirstById(id, val), this);
+  }
+  updateById(id, val) {
+    return toPageList(super.updateById(id, val), this);
+  }
+  setPageOptions(options) {
+    this._options = options;
+    return this;
+  }
+};
+var isPageList = (l) => isList(l) && isA(l, "total");
+var toPageList = (items = [], options) => {
+  return choose(items).case(
+    (i) => i.length === 1 && isNumber(i[0]),
+    (i) => new PageList().add(...i)
+  ).else((i) => new PageList(...i)).setPageOptions(isPageList(options) ? options.options : options);
+};
+var asPageList = (c, items = toPageList()) => items.map((i) => ofConstruct(c, i));
+
+// 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(name, provider, options) {
+    super(name);
+    this.provider = provider;
+    this.options = options;
+  }
+  static Default = new _Database("Default", DefaultProvider);
+  provide = () => ofConstruct(this.provider, this);
+};
+
+// 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/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/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/DateTime.ts
+import { DateTime as LuxonDateTime, Settings } from "luxon";
+
+// 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/utils/Seconds.ts
+var seconds = {
+  toDuration: (s) => {
+    const seconds2 = s % 60;
+    const minutes = Math.floor(s / 60) % 60;
+    const hours = Math.floor(s / 3600) % 24;
+    const days2 = Math.floor(s / 86400);
+    return { days: days2, hours, minutes, seconds: seconds2 };
+  },
+  toText: (s) => {
+    const { days: days2, hours, minutes, seconds: secs } = seconds.toDuration(s);
+    return toList(ifTrue(days2, `${days2}d`), ifTrue(hours, `${hours}h`), ifTrue(minutes, `${minutes}m`), ifTrue(days2 + hours + minutes === 0, `${secs}s`)).mapDefined((s2) => s2).join(" ");
+  }
+};
+
+// src/domain/DateTime.ts
+Settings.defaultZone = "utc";
+var DateTime = class _DateTime extends Value {
+  luxon;
+  constructor(value, format) {
+    const luxon = choose(value).type(isString, (v) => format ? LuxonDateTime.fromFormat(v, format, { setZone: true }) : LuxonDateTime.fromISO(v, { setZone: true })).type(isNumber, (v) => LuxonDateTime.fromMillis(v)).type(isDate, (v) => LuxonDateTime.fromJSDate(v)).type(isDateTime, (v) => v.luxon).else(value instanceof LuxonDateTime ? value : LuxonDateTime.fromISO(void 0));
+    super(luxon.toISO() ?? void 0);
+    this.luxon = luxon;
+  }
+  static get now() {
+    return new _DateTime(LuxonDateTime.utc());
+  }
+  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 inAmsterdam() {
+    return this.withZone("Europe/Amsterdam");
+  }
+  get inNewYork() {
+    return this.withZone("America/New_York");
+  }
+  get inLondon() {
+    return this.withZone("Europe/London");
+  }
+  get inWarsaw() {
+    return this.withZone("Europe/Warsaw");
+  }
+  get utc() {
+    return this.luxon.setZone("utc");
+  }
+  from(dateOrLocale, maybeLocale) {
+    return use(
+      (isString(dateOrLocale) ? dateOrLocale : maybeLocale) ?? "en",
+      (locale) => ifDefined(
+        isA(dateOrLocale) ? dateOrLocale : void 0,
+        (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 = "day") {
+    return new _DateTime(this.luxon.plus(isNumber(n) ? { [unit]: n } : n));
+  }
+  subtract(n, unit = "day") {
+    return new _DateTime(this.luxon.minus(isNumber(n) ? { [unit]: n } : n));
+  }
+  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));
+  }
+  endOf(unit = "day") {
+    return new _DateTime(this.luxon.endOf(unit));
+  }
+  isWeekend() {
+    return this.luxon.isWeekend;
+  }
+  withZone(zone) {
+    return new _DateTime(this.luxon.setZone(zone));
+  }
+  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;
+  }
+  toEpoch() {
+    return this.luxon.toMillis();
+  }
+  ago(end = _DateTime.now) {
+    return seconds.toText(end.diff(this, "second"));
+  }
+  withClock(clock) {
+    return tryTo(() => [this.toDate(), clock.toDate()]).map(([td, cd]) => new Date(td.getFullYear(), td.getMonth(), td.getDate(), cd.getHours(), cd.getMinutes(), cd.getSeconds())).map((d) => new _DateTime(d)).value;
+  }
+};
+var isDateTime = (dt2) => isDefined(dt2) && dt2 instanceof DateTime;
+var dt = (dt2) => new DateTime(dt2);
+
+// 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 optional = () => 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 = (values2, message) => constraint((v) => isDefined(v) && isIn(v, values2), message ?? "Value {actual} must appear in list.");
+var inOptionalList = (values2, message) => constraint((v) => !isDefined(v) || isIn(v, values2), 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/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(json3) {
+    super(
+      choose(json3).is.defined(
+        (j) => j,
+        (j) => j
+      ).else({
+        by: isIdentity(ctx.request?.identity) ? ctx.request?.identity : { id: 0, user: "easy" },
+        when: DateTime.now.toJSON()
+      })
+    );
+  }
+};
+__decorateClass([
+  required()
+], Audit.prototype, "by", 2);
+__decorateClass([
+  valid()
+], Audit.prototype, "when", 2);
+
+// src/types/Uuid.ts
+import { v4 as uuid } from "uuid";
+var toUuid = () => 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 includeUuid = new RegExp(/\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/i);
+var includesUuid = (value) => includeUuid.test(asString(value));
+
+// src/types/Id.ts
+var toId = () => toUuid();
+
+// 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/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, json3) {
+    return reject(Exception.IsNotImplemented);
+  }
+  remove(id) {
+    return reject(Exception.IsNotImplemented);
+  }
+  upsert(id, item) {
+    return reject(Exception.IsNotImplemented);
+  }
+};
+
+// 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, json3) {
+    return this.gateway.byId(id).then((j) => when(j).not.isDefined.reject(Exception.DoesNotExist)).then((j) => new this.ctor(j).update(json3)).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);
+  }
+};
+var Agent = class extends Repository {
+  constructor(gateway) {
+    super();
+    this.gateway = gateway;
+  }
+  all(options) {
+    return this.gateway.all(options);
+  }
+  byId(id) {
+    return this.gateway.byId(id);
+  }
+  byIds(...ids) {
+    return this.gateway.byIds(...ids);
+  }
+  byKey(key, options) {
+    return this.gateway.by("key", key, options);
+  }
+  by(key, value, options) {
+    return this.gateway.by(key.toString(), value, options);
+  }
+  search(q, options) {
+    return this.gateway.search(q, options);
+  }
+  filter(options) {
+    return this.gateway.filter(options);
+  }
+  exists(id) {
+    return this.gateway.exists(id);
+  }
+  add(t) {
+    return this.gateway.add(toJson(t));
+  }
+  update(id, t) {
+    return this.gateway.update({ ...toJson(t), id });
+  }
+  upsert(id, t) {
+    return this.gateway.upsert({ ...toJson(t), id });
+  }
+  remove(id) {
+    return this.gateway.remove(id);
+  }
+};
+
+// 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/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)
+};
+var isCacheAge = (ca) => isString(ca) || isNumber(ca);
+
+// 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, isCacheAge(v) ? `${k}=${cacheAge.toSeconds(v)}` : k)).join(",");
+  }
+};
+
+// src/http/ContentType.ts
+import formUrlEncoded from "form-urlencoded";
+var ContentType = class _ContentType extends Enum {
+  constructor(name, type, encoder = (b) => asString(b)) {
+    super(name, type);
+    this.type = type;
+    this.encoder = encoder;
+  }
+  static Form = new _ContentType("form", "application/x-www-form-urlencoded", (b) => formUrlEncoded(b));
+  static Json = new _ContentType("json", "application/json", (b) => b);
+  static RawJson = new _ContentType("rawJson", "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(name) {
+    super(name, name.toLowerCase(), name.toUpperCase());
+  }
+};
+
+// 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/Response.ts
+var isResponse = (r) => isA(r, "status", "body");
+
+// 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/toResponse.ts
+function toResponse(status, body, headers) {
+  return {
+    status: toHttpStatus(status),
+    headers,
+    body: rest.to(body)
+  };
+}
+
+// src/process/Scope.ts
+var Scope = class _Scope extends Enum {
+  constructor(name, id = text(name).kebab, subs = toList()) {
+    super(name, id.toString());
+    this.name = name;
+    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(name) {
+    super(name);
+  }
+  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(json3) {
+    return this.repo.add(json3);
+  }
+  update(id, json3) {
+    return this.repo.update(id, json3);
+  }
+  upsert(id, json3) {
+    return this.repo.upsert(id, json3);
+  }
+  remove(id) {
+    return this.repo.remove(id);
+  }
+};
+
+// src/process/UseCase.ts
+var UseCase = class _UseCase extends Enum {
+  constructor(app, name, id = text(name).kebab, scopes = toList()) {
+    super(name, id.toString());
+    this.app = app;
+    this.scopes = scopes;
+  }
+  static byScopes(...s) {
+    return this.filter((u) => u.scopes.some((us) => isIn(us, s)));
+  }
+  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))
+    );
+  }
+};
+
+// 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);
+}
+
+// ../../node_modules/jwt-decode/build/esm/index.js
+var InvalidTokenError = class extends Error {
+};
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+    let code = p.charCodeAt(0).toString(16).toUpperCase();
+    if (code.length < 2) {
+      code = "0" + code;
+    }
+    return "%" + code;
+  }));
+}
+function base64UrlDecode(str) {
+  let output = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (output.length % 4) {
+    case 0:
+      break;
+    case 2:
+      output += "==";
+      break;
+    case 3:
+      output += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+  try {
+    return b64DecodeUnicode(output);
+  } catch (err) {
+    return atob(output);
+  }
+}
+function jwtDecode(token, options) {
+  if (typeof token !== "string") {
+    throw new InvalidTokenError("Invalid token specified: must be a string");
+  }
+  options || (options = {});
+  const pos = options.header === true ? 0 : 1;
+  const part = token.split(".")[pos];
+  if (typeof part !== "string") {
+    throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+  }
+  let decoded;
+  try {
+    decoded = base64UrlDecode(part);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+  }
+  try {
+    return JSON.parse(decoded);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+  }
+}
+
+// src/security/Jwt.ts
+var Jwt = class _Jwt extends Value {
+  static of = (a) => new _Jwt(a.jwt);
+  decode = () => jwtDecode(this.value);
+  toJSON() {
+    return { jwt: this.value };
+  }
+};
+
+// src/services/AxiosProvider.ts
+import axios from "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 = axios) {
+    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(route, routeId, api2 = new Api()) {
+    super(api2);
+    this.route = route;
+    this.routeId = routeId;
+    this.api = api2;
+  }
+  all(options) {
+    return this.get(this.route().expand(options ?? {}), options);
+  }
+  byId(id) {
+    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().expand({ ...options, q }));
+  }
+  exists(id) {
+    return this.byId(id).then((r) => isDefined(r)).catch((r) => HttpStatus.NotFound.equals(r.status) ? false : Promise.reject(r));
+  }
+  add(item) {
+    return this.post(this.route(), item);
+  }
+  filter(options) {
+    return this.postSearch(this.route().expand(options ?? {}));
+  }
+  update(item) {
+    return this.patch(this.routeId().id(item.id), item);
+  }
+  upsert(item) {
+    return this.put(this.routeId().id(item.id), item);
+  }
+  remove(id) {
+    return this.delete(this.routeId().id(id));
+  }
+};
+
+// 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/services/MappedRouteGateway.ts
+var MappedRouteGateway = class extends RouteGateway {
+  constructor(route, routeId, map = new Mapper(), api2 = new Api()) {
+    super(route, routeId, api2);
+    this.route = route;
+    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/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/utils/View.ts
+var ignore = Symbol("view.ignore");
+var keep = Symbol("view.keep");
+var json2 = Symbol("view.json");
+var spread = "view.spread";
+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) }).equals(json2, { key, f: (a) => asJson(traverse(a, key)) }).type(isString, (s) => ({ key, f: (a) => traverse(a, s) })).type(isEnumConstructor, (c) => ({
+  key,
+  f: (a, key2) => use(traverse(a, key2), (v) => isArray(v) ? c.byIds(v) : c.byId(v))
+})).type(isConstructor, (c) => ({
+  key,
+  f: (a, key2) => use(traverse(a, key2), (v) => isArray(v) ? v.map((i) => optional2(c, i)) : optional2(c, v))
+})).type(isSimpleView, (f) => ({ key, f: (a) => ifDefined(traverse(a, key), (v) => f.from(v)) })).type(isFunction, (f) => ({ key, f })).else((v) => ({ key, f: () => v }));
+var optional2 = (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.options
+      );
+    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) => v.key === spread ? { ...acc, ...asJson(v.f(src, v.key)) } : 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,
+  json: json2,
+  spread,
+  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/services/ViewRouteGateway.ts
+var ViewRouteGateway = class extends RouteGateway {
+  constructor(route, routeId, views2 = {
+    in: view({}).fromSource,
+    out: view({}).fromSource
+  }, api2 = new Api()) {
+    super(route, routeId, api2);
+    this.route = route;
+    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/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 Join = 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 Table = class extends Mapper {
+  map = {
+    ...mappings,
+    column: (name, options) => new Column(this, name, 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 = (name, options) => this.map.column(name, 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 Join(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));
+  }
+};
+
+// 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/Currency.ts
+var isCurrency = (c) => isA(c, "id", "name", "digits", "code");
+
+// src/types/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/types/Falsy.ts
+var isFalsy = (v) => !v;
+var isTruthy = (v) => !isFalsy(v);
+
+// src/types/Indexed.ts
+var isIndexed = (u) => isA(u, "index");
+
+// src/types/Message.ts
+var ofMessage = (g, ...params) => isFunc(g) ? g(...params) : g;
+
+// src/types/Nullish.ts
+var isNullish = (v) => v == null;
+
+// 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/Sort.ts
+var asc = 1;
+var desc = -1;
+
+// src/types/Tag.ts
+var tag = (name) => (subject, property) => {
+  meta(subject).property(property).set(name, 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((route) => ({
+      route,
+      query: this.props.mapDefined((p) => p.segment?.query ? p.segment?.query(p.value) : void 0)?.join("&")
+    })).map(({ route, query }) => isNotEmpty(query) ? `${route}?${query}` : route).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);
+  }
+};
+var clipUri = (uri2) => tryTo(() => asString(uri2)).map((uri3) => uri3.replace(/^(https?:\/\/)?(www\.)?/, "")).map((uri3) => uri3.replace(/\/$/, "")).value;
+
+// 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/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/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/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);
+export {
+  Agent,
+  Api,
+  ApiGateway,
+  App,
+  Audit,
+  AxiosProvider,
+  BaseContext,
+  BaseRequestContext,
+  CacheControl,
+  Child,
+  Clause,
+  Column,
+  Condition,
+  ContentType,
+  Context,
+  Convert,
+  Database,
+  DateTime,
+  DefaultProvider,
+  Delete,
+  DotEnvContext,
+  EasyUri,
+  Entity,
+  Enum,
+  Environment,
+  Exception,
+  Field,
+  Gateway,
+  HttpHeader,
+  HttpStatus,
+  HttpVerb,
+  InMemoryGateway,
+  Insert,
+  Join,
+  Jwt,
+  List,
+  LogicalCondition,
+  Manage,
+  MappedRouteGateway,
+  Mapper,
+  OrderColumn,
+  PageList,
+  ParathesizedClause,
+  Parser,
+  PatternColumn,
+  Property,
+  Repo,
+  Repository,
+  Req,
+  RequestOptions,
+  Results,
+  RouteGateway,
+  Scope,
+  Search,
+  Select,
+  Sentence,
+  SortCondition,
+  SqlQuery,
+  State,
+  Struct,
+  Table,
+  TableGateway,
+  Template,
+  ToText,
+  Try,
+  Typo,
+  Update,
+  UseCase,
+  Value,
+  View,
+  ViewRouteGateway,
+  Wait,
+  When,
+  accumulate,
+  any,
+  api,
+  array,
+  asJson,
+  asList,
+  asNumber,
+  asPageList,
+  asResults,
+  asString,
+  asc,
+  base64,
+  build,
+  cache,
+  cacheAge,
+  capitalize,
+  choose,
+  clipUri,
+  constraint,
+  convert,
+  ctx,
+  days,
+  defined,
+  desc,
+  dir,
+  dt,
+  entries,
+  extractKeys,
+  future,
+  gt,
+  gte,
+  ifA,
+  ifDefined,
+  ifEither,
+  ifFalse,
+  ifGet,
+  ifNotEmpty,
+  ifTrue,
+  inFuture,
+  inList,
+  inOptionalList,
+  inPast,
+  includes,
+  includesUuid,
+  isA,
+  isAn,
+  isArray,
+  isBoolean,
+  isCacheAge,
+  isClause,
+  isConstructor,
+  isCurrency,
+  isDate,
+  isDateTime,
+  isDefined,
+  isDoesNotExist,
+  isEmpty,
+  isEmptyObject,
+  isEnum,
+  isEnumConstructor,
+  isEqual,
+  isError,
+  isException,
+  isFalsy,
+  isField,
+  isFunc,
+  isFunction,
+  isHttpStatus,
+  isIdentity,
+  isIn,
+  isIndexed,
+  isInstance,
+  isIntersecting,
+  isIsoDateString,
+  isJson,
+  isList,
+  isLoading,
+  isMapping,
+  isNotEmpty,
+  isNotPresent,
+  isNullish,
+  isNumber,
+  isObject,
+  isPageList,
+  isPresent,
+  isPrimitive,
+  isRequestOptions,
+  isResponse,
+  isRestResult,
+  isResult,
+  isResults,
+  isSimpleView,
+  isSortCondition,
+  isString,
+  isStruct,
+  isText,
+  isTrue,
+  isTruthy,
+  isUndefined,
+  isUuid,
+  isValid,
+  isValidatable,
+  isValue,
+  json,
+  kebab,
+  keys,
+  log,
+  lt,
+  lte,
+  mappings,
+  maxLength,
+  maxValue,
+  meta,
+  minLength,
+  minValue,
+  notEmpty,
+  ofConstruct,
+  ofGet,
+  ofMessage,
+  ofProperty,
+  on,
+  optional,
+  past,
+  quote,
+  reject,
+  replaceAll,
+  required,
+  resolve,
+  rest,
+  rule,
+  searchable,
+  seconds,
+  settled,
+  singleton,
+  tag,
+  takeFirstKey,
+  template,
+  text,
+  textValue,
+  toArray,
+  toCacheOptions,
+  toClause,
+  toCondition,
+  toFilter,
+  toHttpStatus,
+  toId,
+  toJson,
+  toList,
+  toName,
+  toObject,
+  toPageList,
+  toPageOptions,
+  toReq,
+  toResponse,
+  toResult,
+  toResults,
+  toSegment,
+  toShortFilter,
+  toUuid,
+  toViewer,
+  toWords,
+  traverse,
+  traverseSet,
+  tryTo,
+  tuple,
+  tuple2,
+  tuple3,
+  tuple4,
+  tuple5,
+  tupleO,
+  uri,
+  use,
+  valid,
+  validate,
+  validateReject,
+  values,
+  view,
+  views,
+  wait,
+  we,
+  when
+};
 //# sourceMappingURL=index.mjs.map