@colisweb/rescript-toolkit 2.8.2 → 2.9.0-mobile

package/lib/es6_global/src/decoders/Toolkit__Decoders.bs.js

@@ -0,0 +1,1038 @@
+
+
+import * as Curry from "../../../../node_modules/rescript/lib/es6/curry.js";
+import * as Decco from "../../../../node_modules/decco/lib/es6_global/src/Decco.bs.js";
+import * as Js_json from "../../../../node_modules/rescript/lib/es6/js_json.js";
+import * as DateFns from "date-fns";
+import * as Belt_Array from "../../../../node_modules/rescript/lib/es6/belt_Array.js";
+import * as Belt_Float from "../../../../node_modules/rescript/lib/es6/belt_Float.js";
+import * as Pervasives from "../../../../node_modules/rescript/lib/es6/pervasives.js";
+import * as Belt_Option from "../../../../node_modules/rescript/lib/es6/belt_Option.js";
+import * as Belt_Result from "../../../../node_modules/rescript/lib/es6/belt_Result.js";
+import * as Caml_option from "../../../../node_modules/rescript/lib/es6/caml_option.js";
+import * as Toolkit__Utils_UnitMeasure from "../utils/Toolkit__Utils_UnitMeasure.bs.js";
+
+function encoder(value) {
+  return Decco.stringToJson(value.toISOString());
+}
+
+function decoder(json) {
+  var value = Decco.stringFromJson(json);
+  if (value.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: new Date(value._0)
+          };
+  } else {
+    return value;
+  }
+}
+
+var codec = [
+  encoder,
+  decoder
+];
+
+var t_encode = encoder;
+
+var t_decode = decoder;
+
+var Datetime = {
+  encoder: encoder,
+  decoder: decoder,
+  codec: codec,
+  t_encode: t_encode,
+  t_decode: t_decode
+};
+
+function encoder$1(date) {
+  return Decco.stringToJson(DateFns.format(date, "yyyy-MM-dd"));
+}
+
+function decoder$1(json) {
+  var v = Decco.stringFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: new Date(v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$1 = [
+  encoder$1,
+  decoder$1
+];
+
+var t_encode$1 = encoder$1;
+
+var t_decode$1 = decoder$1;
+
+var $$Date$1 = {
+  encoder: encoder$1,
+  decoder: decoder$1,
+  codec: codec$1,
+  t_encode: t_encode$1,
+  t_decode: t_decode$1
+};
+
+var encoder$2 = Decco.intToJson;
+
+function decoder$2(json) {
+  var match = Js_json.classify(json);
+  if (typeof match === "number") {
+    return Decco.error("", "Not a number", json);
+  }
+  switch (match.TAG | 0) {
+    case /* JSONString */0 :
+        var value = Decco.stringFromJson(json);
+        if (value.TAG === /* Ok */0) {
+          return Decco.intFromJson(Number(value._0));
+        } else {
+          return Decco.error("", "Not an integer", json);
+        }
+    case /* JSONNumber */1 :
+        return Decco.intFromJson(json);
+    default:
+      return Decco.error("", "Not a number", json);
+  }
+}
+
+var codec$2 = [
+  encoder$2,
+  decoder$2
+];
+
+var t_encode$2 = encoder$2;
+
+var t_decode$2 = decoder$2;
+
+var Int = {
+  encoder: encoder$2,
+  decoder: decoder$2,
+  codec: codec$2,
+  t_encode: t_encode$2,
+  t_decode: t_decode$2
+};
+
+var encoder$3 = Decco.boolToJson;
+
+function decoder$3(json) {
+  var match = Js_json.classify(json);
+  if (typeof match === "number") {
+    switch (match) {
+      case /* JSONFalse */0 :
+          return {
+                  TAG: /* Ok */0,
+                  _0: false
+                };
+      case /* JSONTrue */1 :
+          return {
+                  TAG: /* Ok */0,
+                  _0: true
+                };
+      default:
+        return Decco.error("", "Not a boolean", json);
+    }
+  } else {
+    if (match.TAG !== /* JSONString */0) {
+      return Decco.error("", "Not a boolean", json);
+    }
+    var value = Decco.stringFromJson(json);
+    if (value.TAG === /* Ok */0) {
+      return Decco.boolFromJson(Pervasives.bool_of_string(value._0));
+    } else {
+      return Decco.error("", "Not a boolean", json);
+    }
+  }
+}
+
+var codec$3 = [
+  encoder$3,
+  decoder$3
+];
+
+var t_encode$3 = encoder$3;
+
+var t_decode$3 = decoder$3;
+
+var $$Boolean = {
+  encoder: encoder$3,
+  decoder: decoder$3,
+  codec: codec$3,
+  t_encode: t_encode$3,
+  t_decode: t_decode$3
+};
+
+var encoder$4 = Decco.floatToJson;
+
+function decoder$4(json) {
+  var match = Js_json.classify(json);
+  if (typeof match === "number") {
+    return Decco.error("", "Not a number", json);
+  }
+  switch (match.TAG | 0) {
+    case /* JSONString */0 :
+        var value = Decco.stringFromJson(json);
+        if (value.TAG === /* Ok */0) {
+          return Decco.floatFromJson(Number(value._0));
+        } else {
+          return Decco.error("", "Not a number", json);
+        }
+    case /* JSONNumber */1 :
+        return Decco.floatFromJson(json);
+    default:
+      return Decco.error("", "Not a number", json);
+  }
+}
+
+var codec$4 = [
+  encoder$4,
+  decoder$4
+];
+
+var t_encode$4 = encoder$4;
+
+var t_decode$4 = decoder$4;
+
+var Float = {
+  encoder: encoder$4,
+  decoder: decoder$4,
+  codec: codec$4,
+  t_encode: t_encode$4,
+  t_decode: t_decode$4
+};
+
+function Enum(Config) {
+  var encoder = function (value) {
+    return Decco.stringToJson(Curry._1(Config.enumToJs, value));
+  };
+  var decoder = function (json) {
+    var value = Decco.stringFromJson(json);
+    if (value.TAG !== /* Ok */0) {
+      return value;
+    }
+    var value$1 = value._0;
+    var value$2 = Curry._1(Config.enumFromJs, value$1);
+    if (value$2 !== undefined) {
+      return {
+              TAG: /* Ok */0,
+              _0: Caml_option.valFromOption(value$2)
+            };
+    } else {
+      return Decco.error("", "Invalid enum " + value$1, json);
+    }
+  };
+  var codec = [
+    encoder,
+    decoder
+  ];
+  var toString = function (v) {
+    return Curry._1(Config.enumToJs, v);
+  };
+  var fromString = function (v) {
+    return Curry._1(Config.enumFromJs, v);
+  };
+  var t_encode = encoder;
+  var t_decode = decoder;
+  return {
+          encoder: encoder,
+          decoder: decoder,
+          codec: codec,
+          toString: toString,
+          fromString: fromString,
+          t_encode: t_encode,
+          t_decode: t_decode
+        };
+}
+
+function encoder$5(encoder$6, value) {
+  if (value !== undefined) {
+    return Curry._1(encoder$6, Caml_option.valFromOption(value));
+  } else {
+    return undefined;
+  }
+}
+
+function decoder$5(decoder$6, json) {
+  if (json !== undefined) {
+    return Decco.optionFromJson(decoder$6, json);
+  } else {
+    return {
+            TAG: /* Ok */0,
+            _0: undefined
+          };
+  }
+}
+
+var codec$5 = [
+  encoder$5,
+  decoder$5
+];
+
+var t_encode$5 = encoder$5;
+
+var t_decode$5 = decoder$5;
+
+var $$Option = {
+  encoder: encoder$5,
+  decoder: decoder$5,
+  codec: codec$5,
+  t_encode: t_encode$5,
+  t_decode: t_decode$5
+};
+
+function encoder$6(value) {
+  return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Dimension.toString(value, undefined, undefined));
+}
+
+function decoder$6(json) {
+  var v = Decco.stringFromJson(json);
+  if (v.TAG !== /* Ok */0) {
+    return v;
+  }
+  var valueUnitArray = v._0.split(" ");
+  var match = Belt_Option.flatMap(Belt_Array.get(valueUnitArray, 0), Belt_Float.fromString);
+  var match$1 = Belt_Array.get(valueUnitArray, 1);
+  if (match === undefined) {
+    return Decco.error(undefined, "unhandled no value", json);
+  }
+  if (match$1 !== undefined) {
+    switch (match$1) {
+      case "cm" :
+          return {
+                  TAG: /* Ok */0,
+                  _0: {
+                    NAME: "cm",
+                    VAL: match
+                  }
+                };
+      case "dm" :
+          return {
+                  TAG: /* Ok */0,
+                  _0: {
+                    NAME: "dm",
+                    VAL: match
+                  }
+                };
+      case "km" :
+          return {
+                  TAG: /* Ok */0,
+                  _0: {
+                    NAME: "km",
+                    VAL: match
+                  }
+                };
+      case "mm" :
+          return {
+                  TAG: /* Ok */0,
+                  _0: {
+                    NAME: "mm",
+                    VAL: match
+                  }
+                };
+      default:
+        
+    }
+  }
+  if (match$1 !== undefined) {
+    return Decco.error(undefined, "unhandled dimension unit", json);
+  } else {
+    return Decco.error(undefined, "unhandled no unit", json);
+  }
+}
+
+var codec$6 = [
+  encoder$6,
+  decoder$6
+];
+
+var toValue = Toolkit__Utils_UnitMeasure.Dimension.toValue;
+
+var toString = Toolkit__Utils_UnitMeasure.Dimension.toString;
+
+var t_encode$6 = encoder$6;
+
+var t_decode$6 = decoder$6;
+
+var WithUnit = {
+  encoder: encoder$6,
+  decoder: decoder$6,
+  codec: codec$6,
+  toValue: toValue,
+  toString: toString,
+  t_encode: t_encode$6,
+  t_decode: t_decode$6
+};
+
+function Make(C) {
+  var encoder = function (value) {
+    return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Dimension.toString(value, undefined, undefined));
+  };
+  var decoder = function (json) {
+    var v = Decco.floatFromJson(json);
+    if (v.TAG === /* Ok */0) {
+      return {
+              TAG: /* Ok */0,
+              _0: Curry._1(C.convert, v._0)
+            };
+    } else {
+      return v;
+    }
+  };
+  var codec = [
+    encoder,
+    decoder
+  ];
+  var t_encode = encoder;
+  var t_decode = decoder;
+  return {
+          encoder: encoder,
+          decoder: decoder,
+          codec: codec,
+          t_encode: t_encode,
+          t_decode: t_decode
+        };
+}
+
+var convert = Toolkit__Utils_UnitMeasure.Dimension.makeMm;
+
+function encoder$7(value) {
+  return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Dimension.toString(value, undefined, undefined));
+}
+
+function decoder$7(json) {
+  var v = Decco.floatFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: Curry._1(convert, v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$7 = [
+  encoder$7,
+  decoder$7
+];
+
+var t_encode$7 = encoder$7;
+
+var t_decode$7 = decoder$7;
+
+var Mm = {
+  encoder: encoder$7,
+  decoder: decoder$7,
+  codec: codec$7,
+  t_encode: t_encode$7,
+  t_decode: t_decode$7
+};
+
+var convert$1 = Toolkit__Utils_UnitMeasure.Dimension.makeCm;
+
+function encoder$8(value) {
+  return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Dimension.toString(value, undefined, undefined));
+}
+
+function decoder$8(json) {
+  var v = Decco.floatFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: Curry._1(convert$1, v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$8 = [
+  encoder$8,
+  decoder$8
+];
+
+var t_encode$8 = encoder$8;
+
+var t_decode$8 = decoder$8;
+
+var Cm = {
+  encoder: encoder$8,
+  decoder: decoder$8,
+  codec: codec$8,
+  t_encode: t_encode$8,
+  t_decode: t_decode$8
+};
+
+var convert$2 = Toolkit__Utils_UnitMeasure.Dimension.makeDm;
+
+function encoder$9(value) {
+  return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Dimension.toString(value, undefined, undefined));
+}
+
+function decoder$9(json) {
+  var v = Decco.floatFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: Curry._1(convert$2, v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$9 = [
+  encoder$9,
+  decoder$9
+];
+
+var t_encode$9 = encoder$9;
+
+var t_decode$9 = decoder$9;
+
+var Dm = {
+  encoder: encoder$9,
+  decoder: decoder$9,
+  codec: codec$9,
+  t_encode: t_encode$9,
+  t_decode: t_decode$9
+};
+
+var convert$3 = Toolkit__Utils_UnitMeasure.Dimension.makeKm;
+
+function encoder$10(value) {
+  return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Dimension.toString(value, undefined, undefined));
+}
+
+function decoder$10(json) {
+  var v = Decco.floatFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: Curry._1(convert$3, v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$10 = [
+  encoder$10,
+  decoder$10
+];
+
+var t_encode$10 = encoder$10;
+
+var t_decode$10 = decoder$10;
+
+var Km = {
+  encoder: encoder$10,
+  decoder: decoder$10,
+  codec: codec$10,
+  t_encode: t_encode$10,
+  t_decode: t_decode$10
+};
+
+var Dimension = {
+  WithUnit: WithUnit,
+  Make: Make,
+  Mm: Mm,
+  Cm: Cm,
+  Dm: Dm,
+  Km: Km
+};
+
+function encoder$11(value) {
+  return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Weight.display(value, undefined, undefined));
+}
+
+function decoder$11(json) {
+  var v = Decco.stringFromJson(json);
+  if (v.TAG !== /* Ok */0) {
+    return v;
+  }
+  var valueUnitArray = v._0.split(" ");
+  var match = Belt_Option.flatMap(Belt_Array.get(valueUnitArray, 0), Belt_Float.fromString);
+  var match$1 = Belt_Array.get(valueUnitArray, 1);
+  if (match === undefined) {
+    return Decco.error(undefined, "unhandled no value", json);
+  }
+  if (match$1 !== undefined) {
+    switch (match$1) {
+      case "g" :
+          return {
+                  TAG: /* Ok */0,
+                  _0: {
+                    NAME: "g",
+                    VAL: match
+                  }
+                };
+      case "kg" :
+          return {
+                  TAG: /* Ok */0,
+                  _0: {
+                    NAME: "kg",
+                    VAL: match
+                  }
+                };
+      default:
+        
+    }
+  }
+  if (match$1 !== undefined) {
+    return Decco.error(undefined, "unhandled weight unit", json);
+  } else {
+    return Decco.error(undefined, "unhandled no unit", json);
+  }
+}
+
+var codec$11 = [
+  encoder$11,
+  decoder$11
+];
+
+var t_encode$11 = encoder$11;
+
+var t_decode$11 = decoder$11;
+
+var WithUnit$1 = {
+  encoder: encoder$11,
+  decoder: decoder$11,
+  codec: codec$11,
+  t_encode: t_encode$11,
+  t_decode: t_decode$11
+};
+
+function Make$1(C) {
+  var encoder = function (value) {
+    return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Weight.display(value, undefined, undefined));
+  };
+  var decoder = function (json) {
+    var v = Decco.floatFromJson(json);
+    if (v.TAG === /* Ok */0) {
+      return {
+              TAG: /* Ok */0,
+              _0: Curry._1(C.convert, v._0)
+            };
+    } else {
+      return v;
+    }
+  };
+  var codec = [
+    encoder,
+    decoder
+  ];
+  var toValue = Toolkit__Utils_UnitMeasure.Weight.toValue;
+  var display = Toolkit__Utils_UnitMeasure.Weight.display;
+  var t_encode = encoder;
+  var t_decode = decoder;
+  return {
+          encoder: encoder,
+          decoder: decoder,
+          codec: codec,
+          toValue: toValue,
+          display: display,
+          t_encode: t_encode,
+          t_decode: t_decode
+        };
+}
+
+var convert$4 = Toolkit__Utils_UnitMeasure.Weight.makeG;
+
+function encoder$12(value) {
+  return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Weight.display(value, undefined, undefined));
+}
+
+function decoder$12(json) {
+  var v = Decco.floatFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: Curry._1(convert$4, v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$12 = [
+  encoder$12,
+  decoder$12
+];
+
+var toValue$1 = Toolkit__Utils_UnitMeasure.Weight.toValue;
+
+var display = Toolkit__Utils_UnitMeasure.Weight.display;
+
+var t_encode$12 = encoder$12;
+
+var t_decode$12 = decoder$12;
+
+var G = {
+  encoder: encoder$12,
+  decoder: decoder$12,
+  codec: codec$12,
+  toValue: toValue$1,
+  display: display,
+  t_encode: t_encode$12,
+  t_decode: t_decode$12
+};
+
+var convert$5 = Toolkit__Utils_UnitMeasure.Weight.makeKg;
+
+function encoder$13(value) {
+  return Decco.stringToJson(Toolkit__Utils_UnitMeasure.Weight.display(value, undefined, undefined));
+}
+
+function decoder$13(json) {
+  var v = Decco.floatFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: Curry._1(convert$5, v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$13 = [
+  encoder$13,
+  decoder$13
+];
+
+var toValue$2 = Toolkit__Utils_UnitMeasure.Weight.toValue;
+
+var display$1 = Toolkit__Utils_UnitMeasure.Weight.display;
+
+var t_encode$13 = encoder$13;
+
+var t_decode$13 = decoder$13;
+
+var Kg = {
+  encoder: encoder$13,
+  decoder: decoder$13,
+  codec: codec$13,
+  toValue: toValue$2,
+  display: display$1,
+  t_encode: t_encode$13,
+  t_decode: t_decode$13
+};
+
+var Weight = {
+  WithUnit: WithUnit$1,
+  Make: Make$1,
+  G: G,
+  Kg: Kg
+};
+
+function encoder$14(value) {
+  if (value.NAME === "min") {
+    return value.VAL.toString() + " min";
+  } else {
+    return value.VAL.toString() + " h";
+  }
+}
+
+function decoder$14(json) {
+  var v = Decco.stringFromJson(json);
+  if (v.TAG !== /* Ok */0) {
+    return v;
+  }
+  var valueUnitArray = v._0.split(" ");
+  var match = Belt_Option.flatMap(Belt_Array.get(valueUnitArray, 0), Belt_Float.fromString);
+  var match$1 = Belt_Array.get(valueUnitArray, 1);
+  if (match === undefined) {
+    return Decco.error(undefined, "unhandled no value", json);
+  }
+  if (match$1 !== undefined) {
+    switch (match$1) {
+      case "h" :
+          return {
+                  TAG: /* Ok */0,
+                  _0: {
+                    NAME: "h",
+                    VAL: match
+                  }
+                };
+      case "min" :
+          return {
+                  TAG: /* Ok */0,
+                  _0: {
+                    NAME: "min",
+                    VAL: match
+                  }
+                };
+      default:
+        
+    }
+  }
+  if (match$1 !== undefined) {
+    return Decco.error(undefined, "unhandled time unit", json);
+  } else {
+    return Decco.error(undefined, "unhandled no unit", json);
+  }
+}
+
+var codec$14 = [
+  encoder$14,
+  decoder$14
+];
+
+var t_encode$14 = encoder$14;
+
+var t_decode$14 = decoder$14;
+
+var WithUnit$2 = {
+  encoder: encoder$14,
+  decoder: decoder$14,
+  codec: codec$14,
+  t_encode: t_encode$14,
+  t_decode: t_decode$14
+};
+
+function Make$2(C) {
+  var encoder = function (value) {
+    if (value.NAME === "min") {
+      return value.VAL.toString() + " min";
+    } else {
+      return value.VAL.toString() + " h";
+    }
+  };
+  var decoder = function (json) {
+    var v = Decco.floatFromJson(json);
+    if (v.TAG === /* Ok */0) {
+      return {
+              TAG: /* Ok */0,
+              _0: Curry._1(C.convert, v._0)
+            };
+    } else {
+      return v;
+    }
+  };
+  var codec = [
+    encoder,
+    decoder
+  ];
+  var toValue = Toolkit__Utils_UnitMeasure.Time.toValue;
+  var display = Toolkit__Utils_UnitMeasure.Time.display;
+  var t_encode = encoder;
+  var t_decode = decoder;
+  return {
+          encoder: encoder,
+          decoder: decoder,
+          codec: codec,
+          toValue: toValue,
+          display: display,
+          t_encode: t_encode,
+          t_decode: t_decode
+        };
+}
+
+var convert$6 = Toolkit__Utils_UnitMeasure.Time.makeMin;
+
+function encoder$15(value) {
+  if (value.NAME === "min") {
+    return value.VAL.toString() + " min";
+  } else {
+    return value.VAL.toString() + " h";
+  }
+}
+
+function decoder$15(json) {
+  var v = Decco.floatFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: Curry._1(convert$6, v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$15 = [
+  encoder$15,
+  decoder$15
+];
+
+var toValue$3 = Toolkit__Utils_UnitMeasure.Time.toValue;
+
+var display$2 = Toolkit__Utils_UnitMeasure.Time.display;
+
+var t_encode$15 = encoder$15;
+
+var t_decode$15 = decoder$15;
+
+var Min = {
+  encoder: encoder$15,
+  decoder: decoder$15,
+  codec: codec$15,
+  toValue: toValue$3,
+  display: display$2,
+  t_encode: t_encode$15,
+  t_decode: t_decode$15
+};
+
+var convert$7 = Toolkit__Utils_UnitMeasure.Time.makeH;
+
+function encoder$16(value) {
+  if (value.NAME === "min") {
+    return value.VAL.toString() + " min";
+  } else {
+    return value.VAL.toString() + " h";
+  }
+}
+
+function decoder$16(json) {
+  var v = Decco.floatFromJson(json);
+  if (v.TAG === /* Ok */0) {
+    return {
+            TAG: /* Ok */0,
+            _0: Curry._1(convert$7, v._0)
+          };
+  } else {
+    return v;
+  }
+}
+
+var codec$16 = [
+  encoder$16,
+  decoder$16
+];
+
+var toValue$4 = Toolkit__Utils_UnitMeasure.Time.toValue;
+
+var display$3 = Toolkit__Utils_UnitMeasure.Time.display;
+
+var t_encode$16 = encoder$16;
+
+var t_decode$16 = decoder$16;
+
+var H = {
+  encoder: encoder$16,
+  decoder: decoder$16,
+  codec: codec$16,
+  toValue: toValue$4,
+  display: display$3,
+  t_encode: t_encode$16,
+  t_decode: t_decode$16
+};
+
+var Time = {
+  WithUnit: WithUnit$2,
+  Make: Make$2,
+  Min: Min,
+  H: H
+};
+
+var UnitMeasure = {
+  Dimension: Dimension,
+  Weight: Weight,
+  Time: Time
+};
+
+function encoder$17(encoder$18, value) {
+  return Decco.stringToJson(Belt_Array.map(value, encoder$18).join(","));
+}
+
+function decoder$17(decoder$18, json) {
+  var string = Decco.stringFromJson(json);
+  if (string.TAG !== /* Ok */0) {
+    return string;
+  }
+  var resultArray = Belt_Array.map(string._0.split(","), Curry.__1(decoder$18));
+  var error = Belt_Array.getBy(resultArray, Belt_Result.isError);
+  if (error !== undefined) {
+    return Decco.error("", "Invalid content", json);
+  } else {
+    return {
+            TAG: /* Ok */0,
+            _0: Belt_Array.map(resultArray, Belt_Result.getExn)
+          };
+  }
+}
+
+var codec$17 = [
+  encoder$17,
+  decoder$17
+];
+
+var t_encode$17 = encoder$17;
+
+var t_decode$17 = decoder$17;
+
+var StringArray = {
+  encoder: encoder$17,
+  decoder: decoder$17,
+  codec: codec$17,
+  t_encode: t_encode$17,
+  t_decode: t_decode$17
+};
+
+var _map = {"asc":"asc","desc":"desc"};
+
+var encoder$18 = Decco.stringToJson;
+
+function decoder$18(json) {
+  var value = Decco.stringFromJson(json);
+  if (value.TAG !== /* Ok */0) {
+    return value;
+  }
+  var value$1 = value._0;
+  var value$2 = _map[value$1];
+  if (value$2 !== undefined) {
+    return {
+            TAG: /* Ok */0,
+            _0: Caml_option.valFromOption(value$2)
+          };
+  } else {
+    return Decco.error("", "Invalid enum " + value$1, json);
+  }
+}
+
+var codec$18 = [
+  encoder$18,
+  decoder$18
+];
+
+function toString$1(v) {
+  return v;
+}
+
+function fromString(v) {
+  return _map[v];
+}
+
+var t_encode$18 = encoder$18;
+
+var t_decode$18 = decoder$18;
+
+var SortOrder = {
+  encoder: encoder$18,
+  decoder: decoder$18,
+  codec: codec$18,
+  toString: toString$1,
+  fromString: fromString,
+  t_encode: t_encode$18,
+  t_decode: t_decode$18
+};
+
+export {
+  Datetime ,
+  $$Date$1 as $$Date,
+  Int ,
+  $$Boolean ,
+  Float ,
+  Enum ,
+  $$Option ,
+  UnitMeasure ,
+  StringArray ,
+  SortOrder ,
+  
+}
+/* date-fns Not a pure module */