@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Decode.fs.js

@@ -0,0 +1,2337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Auto () {
+        return Auto;
+    },
+    get Auto_$reflection () {
+        return Auto_$reflection;
+    },
+    get Auto_generateBoxedDecoderCached_Z6670B51 () {
+        return Auto_generateBoxedDecoderCached_Z6670B51;
+    },
+    get Auto_generateBoxedDecoder_Z6670B51 () {
+        return Auto_generateBoxedDecoder_Z6670B51;
+    },
+    get Getters$1 () {
+        return Getters$1;
+    },
+    get Getters$1_$ctor_4A51B60E () {
+        return Getters$1_$ctor_4A51B60E;
+    },
+    get Getters$1_$reflection () {
+        return Getters$1_$reflection;
+    },
+    get Getters$1__get_Errors () {
+        return Getters$1__get_Errors;
+    },
+    get Helpers_isUndefined () {
+        return Helpers_isUndefined;
+    },
+    get all () {
+        return all;
+    },
+    get andMap () {
+        return andMap;
+    },
+    get andThen () {
+        return andThen;
+    },
+    get array () {
+        return array;
+    },
+    get at () {
+        return at;
+    },
+    get bigint () {
+        return bigint;
+    },
+    get bool () {
+        return bool;
+    },
+    get byte () {
+        return byte;
+    },
+    get char () {
+        return char;
+    },
+    get datetime () {
+        return datetime;
+    },
+    get datetimeLocal () {
+        return datetimeLocal;
+    },
+    get datetimeOffset () {
+        return datetimeOffset;
+    },
+    get datetimeUtc () {
+        return datetimeUtc;
+    },
+    get decimal () {
+        return decimal;
+    },
+    get decodeString () {
+        return decodeString;
+    },
+    get decodeValue () {
+        return decodeValue;
+    },
+    get dict () {
+        return dict;
+    },
+    get fail () {
+        return fail;
+    },
+    get field () {
+        return field;
+    },
+    get float () {
+        return float;
+    },
+    get float32 () {
+        return float32;
+    },
+    get fromString () {
+        return fromString;
+    },
+    get fromValue () {
+        return fromValue;
+    },
+    get guid () {
+        return guid;
+    },
+    get index () {
+        return index;
+    },
+    get int () {
+        return int;
+    },
+    get int16 () {
+        return int16;
+    },
+    get int64 () {
+        return int64;
+    },
+    get keyValuePairs () {
+        return keyValuePairs;
+    },
+    get keys () {
+        return keys;
+    },
+    get list () {
+        return list;
+    },
+    get map () {
+        return map;
+    },
+    get map$0027 () {
+        return map$0027;
+    },
+    get map2 () {
+        return map2;
+    },
+    get map3 () {
+        return map3;
+    },
+    get map4 () {
+        return map4;
+    },
+    get map5 () {
+        return map5;
+    },
+    get map6 () {
+        return map6;
+    },
+    get map7 () {
+        return map7;
+    },
+    get map8 () {
+        return map8;
+    },
+    get nil () {
+        return nil;
+    },
+    get object () {
+        return object;
+    },
+    get oneOf () {
+        return oneOf;
+    },
+    get option () {
+        return option;
+    },
+    get optional () {
+        return optional;
+    },
+    get optionalAt () {
+        return optionalAt;
+    },
+    get sbyte () {
+        return sbyte;
+    },
+    get seq () {
+        return seq;
+    },
+    get string () {
+        return string;
+    },
+    get succeed () {
+        return succeed;
+    },
+    get timespan () {
+        return timespan;
+    },
+    get tuple2 () {
+        return tuple2;
+    },
+    get tuple3 () {
+        return tuple3;
+    },
+    get tuple4 () {
+        return tuple4;
+    },
+    get tuple5 () {
+        return tuple5;
+    },
+    get tuple6 () {
+        return tuple6;
+    },
+    get tuple7 () {
+        return tuple7;
+    },
+    get tuple8 () {
+        return tuple8;
+    },
+    get uint16 () {
+        return uint16;
+    },
+    get uint32 () {
+        return uint32;
+    },
+    get uint64 () {
+        return uint64;
+    },
+    get unit () {
+        return unit;
+    },
+    get unsafeFromString () {
+        return unsafeFromString;
+    },
+    get value () {
+        return value;
+    }
+});
+const _String = require("@fable-org/fable-library-js/String.js");
+const _Typesfs = require("./Types.fs.js");
+const _Result = require("@fable-org/fable-library-js/Result.js");
+const _Guid = require("@fable-org/fable-library-js/Guid.js");
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Int32 = require("@fable-org/fable-library-js/Int32.js");
+const _BigInt = require("@fable-org/fable-library-js/BigInt.js");
+const _Long = require("@fable-org/fable-library-js/Long.js");
+const _Decimal = /*#__PURE__*/ _interop_require_wildcard(require("@fable-org/fable-library-js/Decimal.js"));
+const _Date = require("@fable-org/fable-library-js/Date.js");
+const _DateOffset = require("@fable-org/fable-library-js/DateOffset.js");
+const _TimeSpan = require("@fable-org/fable-library-js/TimeSpan.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _Array = require("@fable-org/fable-library-js/Array.js");
+const _Seq = require("@fable-org/fable-library-js/Seq.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _Set = require("@fable-org/fable-library-js/Set.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function Helpers_isUndefined(o) {
+    return typeof o === "undefined";
+}
+function genericMsg(msg, value_1, newLine) {
+    try {
+        return "Expecting " + msg + " but instead got:" + (newLine ? "\n" : " ") + (JSON.stringify(value_1, null, 4) + '');
+    } catch (matchValue) {
+        return "Expecting " + msg + " but decoder failed. Couldn\'t report given value due to circular structure." + (newLine ? "\n" : " ");
+    }
+}
+function errorToString(path, error) {
+    let reason_1;
+    switch(error.tag){
+        case /* BadType */ 2:
+            {
+                reason_1 = genericMsg(error.fields[0], error.fields[1], true);
+                break;
+            }
+        case /* BadPrimitiveExtra */ 1:
+            {
+                const reason = error.fields[2];
+                reason_1 = genericMsg(error.fields[0], error.fields[1], false) + "\nReason: " + reason;
+                break;
+            }
+        case /* BadField */ 3:
+            {
+                reason_1 = genericMsg(error.fields[0], error.fields[1], true);
+                break;
+            }
+        case /* BadPath */ 4:
+            {
+                const fieldName = error.fields[2];
+                reason_1 = genericMsg(error.fields[0], error.fields[1], true) + ("\nNode `" + fieldName + "` is unkown.");
+                break;
+            }
+        case /* TooSmallArray */ 5:
+            {
+                const value_6 = error.fields[1];
+                reason_1 = "Expecting " + error.fields[0] + ".\n" + (JSON.stringify(value_6, null, 4) + '');
+                break;
+            }
+        case /* BadOneOf */ 7:
+            {
+                reason_1 = "The following errors were found:\n\n" + (0, _String.join)("\n\n", error.fields[0]);
+                break;
+            }
+        case /* FailMessage */ 6:
+            {
+                reason_1 = "The following `failure` occurred with the decoder: " + error.fields[0];
+                break;
+            }
+        default:
+            reason_1 = genericMsg(error.fields[0], error.fields[1], false);
+    }
+    if (error.tag === /* BadOneOf */ 7) {
+        return reason_1;
+    } else {
+        return "Error at: `" + path + "`\n" + reason_1;
+    }
+}
+function fromValue(path, decoder, value_1) {
+    const matchValue = decoder(path, value_1);
+    if (matchValue.tag === /* Error */ 1) {
+        const error = matchValue.fields[0];
+        return (0, _Result.FSharpResult$2_Error)(errorToString(error[0], error[1]));
+    } else {
+        return (0, _Result.FSharpResult$2_Ok)(matchValue.fields[0]);
+    }
+}
+function fromString(decoder, value_1) {
+    try {
+        return fromValue("$", decoder, JSON.parse(value_1));
+    } catch (matchValue) {
+        if (matchValue instanceof SyntaxError) {
+            return (0, _Result.FSharpResult$2_Error)("Given an invalid JSON: " + matchValue.message);
+        } else {
+            throw matchValue;
+        }
+    }
+}
+function unsafeFromString(decoder, value_1) {
+    const matchValue = fromString(decoder, value_1);
+    if (matchValue.tag === /* Error */ 1) {
+        throw new Error(matchValue.fields[0]);
+    } else {
+        return matchValue.fields[0];
+    }
+}
+function decodeValue(path, decoder) {
+    const decoder_1 = decoder;
+    return (value_1)=>fromValue(path, decoder_1, value_1);
+}
+function decodeString(decoder) {
+    const decoder_1 = decoder;
+    return (value_1)=>fromString(decoder_1, value_1);
+}
+function string(path, value_1) {
+    if (typeof value_1 === "string") {
+        return (0, _Result.FSharpResult$2_Ok)(value_1);
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a string", value_1)
+        ]);
+    }
+}
+function char(path, value_1) {
+    if (typeof value_1 === "string") {
+        const str = value_1;
+        if (str.length === 1) {
+            return (0, _Result.FSharpResult$2_Ok)(str[0]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a single character string", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a char", value_1)
+        ]);
+    }
+}
+function guid(path, value_1) {
+    if (typeof value_1 === "string") {
+        let matchValue;
+        let outArg = "00000000-0000-0000-0000-000000000000";
+        matchValue = [
+            (0, _Guid.tryParse)(value_1, new _Types.FSharpRef(()=>outArg, (v)=>{
+                outArg = v;
+            })),
+            outArg
+        ];
+        if (matchValue[0]) {
+            return (0, _Result.FSharpResult$2_Ok)(matchValue[1]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a guid", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a guid", value_1)
+        ]);
+    }
+}
+function unit(path, value_1) {
+    if (value_1 == null) {
+        return (0, _Result.FSharpResult$2_Ok)(undefined);
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("null", value_1)
+        ]);
+    }
+}
+const sbyte = (path)=>(value_2)=>{
+        const path_1 = path;
+        const value_3 = value_2;
+        if (typeof value_3 === "number") {
+            const value_1_1 = value_3;
+            return isFinite(value_1_1) && Math.floor(value_1_1) === value_1_1 ? -128 <= value_1_1 && value_1_1 <= 127 ? (0, _Result.FSharpResult$2_Ok)((value_1_1 + 0x80 & 0xFF) - 0x80) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("a sbyte", value_1_1, "Value was either too large or too small for a sbyte")
+            ]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("a sbyte", value_1_1, "Value is not an integral value")
+            ]);
+        } else if (typeof value_3 === "string") {
+            let matchValue;
+            let outArg = 0;
+            matchValue = [
+                (0, _Int32.tryParse)(value_3, 511, false, 8, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v | 0;
+                })),
+                outArg
+            ];
+            return matchValue[0] ? (0, _Result.FSharpResult$2_Ok)(matchValue[1]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a sbyte", value_3)
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a sbyte", value_3)
+            ]);
+        }
+    };
+const byte = (path)=>(value_2)=>{
+        const path_1 = path;
+        const value_3 = value_2;
+        if (typeof value_3 === "number") {
+            const value_1_1 = value_3;
+            return isFinite(value_1_1) && Math.floor(value_1_1) === value_1_1 ? 0 <= value_1_1 && value_1_1 <= 255 ? (0, _Result.FSharpResult$2_Ok)(value_1_1 & 0xFF) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("a byte", value_1_1, "Value was either too large or too small for a byte")
+            ]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("a byte", value_1_1, "Value is not an integral value")
+            ]);
+        } else if (typeof value_3 === "string") {
+            let matchValue;
+            let outArg = 0;
+            matchValue = [
+                (0, _Int32.tryParse)(value_3, 511, true, 8, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v;
+                })),
+                outArg
+            ];
+            return matchValue[0] ? (0, _Result.FSharpResult$2_Ok)(matchValue[1]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a byte", value_3)
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a byte", value_3)
+            ]);
+        }
+    };
+const int16 = (path)=>(value_2)=>{
+        const path_1 = path;
+        const value_3 = value_2;
+        if (typeof value_3 === "number") {
+            const value_1_1 = value_3;
+            return isFinite(value_1_1) && Math.floor(value_1_1) === value_1_1 ? -32768 <= value_1_1 && value_1_1 <= 32767 ? (0, _Result.FSharpResult$2_Ok)((value_1_1 + 0x8000 & 0xFFFF) - 0x8000) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an int16", value_1_1, "Value was either too large or too small for an int16")
+            ]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an int16", value_1_1, "Value is not an integral value")
+            ]);
+        } else if (typeof value_3 === "string") {
+            let matchValue;
+            let outArg = 0;
+            matchValue = [
+                (0, _Int32.tryParse)(value_3, 511, false, 16, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v | 0;
+                })),
+                outArg
+            ];
+            return matchValue[0] ? (0, _Result.FSharpResult$2_Ok)(matchValue[1]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an int16", value_3)
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an int16", value_3)
+            ]);
+        }
+    };
+const uint16 = (path)=>(value_2)=>{
+        const path_1 = path;
+        const value_3 = value_2;
+        if (typeof value_3 === "number") {
+            const value_1_1 = value_3;
+            return isFinite(value_1_1) && Math.floor(value_1_1) === value_1_1 ? 0 <= value_1_1 && value_1_1 <= 65535 ? (0, _Result.FSharpResult$2_Ok)(value_1_1 & 0xFFFF) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an uint16", value_1_1, "Value was either too large or too small for an uint16")
+            ]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an uint16", value_1_1, "Value is not an integral value")
+            ]);
+        } else if (typeof value_3 === "string") {
+            let matchValue;
+            let outArg = 0;
+            matchValue = [
+                (0, _Int32.tryParse)(value_3, 511, true, 16, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v;
+                })),
+                outArg
+            ];
+            return matchValue[0] ? (0, _Result.FSharpResult$2_Ok)(matchValue[1]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an uint16", value_3)
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an uint16", value_3)
+            ]);
+        }
+    };
+const int = (path)=>(value_2)=>{
+        const path_1 = path;
+        const value_3 = value_2;
+        if (typeof value_3 === "number") {
+            const value_1_1 = value_3;
+            return isFinite(value_1_1) && Math.floor(value_1_1) === value_1_1 ? -2147483648 <= value_1_1 && value_1_1 <= 2147483647 ? (0, _Result.FSharpResult$2_Ok)(~~value_1_1) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an int", value_1_1, "Value was either too large or too small for an int")
+            ]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an int", value_1_1, "Value is not an integral value")
+            ]);
+        } else if (typeof value_3 === "string") {
+            let matchValue;
+            let outArg = 0;
+            matchValue = [
+                (0, _Int32.tryParse)(value_3, 511, false, 32, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v | 0;
+                })),
+                outArg
+            ];
+            return matchValue[0] ? (0, _Result.FSharpResult$2_Ok)(matchValue[1]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an int", value_3)
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an int", value_3)
+            ]);
+        }
+    };
+const uint32 = (path)=>(value_2)=>{
+        const path_1 = path;
+        const value_3 = value_2;
+        if (typeof value_3 === "number") {
+            const value_1_1 = value_3;
+            return isFinite(value_1_1) && Math.floor(value_1_1) === value_1_1 ? 0 <= value_1_1 && value_1_1 <= 4294967295 ? (0, _Result.FSharpResult$2_Ok)(value_1_1 >>> 0) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an uint32", value_1_1, "Value was either too large or too small for an uint32")
+            ]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an uint32", value_1_1, "Value is not an integral value")
+            ]);
+        } else if (typeof value_3 === "string") {
+            let matchValue;
+            let outArg = 0;
+            matchValue = [
+                (0, _Int32.tryParse)(value_3, 511, true, 32, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v;
+                })),
+                outArg
+            ];
+            return matchValue[0] ? (0, _Result.FSharpResult$2_Ok)(matchValue[1]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an uint32", value_3)
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an uint32", value_3)
+            ]);
+        }
+    };
+const int64 = (path)=>(value_2)=>{
+        const path_1 = path;
+        const value_3 = value_2;
+        if (typeof value_3 === "number") {
+            const value_1_1 = value_3;
+            return isFinite(value_1_1) && Math.floor(value_1_1) === value_1_1 ? (0, _BigInt.toFloat64)(-9223372036854775808n) <= value_1_1 && value_1_1 <= (0, _BigInt.toFloat64)(9223372036854775807n) ? (0, _Result.FSharpResult$2_Ok)((0, _BigInt.toInt64)((0, _BigInt.fromFloat64)(value_1_1))) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an int64", value_1_1, "Value was either too large or too small for an int64")
+            ]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an int64", value_1_1, "Value is not an integral value")
+            ]);
+        } else if (typeof value_3 === "string") {
+            let matchValue;
+            let outArg = 0n;
+            matchValue = [
+                (0, _Long.tryParse)(value_3, 511, false, 64, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v;
+                })),
+                outArg
+            ];
+            return matchValue[0] ? (0, _Result.FSharpResult$2_Ok)(matchValue[1]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an int64", value_3)
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an int64", value_3)
+            ]);
+        }
+    };
+const uint64 = (path)=>(value_2)=>{
+        const path_1 = path;
+        const value_3 = value_2;
+        if (typeof value_3 === "number") {
+            const value_1_1 = value_3;
+            return isFinite(value_1_1) && Math.floor(value_1_1) === value_1_1 ? (0, _BigInt.toFloat64)(0n) <= value_1_1 && value_1_1 <= (0, _BigInt.toFloat64)(18446744073709551615n) ? (0, _Result.FSharpResult$2_Ok)((0, _BigInt.toUInt64)((0, _BigInt.fromFloat64)(value_1_1))) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an uint64", value_1_1, "Value was either too large or too small for an uint64")
+            ]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitiveExtra)("an uint64", value_1_1, "Value is not an integral value")
+            ]);
+        } else if (typeof value_3 === "string") {
+            let matchValue;
+            let outArg = 0n;
+            matchValue = [
+                (0, _Long.tryParse)(value_3, 511, true, 64, new _Types.FSharpRef(()=>outArg, (v)=>{
+                    outArg = v;
+                })),
+                outArg
+            ];
+            return matchValue[0] ? (0, _Result.FSharpResult$2_Ok)(matchValue[1]) : (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an uint64", value_3)
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path_1,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("an uint64", value_3)
+            ]);
+        }
+    };
+function bigint(path, value_1) {
+    if (typeof value_1 === "number") {
+        return (0, _Result.FSharpResult$2_Ok)((0, _BigInt.fromInt32)(value_1));
+    } else if (typeof value_1 === "string") {
+        try {
+            return (0, _Result.FSharpResult$2_Ok)((0, _BigInt.parse)(value_1));
+        } catch (matchValue) {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a bigint", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a bigint", value_1)
+        ]);
+    }
+}
+function bool(path, value_1) {
+    if (typeof value_1 === "boolean") {
+        return (0, _Result.FSharpResult$2_Ok)(value_1);
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a boolean", value_1)
+        ]);
+    }
+}
+function float(path, value_1) {
+    if (typeof value_1 === "number") {
+        return (0, _Result.FSharpResult$2_Ok)(value_1);
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a float", value_1)
+        ]);
+    }
+}
+function float32(path, value_1) {
+    if (typeof value_1 === "number") {
+        return (0, _Result.FSharpResult$2_Ok)(value_1);
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a float32", value_1)
+        ]);
+    }
+}
+function decimal(path, value_1) {
+    if (typeof value_1 === "number") {
+        return (0, _Result.FSharpResult$2_Ok)(new _Decimal.default(value_1));
+    } else if (typeof value_1 === "string") {
+        let matchValue;
+        let outArg = new _Decimal.default("0");
+        matchValue = [
+            (0, _Decimal.tryParse)(value_1, new _Types.FSharpRef(()=>outArg, (v)=>{
+                outArg = v;
+            })),
+            outArg
+        ];
+        if (matchValue[0]) {
+            return (0, _Result.FSharpResult$2_Ok)(matchValue[1]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a decimal", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a decimal", value_1)
+        ]);
+    }
+}
+function datetime(path, value_1) {
+    if (typeof value_1 === "string") {
+        let matchValue;
+        let outArg = (0, _Date.minValue)();
+        matchValue = [
+            (0, _Date.tryParse)(value_1, new _Types.FSharpRef(()=>outArg, (v)=>{
+                outArg = v;
+            })),
+            outArg
+        ];
+        if (matchValue[0]) {
+            return (0, _Result.FSharpResult$2_Ok)((0, _Date.toUniversalTime)(matchValue[1]));
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a datetime", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a datetime", value_1)
+        ]);
+    }
+}
+function datetimeUtc(path, value_1) {
+    if (typeof value_1 === "string") {
+        let matchValue;
+        let outArg = (0, _Date.minValue)();
+        matchValue = [
+            (0, _Date.tryParse)(value_1, new _Types.FSharpRef(()=>outArg, (v)=>{
+                outArg = v;
+            })),
+            outArg
+        ];
+        if (matchValue[0]) {
+            return (0, _Result.FSharpResult$2_Ok)((0, _Date.toUniversalTime)(matchValue[1]));
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a datetime", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a datetime", value_1)
+        ]);
+    }
+}
+function datetimeLocal(path, value_1) {
+    if (typeof value_1 === "string") {
+        let matchValue;
+        let outArg = (0, _Date.minValue)();
+        matchValue = [
+            (0, _Date.tryParse)(value_1, new _Types.FSharpRef(()=>outArg, (v)=>{
+                outArg = v;
+            })),
+            outArg
+        ];
+        if (matchValue[0]) {
+            return (0, _Result.FSharpResult$2_Ok)(matchValue[1]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a datetime", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a datetime", value_1)
+        ]);
+    }
+}
+function datetimeOffset(path, value_1) {
+    if (typeof value_1 === "string") {
+        let matchValue;
+        let outArg = (0, _DateOffset.minValue)();
+        matchValue = [
+            (0, _DateOffset.tryParse)(value_1, new _Types.FSharpRef(()=>outArg, (v)=>{
+                outArg = v;
+            })),
+            outArg
+        ];
+        if (matchValue[0]) {
+            return (0, _Result.FSharpResult$2_Ok)(matchValue[1]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a datetimeoffset", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a datetime", value_1)
+        ]);
+    }
+}
+function timespan(path, value_1) {
+    if (typeof value_1 === "string") {
+        let matchValue;
+        let outArg = 0;
+        matchValue = [
+            (0, _TimeSpan.tryParse)(value_1, new _Types.FSharpRef(()=>outArg, (v)=>{
+                outArg = v;
+            })),
+            outArg
+        ];
+        if (matchValue[0]) {
+            return (0, _Result.FSharpResult$2_Ok)(matchValue[1]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadPrimitive)("a timespan", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a timespan", value_1)
+        ]);
+    }
+}
+function decodeMaybeNull(path, decoder, value_1) {
+    if (value_1 == null) {
+        return (0, _Result.FSharpResult$2_Ok)(undefined);
+    } else {
+        const matchValue = decoder(path, value_1);
+        if (matchValue.tag === /* Error */ 1) {
+            return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+        } else {
+            return (0, _Result.FSharpResult$2_Ok)((0, _Option.some)(matchValue.fields[0]));
+        }
+    }
+}
+function optional(fieldName, decoder, path, value_1) {
+    if (value_1 === null ? false : Object.getPrototypeOf(value_1 || false) === Object.prototype) {
+        const fieldValue = value_1[fieldName];
+        if (Helpers_isUndefined(fieldValue)) {
+            return (0, _Result.FSharpResult$2_Ok)(undefined);
+        } else {
+            return decodeMaybeNull(path + "." + fieldName, decoder, fieldValue);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadType)("an object", value_1)
+        ]);
+    }
+}
+function badPathError(fieldNames, currentPath, value_1) {
+    return (0, _Result.FSharpResult$2_Error)([
+        (0, _Option.defaultArg)(currentPath, (0, _String.join)(".", (0, _List.cons)("$", fieldNames))),
+        (0, _Typesfs.ErrorReason_BadPath)("an object with path `" + (0, _String.join)(".", fieldNames) + "`", value_1, (0, _Option.defaultArg)((0, _List.tryLast)(fieldNames), ""))
+    ]);
+}
+function optionalAt(fieldNames, decoder, firstPath, firstValue) {
+    const _arg = (0, _List.fold)((tupledArg, field_1)=>{
+        const curPath = tupledArg[0];
+        const curValue = tupledArg[1];
+        const res = tupledArg[2];
+        if (res == null) {
+            if (curValue == null) {
+                return [
+                    curPath,
+                    curValue,
+                    (0, _Result.FSharpResult$2_Ok)(undefined)
+                ];
+            } else if (curValue === null ? false : Object.getPrototypeOf(curValue || false) === Object.prototype) {
+                return [
+                    curPath + "." + field_1,
+                    curValue[field_1],
+                    undefined
+                ];
+            } else {
+                return [
+                    curPath,
+                    curValue,
+                    (0, _Result.FSharpResult$2_Error)([
+                        curPath,
+                        (0, _Typesfs.ErrorReason_BadType)("an object", curValue)
+                    ])
+                ];
+            }
+        } else {
+            return [
+                curPath,
+                curValue,
+                res
+            ];
+        }
+    }, [
+        firstPath,
+        firstValue,
+        undefined
+    ], fieldNames);
+    if (_arg[2] == null) {
+        const lastValue = _arg[1];
+        if (Helpers_isUndefined(lastValue)) {
+            return (0, _Result.FSharpResult$2_Ok)(undefined);
+        } else {
+            return decodeMaybeNull(_arg[0], decoder, lastValue);
+        }
+    } else {
+        return (0, _Option.value)(_arg[2]);
+    }
+}
+function field(fieldName, decoder, path, value_1) {
+    if (value_1 === null ? false : Object.getPrototypeOf(value_1 || false) === Object.prototype) {
+        const fieldValue = value_1[fieldName];
+        if (Helpers_isUndefined(fieldValue)) {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadField)("an object with a field named `" + fieldName + "`", value_1)
+            ]);
+        } else {
+            return decoder(path + "." + fieldName, fieldValue);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadType)("an object", value_1)
+        ]);
+    }
+}
+function at(fieldNames, decoder, firstPath, firstValue) {
+    const _arg = (0, _List.fold)((tupledArg, field_1)=>{
+        const curPath = tupledArg[0];
+        const curValue = tupledArg[1];
+        const res = tupledArg[2];
+        if (res == null) {
+            if (curValue == null) {
+                return [
+                    curPath,
+                    curValue,
+                    badPathError(fieldNames, curPath, firstValue)
+                ];
+            } else if (curValue === null ? false : Object.getPrototypeOf(curValue || false) === Object.prototype) {
+                const curValue_1 = curValue[field_1];
+                if (Helpers_isUndefined(curValue_1)) {
+                    return [
+                        curPath,
+                        curValue_1,
+                        badPathError(fieldNames, undefined, firstValue)
+                    ];
+                } else {
+                    return [
+                        curPath + "." + field_1,
+                        curValue_1,
+                        undefined
+                    ];
+                }
+            } else {
+                return [
+                    curPath,
+                    curValue,
+                    (0, _Result.FSharpResult$2_Error)([
+                        curPath,
+                        (0, _Typesfs.ErrorReason_BadType)("an object", curValue)
+                    ])
+                ];
+            }
+        } else {
+            return [
+                curPath,
+                curValue,
+                res
+            ];
+        }
+    }, [
+        firstPath,
+        firstValue,
+        undefined
+    ], fieldNames);
+    if (_arg[2] == null) {
+        return decoder(_arg[0], _arg[1]);
+    } else {
+        return (0, _Option.value)(_arg[2]);
+    }
+}
+function index(requestedIndex, decoder, path, value_1) {
+    let copyOfStruct;
+    const currentPath = path + ".[" + (0, _Util.int32ToString)(requestedIndex) + "]";
+    if (Array.isArray(value_1)) {
+        const vArray = value_1;
+        if (requestedIndex < vArray.length) {
+            return decoder(currentPath, (0, _Array.item)(requestedIndex, vArray));
+        } else {
+            return (0, _Result.FSharpResult$2_Error)([
+                currentPath,
+                (0, _Typesfs.ErrorReason_TooSmallArray)("a longer array. Need index `" + (0, _Util.int32ToString)(requestedIndex) + "` but there are only `" + (copyOfStruct = vArray.length, (0, _Util.int32ToString)(copyOfStruct)) + "` entries", value_1)
+            ]);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            currentPath,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("an array", value_1)
+        ]);
+    }
+}
+function option(decoder, path, value_1) {
+    if (value_1 == null) {
+        return (0, _Result.FSharpResult$2_Ok)(undefined);
+    } else {
+        return (0, _Result.Result_Map)(_Option.some, decoder(path, value_1));
+    }
+}
+function list(decoder, path, value_1) {
+    if (Array.isArray(value_1)) {
+        let i = -1;
+        return (0, _Result.Result_Map)(_List.reverse, (0, _Array.fold)((acc, value_2)=>{
+            i = i + 1 | 0;
+            if (acc.tag === /* Ok */ 0) {
+                const acc_1 = acc.fields[0];
+                const matchValue = decoder(path + ".[" + (0, _Util.int32ToString)(i) + "]", value_2);
+                if (matchValue.tag === /* Ok */ 0) {
+                    return (0, _Result.FSharpResult$2_Ok)((0, _List.cons)(matchValue.fields[0], acc_1));
+                } else {
+                    return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+                }
+            } else {
+                return acc;
+            }
+        }, (0, _Result.FSharpResult$2_Ok)((0, _List.empty)()), value_1));
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a list", value_1)
+        ]);
+    }
+}
+function seq(decoder, path, value_1) {
+    if (Array.isArray(value_1)) {
+        let i = -1;
+        return (0, _Result.Result_Map)(_Seq.reverse, (0, _Array.fold)((acc, value_2)=>{
+            i = i + 1 | 0;
+            if (acc.tag === /* Ok */ 0) {
+                const acc_1 = acc.fields[0];
+                const matchValue = decoder(path + ".[" + (0, _Util.int32ToString)(i) + "]", value_2);
+                if (matchValue.tag === /* Ok */ 0) {
+                    return (0, _Result.FSharpResult$2_Ok)((0, _Seq.append)([
+                        matchValue.fields[0]
+                    ], acc_1));
+                } else {
+                    return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+                }
+            } else {
+                return acc;
+            }
+        }, (0, _Result.FSharpResult$2_Ok)([]), value_1));
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("a seq", value_1)
+        ]);
+    }
+}
+function array(decoder, path, value_1) {
+    if (Array.isArray(value_1)) {
+        let i = -1;
+        const tokens = value_1;
+        return (0, _Array.fold)((acc, value_2)=>{
+            i = i + 1 | 0;
+            if (acc.tag === /* Ok */ 0) {
+                const acc_1 = acc.fields[0];
+                const matchValue = decoder(path + ".[" + (0, _Util.int32ToString)(i) + "]", value_2);
+                if (matchValue.tag === /* Ok */ 0) {
+                    const value_3 = matchValue.fields[0];
+                    (0, _Array.setItem)(acc_1, i, value_3);
+                    return (0, _Result.FSharpResult$2_Ok)(acc_1);
+                } else {
+                    return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+                }
+            } else {
+                return acc;
+            }
+        }, (0, _Result.FSharpResult$2_Ok)((0, _Array.fill)(new Array(tokens.length), 0, tokens.length, null)), tokens);
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("an array", value_1)
+        ]);
+    }
+}
+function keys(path, value_1) {
+    if (value_1 === null ? false : Object.getPrototypeOf(value_1 || false) === Object.prototype) {
+        return (0, _Result.FSharpResult$2_Ok)((0, _List.ofSeq)(Object.keys(value_1)));
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("an object", value_1)
+        ]);
+    }
+}
+function keyValuePairs(decoder, path, value_1) {
+    const matchValue = keys(path, value_1);
+    if (matchValue.tag === /* Error */ 1) {
+        return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+    } else {
+        return (0, _Result.Result_Map)(_List.reverse, (0, _List.fold)((acc, prop)=>{
+            if (acc.tag === /* Ok */ 0) {
+                const acc_1 = acc.fields[0];
+                const matchValue_1 = decoder(path, value_1[prop]);
+                if (matchValue_1.tag === /* Ok */ 0) {
+                    return (0, _Result.FSharpResult$2_Ok)((0, _List.cons)([
+                        prop,
+                        matchValue_1.fields[0]
+                    ], acc_1));
+                } else {
+                    return (0, _Result.FSharpResult$2_Error)(matchValue_1.fields[0]);
+                }
+            } else {
+                return acc;
+            }
+        }, (0, _Result.FSharpResult$2_Ok)((0, _List.empty)()), matchValue.fields[0]));
+    }
+}
+function oneOf(decoders, path, value_1) {
+    const runner = (decoders_1_mut, errors_mut)=>{
+        runner: while(true){
+            const decoders_1 = decoders_1_mut, errors = errors_mut;
+            if ((0, _List.isEmpty)(decoders_1)) {
+                return (0, _Result.FSharpResult$2_Error)([
+                    path,
+                    (0, _Typesfs.ErrorReason_BadOneOf)(errors)
+                ]);
+            } else {
+                const matchValue = fromValue(path, (0, _Util.uncurry2)((0, _List.head)(decoders_1)), value_1);
+                if (matchValue.tag === /* Error */ 1) {
+                    decoders_1_mut = (0, _List.tail)(decoders_1);
+                    errors_mut = (0, _List.append)(errors, (0, _List.singleton)(matchValue.fields[0]));
+                    continue runner;
+                } else {
+                    return (0, _Result.FSharpResult$2_Ok)(matchValue.fields[0]);
+                }
+            }
+            break;
+        }
+    };
+    return runner(decoders, (0, _List.empty)());
+}
+function nil(output, path, value_1) {
+    if (value_1 == null) {
+        return (0, _Result.FSharpResult$2_Ok)(output);
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("null", value_1)
+        ]);
+    }
+}
+function value(_arg, v) {
+    return (0, _Result.FSharpResult$2_Ok)(v);
+}
+function succeed(output, _arg, _arg_1) {
+    return (0, _Result.FSharpResult$2_Ok)(output);
+}
+function fail(msg, path, _arg) {
+    return (0, _Result.FSharpResult$2_Error)([
+        path,
+        (0, _Typesfs.ErrorReason_FailMessage)(msg)
+    ]);
+}
+function andThen(cb, decoder, path, value_1) {
+    const matchValue = decoder(path, value_1);
+    if (matchValue.tag === /* Ok */ 0) {
+        return cb(matchValue.fields[0], path, value_1);
+    } else {
+        return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+    }
+}
+function all(decoders, path, value_1) {
+    const runner = (decoders_1_mut, values_mut)=>{
+        runner: while(true){
+            const decoders_1 = decoders_1_mut, values = values_mut;
+            if ((0, _List.isEmpty)(decoders_1)) {
+                return (0, _Result.FSharpResult$2_Ok)(values);
+            } else {
+                const matchValue = (0, _List.head)(decoders_1)(path)(value_1);
+                if (matchValue.tag === /* Error */ 1) {
+                    return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+                } else {
+                    decoders_1_mut = (0, _List.tail)(decoders_1);
+                    values_mut = (0, _List.append)(values, (0, _List.singleton)(matchValue.fields[0]));
+                    continue runner;
+                }
+            }
+            break;
+        }
+    };
+    return runner(decoders, (0, _List.empty)());
+}
+function map(ctor, d1, path, value_1) {
+    const matchValue = d1(path, value_1);
+    if (matchValue.tag === /* Error */ 1) {
+        return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+    } else {
+        return (0, _Result.FSharpResult$2_Ok)(ctor(matchValue.fields[0]));
+    }
+}
+function map2(ctor, d1, d2, path, value_1) {
+    const matchValue = d1(path, value_1);
+    const matchValue_1 = d2(path, value_1);
+    const copyOfStruct = matchValue;
+    if (copyOfStruct.tag === /* Error */ 1) {
+        const er = copyOfStruct.fields[0];
+        return (0, _Result.FSharpResult$2_Error)(er);
+    } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */ 1) {
+            const er_1 = copyOfStruct_1.fields[0];
+            return (0, _Result.FSharpResult$2_Error)(er_1);
+        } else {
+            const v1 = copyOfStruct.fields[0];
+            const v2 = copyOfStruct_1.fields[0];
+            return (0, _Result.FSharpResult$2_Ok)(ctor(v1, v2));
+        }
+    }
+}
+function map3(ctor, d1, d2, d3, path, value_1) {
+    const matchValue = d1(path, value_1);
+    const matchValue_1 = d2(path, value_1);
+    const matchValue_2 = d3(path, value_1);
+    const copyOfStruct = matchValue;
+    if (copyOfStruct.tag === /* Error */ 1) {
+        const er = copyOfStruct.fields[0];
+        return (0, _Result.FSharpResult$2_Error)(er);
+    } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */ 1) {
+            const er_1 = copyOfStruct_1.fields[0];
+            return (0, _Result.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 (0, _Result.FSharpResult$2_Error)(er_2);
+            } else {
+                const v1 = copyOfStruct.fields[0];
+                const v2 = copyOfStruct_1.fields[0];
+                const v3 = copyOfStruct_2.fields[0];
+                return (0, _Result.FSharpResult$2_Ok)(ctor(v1, v2, v3));
+            }
+        }
+    }
+}
+function map4(ctor, d1, d2, d3, d4, path, value_1) {
+    const matchValue = d1(path, value_1);
+    const matchValue_1 = d2(path, value_1);
+    const matchValue_2 = d3(path, value_1);
+    const matchValue_3 = d4(path, value_1);
+    const copyOfStruct = matchValue;
+    if (copyOfStruct.tag === /* Error */ 1) {
+        const er = copyOfStruct.fields[0];
+        return (0, _Result.FSharpResult$2_Error)(er);
+    } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */ 1) {
+            const er_1 = copyOfStruct_1.fields[0];
+            return (0, _Result.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 (0, _Result.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 (0, _Result.FSharpResult$2_Error)(er_3);
+                } else {
+                    const v1 = copyOfStruct.fields[0];
+                    const v2 = copyOfStruct_1.fields[0];
+                    const v3 = copyOfStruct_2.fields[0];
+                    const v4 = copyOfStruct_3.fields[0];
+                    return (0, _Result.FSharpResult$2_Ok)(ctor(v1, v2, v3, v4));
+                }
+            }
+        }
+    }
+}
+function map5(ctor, d1, d2, d3, d4, d5, path, value_1) {
+    const matchValue = d1(path, value_1);
+    const matchValue_1 = d2(path, value_1);
+    const matchValue_2 = d3(path, value_1);
+    const matchValue_3 = d4(path, value_1);
+    const matchValue_4 = d5(path, value_1);
+    const copyOfStruct = matchValue;
+    if (copyOfStruct.tag === /* Error */ 1) {
+        const er = copyOfStruct.fields[0];
+        return (0, _Result.FSharpResult$2_Error)(er);
+    } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */ 1) {
+            const er_1 = copyOfStruct_1.fields[0];
+            return (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.FSharpResult$2_Error)(er_4);
+                    } else {
+                        const v1 = copyOfStruct.fields[0];
+                        const v2 = copyOfStruct_1.fields[0];
+                        const v3 = copyOfStruct_2.fields[0];
+                        const v4 = copyOfStruct_3.fields[0];
+                        const v5 = copyOfStruct_4.fields[0];
+                        return (0, _Result.FSharpResult$2_Ok)(ctor(v1, v2, v3, v4, v5));
+                    }
+                }
+            }
+        }
+    }
+}
+function map6(ctor, d1, d2, d3, d4, d5, d6, path, value_1) {
+    const matchValue = d1(path, value_1);
+    const matchValue_1 = d2(path, value_1);
+    const matchValue_2 = d3(path, value_1);
+    const matchValue_3 = d4(path, value_1);
+    const matchValue_4 = d5(path, value_1);
+    const matchValue_5 = d6(path, value_1);
+    const copyOfStruct = matchValue;
+    if (copyOfStruct.tag === /* Error */ 1) {
+        const er = copyOfStruct.fields[0];
+        return (0, _Result.FSharpResult$2_Error)(er);
+    } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */ 1) {
+            const er_1 = copyOfStruct_1.fields[0];
+            return (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.FSharpResult$2_Error)(er_5);
+                        } else {
+                            const v1 = copyOfStruct.fields[0];
+                            const v2 = copyOfStruct_1.fields[0];
+                            const v3 = copyOfStruct_2.fields[0];
+                            const v4 = copyOfStruct_3.fields[0];
+                            const v5 = copyOfStruct_4.fields[0];
+                            const v6 = copyOfStruct_5.fields[0];
+                            return (0, _Result.FSharpResult$2_Ok)(ctor(v1, v2, v3, v4, v5, v6));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function map7(ctor, d1, d2, d3, d4, d5, d6, d7, path, value_1) {
+    const matchValue = d1(path, value_1);
+    const matchValue_1 = d2(path, value_1);
+    const matchValue_2 = d3(path, value_1);
+    const matchValue_3 = d4(path, value_1);
+    const matchValue_4 = d5(path, value_1);
+    const matchValue_5 = d6(path, value_1);
+    const matchValue_6 = d7(path, value_1);
+    const copyOfStruct = matchValue;
+    if (copyOfStruct.tag === /* Error */ 1) {
+        const er = copyOfStruct.fields[0];
+        return (0, _Result.FSharpResult$2_Error)(er);
+    } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */ 1) {
+            const er_1 = copyOfStruct_1.fields[0];
+            return (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.FSharpResult$2_Error)(er_6);
+                            } else {
+                                const v1 = copyOfStruct.fields[0];
+                                const v2 = copyOfStruct_1.fields[0];
+                                const v3 = copyOfStruct_2.fields[0];
+                                const v4 = copyOfStruct_3.fields[0];
+                                const v5 = copyOfStruct_4.fields[0];
+                                const v6 = copyOfStruct_5.fields[0];
+                                const v7 = copyOfStruct_6.fields[0];
+                                return (0, _Result.FSharpResult$2_Ok)(ctor(v1, v2, v3, v4, v5, v6, v7));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function map8(ctor, d1, d2, d3, d4, d5, d6, d7, d8, path, value_1) {
+    const matchValue = d1(path, value_1);
+    const matchValue_1 = d2(path, value_1);
+    const matchValue_2 = d3(path, value_1);
+    const matchValue_3 = d4(path, value_1);
+    const matchValue_4 = d5(path, value_1);
+    const matchValue_5 = d6(path, value_1);
+    const matchValue_6 = d7(path, value_1);
+    const matchValue_7 = d8(path, value_1);
+    const copyOfStruct = matchValue;
+    if (copyOfStruct.tag === /* Error */ 1) {
+        const er = copyOfStruct.fields[0];
+        return (0, _Result.FSharpResult$2_Error)(er);
+    } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */ 1) {
+            const er_1 = copyOfStruct_1.fields[0];
+            return (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.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 (0, _Result.FSharpResult$2_Error)(er_6);
+                            } else {
+                                const copyOfStruct_7 = matchValue_7;
+                                if (copyOfStruct_7.tag === /* Error */ 1) {
+                                    const er_7 = copyOfStruct_7.fields[0];
+                                    return (0, _Result.FSharpResult$2_Error)(er_7);
+                                } else {
+                                    const v1 = copyOfStruct.fields[0];
+                                    const v2 = copyOfStruct_1.fields[0];
+                                    const v3 = copyOfStruct_2.fields[0];
+                                    const v4 = copyOfStruct_3.fields[0];
+                                    const v5 = copyOfStruct_4.fields[0];
+                                    const v6 = copyOfStruct_5.fields[0];
+                                    const v7 = copyOfStruct_6.fields[0];
+                                    const v8 = copyOfStruct_7.fields[0];
+                                    return (0, _Result.FSharpResult$2_Ok)(ctor(v1, v2, v3, v4, v5, v6, v7, v8));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function andMap() {
+    return (d)=>(d_1)=>(path)=>(value_1)=>map2((arg, func)=>func(arg), (0, _Util.uncurry2)(d), (0, _Util.uncurry2)(d_1), path, value_1);
+}
+function unwrapWith(errors, path, decoder, value_1) {
+    const matchValue = decoder(path, value_1);
+    if (matchValue.tag === /* Error */ 1) {
+        const er = matchValue.fields[0];
+        void errors.push(er);
+        return (0, _Util.defaultOf)();
+    } else {
+        return matchValue.fields[0];
+    }
+}
+class Getters$1 {
+    get Required() {
+        const __ = this;
+        return __.required;
+    }
+    get Optional() {
+        const __ = this;
+        return __.optional;
+    }
+    constructor(path, v){
+        let _this, _this_1;
+        this.errors = [];
+        this.required = (_this = this, {
+            Field (fieldName, decoder) {
+                return unwrapWith(_this.errors, path, (path_1, value_1)=>field(fieldName, decoder, path_1, value_1), v);
+            },
+            At (fieldNames, decoder_2) {
+                return unwrapWith(_this.errors, path, (firstPath, firstValue)=>at(fieldNames, decoder_2, firstPath, firstValue), v);
+            },
+            Raw (decoder_4) {
+                return unwrapWith(_this.errors, path, decoder_4, v);
+            }
+        });
+        this.optional = (_this_1 = this, {
+            Field (fieldName_1, decoder_5) {
+                return unwrapWith(_this_1.errors, path, (path_2, value_2)=>optional(fieldName_1, decoder_5, path_2, value_2), v);
+            },
+            At (fieldNames_1, decoder_7) {
+                return unwrapWith(_this_1.errors, path, (firstPath_1, firstValue_1)=>optionalAt(fieldNames_1, decoder_7, firstPath_1, firstValue_1), v);
+            },
+            Raw (decoder_9) {
+                const matchValue = decoder_9(path, v);
+                if (matchValue.tag === /* Error */ 1) {
+                    const reason = matchValue.fields[0][1];
+                    const error = matchValue.fields[0];
+                    let matchResult, v_2;
+                    switch(reason.tag){
+                        case /* BadField */ 3:
+                        case /* BadPath */ 4:
+                            {
+                                matchResult = 1;
+                                break;
+                            }
+                        case /* TooSmallArray */ 5:
+                        case /* FailMessage */ 6:
+                        case /* BadOneOf */ 7:
+                            {
+                                matchResult = 2;
+                                break;
+                            }
+                        case /* BadPrimitiveExtra */ 1:
+                            {
+                                matchResult = 0;
+                                v_2 = reason.fields[1];
+                                break;
+                            }
+                        case /* BadType */ 2:
+                            {
+                                matchResult = 0;
+                                v_2 = reason.fields[1];
+                                break;
+                            }
+                        default:
+                            {
+                                matchResult = 0;
+                                v_2 = reason.fields[1];
+                            }
+                    }
+                    switch(matchResult){
+                        case 0:
+                            if (v_2 == null) {
+                                return undefined;
+                            } else {
+                                void _this_1.errors.push(error);
+                                return (0, _Util.defaultOf)();
+                            }
+                        case 1:
+                            return undefined;
+                        default:
+                            {
+                                void _this_1.errors.push(error);
+                                return (0, _Util.defaultOf)();
+                            }
+                    }
+                } else {
+                    return (0, _Option.some)(matchValue.fields[0]);
+                }
+            }
+        });
+    }
+}
+function Getters$1_$reflection(gen0) {
+    return (0, _Reflection.class_type)("Thoth.Json.Decode.Getters`1", [
+        gen0
+    ], Getters$1);
+}
+function Getters$1_$ctor_4A51B60E(path, v) {
+    return new Getters$1(path, v);
+}
+function Getters$1__get_Errors(__) {
+    return (0, _Seq.toList)(__.errors);
+}
+function object(builder, path, v) {
+    const getters = Getters$1_$ctor_4A51B60E(path, v);
+    const result = builder(getters);
+    const matchValue = Getters$1__get_Errors(getters);
+    if (!(0, _List.isEmpty)(matchValue)) {
+        const errors = matchValue;
+        if ((0, _List.length)(errors) > 1) {
+            return (0, _Result.FSharpResult$2_Error)([
+                path,
+                (0, _Typesfs.ErrorReason_BadOneOf)((0, _List.map)((tupledArg)=>errorToString(tupledArg[0], tupledArg[1]), errors))
+            ]);
+        } else {
+            return (0, _Result.FSharpResult$2_Error)((0, _List.head)(matchValue));
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Ok)(result);
+    }
+}
+function tuple2(decoder1, decoder2) {
+    let decoder_3;
+    const decoder = decoder1;
+    decoder_3 = (path)=>(value_1)=>index(0, decoder, path, value_1);
+    return (path_3)=>(value_4)=>andThen((0, _Util.uncurry3)((v1)=>{
+                let decoder_2;
+                const decoder_1 = decoder2;
+                decoder_2 = (path_1)=>(value_2)=>index(1, decoder_1, path_1, value_2);
+                return (path_2)=>(value_3)=>andThen((v2, arg10$0040, arg20$0040)=>succeed([
+                                v1,
+                                v2
+                            ], arg10$0040, arg20$0040), (0, _Util.uncurry2)(decoder_2), path_2, value_3);
+            }), (0, _Util.uncurry2)(decoder_3), path_3, value_4);
+}
+function tuple3(decoder1, decoder2, decoder3) {
+    let decoder_5;
+    const decoder = decoder1;
+    decoder_5 = (path)=>(value_1)=>index(0, decoder, path, value_1);
+    return (path_5)=>(value_6)=>andThen((0, _Util.uncurry3)((v1)=>{
+                let decoder_4;
+                const decoder_1 = decoder2;
+                decoder_4 = (path_1)=>(value_2)=>index(1, decoder_1, path_1, value_2);
+                return (path_4)=>(value_5)=>andThen((0, _Util.uncurry3)((v2)=>{
+                            let decoder_3;
+                            const decoder_2 = decoder3;
+                            decoder_3 = (path_2)=>(value_3)=>index(2, decoder_2, path_2, value_3);
+                            return (path_3)=>(value_4)=>andThen((v3, arg10$0040, arg20$0040)=>succeed([
+                                            v1,
+                                            v2,
+                                            v3
+                                        ], arg10$0040, arg20$0040), (0, _Util.uncurry2)(decoder_3), path_3, value_4);
+                        }), (0, _Util.uncurry2)(decoder_4), path_4, value_5);
+            }), (0, _Util.uncurry2)(decoder_5), path_5, value_6);
+}
+function tuple4(decoder1, decoder2, decoder3, decoder4) {
+    let decoder_7;
+    const decoder = decoder1;
+    decoder_7 = (path)=>(value_1)=>index(0, decoder, path, value_1);
+    return (path_7)=>(value_8)=>andThen((0, _Util.uncurry3)((v1)=>{
+                let decoder_6;
+                const decoder_1 = decoder2;
+                decoder_6 = (path_1)=>(value_2)=>index(1, decoder_1, path_1, value_2);
+                return (path_6)=>(value_7)=>andThen((0, _Util.uncurry3)((v2)=>{
+                            let decoder_5;
+                            const decoder_2 = decoder3;
+                            decoder_5 = (path_2)=>(value_3)=>index(2, decoder_2, path_2, value_3);
+                            return (path_5)=>(value_6)=>andThen((0, _Util.uncurry3)((v3)=>{
+                                        let decoder_4;
+                                        const decoder_3 = decoder4;
+                                        decoder_4 = (path_3)=>(value_4)=>index(3, decoder_3, path_3, value_4);
+                                        return (path_4)=>(value_5)=>andThen((v4, arg10$0040, arg20$0040)=>succeed([
+                                                        v1,
+                                                        v2,
+                                                        v3,
+                                                        v4
+                                                    ], arg10$0040, arg20$0040), (0, _Util.uncurry2)(decoder_4), path_4, value_5);
+                                    }), (0, _Util.uncurry2)(decoder_5), path_5, value_6);
+                        }), (0, _Util.uncurry2)(decoder_6), path_6, value_7);
+            }), (0, _Util.uncurry2)(decoder_7), path_7, value_8);
+}
+function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
+    let decoder_9;
+    const decoder = decoder1;
+    decoder_9 = (path)=>(value_1)=>index(0, decoder, path, value_1);
+    return (path_9)=>(value_10)=>andThen((0, _Util.uncurry3)((v1)=>{
+                let decoder_8;
+                const decoder_1 = decoder2;
+                decoder_8 = (path_1)=>(value_2)=>index(1, decoder_1, path_1, value_2);
+                return (path_8)=>(value_9)=>andThen((0, _Util.uncurry3)((v2)=>{
+                            let decoder_7;
+                            const decoder_2 = decoder3;
+                            decoder_7 = (path_2)=>(value_3)=>index(2, decoder_2, path_2, value_3);
+                            return (path_7)=>(value_8)=>andThen((0, _Util.uncurry3)((v3)=>{
+                                        let decoder_6;
+                                        const decoder_3 = decoder4;
+                                        decoder_6 = (path_3)=>(value_4)=>index(3, decoder_3, path_3, value_4);
+                                        return (path_6)=>(value_7)=>andThen((0, _Util.uncurry3)((v4)=>{
+                                                    let decoder_5;
+                                                    const decoder_4 = decoder5;
+                                                    decoder_5 = (path_4)=>(value_5)=>index(4, decoder_4, path_4, value_5);
+                                                    return (path_5)=>(value_6)=>andThen((v5, arg10$0040, arg20$0040)=>succeed([
+                                                                    v1,
+                                                                    v2,
+                                                                    v3,
+                                                                    v4,
+                                                                    v5
+                                                                ], arg10$0040, arg20$0040), (0, _Util.uncurry2)(decoder_5), path_5, value_6);
+                                                }), (0, _Util.uncurry2)(decoder_6), path_6, value_7);
+                                    }), (0, _Util.uncurry2)(decoder_7), path_7, value_8);
+                        }), (0, _Util.uncurry2)(decoder_8), path_8, value_9);
+            }), (0, _Util.uncurry2)(decoder_9), path_9, value_10);
+}
+function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
+    let decoder_11;
+    const decoder = decoder1;
+    decoder_11 = (path)=>(value_1)=>index(0, decoder, path, value_1);
+    return (path_11)=>(value_12)=>andThen((0, _Util.uncurry3)((v1)=>{
+                let decoder_10;
+                const decoder_1 = decoder2;
+                decoder_10 = (path_1)=>(value_2)=>index(1, decoder_1, path_1, value_2);
+                return (path_10)=>(value_11)=>andThen((0, _Util.uncurry3)((v2)=>{
+                            let decoder_9;
+                            const decoder_2 = decoder3;
+                            decoder_9 = (path_2)=>(value_3)=>index(2, decoder_2, path_2, value_3);
+                            return (path_9)=>(value_10)=>andThen((0, _Util.uncurry3)((v3)=>{
+                                        let decoder_8;
+                                        const decoder_3 = decoder4;
+                                        decoder_8 = (path_3)=>(value_4)=>index(3, decoder_3, path_3, value_4);
+                                        return (path_8)=>(value_9)=>andThen((0, _Util.uncurry3)((v4)=>{
+                                                    let decoder_7;
+                                                    const decoder_4 = decoder5;
+                                                    decoder_7 = (path_4)=>(value_5)=>index(4, decoder_4, path_4, value_5);
+                                                    return (path_7)=>(value_8)=>andThen((0, _Util.uncurry3)((v5)=>{
+                                                                let decoder_6;
+                                                                const decoder_5 = decoder6;
+                                                                decoder_6 = (path_5)=>(value_6)=>index(5, decoder_5, path_5, value_6);
+                                                                return (path_6)=>(value_7)=>andThen((v6, arg10$0040, arg20$0040)=>succeed([
+                                                                                v1,
+                                                                                v2,
+                                                                                v3,
+                                                                                v4,
+                                                                                v5,
+                                                                                v6
+                                                                            ], arg10$0040, arg20$0040), (0, _Util.uncurry2)(decoder_6), path_6, value_7);
+                                                            }), (0, _Util.uncurry2)(decoder_7), path_7, value_8);
+                                                }), (0, _Util.uncurry2)(decoder_8), path_8, value_9);
+                                    }), (0, _Util.uncurry2)(decoder_9), path_9, value_10);
+                        }), (0, _Util.uncurry2)(decoder_10), path_10, value_11);
+            }), (0, _Util.uncurry2)(decoder_11), path_11, value_12);
+}
+function tuple7(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6, decoder7) {
+    let decoder_13;
+    const decoder = decoder1;
+    decoder_13 = (path)=>(value_1)=>index(0, decoder, path, value_1);
+    return (path_13)=>(value_14)=>andThen((0, _Util.uncurry3)((v1)=>{
+                let decoder_12;
+                const decoder_1 = decoder2;
+                decoder_12 = (path_1)=>(value_2)=>index(1, decoder_1, path_1, value_2);
+                return (path_12)=>(value_13)=>andThen((0, _Util.uncurry3)((v2)=>{
+                            let decoder_11;
+                            const decoder_2 = decoder3;
+                            decoder_11 = (path_2)=>(value_3)=>index(2, decoder_2, path_2, value_3);
+                            return (path_11)=>(value_12)=>andThen((0, _Util.uncurry3)((v3)=>{
+                                        let decoder_10;
+                                        const decoder_3 = decoder4;
+                                        decoder_10 = (path_3)=>(value_4)=>index(3, decoder_3, path_3, value_4);
+                                        return (path_10)=>(value_11)=>andThen((0, _Util.uncurry3)((v4)=>{
+                                                    let decoder_9;
+                                                    const decoder_4 = decoder5;
+                                                    decoder_9 = (path_4)=>(value_5)=>index(4, decoder_4, path_4, value_5);
+                                                    return (path_9)=>(value_10)=>andThen((0, _Util.uncurry3)((v5)=>{
+                                                                let decoder_8;
+                                                                const decoder_5 = decoder6;
+                                                                decoder_8 = (path_5)=>(value_6)=>index(5, decoder_5, path_5, value_6);
+                                                                return (path_8)=>(value_9)=>andThen((0, _Util.uncurry3)((v6)=>{
+                                                                            let decoder_7;
+                                                                            const decoder_6 = decoder7;
+                                                                            decoder_7 = (path_6)=>(value_7)=>index(6, decoder_6, path_6, value_7);
+                                                                            return (path_7)=>(value_8)=>andThen((v7, arg10$0040, arg20$0040)=>succeed([
+                                                                                            v1,
+                                                                                            v2,
+                                                                                            v3,
+                                                                                            v4,
+                                                                                            v5,
+                                                                                            v6,
+                                                                                            v7
+                                                                                        ], arg10$0040, arg20$0040), (0, _Util.uncurry2)(decoder_7), path_7, value_8);
+                                                                        }), (0, _Util.uncurry2)(decoder_8), path_8, value_9);
+                                                            }), (0, _Util.uncurry2)(decoder_9), path_9, value_10);
+                                                }), (0, _Util.uncurry2)(decoder_10), path_10, value_11);
+                                    }), (0, _Util.uncurry2)(decoder_11), path_11, value_12);
+                        }), (0, _Util.uncurry2)(decoder_12), path_12, value_13);
+            }), (0, _Util.uncurry2)(decoder_13), path_13, value_14);
+}
+function tuple8(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6, decoder7, decoder8) {
+    let decoder_15;
+    const decoder = decoder1;
+    decoder_15 = (path)=>(value_1)=>index(0, decoder, path, value_1);
+    return (path_15)=>(value_16)=>andThen((0, _Util.uncurry3)((v1)=>{
+                let decoder_14;
+                const decoder_1 = decoder2;
+                decoder_14 = (path_1)=>(value_2)=>index(1, decoder_1, path_1, value_2);
+                return (path_14)=>(value_15)=>andThen((0, _Util.uncurry3)((v2)=>{
+                            let decoder_13;
+                            const decoder_2 = decoder3;
+                            decoder_13 = (path_2)=>(value_3)=>index(2, decoder_2, path_2, value_3);
+                            return (path_13)=>(value_14)=>andThen((0, _Util.uncurry3)((v3)=>{
+                                        let decoder_12;
+                                        const decoder_3 = decoder4;
+                                        decoder_12 = (path_3)=>(value_4)=>index(3, decoder_3, path_3, value_4);
+                                        return (path_12)=>(value_13)=>andThen((0, _Util.uncurry3)((v4)=>{
+                                                    let decoder_11;
+                                                    const decoder_4 = decoder5;
+                                                    decoder_11 = (path_4)=>(value_5)=>index(4, decoder_4, path_4, value_5);
+                                                    return (path_11)=>(value_12)=>andThen((0, _Util.uncurry3)((v5)=>{
+                                                                let decoder_10;
+                                                                const decoder_5 = decoder6;
+                                                                decoder_10 = (path_5)=>(value_6)=>index(5, decoder_5, path_5, value_6);
+                                                                return (path_10)=>(value_11)=>andThen((0, _Util.uncurry3)((v6)=>{
+                                                                            let decoder_9;
+                                                                            const decoder_6 = decoder7;
+                                                                            decoder_9 = (path_6)=>(value_7)=>index(6, decoder_6, path_6, value_7);
+                                                                            return (path_9)=>(value_10)=>andThen((0, _Util.uncurry3)((v7)=>{
+                                                                                        let decoder_8;
+                                                                                        const decoder_7 = decoder8;
+                                                                                        decoder_8 = (path_7)=>(value_8)=>index(7, decoder_7, path_7, value_8);
+                                                                                        return (path_8)=>(value_9)=>andThen((v8, arg10$0040, arg20$0040)=>succeed([
+                                                                                                        v1,
+                                                                                                        v2,
+                                                                                                        v3,
+                                                                                                        v4,
+                                                                                                        v5,
+                                                                                                        v6,
+                                                                                                        v7,
+                                                                                                        v8
+                                                                                                    ], arg10$0040, arg20$0040), (0, _Util.uncurry2)(decoder_8), path_8, value_9);
+                                                                                    }), (0, _Util.uncurry2)(decoder_9), path_9, value_10);
+                                                                        }), (0, _Util.uncurry2)(decoder_10), path_10, value_11);
+                                                            }), (0, _Util.uncurry2)(decoder_11), path_11, value_12);
+                                                }), (0, _Util.uncurry2)(decoder_12), path_12, value_13);
+                                    }), (0, _Util.uncurry2)(decoder_13), path_13, value_14);
+                        }), (0, _Util.uncurry2)(decoder_14), path_14, value_15);
+            }), (0, _Util.uncurry2)(decoder_15), path_15, value_16);
+}
+function dict(decoder) {
+    let d;
+    const decoder_1 = decoder;
+    d = (path)=>(value_1)=>keyValuePairs(decoder_1, path, value_1);
+    return (path_1)=>(value_2)=>map((elements)=>(0, _Map.ofList)(elements, {
+                    Compare: _Util.comparePrimitives
+                }), (0, _Util.uncurry2)(d), path_1, value_2);
+}
+function map$0027(keyDecoder, valueDecoder) {
+    let d;
+    const decoder = tuple2(keyDecoder, valueDecoder);
+    d = (path)=>(value_1)=>array((0, _Util.uncurry2)(decoder), path, value_1);
+    return (path_1)=>(value_2)=>map((elements)=>(0, _Map.ofSeq)(elements, {
+                    Compare: _Util.compare
+                }), (0, _Util.uncurry2)(d), path_1, value_2);
+}
+function toMap(xs) {
+    return (0, _Map.ofSeq)(xs, {
+        Compare: _Util.compare
+    });
+}
+function toSet(xs) {
+    return (0, _Set.ofSeq)(xs, {
+        Compare: _Util.compare
+    });
+}
+function autoObject(decoderInfos, path, value_1) {
+    if (!(value_1 === null ? false : Object.getPrototypeOf(value_1 || false) === Object.prototype)) {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("an object", value_1)
+        ]);
+    } else {
+        return (0, _Array.foldBack)((tupledArg, acc)=>{
+            const name = tupledArg[0];
+            if (acc.tag === /* Ok */ 0) {
+                const result = acc.fields[0];
+                return (0, _Result.Result_Map)((v)=>(0, _List.cons)(v, result), tupledArg[1](path + "." + name)(value_1[name]));
+            } else {
+                return acc;
+            }
+        }, decoderInfos, (0, _Result.FSharpResult$2_Ok)((0, _List.empty)()));
+    }
+}
+function autoObject2(keyDecoder, valueDecoder, path, value_1) {
+    if (!(value_1 === null ? false : Object.getPrototypeOf(value_1 || false) === Object.prototype)) {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_BadPrimitive)("an object", value_1)
+        ]);
+    } else {
+        return (0, _Seq.fold)((acc, name)=>{
+            if (acc.tag === /* Ok */ 0) {
+                const acc_1 = acc.fields[0];
+                const matchValue = keyDecoder(path, name);
+                if (matchValue.tag === /* Ok */ 0) {
+                    const k = matchValue.fields[0];
+                    const _arg = valueDecoder(path + "." + name, value_1[name]);
+                    if (_arg.tag === /* Ok */ 0) {
+                        return (0, _Result.FSharpResult$2_Ok)((0, _List.cons)([
+                            k,
+                            _arg.fields[0]
+                        ], acc_1));
+                    } else {
+                        return (0, _Result.FSharpResult$2_Error)(_arg.fields[0]);
+                    }
+                } else {
+                    return (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]);
+                }
+            } else {
+                return acc;
+            }
+        }, (0, _Result.FSharpResult$2_Ok)((0, _List.empty)()), Object.keys(value_1));
+    }
+}
+function mixedArray(offset, decoders, path, values) {
+    let arg_1;
+    const expectedLength = decoders.length + offset | 0;
+    if (expectedLength !== values.length) {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_FailMessage)((arg_1 = values.length | 0, (0, _String.toText)((0, _String.printf)("Expected array of length %i but got %i"))(expectedLength)(arg_1)))
+        ]);
+    } else {
+        let result = (0, _Result.FSharpResult$2_Ok)((0, _List.empty)());
+        for(let i = offset; i <= values.length - 1; i++){
+            if (result.tag === /* Ok */ 0) {
+                const acc = result.fields[0];
+                const path_1 = (0, _String.toText)((0, _String.printf)("%s[%i]"))(path)(i);
+                const decoder = (0, _Array.item)(i - offset, decoders);
+                const value_1 = (0, _Array.item)(i, values);
+                result = (0, _Result.Result_Map)((v)=>(0, _List.cons)(v, acc), decoder(path_1)(value_1));
+            }
+        }
+        return (0, _Result.Result_Map)(_List.reverse, result);
+    }
+}
+function makeUnion(extra, caseStrategy, t, name, path, values) {
+    const uci = (0, _Array.tryFind)((x)=>(0, _Reflection.name)(x) === name, (0, _Reflection.getUnionCases)(t, true));
+    if (uci != null) {
+        const uci_1 = (0, _Option.value)(uci);
+        const decoders = (0, _Array.map)((fi)=>autoDecoder(extra, caseStrategy, false, fi[1]), (0, _Reflection.getUnionCaseFields)(uci_1));
+        return (0, _Result.Result_Map)((values_2)=>(0, _Reflection.makeUnion)(uci_1, (0, _List.toArray)(values_2), true), decoders.length === 0 && values.length <= 1 ? (0, _Result.FSharpResult$2_Ok)((0, _List.empty)()) : mixedArray(1, decoders, path, values));
+    } else {
+        return (0, _Result.FSharpResult$2_Error)([
+            path,
+            (0, _Typesfs.ErrorReason_FailMessage)("Cannot find case " + name + " in " + (0, _Reflection.fullName)(t))
+        ]);
+    }
+}
+function autoDecodeRecordsAndUnions(extra, caseStrategy, isOptional, t) {
+    let arg;
+    const decoderRef = new _Types.FSharpRef((0, _Util.defaultOf)());
+    let extra_1;
+    const matchValue = (0, _Reflection.fullName)(t);
+    extra_1 = matchValue === "" ? extra : (0, _Map.add)(matchValue, decoderRef, extra);
+    let decoder;
+    if ((0, _Reflection.isRecord)(t, true)) {
+        const decoders = (0, _Array.map)((fi)=>[
+                (0, _Typesfs.Util_Casing_convert)(caseStrategy, (0, _Reflection.name)(fi)),
+                autoDecoder(extra_1, caseStrategy, false, fi[1])
+            ], (0, _Reflection.getRecordElements)(t, true));
+        decoder = (path)=>(value_1)=>(0, _Result.Result_Map)((xs)=>(0, _Reflection.makeRecord)(t, (0, _List.toArray)(xs), true), autoObject(decoders, path, value_1));
+    } else if ((0, _Reflection.isUnion)(t, true)) {
+        decoder = (path_1)=>(value_2)=>{
+                if (typeof value_2 === "string") {
+                    return makeUnion(extra_1, caseStrategy, t, value_2, path_1, []);
+                } else if (Array.isArray(value_2)) {
+                    const values = value_2;
+                    return (0, _Result.Result_Bind)((name_2)=>makeUnion(extra_1, caseStrategy, t, name_2, path_1, values), string(path_1 + "[0]", (0, _Array.item)(0, values)));
+                } else {
+                    return (0, _Result.FSharpResult$2_Error)([
+                        path_1,
+                        (0, _Typesfs.ErrorReason_BadPrimitive)("a string or array", value_2)
+                    ]);
+                }
+            };
+    } else if (isOptional) {
+        decoder = (path_2)=>(value_3)=>(0, _Result.FSharpResult$2_Error)([
+                    path_2,
+                    (0, _Typesfs.ErrorReason_BadType)("an extra coder for " + (0, _Reflection.fullName)(t), value_3)
+                ]);
+    } else {
+        throw new Error((arg = (0, _Reflection.fullName)(t), (0, _String.toText)((0, _String.printf)("Cannot generate auto decoder for %s. Please pass an extra decoder.\n\nDocumentation available at: https://thoth-org.github.io/Thoth.Json/documentation/auto/extra-coders.html#ready-to-use-extra-coders"))(arg)));
+    }
+    decoderRef.contents = decoder;
+    return decoder;
+}
+function autoDecoder(extra, caseStrategy, isOptional, t) {
+    let decoder_13, decoder_14, decoder_15, decoder_16;
+    const fullname = (0, _Reflection.fullName)(t);
+    const matchValue = (0, _Map.tryFind)(fullname, extra);
+    if (matchValue == null) {
+        if ((0, _Reflection.isArray)(t)) {
+            const decoder = autoDecoder(extra, caseStrategy, false, (0, _Reflection.getElementType)(t));
+            return (path_1)=>(value_2)=>array((0, _Util.uncurry2)(decoder), path_1, value_2);
+        } else if ((0, _Reflection.isEnum)(t)) {
+            const enumType = (0, _Reflection.fullName)((0, _Reflection.getEnumUnderlyingType)(t));
+            switch(enumType){
+                case "System.SByte":
+                    return (path_2)=>(value_4)=>{
+                            const t_2 = t;
+                            const path_3 = path_2;
+                            const value_5 = value_4;
+                            const matchValue_1 = sbyte(path_3)(value_5);
+                            if (matchValue_1.tag === /* Error */ 1) {
+                                return (0, _Result.FSharpResult$2_Error)(matchValue_1.fields[0]);
+                            } else {
+                                const enumValue = matchValue_1.fields[0] | 0;
+                                return (0, _Seq.contains)(enumValue, (0, _Reflection.getEnumValues)(t_2), {
+                                    Equals: (x, y)=>x === y,
+                                    GetHashCode: _Util.numberHash
+                                }) ? (0, _Result.FSharpResult$2_Ok)((0, _Reflection.parseEnum)(t_2, enumValue.toString())) : (0, _Result.FSharpResult$2_Error)([
+                                    path_3,
+                                    (0, _Typesfs.ErrorReason_BadPrimitiveExtra)((0, _Reflection.fullName)(t_2), value_5, "Unkown value provided for the enum")
+                                ]);
+                            }
+                        };
+                case "System.Byte":
+                    return (path_4)=>(value_7)=>{
+                            const t_3 = t;
+                            const path_5 = path_4;
+                            const value_8 = value_7;
+                            const matchValue_2 = byte(path_5)(value_8);
+                            if (matchValue_2.tag === /* Error */ 1) {
+                                return (0, _Result.FSharpResult$2_Error)(matchValue_2.fields[0]);
+                            } else {
+                                const enumValue_1 = matchValue_2.fields[0];
+                                return (0, _Seq.contains)(enumValue_1, (0, _Reflection.getEnumValues)(t_3), {
+                                    Equals: (x_1, y_1)=>x_1 === y_1,
+                                    GetHashCode: _Util.numberHash
+                                }) ? (0, _Result.FSharpResult$2_Ok)((0, _Reflection.parseEnum)(t_3, enumValue_1.toString())) : (0, _Result.FSharpResult$2_Error)([
+                                    path_5,
+                                    (0, _Typesfs.ErrorReason_BadPrimitiveExtra)((0, _Reflection.fullName)(t_3), value_8, "Unkown value provided for the enum")
+                                ]);
+                            }
+                        };
+                case "System.Int16":
+                    return (path_6)=>(value_10)=>{
+                            const t_4 = t;
+                            const path_7 = path_6;
+                            const value_11 = value_10;
+                            const matchValue_3 = int16(path_7)(value_11);
+                            if (matchValue_3.tag === /* Error */ 1) {
+                                return (0, _Result.FSharpResult$2_Error)(matchValue_3.fields[0]);
+                            } else {
+                                const enumValue_2 = matchValue_3.fields[0] | 0;
+                                return (0, _Seq.contains)(enumValue_2, (0, _Reflection.getEnumValues)(t_4), {
+                                    Equals: (x_2, y_2)=>x_2 === y_2,
+                                    GetHashCode: _Util.numberHash
+                                }) ? (0, _Result.FSharpResult$2_Ok)((0, _Reflection.parseEnum)(t_4, (0, _Util.int16ToString)(enumValue_2))) : (0, _Result.FSharpResult$2_Error)([
+                                    path_7,
+                                    (0, _Typesfs.ErrorReason_BadPrimitiveExtra)((0, _Reflection.fullName)(t_4), value_11, "Unkown value provided for the enum")
+                                ]);
+                            }
+                        };
+                case "System.UInt16":
+                    return (path_8)=>(value_13)=>{
+                            const t_5 = t;
+                            const path_9 = path_8;
+                            const value_14 = value_13;
+                            const matchValue_4 = uint16(path_9)(value_14);
+                            if (matchValue_4.tag === /* Error */ 1) {
+                                return (0, _Result.FSharpResult$2_Error)(matchValue_4.fields[0]);
+                            } else {
+                                const enumValue_3 = matchValue_4.fields[0];
+                                return (0, _Seq.contains)(enumValue_3, (0, _Reflection.getEnumValues)(t_5), {
+                                    Equals: (x_3, y_3)=>x_3 === y_3,
+                                    GetHashCode: _Util.numberHash
+                                }) ? (0, _Result.FSharpResult$2_Ok)((0, _Reflection.parseEnum)(t_5, enumValue_3.toString())) : (0, _Result.FSharpResult$2_Error)([
+                                    path_9,
+                                    (0, _Typesfs.ErrorReason_BadPrimitiveExtra)((0, _Reflection.fullName)(t_5), value_14, "Unkown value provided for the enum")
+                                ]);
+                            }
+                        };
+                case "System.Int32":
+                    return (path_10)=>(value_16)=>{
+                            const t_6 = t;
+                            const path_11 = path_10;
+                            const value_17 = value_16;
+                            const matchValue_5 = int(path_11)(value_17);
+                            if (matchValue_5.tag === /* Error */ 1) {
+                                return (0, _Result.FSharpResult$2_Error)(matchValue_5.fields[0]);
+                            } else {
+                                const enumValue_4 = matchValue_5.fields[0] | 0;
+                                return (0, _Seq.contains)(enumValue_4, (0, _Reflection.getEnumValues)(t_6), {
+                                    Equals: (x_4, y_4)=>x_4 === y_4,
+                                    GetHashCode: _Util.numberHash
+                                }) ? (0, _Result.FSharpResult$2_Ok)((0, _Reflection.parseEnum)(t_6, (0, _Util.int32ToString)(enumValue_4))) : (0, _Result.FSharpResult$2_Error)([
+                                    path_11,
+                                    (0, _Typesfs.ErrorReason_BadPrimitiveExtra)((0, _Reflection.fullName)(t_6), value_17, "Unkown value provided for the enum")
+                                ]);
+                            }
+                        };
+                case "System.UInt32":
+                    return (path_12)=>(value_19)=>{
+                            const t_7 = t;
+                            const path_13 = path_12;
+                            const value_20 = value_19;
+                            const matchValue_6 = uint32(path_13)(value_20);
+                            if (matchValue_6.tag === /* Error */ 1) {
+                                return (0, _Result.FSharpResult$2_Error)(matchValue_6.fields[0]);
+                            } else {
+                                const enumValue_5 = matchValue_6.fields[0];
+                                return (0, _Seq.contains)(enumValue_5, (0, _Reflection.getEnumValues)(t_7), {
+                                    Equals: (x_5, y_5)=>x_5 === y_5,
+                                    GetHashCode: _Util.numberHash
+                                }) ? (0, _Result.FSharpResult$2_Ok)((0, _Reflection.parseEnum)(t_7, enumValue_5.toString())) : (0, _Result.FSharpResult$2_Error)([
+                                    path_13,
+                                    (0, _Typesfs.ErrorReason_BadPrimitiveExtra)((0, _Reflection.fullName)(t_7), value_20, "Unkown value provided for the enum")
+                                ]);
+                            }
+                        };
+                default:
+                    {
+                        const arg = (0, _Reflection.fullName)(t);
+                        const clo_1 = (0, _String.toFail)((0, _String.printf)("Cannot generate auto decoder for %s.\nThoth.Json.Net only support the following enum types:\n- sbyte\n- byte\n- int16\n- uint16\n- int\n- uint32\nIf you can\'t use one of these types, please pass an extra decoder.\n                    "))(arg);
+                        return (arg_1)=>{
+                            const clo_2 = clo_1(arg_1);
+                            return clo_2;
+                        };
+                    }
+            }
+        } else if ((0, _Reflection.isGenericType)(t)) {
+            if ((0, _Reflection.isTuple)(t)) {
+                const decoders = (0, _Array.map)((t_8)=>autoDecoder(extra, caseStrategy, false, t_8), (0, _Reflection.getTupleElements)(t));
+                return (path_14)=>(value_21)=>Array.isArray(value_21) ? (0, _Result.Result_Map)((xs)=>(0, _Reflection.makeTuple)((0, _List.toArray)(xs), t), mixedArray(0, decoders, path_14, value_21)) : (0, _Result.FSharpResult$2_Error)([
+                            path_14,
+                            (0, _Typesfs.ErrorReason_BadPrimitive)("an array", value_21)
+                        ]);
+            } else {
+                const fullname_1 = (0, _Reflection.fullName)((0, _Reflection.getGenericTypeDefinition)(t));
+                switch(fullname_1){
+                    case "Microsoft.FSharp.Core.FSharpOption`1[System.Object]":
+                        return decoder_13 = autoDecoder(extra, caseStrategy, true, (0, _Array.item)(0, (0, _Reflection.getGenerics)(t))), (path_15)=>(value_22)=>option((0, _Util.uncurry2)(decoder_13), path_15, value_22);
+                    case "Microsoft.FSharp.Collections.FSharpList`1[System.Object]":
+                        return decoder_14 = autoDecoder(extra, caseStrategy, false, (0, _Array.item)(0, (0, _Reflection.getGenerics)(t))), (path_16)=>(value_23)=>list((0, _Util.uncurry2)(decoder_14), path_16, value_23);
+                    case "System.Collections.Generic.IEnumerable`1[System.Object]":
+                        return decoder_15 = autoDecoder(extra, caseStrategy, false, (0, _Array.item)(0, (0, _Reflection.getGenerics)(t))), (path_17)=>(value_24)=>seq((0, _Util.uncurry2)(decoder_15), path_17, value_24);
+                    case "Microsoft.FSharp.Collections.FSharpMap`2[System.Object,System.Object]":
+                        {
+                            const keyDecoder = autoDecoder(extra, caseStrategy, false, (0, _Array.item)(0, (0, _Reflection.getGenerics)(t)));
+                            const valueDecoder = autoDecoder(extra, caseStrategy, false, (0, _Array.item)(1, (0, _Reflection.getGenerics)(t)));
+                            let d_20;
+                            const decoders_1 = (0, _List.ofArray)([
+                                (path_18)=>(value_25)=>autoObject2((0, _Util.uncurry2)(keyDecoder), (0, _Util.uncurry2)(valueDecoder), path_18, value_25),
+                                (decoder_16 = tuple2((0, _Util.uncurry2)(keyDecoder), (0, _Util.uncurry2)(valueDecoder)), (path_19)=>(value_26)=>list((0, _Util.uncurry2)(decoder_16), path_19, value_26))
+                            ]);
+                            d_20 = (path_20)=>(value_27)=>oneOf(decoders_1, path_20, value_27);
+                            return (path_21)=>(value_29)=>map(toMap, (0, _Util.uncurry2)(d_20), path_21, value_29);
+                        }
+                    case "Microsoft.FSharp.Collections.FSharpSet`1[System.Object]":
+                        {
+                            const decoder_17 = autoDecoder(extra, caseStrategy, false, (0, _Array.item)(0, (0, _Reflection.getGenerics)(t)));
+                            return (path_22)=>(value_30)=>{
+                                    const matchValue_7 = array((0, _Util.uncurry2)(decoder_17), path_22, value_30);
+                                    return matchValue_7.tag === /* Ok */ 0 ? (0, _Result.FSharpResult$2_Ok)(toSet(matchValue_7.fields[0])) : (0, _Result.FSharpResult$2_Error)(matchValue_7.fields[0]);
+                                };
+                        }
+                    default:
+                        return autoDecodeRecordsAndUnions(extra, caseStrategy, isOptional, t);
+                }
+            }
+        } else {
+            switch(fullname){
+                case "System.Boolean":
+                    return (path_23)=>(value_32)=>bool(path_23, value_32);
+                case "Microsoft.FSharp.Core.Unit":
+                    return (path_24)=>(value_33)=>unit(path_24, value_33);
+                case "System.String":
+                    return (path_25)=>(value_34)=>string(path_25, value_34);
+                case "System.Char":
+                    return (path_26)=>(value_35)=>char(path_26, value_35);
+                case "System.SByte":
+                    return sbyte;
+                case "System.Byte":
+                    return byte;
+                case "System.Int16":
+                    return int16;
+                case "System.UInt16":
+                    return uint16;
+                case "System.Int32":
+                    return int;
+                case "System.UInt32":
+                    return uint32;
+                case "System.Double":
+                    return (path_27)=>(value_36)=>float(path_27, value_36);
+                case "System.Single":
+                    return (path_28)=>(value_37)=>float32(path_28, value_37);
+                case "System.DateTime":
+                    return (path_29)=>(value_38)=>datetimeUtc(path_29, value_38);
+                case "System.DateTimeOffset":
+                    return (path_30)=>(value_39)=>datetimeOffset(path_30, value_39);
+                case "System.TimeSpan":
+                    return (path_31)=>(value_40)=>timespan(path_31, value_40);
+                case "System.Guid":
+                    return (path_32)=>(value_41)=>guid(path_32, value_41);
+                case "System.Object":
+                    return (_arg_6)=>_Result.FSharpResult$2_Ok;
+                default:
+                    return autoDecodeRecordsAndUnions(extra, caseStrategy, isOptional, t);
+            }
+        }
+    } else {
+        const decoderRef = (0, _Option.value)(matchValue);
+        return (path)=>(value_1)=>decoderRef.contents(path)(value_1);
+    }
+}
+function makeExtra(extra) {
+    if (extra != null) {
+        return (0, _Map.map)((_arg, tupledArg)=>new _Types.FSharpRef(tupledArg[1]), (0, _Option.value)(extra).Coders);
+    } else {
+        return (0, _Map.empty)({
+            Compare: _Util.comparePrimitives
+        });
+    }
+}
+class Auto {
+    constructor(){}
+}
+function Auto_$reflection() {
+    return (0, _Reflection.class_type)("Thoth.Json.Decode.Auto", undefined, Auto);
+}
+function Auto_generateBoxedDecoderCached_Z6670B51(t, caseStrategy, extra) {
+    let y_1, y;
+    const caseStrategy_1 = (0, _Option.defaultArg)(caseStrategy, (0, _Typesfs.CaseStrategy_PascalCase)());
+    return (0, _Typesfs.Util_Cache$1__GetOrAdd_43981464)(_Typesfs.Util_CachedDecoders, (y_1 = (y = (0, _Reflection.fullName)(t), (0, _Types.toString)(caseStrategy_1) + y), (0, _Option.defaultArg)((0, _Option.map)((e)=>e.Hash, extra), "") + y_1), ()=>autoDecoder(makeExtra(extra), caseStrategy_1, false, t));
+}
+function Auto_generateBoxedDecoder_Z6670B51(t, caseStrategy, extra) {
+    const caseStrategy_1 = (0, _Option.defaultArg)(caseStrategy, (0, _Typesfs.CaseStrategy_PascalCase)());
+    return autoDecoder(makeExtra(extra), caseStrategy_1, false, t);
+} //# sourceMappingURL=Decode.fs.ts.map
+
+//# sourceMappingURL=Decode.fs.js.map