@f1studio/form-spec 5.0.0-alpha.139 → 5.0.0-alpha.141

package/FormSpec.TS/FormSpec.FS/Interop/Facade/FormAnswersGate.js

@@ -0,0 +1,752 @@
+"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 Decoders_fieldAnswerDecoder () {
+        return Decoders_fieldAnswerDecoder;
+    },
+    get Decoders_fieldKeyDecoder () {
+        return Decoders_fieldKeyDecoder;
+    },
+    get Decoders_fieldValueDecoder () {
+        return Decoders_fieldValueDecoder;
+    },
+    get Decoders_formAnswersDecoder () {
+        return Decoders_formAnswersDecoder;
+    },
+    get Decoders_guidDecoder () {
+        return Decoders_guidDecoder;
+    },
+    get Decoders_matrixDecoder () {
+        return Decoders_matrixDecoder;
+    },
+    get Decoders_matrixItemKeyDecoder () {
+        return Decoders_matrixItemKeyDecoder;
+    },
+    get Decoders_multipleDecoder () {
+        return Decoders_multipleDecoder;
+    },
+    get Decoders_pluginDataDecoder () {
+        return Decoders_pluginDataDecoder;
+    },
+    get Decoders_pluginDataPropertyDecoder () {
+        return Decoders_pluginDataPropertyDecoder;
+    },
+    get Decoders_pluginDataTypeDecoder () {
+        return Decoders_pluginDataTypeDecoder;
+    },
+    get Decoders_pluginPropertyKeyDecoder () {
+        return Decoders_pluginPropertyKeyDecoder;
+    },
+    get Decoders_singleDecoder () {
+        return Decoders_singleDecoder;
+    },
+    get Decoders_validKinds () {
+        return Decoders_validKinds;
+    },
+    get Decoders_validPluginDataTypes () {
+        return Decoders_validPluginDataTypes;
+    },
+    get GateResult_bind () {
+        return GateResult_bind;
+    },
+    get GateResult_collect () {
+        return GateResult_collect;
+    },
+    get GateResult_map () {
+        return GateResult_map;
+    },
+    get Rejection () {
+        return Rejection;
+    },
+    get RejectionPath () {
+        return RejectionPath;
+    },
+    get RejectionPath_$reflection () {
+        return RejectionPath_$reflection;
+    },
+    get RejectionPath_AtField () {
+        return RejectionPath_AtField;
+    },
+    get RejectionPath_AtIndex () {
+        return RejectionPath_AtIndex;
+    },
+    get RejectionPath_Nested () {
+        return RejectionPath_Nested;
+    },
+    get RejectionPath_Root () {
+        return RejectionPath_Root;
+    },
+    get RejectionReason () {
+        return RejectionReason;
+    },
+    get RejectionReason_$reflection () {
+        return RejectionReason_$reflection;
+    },
+    get RejectionReason_DuplicateKeys () {
+        return RejectionReason_DuplicateKeys;
+    },
+    get RejectionReason_EmptyWhenRequired () {
+        return RejectionReason_EmptyWhenRequired;
+    },
+    get RejectionReason_InvalidGuid () {
+        return RejectionReason_InvalidGuid;
+    },
+    get RejectionReason_InvalidPluginDataType () {
+        return RejectionReason_InvalidPluginDataType;
+    },
+    get RejectionReason_MissingField () {
+        return RejectionReason_MissingField;
+    },
+    get RejectionReason_MultipleErrors () {
+        return RejectionReason_MultipleErrors;
+    },
+    get RejectionReason_NotJson () {
+        return RejectionReason_NotJson;
+    },
+    get RejectionReason_UnknownKind () {
+        return RejectionReason_UnknownKind;
+    },
+    get RejectionReason_WrongType () {
+        return RejectionReason_WrongType;
+    },
+    get Rejection_$reflection () {
+        return Rejection_$reflection;
+    },
+    get Rejection_Create_7FA655F1 () {
+        return Rejection_Create_7FA655F1;
+    },
+    get formatPath () {
+        return formatPath;
+    },
+    get formatReason () {
+        return formatReason;
+    },
+    get formatRejection () {
+        return formatRejection;
+    },
+    get gateFieldKey () {
+        return gateFieldKey;
+    },
+    get gateFieldValue () {
+        return gateFieldValue;
+    },
+    get gateFormAnswers () {
+        return gateFormAnswers;
+    },
+    get tryDecodeFieldValueFromObject () {
+        return tryDecodeFieldValueFromObject;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _String = require("@fable-org/fable-library-js/String.js");
+const _Result = require("@fable-org/fable-library-js/Result.js");
+const _Decode = require("../../../Thoth.Json/packages/Thoth.Json/Decode.js");
+const _Guid = require("@fable-org/fable-library-js/Guid.js");
+const _FormSpec = require("../../FormSpec.js");
+const _Set = require("@fable-org/fable-library-js/Set.js");
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _Encode = require("../../../Thoth.Json/packages/Thoth.Json/Encode.js");
+function RejectionPath_Root() {
+    return new RejectionPath(0, []);
+}
+function RejectionPath_AtField(Item) {
+    return new RejectionPath(1, [
+        Item
+    ]);
+}
+function RejectionPath_AtIndex(Item) {
+    return new RejectionPath(2, [
+        Item
+    ]);
+}
+function RejectionPath_Nested(Item1, Item2) {
+    return new RejectionPath(3, [
+        Item1,
+        Item2
+    ]);
+}
+class RejectionPath extends _Types.Union {
+    cases() {
+        return [
+            "Root",
+            "AtField",
+            "AtIndex",
+            "Nested"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function RejectionPath_$reflection() {
+    return (0, _Reflection.union_type)("FormSpec.Interop.FormAnswersGate.RejectionPath", [], RejectionPath, ()=>[
+            [],
+            [
+                [
+                    "Item",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    _Reflection.int32_type
+                ]
+            ],
+            [
+                [
+                    "Item1",
+                    RejectionPath_$reflection()
+                ],
+                [
+                    "Item2",
+                    RejectionPath_$reflection()
+                ]
+            ]
+        ]);
+}
+function RejectionReason_NotJson(parseError) {
+    return new RejectionReason(0, [
+        parseError
+    ]);
+}
+function RejectionReason_MissingField(fieldName) {
+    return new RejectionReason(1, [
+        fieldName
+    ]);
+}
+function RejectionReason_WrongType(fieldName, expected, actual) {
+    return new RejectionReason(2, [
+        fieldName,
+        expected,
+        actual
+    ]);
+}
+function RejectionReason_InvalidGuid(fieldName, raw) {
+    return new RejectionReason(3, [
+        fieldName,
+        raw
+    ]);
+}
+function RejectionReason_UnknownKind(got, expected) {
+    return new RejectionReason(4, [
+        got,
+        expected
+    ]);
+}
+function RejectionReason_InvalidPluginDataType(got, expected) {
+    return new RejectionReason(5, [
+        got,
+        expected
+    ]);
+}
+function RejectionReason_EmptyWhenRequired(fieldName) {
+    return new RejectionReason(6, [
+        fieldName
+    ]);
+}
+function RejectionReason_DuplicateKeys(fieldName, duplicates) {
+    return new RejectionReason(7, [
+        fieldName,
+        duplicates
+    ]);
+}
+function RejectionReason_MultipleErrors(Item) {
+    return new RejectionReason(8, [
+        Item
+    ]);
+}
+class RejectionReason extends _Types.Union {
+    cases() {
+        return [
+            "NotJson",
+            "MissingField",
+            "WrongType",
+            "InvalidGuid",
+            "UnknownKind",
+            "InvalidPluginDataType",
+            "EmptyWhenRequired",
+            "DuplicateKeys",
+            "MultipleErrors"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function RejectionReason_$reflection() {
+    return (0, _Reflection.union_type)("FormSpec.Interop.FormAnswersGate.RejectionReason", [], RejectionReason, ()=>[
+            [
+                [
+                    "parseError",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "fieldName",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "fieldName",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    _Reflection.string_type
+                ],
+                [
+                    "actual",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "fieldName",
+                    _Reflection.string_type
+                ],
+                [
+                    "raw",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "got",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    (0, _Reflection.list_type)(_Reflection.string_type)
+                ]
+            ],
+            [
+                [
+                    "got",
+                    _Reflection.string_type
+                ],
+                [
+                    "expected",
+                    (0, _Reflection.list_type)(_Reflection.string_type)
+                ]
+            ],
+            [
+                [
+                    "fieldName",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "fieldName",
+                    _Reflection.string_type
+                ],
+                [
+                    "duplicates",
+                    (0, _Reflection.list_type)(_Reflection.string_type)
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    (0, _Reflection.list_type)(RejectionReason_$reflection())
+                ]
+            ]
+        ]);
+}
+class Rejection extends _Types.Record {
+    constructor(Path, Reason, RawFragment){
+        super();
+        this.Path = Path;
+        this.Reason = Reason;
+        this.RawFragment = RawFragment;
+    }
+}
+function Rejection_$reflection() {
+    return (0, _Reflection.record_type)("FormSpec.Interop.FormAnswersGate.Rejection", [], Rejection, ()=>[
+            [
+                "Path",
+                RejectionPath_$reflection()
+            ],
+            [
+                "Reason",
+                RejectionReason_$reflection()
+            ],
+            [
+                "RawFragment",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ]
+        ]);
+}
+function Rejection_Create_7FA655F1(path, reason, raw) {
+    return new Rejection(path, reason, raw);
+}
+function formatRejection(r) {
+    const pathStr = formatPath(r.Path);
+    const reasonStr = formatReason(r.Reason);
+    const rawStr = (0, _Option.defaultArg)((0, _Option.map)((s)=>{
+        const truncated = s.length > 80 ? s.slice(undefined, 79 + 1) + "…" : s;
+        return (0, _String.toText)((0, _String.printf)(" | raw: %s"))(truncated);
+    }, r.RawFragment), "");
+    return (0, _String.toText)((0, _String.printf)("[%s] %s%s"))(pathStr)(reasonStr)(rawStr);
+}
+function formatPath(p) {
+    switch(p.tag){
+        case /* AtField */ 1:
+            {
+                const f = p.fields[0];
+                return (0, _String.toText)((0, _String.printf)(".%s"))(f);
+            }
+        case /* AtIndex */ 2:
+            {
+                const i = p.fields[0] | 0;
+                return (0, _String.toText)((0, _String.printf)("[%d]"))(i);
+            }
+        case /* Nested */ 3:
+            {
+                const child = p.fields[1];
+                const arg_2 = formatPath(p.fields[0]);
+                const arg_3 = formatPath(child);
+                return (0, _String.toText)((0, _String.printf)("%s%s"))(arg_2)(arg_3);
+            }
+        default:
+            return "$";
+    }
+}
+function formatReason(r) {
+    switch(r.tag){
+        case /* MissingField */ 1:
+            {
+                const f = r.fields[0];
+                return (0, _String.toText)((0, _String.printf)("Missing required field \'%s\'"))(f);
+            }
+        case /* WrongType */ 2:
+            {
+                const f_1 = r.fields[0];
+                const expected = r.fields[1];
+                const actual = r.fields[2];
+                return (0, _String.toText)((0, _String.printf)("Field \'%s\' expected %s, got %s"))(f_1)(expected)(actual);
+            }
+        case /* InvalidGuid */ 3:
+            {
+                const raw = r.fields[1];
+                const f_2 = r.fields[0];
+                return (0, _String.toText)((0, _String.printf)("Field \'%s\' is not a valid GUID: \'%s\'"))(f_2)(raw);
+            }
+        case /* UnknownKind */ 4:
+            {
+                const got = r.fields[0];
+                const arg_8 = (0, _String.join)(", ", r.fields[1]);
+                return (0, _String.toText)((0, _String.printf)("Unknown kind \'%s\', expected one of: %s"))(got)(arg_8);
+            }
+        case /* InvalidPluginDataType */ 5:
+            {
+                const got_1 = r.fields[0];
+                const arg_10 = (0, _String.join)(", ", r.fields[1]);
+                return (0, _String.toText)((0, _String.printf)("Unknown dataType \'%s\', expected one of: %s"))(got_1)(arg_10);
+            }
+        case /* EmptyWhenRequired */ 6:
+            {
+                const f_3 = r.fields[0];
+                return (0, _String.toText)((0, _String.printf)("Field \'%s\' is empty/whitespace but required at this level"))(f_3);
+            }
+        case /* DuplicateKeys */ 7:
+            {
+                const f_4 = r.fields[0];
+                const arg_13 = (0, _String.join)(", ", r.fields[1]);
+                return (0, _String.toText)((0, _String.printf)("Duplicate keys in \'%s\': %s"))(f_4)(arg_13);
+            }
+        case /* MultipleErrors */ 8:
+            return (0, _String.join)("; ", (0, _List.map)(formatReason, r.fields[0]));
+        default:
+            {
+                const e = r.fields[0];
+                return (0, _String.toText)((0, _String.printf)("Not valid JSON: %s"))(e);
+            }
+    }
+}
+function GateResult_map(f, r) {
+    return (0, _Result.Result_Map)(f, r);
+}
+function GateResult_bind(f, r) {
+    if (r.tag === /* Error */ 1) {
+        return (0, _Result.FSharpResult$2_Error)(r.fields[0]);
+    } else {
+        return f(r.fields[0]);
+    }
+}
+function GateResult_collect(results) {
+    const patternInput = (0, _List.fold)((tupledArg, r)=>{
+        const oks = tupledArg[0];
+        const errs = tupledArg[1];
+        if (r.tag === /* Error */ 1) {
+            return [
+                oks,
+                (0, _List.append)(r.fields[0], errs)
+            ];
+        } else {
+            return [
+                (0, _List.cons)(r.fields[0], oks),
+                errs
+            ];
+        }
+    }, [
+        (0, _List.empty)(),
+        (0, _List.empty)()
+    ], results);
+    const errs_1 = patternInput[1];
+    if ((0, _List.isEmpty)(errs_1)) {
+        return (0, _Result.FSharpResult$2_Ok)((0, _List.reverse)(patternInput[0]));
+    } else {
+        return (0, _Result.FSharpResult$2_Error)(errs_1);
+    }
+}
+const Decoders_validKinds = (0, _List.ofArray)([
+    "single",
+    "multiple",
+    "matrix",
+    "pluginData"
+]);
+const Decoders_validPluginDataTypes = (0, _List.ofArray)([
+    "string",
+    "int",
+    "float",
+    "bool",
+    "datetime"
+]);
+function Decoders_guidDecoder(fieldName) {
+    return (path_2)=>(value_1)=>(0, _Decode.andThen)((0, _Util.uncurry3)((raw)=>{
+                let matchValue;
+                let outArg = "00000000-0000-0000-0000-000000000000";
+                matchValue = [
+                    (0, _Guid.tryParse)(raw, new _Types.FSharpRef(()=>outArg, (v)=>{
+                        outArg = v;
+                    })),
+                    outArg
+                ];
+                if (matchValue[0]) {
+                    return (arg10$0040)=>(arg20$0040)=>(0, _Decode.succeed)(matchValue[1], arg10$0040, arg20$0040);
+                } else {
+                    const msg = (0, _String.toText)((0, _String.printf)("\'%s\' is not a valid GUID: \'%s\'"))(fieldName)(raw);
+                    return (path_1)=>(arg20$0040_1)=>(0, _Decode.fail)(msg, path_1, arg20$0040_1);
+                }
+            }), _Decode.string, path_2, value_1);
+}
+const Decoders_fieldKeyDecoder = (()=>{
+    const d = Decoders_guidDecoder("fieldKey");
+    return (path)=>(value)=>(0, _Decode.map)((Item)=>new _FormSpec.Shared_FieldKey(Item), (0, _Util.uncurry2)(d), path, value);
+})();
+const Decoders_matrixItemKeyDecoder = (()=>{
+    const d = Decoders_guidDecoder("matrixItemKey");
+    return (path)=>(value)=>(0, _Decode.map)((Item)=>new _FormSpec.Shared_MatrixItemKey(Item), (0, _Util.uncurry2)(d), path, value);
+})();
+const Decoders_pluginPropertyKeyDecoder = (()=>{
+    const d = Decoders_guidDecoder("propertyKey");
+    return (path)=>(value)=>(0, _Decode.map)((Item)=>new _FormSpec.Shared_PluginPropertyKey(Item), (0, _Util.uncurry2)(d), path, value);
+})();
+const Decoders_pluginDataTypeDecoder = (path_2)=>(value_1)=>(0, _Decode.andThen)((0, _Util.uncurry3)((raw)=>{
+            if ((0, _List.contains)(raw, Decoders_validPluginDataTypes, {
+                Equals: (x, y)=>x === y,
+                GetHashCode: _Util.stringHash
+            })) {
+                return (arg10$0040)=>(arg20$0040)=>(0, _Decode.succeed)(raw, arg10$0040, arg20$0040);
+            } else {
+                let msg;
+                const arg_1 = (0, _String.join)(", ", Decoders_validPluginDataTypes);
+                msg = (0, _String.toText)((0, _String.printf)("Unknown dataType \'%s\', expected one of: %s"))(raw)(arg_1);
+                return (path_1)=>(arg20$0040_1)=>(0, _Decode.fail)(msg, path_1, arg20$0040_1);
+            }
+        }), _Decode.string, path_2, value_1);
+const Decoders_singleDecoder = (path_3)=>(v)=>(0, _Decode.object)((get$)=>{
+            let objectArg, objectArg_1, objectArg_2, objectArg_3;
+            return new _FormSpec.Shared_FieldAnswer((objectArg = get$.Required, objectArg.Field("fieldKey", (0, _Util.uncurry2)(Decoders_fieldKeyDecoder))), (objectArg_1 = get$.Required, objectArg_1.Field("description", _Decode.string)), (objectArg_2 = get$.Required, objectArg_2.Field("value", _Decode.string)), (objectArg_3 = get$.Optional, objectArg_3.Field("documentation", _Decode.string)));
+        }, path_3, v);
+const Decoders_fieldAnswerDecoder = (path_3)=>(v)=>(0, _Decode.object)((get$)=>{
+            let objectArg, objectArg_1, objectArg_2, objectArg_3;
+            return new _FormSpec.Shared_FieldAnswer((objectArg = get$.Required, objectArg.Field("fieldKey", (0, _Util.uncurry2)(Decoders_fieldKeyDecoder))), (objectArg_1 = get$.Required, objectArg_1.Field("description", _Decode.string)), (objectArg_2 = get$.Required, objectArg_2.Field("value", _Decode.string)), (objectArg_3 = get$.Optional, objectArg_3.Field("documentation", _Decode.string)));
+        }, path_3, v);
+const Decoders_multipleDecoder = (path_1)=>(v)=>(0, _Decode.object)((get$)=>{
+            let objectArg, objectArg_1;
+            return [
+                (objectArg = get$.Required, objectArg.Field("fieldKey", (0, _Util.uncurry2)(Decoders_fieldKeyDecoder))),
+                (0, _Set.ofArray)((objectArg_1 = get$.Required, objectArg_1.Field("values", (path, value)=>(0, _Decode.array)((0, _Util.uncurry2)(Decoders_fieldAnswerDecoder), path, value))), {
+                    Compare: _Util.compare
+                })
+            ];
+        }, path_1, v);
+const Decoders_matrixDecoder = (path_6)=>(v_2)=>(0, _Decode.object)((get$)=>{
+            let objectArg, objectArg_1, objectArg_2, objectArg_3;
+            return new _FormSpec.Shared_MatrixAnswer((objectArg = get$.Required, objectArg.Field("fieldKey", (0, _Util.uncurry2)(Decoders_fieldKeyDecoder))), (objectArg_1 = get$.Required, objectArg_1.Field("description", _Decode.string)), (objectArg_2 = get$.Required, objectArg_2.Field("values", (path_4, value_3)=>(0, _Decode.andThen)((0, _Util.uncurry3)((pairs)=>{
+                    const parsed = (0, _List.map)((tupledArg)=>{
+                        const k = tupledArg[0];
+                        let matchValue;
+                        let outArg = "00000000-0000-0000-0000-000000000000";
+                        matchValue = [
+                            (0, _Guid.tryParse)(k, new _Types.FSharpRef(()=>outArg, (v_1)=>{
+                                outArg = v_1;
+                            })),
+                            outArg
+                        ];
+                        if (matchValue[0]) {
+                            return (0, _Result.FSharpResult$2_Ok)([
+                                new _FormSpec.Shared_MatrixItemKey(matchValue[1]),
+                                tupledArg[1]
+                            ]);
+                        } else {
+                            return (0, _Result.FSharpResult$2_Error)((0, _String.toText)((0, _String.printf)("Matrix key \'%s\' is not a valid GUID"))(k));
+                        }
+                    }, pairs);
+                    const errors = (0, _List.choose)((_arg)=>{
+                        if (_arg.tag === /* Error */ 1) {
+                            return _arg.fields[0];
+                        } else {
+                            return undefined;
+                        }
+                    }, parsed);
+                    if ((0, _List.isEmpty)(errors)) {
+                        const output = (0, _Map.ofList)((0, _List.choose)((_arg_1)=>{
+                            if (_arg_1.tag === /* Ok */ 0) {
+                                return _arg_1.fields[0];
+                            } else {
+                                return undefined;
+                            }
+                        }, parsed), {
+                            Compare: _Util.compare
+                        });
+                        return (arg10$0040)=>(arg20$0040)=>(0, _Decode.succeed)(output, arg10$0040, arg20$0040);
+                    } else {
+                        const msg = (0, _String.join)("; ", errors);
+                        return (path_3)=>(arg20$0040_1)=>(0, _Decode.fail)(msg, path_3, arg20$0040_1);
+                    }
+                }), (path_2, value_2)=>(0, _Decode.keyValuePairs)(_Decode.string, path_2, value_2), path_4, value_3))), (objectArg_3 = get$.Optional, objectArg_3.Field("documentation", _Decode.string)));
+        }, path_6, v_2);
+const Decoders_pluginDataPropertyDecoder = (path_5)=>(v)=>(0, _Decode.object)((get$)=>{
+            let objectArg, objectArg_1, objectArg_2, objectArg_3, objectArg_4, objectArg_5, objectArg_6;
+            return new _FormSpec.Shared_PluginDataProperty((objectArg = get$.Required, objectArg.Field("propertyKey", (0, _Util.uncurry2)(Decoders_pluginPropertyKeyDecoder))), (objectArg_1 = get$.Required, objectArg_1.Field("name", _Decode.string)), (objectArg_2 = get$.Required, objectArg_2.Field("dataType", (0, _Util.uncurry2)(Decoders_pluginDataTypeDecoder))), (objectArg_3 = get$.Required, objectArg_3.Field("value", _Decode.string)), (objectArg_4 = get$.Optional, objectArg_4.Field("displayName", _Decode.string)), (objectArg_5 = get$.Optional, objectArg_5.Field("unit", _Decode.string)), (objectArg_6 = get$.Optional, objectArg_6.Field("description", _Decode.string)));
+        }, path_5, v);
+const Decoders_pluginDataDecoder = (path_1)=>(v)=>(0, _Decode.object)((get$)=>{
+            const objectArg = get$.Required;
+            return objectArg.Field("properties", (path, value)=>(0, _Decode.list)((0, _Util.uncurry2)(Decoders_pluginDataPropertyDecoder), path, value));
+        }, path_1, v);
+const Decoders_fieldValueDecoder = (path_7)=>(value_6)=>(0, _Decode.andThen)((0, _Util.uncurry3)((kind)=>{
+            switch(kind){
+                case "single":
+                    return (path_2)=>(value_2)=>(0, _Decode.map)(_FormSpec.Shared_FieldValue_Single, (0, _Util.uncurry2)(Decoders_singleDecoder), path_2, value_2);
+                case "multiple":
+                    return (path_3)=>(value_3)=>(0, _Decode.map)((tupledArg)=>(0, _FormSpec.Shared_FieldValue_Multiple)(tupledArg[1]), (0, _Util.uncurry2)(Decoders_multipleDecoder), path_3, value_3);
+                case "matrix":
+                    return (path_4)=>(value_4)=>(0, _Decode.map)(_FormSpec.Shared_FieldValue_Matrix, (0, _Util.uncurry2)(Decoders_matrixDecoder), path_4, value_4);
+                case "pluginData":
+                    return (path_5)=>(value_5)=>(0, _Decode.map)(_FormSpec.Shared_FieldValue_PluginData, (0, _Util.uncurry2)(Decoders_pluginDataDecoder), path_5, value_5);
+                default:
+                    {
+                        let msg;
+                        const arg_1 = (0, _String.join)(", ", Decoders_validKinds);
+                        msg = (0, _String.toText)((0, _String.printf)("Unknown kind \'%s\', expected one of: %s"))(kind)(arg_1);
+                        return (path_6)=>(arg20$0040)=>(0, _Decode.fail)(msg, path_6, arg20$0040);
+                    }
+            }
+        }), (path_1, value_1)=>(0, _Decode.field)("kind", _Decode.string, path_1, value_1), path_7, value_6);
+const Decoders_formAnswersDecoder = (path_2)=>(value_1)=>(0, _Decode.andThen)((0, _Util.uncurry3)((pairs)=>{
+            const parsed = (0, _List.map)((tupledArg)=>{
+                const k = tupledArg[0];
+                let matchValue;
+                let outArg = "00000000-0000-0000-0000-000000000000";
+                matchValue = [
+                    (0, _Guid.tryParse)(k, new _Types.FSharpRef(()=>outArg, (v_1)=>{
+                        outArg = v_1;
+                    })),
+                    outArg
+                ];
+                if (matchValue[0]) {
+                    return (0, _Result.FSharpResult$2_Ok)([
+                        new _FormSpec.Shared_FieldKey(matchValue[1]),
+                        tupledArg[1]
+                    ]);
+                } else {
+                    return (0, _Result.FSharpResult$2_Error)((0, _String.toText)((0, _String.printf)("Form answer key \'%s\' is not a valid GUID"))(k));
+                }
+            }, pairs);
+            const errors = (0, _List.choose)((_arg)=>{
+                if (_arg.tag === /* Error */ 1) {
+                    return _arg.fields[0];
+                } else {
+                    return undefined;
+                }
+            }, parsed);
+            if ((0, _List.isEmpty)(errors)) {
+                const output = (0, _Map.ofList)((0, _List.choose)((_arg_1)=>{
+                    if (_arg_1.tag === /* Ok */ 0) {
+                        return _arg_1.fields[0];
+                    } else {
+                        return undefined;
+                    }
+                }, parsed), {
+                    Compare: _Util.compare
+                });
+                return (arg10$0040)=>(arg20$0040)=>(0, _Decode.succeed)(output, arg10$0040, arg20$0040);
+            } else {
+                const msg = (0, _String.join)("; ", errors);
+                return (path_1)=>(arg20$0040_1)=>(0, _Decode.fail)(msg, path_1, arg20$0040_1);
+            }
+        }), (path, value)=>(0, _Decode.keyValuePairs)((0, _Util.uncurry2)(Decoders_fieldValueDecoder), path, value), path_2, value_1);
+function gateFieldValue(json) {
+    const matchValue = (0, _Decode.fromString)((0, _Util.uncurry2)(Decoders_fieldValueDecoder), json);
+    if (matchValue.tag === /* Error */ 1) {
+        return (0, _Result.FSharpResult$2_Error)((0, _List.singleton)(new Rejection(RejectionPath_Root(), RejectionReason_NotJson(matchValue.fields[0]), json.length > 200 ? json.slice(undefined, 199 + 1) + "…" : json)));
+    } else {
+        return (0, _Result.FSharpResult$2_Ok)(matchValue.fields[0]);
+    }
+}
+function gateFormAnswers(json) {
+    const matchValue = (0, _Decode.fromString)((0, _Util.uncurry2)(Decoders_formAnswersDecoder), json);
+    if (matchValue.tag === /* Error */ 1) {
+        return (0, _Result.FSharpResult$2_Error)((0, _List.singleton)(new Rejection(RejectionPath_Root(), RejectionReason_NotJson(matchValue.fields[0]), json.length > 500 ? json.slice(undefined, 499 + 1) + "…" : json)));
+    } else {
+        return (0, _Result.FSharpResult$2_Ok)(matchValue.fields[0]);
+    }
+}
+function gateFieldKey(raw) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(raw, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    if (matchValue[0]) {
+        return (0, _Result.FSharpResult$2_Ok)(new _FormSpec.Shared_FieldKey(matchValue[1]));
+    } else {
+        return (0, _Result.FSharpResult$2_Error)((0, _List.singleton)(new Rejection(RejectionPath_Root(), RejectionReason_InvalidGuid("fieldKey", raw), raw)));
+    }
+}
+function tryDecodeFieldValueFromObject(objValue) {
+    let s, s_1;
+    if (objValue == null) {
+        return undefined;
+    } else {
+        try {
+            const matchValue = (0, _Decode.fromString)((0, _Util.uncurry2)(Decoders_fieldValueDecoder), typeof objValue === "string" ? (s = objValue, s.trimStart().startsWith("{")) ? (s_1 = objValue, s_1) : (0, _Encode.toString)(0, (0, _Encode.Auto_generateBoxedEncoder_437914C6)(_Reflection.obj_type, undefined, undefined, undefined)(objValue)) : (0, _Encode.toString)(0, (0, _Encode.Auto_generateBoxedEncoder_437914C6)(_Reflection.obj_type, undefined, undefined, undefined)(objValue)));
+            return matchValue.tag === /* Error */ 1 ? undefined : matchValue.fields[0];
+        } catch (matchValue_1) {
+            return undefined;
+        }
+    }
+} //# sourceMappingURL=FormAnswersGate.ts.map
+
+//# sourceMappingURL=FormAnswersGate.js.map