@nfdi4plants/arctrl 3.0.0-beta.5 → 3.0.0-beta.6

package/dist/ts/ts/fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js

@@ -1,16 +1,22 @@
-import { ErrorReason$1_BadOneOf, ErrorReason$1_BadPrimitive, ErrorReason$1_BadPrimitiveExtra, ErrorReason$1_TooSmallArray, ErrorReason$1_BadType, ErrorReason$1_BadField, ErrorReason$1_BadPath } from './Types.fs.js';
+import { ErrorReason$1_BadPrimitive, ErrorReason$1_BadPrimitiveExtra, ErrorReason$1_BadType, ErrorReason$1_BadPath, ErrorReason$1_BadField, ErrorReason$1_TooSmallArray, ErrorReason$1_BadOneOf, ErrorReason$1_FailMessage } from './Types.fs.js';
 import { join } from '../../../node_modules/@fable-org/fable-library-js/String.js';
-import { empty, isEmpty, head, tail, append, singleton, length, map as map$1, fold as fold$1, tryLast } from '../../../node_modules/@fable-org/fable-library-js/List.js';
-import { FSharpResult$2_Error, FSharpResult$2_Ok, Result_MapError } from '../../../node_modules/@fable-org/fable-library-js/Result.js';
-import { tryParse as tryParse$2 } from '../../../node_modules/@fable-org/fable-library-js/Guid.js';
+import { map as map$1, tryLast, fold, empty, append, singleton, ofSeq, reverse as reverse$1, cons, isEmpty, head, tail, length } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok, Result_MapError, Result_Map } from '../../../node_modules/@fable-org/fable-library-js/Result.js';
+import { tryParse } from '../../../node_modules/@fable-org/fable-library-js/Guid.js';
 import { FSharpRef } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
-import { tryParse } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
-import { tryParse as tryParse$1 } from '../../../node_modules/@fable-org/fable-library-js/Decimal.js';
-import { some, value, defaultArg } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
-import { defaultOf, int32ToString, compare } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
-import { item, fold, fill, setItem } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
-import { toList } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
-import { ofSeq } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+import { tryParse as tryParse$1 } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { toFloat64, toInt64, fromFloat64, toUInt64, fromInt32, tryParse as tryParse$3 } from '../../../node_modules/@fable-org/fable-library-js/BigInt.js';
+import { tryParse as tryParse$2 } from '../../../node_modules/@fable-org/fable-library-js/Long.js';
+import { tryParse as tryParse$4 } from '../../../node_modules/@fable-org/fable-library-js/Decimal.js';
+import { minValue, tryParse as tryParse$5, toUniversalTime } from '../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { minValue as minValue$1, tryParse as tryParse$6 } from '../../../node_modules/@fable-org/fable-library-js/DateOffset.js';
+import { tryParse as tryParse$7 } from '../../../node_modules/@fable-org/fable-library-js/TimeSpan.js';
+import { some, defaultArg, value as value$1 } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { int32ToString, defaultOf, comparePrimitives, compare } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { item, fold as fold$1, setItem, fill } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { reverse, append as append$1, toList } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { ofList, ofSeq as ofSeq$1 } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
 import { Big } from '../../../node_modules/@fable-org/fable-library-js/lib/big.js';
 
 function Helpers_prependPath(path, err_, err__1) {
@@ -78,17 +84,37 @@ function errorToString(helpers, path, error) {
     return "Error at: `" + path + "`\n" + reason_1;
   }
 }
+function Advanced_fromValue(helpers, decoder, value_1) {
+  const matchValue = decoder.Decode(helpers, value_1);
+  if (matchValue.tag === /* Error */
+  1) {
+    const error = matchValue.fields[0];
+    return FSharpResult$2_Error(errorToString(helpers, error[0], error[1]));
+  } else {
+    return FSharpResult$2_Ok(matchValue.fields[0]);
+  }
+}
 const string = {
   Decode(helpers, value_1) {
     return helpers.isString(value_1) ? FSharpResult$2_Ok(helpers.asString(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a string", value_1)]);
   }
 };
+const char = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      const str = helpers.asString(value_1);
+      return str.length === 1 ? FSharpResult$2_Ok(str[0]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a single character string", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a char", value_1)]);
+    }
+  }
+};
 const guid = {
   Decode(helpers, value_1) {
     if (helpers.isString(value_1)) {
       let matchValue;
       let outArg = "00000000-0000-0000-0000-000000000000";
-      matchValue = [tryParse$2(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+      matchValue = [tryParse(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
         outArg = v;
       })), outArg];
       return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a guid", value_1)]);
@@ -102,6 +128,90 @@ const unit = {
     return helpers.isNullValue(value_1) ? FSharpResult$2_Ok(void 0) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("null", value_1)]);
   }
 };
+const sbyte = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return -128 <= floatValue && floatValue <= 127 ? FSharpResult$2_Ok((floatValue + 128 & 255) - 128) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("a sbyte", value_2, "Value was either too large or too small for a sbyte")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("a sbyte", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, false, 8, new FSharpRef(() => outArg, (v) => {
+        outArg = v | 0;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a sbyte", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a sbyte", value_2)]);
+    }
+  }
+};
+const byte = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return 0 <= floatValue && floatValue <= 255 ? FSharpResult$2_Ok(floatValue & 255) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("a byte", value_2, "Value was either too large or too small for a byte")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("a byte", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, true, 8, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a byte", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a byte", value_2)]);
+    }
+  }
+};
+const int16 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return -32768 <= floatValue && floatValue <= 32767 ? FSharpResult$2_Ok((floatValue + 32768 & 65535) - 32768) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int16", value_2, "Value was either too large or too small for an int16")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int16", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, false, 16, new FSharpRef(() => outArg, (v) => {
+        outArg = v | 0;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int16", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int16", value_2)]);
+    }
+  }
+};
+const uint16 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return 0 <= floatValue && floatValue <= 65535 ? FSharpResult$2_Ok(floatValue & 65535) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint16", value_2, "Value was either too large or too small for an uint16")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint16", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, true, 16, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint16", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint16", value_2)]);
+    }
+  }
+};
 const int = {
   Decode(helpers, value_2) {
     if (helpers.isNumber(value_2)) {
@@ -114,7 +224,7 @@ const int = {
     } else if (helpers.isString(value_2)) {
       let matchValue;
       let outArg = 0;
-      matchValue = [tryParse(helpers.asString(value_2), 511, false, 32, new FSharpRef(() => outArg, (v) => {
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, false, 32, new FSharpRef(() => outArg, (v) => {
         outArg = v | 0;
       })), outArg];
       return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int", value_2)]);
@@ -123,6 +233,85 @@ const int = {
     }
   }
 };
+const uint32 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return 0 <= floatValue && floatValue <= 4294967295 ? FSharpResult$2_Ok(floatValue >>> 0) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint32", value_2, "Value was either too large or too small for an uint32")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint32", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, true, 32, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint32", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint32", value_2)]);
+    }
+  }
+};
+const int64 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return toFloat64(-9223372036854775808n) <= floatValue && floatValue <= toFloat64(9223372036854775807n) ? FSharpResult$2_Ok(toInt64(fromFloat64(floatValue))) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int64", value_2, "Value was either too large or too small for an int64")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int64", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0n;
+      matchValue = [tryParse$2(helpers.asString(value_2), 511, false, 64, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int64", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int64", value_2)]);
+    }
+  }
+};
+const uint64 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return toFloat64(0n) <= floatValue && floatValue <= toFloat64(18446744073709551615n) ? FSharpResult$2_Ok(toUInt64(fromFloat64(floatValue))) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint64", value_2, "Value was either too large or too small for an uint64")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint64", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0n;
+      matchValue = [tryParse$2(helpers.asString(value_2), 511, true, 64, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint64", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint64", value_2)]);
+    }
+  }
+};
+const bigint = {
+  Decode(helpers, value_1) {
+    if (helpers.isNumber(value_1)) {
+      return FSharpResult$2_Ok(fromInt32(helpers.asInt(value_1)));
+    } else if (helpers.isString(value_1)) {
+      let parseResult;
+      let outArg = 0n;
+      parseResult = [tryParse$3(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return parseResult[0] ? FSharpResult$2_Ok(parseResult[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a bigint", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a bigint", value_1)]);
+    }
+  }
+};
 const bool = {
   Decode(helpers, value_1) {
     return helpers.isBoolean(value_1) ? FSharpResult$2_Ok(helpers.asBoolean(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a boolean", value_1)]);
@@ -133,6 +322,11 @@ const float = {
     return helpers.isNumber(value_1) ? FSharpResult$2_Ok(helpers.asFloat(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a float", value_1)]);
   }
 };
+const float32 = {
+  Decode(helpers, value_1) {
+    return helpers.isNumber(value_1) ? FSharpResult$2_Ok(helpers.asFloat32(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a float32", value_1)]);
+  }
+};
 const decimal = {
   Decode(helpers, value_1) {
     if (helpers.isNumber(value_1)) {
@@ -140,7 +334,7 @@ const decimal = {
     } else if (helpers.isString(value_1)) {
       let matchValue;
       let outArg = new Big("0");
-      matchValue = [tryParse$1(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+      matchValue = [tryParse$4(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
         outArg = v;
       })), outArg];
       return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a decimal", value_1)]);
@@ -149,6 +343,62 @@ const decimal = {
     }
   }
 };
+const datetimeUtc = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = minValue();
+      matchValue = [tryParse$5(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(toUniversalTime(matchValue[1])) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    }
+  }
+};
+const datetimeLocal = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = minValue();
+      matchValue = [tryParse$5(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    }
+  }
+};
+const datetimeOffset = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = minValue$1();
+      matchValue = [tryParse$6(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetimeoffset", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    }
+  }
+};
+const timespan = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$7(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a timespan", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a timespan", value_1)]);
+    }
+  }
+};
 function decodeMaybeNull(helpers, path, decoder, value_1) {
   let tupledArg;
   if (helpers.isNullValue(value_1)) {
@@ -173,10 +423,29 @@ function optional(fieldName, decoder) {
 function badPathError(fieldNames, currentPath, value_1) {
   return FSharpResult$2_Error(["." + defaultArg(currentPath, join(".", fieldNames)), ErrorReason$1_BadPath("an object with path `" + join(".", fieldNames) + "`", value_1, defaultArg(tryLast(fieldNames), ""))]);
 }
+function map2(ctor, d1, d2) {
+  return {
+    Decode(helpers, value_1) {
+      let er_1, v1, v2;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        return copyOfStruct_1.tag === /* Error */
+        1 ? (er_1 = copyOfStruct_1.fields[0], FSharpResult$2_Error(er_1)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], FSharpResult$2_Ok(ctor(v1, v2)));
+      }
+    }
+  };
+}
 function optionalAt(fieldNames, decoder) {
   return {
     Decode(helpers, firstValue) {
-      const _arg = fold$1((tupledArg, field_1) => {
+      const _arg = fold((tupledArg, field_1) => {
         const curPath = tupledArg[0];
         const curValue = tupledArg[1];
         const res = tupledArg[2];
@@ -200,7 +469,7 @@ function optionalAt(fieldNames, decoder) {
         const lastValue = _arg[1];
         return helpers.isNullValue(lastValue) ? FSharpResult$2_Ok(void 0) : decodeMaybeNull(helpers, _arg[0], decoder, lastValue);
       } else {
-        return value(_arg[2]);
+        return value$1(_arg[2]);
       }
     }
   };
@@ -225,7 +494,7 @@ function field(fieldName, decoder) {
 function at(fieldNames, decoder) {
   return {
     Decode(helpers, firstValue) {
-      const _arg = fold$1((tupledArg, field_1) => {
+      const _arg = fold((tupledArg, field_1) => {
         const curPath = tupledArg[0];
         const curValue = tupledArg[1];
         const res = tupledArg[2];
@@ -245,7 +514,7 @@ function at(fieldNames, decoder) {
           return [curPath, curValue, res];
         }
       }, ["", firstValue, void 0], fieldNames);
-      return _arg[2] == null ? Result_MapError((tupledArg_1) => Helpers_prependPath(_arg[0], tupledArg_1[0], tupledArg_1[1]), decoder.Decode(helpers, _arg[1])) : value(_arg[2]);
+      return _arg[2] == null ? Result_MapError((tupledArg_1) => Helpers_prependPath(_arg[0], tupledArg_1[0], tupledArg_1[1]), decoder.Decode(helpers, _arg[1])) : value$1(_arg[2]);
     }
   };
 }
@@ -284,7 +553,7 @@ function list(decoder) {
           }
           i = i + 1 | 0;
         }
-        return error == null ? FSharpResult$2_Ok(result) : FSharpResult$2_Error(value(error));
+        return error == null ? FSharpResult$2_Ok(result) : FSharpResult$2_Error(value$1(error));
       } else {
         return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a list", value_1)]);
       }
@@ -313,20 +582,48 @@ function resizeArray(decoder) {
           }
           i = i + 1 | 0;
         }
-        return error == null ? FSharpResult$2_Ok(Array.from(result)) : FSharpResult$2_Error(value(error));
+        return error == null ? FSharpResult$2_Ok(Array.from(result)) : FSharpResult$2_Error(value$1(error));
       } else {
         return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a ResizeArray", value_1)]);
       }
     }
   };
 }
+function seq(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      if (helpers.isArray(value_1)) {
+        let i = -1;
+        return Result_Map(reverse, fold$1((acc, value_2) => {
+          let tupledArg;
+          i = i + 1 | 0;
+          if (acc.tag === /* Ok */
+          0) {
+            const acc_1 = acc.fields[0];
+            const matchValue = decoder.Decode(helpers, value_2);
+            if (matchValue.tag === /* Ok */
+            0) {
+              return FSharpResult$2_Ok(append$1([matchValue.fields[0]], acc_1));
+            } else {
+              return FSharpResult$2_Error((tupledArg = matchValue.fields[0], Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1])));
+            }
+          } else {
+            return acc;
+          }
+        }, FSharpResult$2_Ok([]), helpers.asArray(value_1)));
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a seq", value_1)]);
+      }
+    }
+  };
+}
 function array(decoder) {
   return {
     Decode(helpers, value_1) {
       if (helpers.isArray(value_1)) {
         let i = -1;
         const tokens = helpers.asArray(value_1);
-        return fold((acc, value_2) => {
+        return fold$1((acc, value_2) => {
           let tupledArg;
           i = i + 1 | 0;
           if (acc.tag === /* Ok */
@@ -351,6 +648,35 @@ function array(decoder) {
     }
   };
 }
+const keys = {
+  Decode(helpers, value_1) {
+    return helpers.isObject(value_1) ? FSharpResult$2_Ok(ofSeq(helpers.getProperties(value_1))) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value_1)]);
+  }
+};
+function keyValuePairs(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      const matchValue = keys.Decode(helpers, value_1);
+      return matchValue.tag === /* Error */
+      1 ? FSharpResult$2_Error(matchValue.fields[0]) : Result_Map(reverse$1, fold((acc, prop) => {
+        if (acc.tag === /* Ok */
+        0) {
+          const acc_1 = acc.fields[0];
+          const fieldValue = helpers.getProperty(prop, value_1);
+          const matchValue_1 = decoder.Decode(helpers, fieldValue);
+          if (matchValue_1.tag === /* Ok */
+          0) {
+            return FSharpResult$2_Ok(cons([prop, matchValue_1.fields[0]], acc_1));
+          } else {
+            return FSharpResult$2_Error(matchValue_1.fields[0]);
+          }
+        } else {
+          return acc;
+        }
+      }, FSharpResult$2_Ok(empty()), matchValue.fields[0]));
+    }
+  };
+}
 function oneOf(decoders) {
   return {
     Decode(helpers, value_1) {
@@ -371,12 +697,23 @@ function oneOf(decoders) {
                 return FSharpResult$2_Ok(matchValue.fields[0]);
               }
             }
+            break;
           }
       };
       return runner(decoders, empty());
     }
   };
 }
+function nil(output) {
+  return {
+    Decode(helpers, value_1) {
+      return helpers.isNullValue(value_1) ? FSharpResult$2_Ok(output) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("null", value_1)]);
+    }
+  };
+}
+function value(_arg, v) {
+  return FSharpResult$2_Ok(v);
+}
 function succeed(output) {
   return {
     Decode(_arg, _arg_1) {
@@ -384,6 +721,13 @@ function succeed(output) {
     }
   };
 }
+function fail(msg) {
+  return {
+    Decode(_arg, _arg_1) {
+      return FSharpResult$2_Error(["", ErrorReason$1_FailMessage(msg)]);
+    }
+  };
+}
 function andThen(cb, decoder) {
   return {
     Decode(helpers, value_1) {
@@ -398,6 +742,33 @@ function andThen(cb, decoder) {
     }
   };
 }
+function all(decoders) {
+  return {
+    Decode(helpers, value_1) {
+      const runner = (decoders_1_mut, values_mut) => {
+        runner:
+          while (true) {
+            const decoders_1 = decoders_1_mut, values = values_mut;
+            if (isEmpty(decoders_1)) {
+              return FSharpResult$2_Ok(values);
+            } else {
+              const matchValue = head(decoders_1).Decode(helpers, value_1);
+              if (matchValue.tag === /* Error */
+              1) {
+                return FSharpResult$2_Error(matchValue.fields[0]);
+              } else {
+                decoders_1_mut = tail(decoders_1);
+                values_mut = append(values, singleton(matchValue.fields[0]));
+                continue runner;
+              }
+            }
+            break;
+          }
+      };
+      return runner(decoders, empty());
+    }
+  };
+}
 function map(ctor, d1) {
   return {
     Decode(helpers, value_1) {
@@ -407,6 +778,316 @@ function map(ctor, d1) {
     }
   };
 }
+function map3(ctor, d1, d2, d3) {
+  return {
+    Decode(helpers, value_1) {
+      let er_2, v1, v2, v3;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          return copyOfStruct_2.tag === /* Error */
+          1 ? (er_2 = copyOfStruct_2.fields[0], FSharpResult$2_Error(er_2)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3)));
+        }
+      }
+    }
+  };
+}
+function map4(ctor, d1, d2, d3, d4) {
+  return {
+    Decode(helpers, value_1) {
+      let er_3, v1, v2, v3, v4;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            return copyOfStruct_3.tag === /* Error */
+            1 ? (er_3 = copyOfStruct_3.fields[0], FSharpResult$2_Error(er_3)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4)));
+          }
+        }
+      }
+    }
+  };
+}
+function map5(ctor, d1, d2, d3, d4, d5) {
+  return {
+    Decode(helpers, value_1) {
+      let er_4, v1, v2, v3, v4, v5;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const matchValue_4 = d5.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            if (copyOfStruct_3.tag === /* Error */
+            1) {
+              const er_3 = copyOfStruct_3.fields[0];
+              return FSharpResult$2_Error(er_3);
+            } else {
+              const copyOfStruct_4 = matchValue_4;
+              return copyOfStruct_4.tag === /* Error */
+              1 ? (er_4 = copyOfStruct_4.fields[0], FSharpResult$2_Error(er_4)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], v5 = copyOfStruct_4.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4, v5)));
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function map6(ctor, d1, d2, d3, d4, d5, d6) {
+  return {
+    Decode(helpers, value_1) {
+      let er_5, v1, v2, v3, v4, v5, v6;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const matchValue_4 = d5.Decode(helpers, value_1);
+      const matchValue_5 = d6.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            if (copyOfStruct_3.tag === /* Error */
+            1) {
+              const er_3 = copyOfStruct_3.fields[0];
+              return FSharpResult$2_Error(er_3);
+            } else {
+              const copyOfStruct_4 = matchValue_4;
+              if (copyOfStruct_4.tag === /* Error */
+              1) {
+                const er_4 = copyOfStruct_4.fields[0];
+                return FSharpResult$2_Error(er_4);
+              } else {
+                const copyOfStruct_5 = matchValue_5;
+                return copyOfStruct_5.tag === /* Error */
+                1 ? (er_5 = copyOfStruct_5.fields[0], FSharpResult$2_Error(er_5)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], v5 = copyOfStruct_4.fields[0], v6 = copyOfStruct_5.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4, v5, v6)));
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function map7(ctor, d1, d2, d3, d4, d5, d6, d7) {
+  return {
+    Decode(helpers, value_1) {
+      let er_6, v1, v2, v3, v4, v5, v6, v7;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const matchValue_4 = d5.Decode(helpers, value_1);
+      const matchValue_5 = d6.Decode(helpers, value_1);
+      const matchValue_6 = d7.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            if (copyOfStruct_3.tag === /* Error */
+            1) {
+              const er_3 = copyOfStruct_3.fields[0];
+              return FSharpResult$2_Error(er_3);
+            } else {
+              const copyOfStruct_4 = matchValue_4;
+              if (copyOfStruct_4.tag === /* Error */
+              1) {
+                const er_4 = copyOfStruct_4.fields[0];
+                return FSharpResult$2_Error(er_4);
+              } else {
+                const copyOfStruct_5 = matchValue_5;
+                if (copyOfStruct_5.tag === /* Error */
+                1) {
+                  const er_5 = copyOfStruct_5.fields[0];
+                  return FSharpResult$2_Error(er_5);
+                } else {
+                  const copyOfStruct_6 = matchValue_6;
+                  return copyOfStruct_6.tag === /* Error */
+                  1 ? (er_6 = copyOfStruct_6.fields[0], FSharpResult$2_Error(er_6)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], v5 = copyOfStruct_4.fields[0], v6 = copyOfStruct_5.fields[0], v7 = copyOfStruct_6.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4, v5, v6, v7)));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function map8(ctor, d1, d2, d3, d4, d5, d6, d7, d8) {
+  return {
+    Decode(helpers, value_1) {
+      let er_7, v1, v2, v3, v4, v5, v6, v7, v8;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const matchValue_4 = d5.Decode(helpers, value_1);
+      const matchValue_5 = d6.Decode(helpers, value_1);
+      const matchValue_6 = d7.Decode(helpers, value_1);
+      const matchValue_7 = d8.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            if (copyOfStruct_3.tag === /* Error */
+            1) {
+              const er_3 = copyOfStruct_3.fields[0];
+              return FSharpResult$2_Error(er_3);
+            } else {
+              const copyOfStruct_4 = matchValue_4;
+              if (copyOfStruct_4.tag === /* Error */
+              1) {
+                const er_4 = copyOfStruct_4.fields[0];
+                return FSharpResult$2_Error(er_4);
+              } else {
+                const copyOfStruct_5 = matchValue_5;
+                if (copyOfStruct_5.tag === /* Error */
+                1) {
+                  const er_5 = copyOfStruct_5.fields[0];
+                  return FSharpResult$2_Error(er_5);
+                } else {
+                  const copyOfStruct_6 = matchValue_6;
+                  if (copyOfStruct_6.tag === /* Error */
+                  1) {
+                    const er_6 = copyOfStruct_6.fields[0];
+                    return FSharpResult$2_Error(er_6);
+                  } else {
+                    const copyOfStruct_7 = matchValue_7;
+                    return copyOfStruct_7.tag === /* Error */
+                    1 ? (er_7 = copyOfStruct_7.fields[0], FSharpResult$2_Error(er_7)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], v5 = copyOfStruct_4.fields[0], v6 = copyOfStruct_5.fields[0], v7 = copyOfStruct_6.fields[0], v8 = copyOfStruct_7.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4, v5, v6, v7, v8)));
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function lossyOption(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      return helpers.isNullValue(value_1) ? FSharpResult$2_Ok(void 0) : Result_Map(some, decoder.Decode(helpers, value_1));
+    }
+  };
+}
+function losslessOption(decoder) {
+  return andThen((typeName) => {
+    if (typeName === "option") {
+      return andThen((state) => {
+        switch (state) {
+          case "none":
+            return succeed(void 0);
+          case "some":
+            return map(some, field("$value", decoder));
+          default:
+            return fail("Expecting a state field with value 'none' or 'some' but got " + state);
+        }
+      }, field("$case", string));
+    } else {
+      return fail("Expecting an Option type but got " + typeName);
+    }
+  }, field("$type", string));
+}
+function andMap() {
+  return (d) => (d_1) => map2((arg, func) => func(arg), d, d_1);
+}
 function unwrapWith(errors, helpers, decoder, value_1) {
   const matchValue = decoder.Decode(helpers, value_1);
   if (matchValue.tag === /* Error */
@@ -511,6 +1192,9 @@ class Getters$2 {
     return __.optional;
   }
 }
+function Getters$2_$reflection(gen0, gen1) {
+  return class_type("Thoth.Json.Core.Decode.Getters`2", [gen0, gen1], Getters$2);
+}
 function Getters$2_$ctor_Z4BE6C149(helpers, value_1) {
   return new Getters$2(helpers, value_1);
 }
@@ -535,10 +1219,33 @@ function object(builder) {
 function tuple2(decoder1, decoder2) {
   return andThen((v1) => andThen((v2) => succeed([v1, v2]), index(1, decoder2)), index(0, decoder1));
 }
+function tuple3(decoder1, decoder2, decoder3) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => succeed([v1, v2, v3]), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple4(decoder1, decoder2, decoder3, decoder4) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => succeed([v1, v2, v3, v4]), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => andThen((v5) => succeed([v1, v2, v3, v4, v5]), index(4, decoder5)), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => andThen((v5) => andThen((v6) => succeed([v1, v2, v3, v4, v5, v6]), index(5, decoder6)), index(4, decoder5)), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple7(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6, decoder7) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => andThen((v5) => andThen((v6) => andThen((v7) => succeed([v1, v2, v3, v4, v5, v6, v7]), index(6, decoder7)), index(5, decoder6)), index(4, decoder5)), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple8(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6, decoder7, decoder8) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => andThen((v5) => andThen((v6) => andThen((v7) => andThen((v8) => succeed([v1, v2, v3, v4, v5, v6, v7, v8]), index(7, decoder8)), index(6, decoder7)), index(5, decoder6)), index(4, decoder5)), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function dict(decoder) {
+  return map((elements) => ofList(elements, {
+    Compare: comparePrimitives
+  }), keyValuePairs(decoder));
+}
 function map$0027(keyDecoder, valueDecoder) {
-  return map((elements) => ofSeq(elements, {
+  return map((elements) => ofSeq$1(elements, {
     Compare: compare
   }), array(tuple2(keyDecoder, valueDecoder)));
 }
 
-export { Getters$2, Getters$2_$ctor_Z4BE6C149, Getters$2__get_Errors, Helpers_prependPath, andThen, array, at, bool, decimal, errorToString, field, float, guid, index, int, list, map, map$0027, object, oneOf, optional, optionalAt, resizeArray, string, succeed, tuple2, unit };
+export { Advanced_fromValue, Getters$2, Getters$2_$ctor_Z4BE6C149, Getters$2_$reflection, Getters$2__get_Errors, Helpers_prependPath, all, andMap, andThen, array, at, bigint, bool, byte, char, datetimeLocal, datetimeOffset, datetimeUtc, decimal, dict, errorToString, fail, field, float, float32, guid, index, int, int16, int64, keyValuePairs, keys, list, losslessOption, lossyOption, map, map$0027, map2, map3, map4, map5, map6, map7, map8, nil, object, oneOf, optional, optionalAt, resizeArray, sbyte, seq, string, succeed, timespan, tuple2, tuple3, tuple4, tuple5, tuple6, tuple7, tuple8, uint16, uint32, uint64, unit, value };