@f1studio/form-spec 5.0.0-alpha.128 → 5.0.0-alpha.130

package/src/Thoth.Json/packages/Thoth.Json/Encode.ts

@@ -0,0 +1,475 @@
+import { decimal as decimal_1, toString as toString_1 } from "@fable-org/fable-library-js/Decimal.js";
+import { comparePrimitives, Lazy, IDisposable, disposeSafe, IEnumerator, getEnumerator, defaultOf } from "@fable-org/fable-library-js/Util.js";
+import { map as map_1, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { empty, map as map_5, tryFind, add, FSharpMap, toList } from "@fable-org/fable-library-js/Map.js";
+import { uint64 as uint64_1, int64 as int64_1, toString as toString_2 } from "@fable-org/fable-library-js/BigInt.js";
+import { toString as toString_3 } from "@fable-org/fable-library-js/Date.js";
+import { toString as toString_4 } from "@fable-org/fable-library-js/TimeSpan.js";
+import { defaultArg, value as value_44, Option, map as map_2, defaultArgWith, some } from "@fable-org/fable-library-js/Option.js";
+import { float32, float64, uint32, uint16, int16, uint8, int8, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { toString as toString_5, FSharpRef } from "@fable-org/fable-library-js/Types.js";
+import { class_type, TypeInfo, getGenerics, getGenericTypeDefinition, getTupleFields, getTupleElements, isTuple, isGenericType, getEnumUnderlyingType, isEnum, getElementType, isArray, getUnionCaseFields, getUnionFields, isUnion, getRecordElements, getRecordField, name, isRecord, fullName as fullName_1 } from "@fable-org/fable-library-js/Reflection.js";
+import { item, setItem, fill, map as map_3 } from "@fable-org/fable-library-js/Array.js";
+import { Util_CachedEncoders, Util_Cache$1__GetOrAdd_43981464, CaseStrategy_PascalCase, ExtraCoders, ErrorReason_$union, CaseStrategy_$union, Util_Casing_convert } from "./Types.js";
+import { mapIndexed, map as map_4, fold } from "@fable-org/fable-library-js/Seq.js";
+import { toFail, printf, toText } from "@fable-org/fable-library-js/String.js";
+import { FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+
+/**
+ * **Description**
+ * Encode a GUID
+ * 
+ * **Parameters**
+ * * `value` - parameter of type `System.Guid`
+ * 
+ * **Output Type**
+ * * `Value`
+ * 
+ * **Exceptions**
+ */
+export function guid(value: string): any {
+    return value;
+}
+
+/**
+ * **Description**
+ * Encode a Decimal.
+ * 
+ * **Parameters**
+ * * `value` - parameter of type `decimal`
+ * 
+ * **Output Type**
+ * * `Value`
+ * 
+ * **Exceptions**
+ */
+export function decimal(value: decimal_1): any {
+    return toString_1(value);
+}
+
+export const nil: any = defaultOf();
+
+/**
+ * **Description**
+ * Encode an object
+ * 
+ * **Parameters**
+ * * `values` - parameter of type `(string * Value) list`
+ * 
+ * **Output Type**
+ * * `Value`
+ * 
+ * **Exceptions**
+ */
+export function object(values: Iterable<[string, any]>): any {
+    const o: any = {};
+    const enumerator: IEnumerator<[string, any]> = getEnumerator(values);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const forLoopVar: [string, any] = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            o[forLoopVar[0]] = forLoopVar[1];
+        }
+    }
+    finally {
+        disposeSafe(enumerator as IDisposable);
+    }
+    return o;
+}
+
+/**
+ * **Description**
+ * Encode a list
+ * **Parameters**
+ * * `values` - parameter of type `Value list`
+ * 
+ * **Output Type**
+ * * `Value`
+ * 
+ * **Exceptions**
+ */
+export function list(values: FSharpList<any>): any {
+    return Array.from(values);
+}
+
+export function seq(values: Iterable<any>): any {
+    return Array.from(values);
+}
+
+/**
+ * **Description**
+ * Encode a dictionary
+ * **Parameters**
+ * * `values` - parameter of type `Map<string, Value>`
+ * 
+ * **Output Type**
+ * * `Value`
+ * 
+ * **Exceptions**
+ */
+export function dict(values: FSharpMap<string, any>): any {
+    return object(toList<string, any>(values));
+}
+
+export function bigint(value: bigint): any {
+    return toString_2(value);
+}
+
+export function datetimeOffset(value: Date): any {
+    return toString_3(value, "O", {});
+}
+
+/**
+ * **Description**
+ * Encode a timespan
+ * **Parameters**
+ * * `value` - parameter of type `System.TimeSpan`
+ * 
+ * **Output Type**
+ * * `Value`
+ * 
+ * **Exceptions**
+ */
+export function timespan(value: number): any {
+    return toString_4(value);
+}
+
+export function int64(value: int64_1): any {
+    return String(value);
+}
+
+export function uint64(value: uint64_1): any {
+    return String(value);
+}
+
+export function unit(): any {
+    return defaultOf();
+}
+
+export function tuple2<T1, T2>(enc1: ((arg0: T1) => any), enc2: ((arg0: T2) => any), v1: T1, v2: T2): any {
+    return [enc1(v1), enc2(v2)];
+}
+
+export function tuple3<T1, T2, T3>(enc1: ((arg0: T1) => any), enc2: ((arg0: T2) => any), enc3: ((arg0: T3) => any), v1: T1, v2: T2, v3: T3): any {
+    return [enc1(v1), enc2(v2), enc3(v3)];
+}
+
+export function tuple4<T1, T2, T3, T4>(enc1: ((arg0: T1) => any), enc2: ((arg0: T2) => any), enc3: ((arg0: T3) => any), enc4: ((arg0: T4) => any), v1: T1, v2: T2, v3: T3, v4: T4): any {
+    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4)];
+}
+
+export function tuple5<T1, T2, T3, T4, T5>(enc1: ((arg0: T1) => any), enc2: ((arg0: T2) => any), enc3: ((arg0: T3) => any), enc4: ((arg0: T4) => any), enc5: ((arg0: T5) => any), v1: T1, v2: T2, v3: T3, v4: T4, v5: T5): any {
+    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5)];
+}
+
+export function tuple6<T1, T2, T3, T4, T5, T6>(enc1: ((arg0: T1) => any), enc2: ((arg0: T2) => any), enc3: ((arg0: T3) => any), enc4: ((arg0: T4) => any), enc5: ((arg0: T5) => any), enc6: ((arg0: T6) => any), v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6): any {
+    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6)];
+}
+
+export function tuple7<T1, T2, T3, T4, T5, T6, T7>(enc1: ((arg0: T1) => any), enc2: ((arg0: T2) => any), enc3: ((arg0: T3) => any), enc4: ((arg0: T4) => any), enc5: ((arg0: T5) => any), enc6: ((arg0: T6) => any), enc7: ((arg0: T7) => any), v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7): any {
+    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6), enc7(v7)];
+}
+
+export function tuple8<T1, T2, T3, T4, T5, T6, T7, T8>(enc1: ((arg0: T1) => any), enc2: ((arg0: T2) => any), enc3: ((arg0: T3) => any), enc4: ((arg0: T4) => any), enc5: ((arg0: T5) => any), enc6: ((arg0: T6) => any), enc7: ((arg0: T7) => any), enc8: ((arg0: T8) => any), v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8): any {
+    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6), enc7(v7), enc8(v8)];
+}
+
+export function map<key, value>(keyEncoder: ((arg0: key) => any), valueEncoder: ((arg0: value) => any), values: FSharpMap<key, value>): any {
+    return list(map_1<[key, value], any>((tupledArg: [key, value]): any => tuple2<key, value>(keyEncoder, valueEncoder, tupledArg[0], tupledArg[1]), toList<key, value>(values)));
+}
+
+export function Enum_byte<TEnum>(value: TEnum): any {
+    return value;
+}
+
+export function Enum_sbyte<TEnum>(value: TEnum): any {
+    return value;
+}
+
+export function Enum_int16<TEnum>(value: TEnum): any {
+    return value;
+}
+
+export function Enum_uint16<TEnum>(value: TEnum): any {
+    return value;
+}
+
+export function Enum_int<TEnum>(value: TEnum): any {
+    return value;
+}
+
+export function Enum_uint32<TEnum>(value: TEnum): any {
+    return value;
+}
+
+/**
+ * **Description**
+ * 
+ * The DateTime is always encoded using UTC representation
+ * 
+ * **Parameters**
+ * * `value` - parameter of type `System.DateTime`
+ * 
+ * **Output Type**
+ * * `Value`
+ * 
+ * **Exceptions**
+ */
+export function datetime(value: Date): any {
+    return toString_3(value, "O", {});
+}
+
+/**
+ * **Description**
+ * Convert a `Value` into a prettified string.
+ * **Parameters**
+ * * `space` - parameter of type `int` - Amount of indentation
+ * * `value` - parameter of type `obj` - Value to convert
+ * 
+ * **Output Type**
+ * * `string`
+ * 
+ * **Exceptions**
+ */
+export function toString(space: int32, value: any): string {
+    return JSON.stringify(value, undefined, some(space));
+}
+
+/**
+ * **Description**
+ * Encode an option
+ * **Parameters**
+ * * `encoder` - parameter of type `'a -> Value`
+ * 
+ * **Output Type**
+ * * `'a option -> Value`
+ * 
+ * **Exceptions**
+ */
+export function option<a>(encoder: ((arg0: a) => any)): ((arg0: Option<a>) => any) {
+    return (arg: Option<a>): any => defaultArgWith<any>(map_2<a, any>(encoder, arg), (): any => nil);
+}
+
+function autoEncodeRecordsAndUnions(extra: FSharpMap<string, FSharpRef<((arg0: any) => any)>>, caseStrategy: CaseStrategy_$union, skipNullField: boolean, t: any): ((arg0: any) => any) {
+    let arg: string;
+    const encoderRef: FSharpRef<((arg0: any) => any)> = new FSharpRef<((arg0: any) => any)>(defaultOf());
+    let extra_1: FSharpMap<string, FSharpRef<((arg0: any) => any)>>;
+    const matchValue: string = fullName_1(t);
+    extra_1 = ((matchValue === "") ? extra : add<string, FSharpRef<((arg0: any) => any)>>(matchValue, encoderRef, extra));
+    let encoder: ((arg0: any) => any);
+    if (isRecord(t, true)) {
+        const setters: ((arg0: any) => ((arg0: any) => any))[] = map_3<any, ((arg0: any) => ((arg0: any) => any))>((fi: any): ((arg0: any) => ((arg0: any) => any)) => {
+            const targetKey: string = Util_Casing_convert(caseStrategy, name(fi));
+            const encode_1: ((arg0: any) => any) = autoEncoder(extra_1, caseStrategy, skipNullField, fi[1]);
+            return (source: any): ((arg0: any) => any) => ((target: any): any => {
+                const value: any = getRecordField(source, fi);
+                if (!skipNullField ? true : (skipNullField && !(value == null))) {
+                    target[targetKey]=encode_1(value);
+                }
+                return target;
+            });
+        }, getRecordElements(t, true));
+        encoder = ((source_1: any): any => fold<((arg0: any) => ((arg0: any) => any)), any>((target_1: any, set$: ((arg0: any) => ((arg0: any) => any))): any => set$(source_1)(target_1), {}, setters));
+    }
+    else if (isUnion(t, true)) {
+        encoder = ((value_1: any): any => {
+            const patternInput: [any, any[]] = getUnionFields(value_1, t, true);
+            const info: any = patternInput[0];
+            const fields: any[] = patternInput[1];
+            const matchValue_1: int32 = fields.length | 0;
+            if (matchValue_1 === 0) {
+                return name(info);
+            }
+            else {
+                const len: int32 = matchValue_1 | 0;
+                const fieldTypes: any[] = getUnionCaseFields(info);
+                const target_2: any[] = fill(new Array(len + 1), 0, len + 1, null);
+                setItem(target_2, 0, name(info));
+                for (let i = 1; i <= len; i++) {
+                    const encode_2: ((arg0: any) => any) = autoEncoder(extra_1, caseStrategy, skipNullField, item(i - 1, fieldTypes)[1]);
+                    setItem(target_2, i, encode_2(item(i - 1, fields)));
+                }
+                return target_2;
+            }
+        });
+    }
+    else {
+        throw new Error((arg = fullName_1(t), toText(printf("Cannot generate auto encoder for %s. Please pass an extra encoder.\n\nDocumentation available at: https://thoth-org.github.io/Thoth.Json/documentation/auto/extra-coders.html#ready-to-use-extra-coders"))(arg)));
+    }
+    encoderRef.contents = encoder;
+    return encoder;
+}
+
+function autoEncoder(extra: FSharpMap<string, FSharpRef<((arg0: any) => any)>>, caseStrategy: CaseStrategy_$union, skipNullField: boolean, t: any): ((arg0: any) => any) {
+    const fullname: string = fullName_1(t);
+    const matchValue: Option<FSharpRef<((arg0: any) => any)>> = tryFind<string, FSharpRef<((arg0: any) => any)>>(fullname, extra);
+    if (matchValue == null) {
+        if (isArray(t)) {
+            const encoder: ((arg0: any) => any) = autoEncoder(extra, caseStrategy, skipNullField, getElementType(t));
+            return (value: any): any => seq(map_4<any, any>(encoder, value as Iterable<any>));
+        }
+        else if (isEnum(t)) {
+            const enumType: string = fullName_1(getEnumUnderlyingType(t));
+            switch (enumType) {
+                case "System.SByte":
+                    return (value_1: int8): any => value_1;
+                case "System.Byte":
+                    return (value_3: uint8): any => value_3;
+                case "System.Int16":
+                    return (value_5: int16): any => value_5;
+                case "System.UInt16":
+                    return (value_7: uint16): any => value_7;
+                case "System.Int32":
+                    return (value_9: int32): any => value_9;
+                case "System.UInt32":
+                    return (value_11: uint32): any => value_11;
+                default: {
+                    const arg: string = fullName_1(t);
+                    const clo_1: ((arg0: any) => any) = toFail(printf("Cannot generate auto encoder for %s.\nThoth.Json.Net only support the following enum types:\n- sbyte\n- byte\n- int16\n- uint16\n- int\n- uint32\n\nIf you can\'t use one of these types, please pass an extra encoder.\n\nDocumentation available at: https://thoth-org.github.io/Thoth.Json/documentation/auto/extra-coders.html#ready-to-use-extra-coders\n                    "))(arg);
+                    return clo_1;
+                }
+            }
+        }
+        else if (isGenericType(t)) {
+            if (isTuple(t)) {
+                const encoders: ((arg0: any) => any)[] = map_3<any, ((arg0: any) => any)>((t_2: any): ((arg0: any) => any) => autoEncoder(extra, caseStrategy, skipNullField, t_2), getTupleElements(t));
+                return (value_13: any): any => seq(mapIndexed<any, any>((i: int32, x: any): any => item(i, encoders)(x), getTupleFields(value_13)));
+            }
+            else {
+                const fullname_1: string = fullName_1(getGenericTypeDefinition(t));
+                if (fullname_1 === "Microsoft.FSharp.Core.FSharpOption`1[System.Object]") {
+                    const encoder_2: any = new Lazy<((arg0: any) => any)>((): ((arg0: any) => any) => option<any>(autoEncoder(extra, caseStrategy, skipNullField, item(0, getGenerics(t)))));
+                    return (value_14: any): any => {
+                        if (value_14 == null) {
+                            return nil;
+                        }
+                        else {
+                            return encoder_2.Value(value_14);
+                        }
+                    };
+                }
+                else if (((fullname_1 === "Microsoft.FSharp.Collections.FSharpList`1[System.Object]") ? true : (fullname_1 === "Microsoft.FSharp.Collections.FSharpSet`1[System.Object]")) ? true : (fullname_1 === "System.Collections.Generic.IEnumerable`1[System.Object]")) {
+                    const encoder_3: ((arg0: any) => any) = autoEncoder(extra, caseStrategy, skipNullField, item(0, getGenerics(t)));
+                    return (value_15: any): any => seq(map_4<any, any>(encoder_3, value_15 as Iterable<any>));
+                }
+                else if (fullname_1 === "Microsoft.FSharp.Collections.FSharpMap`2[System.Object,System.Object]") {
+                    const keyType: any = item(0, getGenerics(t));
+                    const valueEncoder: ((arg0: any) => any) = autoEncoder(extra, caseStrategy, skipNullField, item(1, getGenerics(t)));
+                    if ((fullName_1(keyType) === "System.String") ? true : (fullName_1(keyType) === "System.Guid")) {
+                        return (value_16: any): any => fold<[string, any], any>((target: any, _arg: [string, any]): any => {
+                            const activePatternResult: [string, any] = _arg;
+                            target[activePatternResult[0]]=valueEncoder(activePatternResult[1]);
+                            return target;
+                        }, {}, value_16 as FSharpMap<string, any>);
+                    }
+                    else {
+                        let keyEncoder: ((arg0: string) => any);
+                        const clo_2: ((arg0: any) => any) = autoEncoder(extra, caseStrategy, skipNullField, keyType);
+                        keyEncoder = (clo_2);
+                        return (value_17: any): any => seq(map_4<[string, any], any>((_arg_1: [string, any]): any => {
+                            const activePatternResult_1: [string, any] = _arg_1;
+                            return [keyEncoder(activePatternResult_1[0]), valueEncoder(activePatternResult_1[1])];
+                        }, value_17 as FSharpMap<string, any>));
+                    }
+                }
+                else {
+                    return autoEncodeRecordsAndUnions(extra, caseStrategy, skipNullField, t);
+                }
+            }
+        }
+        else {
+            switch (fullname) {
+                case "System.Boolean":
+                    return (value_18: boolean): any => value_18;
+                case "Microsoft.FSharp.Core.Unit":
+                    return unit;
+                case "System.String":
+                    return (value_20: string): any => value_20;
+                case "System.Char":
+                    return (value_22: string): any => value_22;
+                case "System.SByte":
+                    return (value_24: int8): any => value_24;
+                case "System.Byte":
+                    return (value_26: uint8): any => value_26;
+                case "System.Int16":
+                    return (value_28: int16): any => value_28;
+                case "System.UInt16":
+                    return (value_30: uint16): any => value_30;
+                case "System.Int32":
+                    return (value_32: int32): any => value_32;
+                case "System.UInt32":
+                    return (value_34: uint32): any => value_34;
+                case "System.Double":
+                    return (value_36: float64): any => value_36;
+                case "System.Single":
+                    return (value_38: float32): any => value_38;
+                case "System.DateTime":
+                    return datetime;
+                case "System.DateTimeOffset":
+                    return datetimeOffset;
+                case "System.TimeSpan":
+                    return timespan;
+                case "System.Guid":
+                    return guid;
+                case "System.Object":
+                    return (x_1: any): any => x_1;
+                default:
+                    return autoEncodeRecordsAndUnions(extra, caseStrategy, skipNullField, t);
+            }
+        }
+    }
+    else {
+        const encoderRef: FSharpRef<((arg0: any) => any)> = value_44(matchValue);
+        return (v: any): any => encoderRef.contents(v);
+    }
+}
+
+function makeExtra(extra: Option<ExtraCoders>): FSharpMap<string, FSharpRef<((arg0: any) => any)>> {
+    if (extra != null) {
+        return map_5<string, [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))], FSharpRef<((arg0: any) => any)>>((_arg: string, tupledArg: [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))]): FSharpRef<((arg0: any) => any)> => (new FSharpRef<((arg0: any) => any)>(tupledArg[0])), value_44(extra).Coders);
+    }
+    else {
+        return empty<string, FSharpRef<((arg0: any) => any)>>({
+            Compare: comparePrimitives,
+        });
+    }
+}
+
+export class Auto {
+    constructor() {
+    }
+}
+
+export function Auto_$reflection(): TypeInfo {
+    return class_type("Thoth.Json.Encode.Auto", undefined, Auto);
+}
+
+export function Auto_generateBoxedEncoderCached_437914C6(t: any, caseStrategy?: CaseStrategy_$union, extra?: ExtraCoders, skipNullField?: boolean): ((arg0: any) => any) {
+    let y_1: string, y: string;
+    const caseStrategy_1: CaseStrategy_$union = defaultArg<CaseStrategy_$union>(caseStrategy, CaseStrategy_PascalCase());
+    const skipNullField_1: boolean = defaultArg<boolean>(skipNullField, true);
+    return Util_Cache$1__GetOrAdd_43981464<((arg0: any) => any)>(Util_CachedEncoders, (y_1 = ((y = fullName_1(t), toString_5(caseStrategy_1) + y)), defaultArg(map_2<ExtraCoders, string>((e: ExtraCoders): string => e.Hash, extra), "") + y_1), (): ((arg0: any) => any) => autoEncoder(makeExtra(extra), caseStrategy_1, skipNullField_1, t));
+}
+
+export function Auto_generateBoxedEncoder_437914C6(t: any, caseStrategy?: CaseStrategy_$union, extra?: ExtraCoders, skipNullField?: boolean): ((arg0: any) => any) {
+    const caseStrategy_1: CaseStrategy_$union = defaultArg<CaseStrategy_$union>(caseStrategy, CaseStrategy_PascalCase());
+    const skipNullField_1: boolean = defaultArg<boolean>(skipNullField, true);
+    return autoEncoder(makeExtra(extra), caseStrategy_1, skipNullField_1, t);
+}
+
+/**
+ * **Description**
+ * Convert a `Value` into a prettified string.
+ * **Parameters**
+ * * `space` - parameter of type `int` - Amount of indentation
+ * * `value` - parameter of type `obj` - Value to convert
+ * 
+ * **Output Type**
+ * * `string`
+ * 
+ * **Exceptions**
+ */
+export function encode(space: int32, value: any): string {
+    return toString(space, value);
+}
+
+//# sourceMappingURL=Encode.ts.map

package/src/Thoth.Json/packages/Thoth.Json/Extra.ts

@@ -0,0 +1,11 @@
+import { empty as empty_1 } from "@fable-org/fable-library-js/Map.js";
+import { comparePrimitives } from "@fable-org/fable-library-js/Util.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { ExtraCoders, ErrorReason_$union } from "./Types.js";
+
+export const empty: ExtraCoders = new ExtraCoders("", empty_1<string, [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))]>({
+    Compare: comparePrimitives,
+}));
+
+//# sourceMappingURL=Extra.ts.map

package/src/Thoth.Json/packages/Thoth.Json/Types.ts

@@ -0,0 +1,176 @@
+import { FSharpRef, Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { FSharpList } from "@fable-org/fable-library-js/List.js";
+import { record_type, class_type, tuple_type, lambda_type, union_type, list_type, obj_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { FSharpResult$2, FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { defaultOf, IMap } from "@fable-org/fable-library-js/Util.js";
+import { addToDict, tryGetValue } from "@fable-org/fable-library-js/MapUtil.js";
+import { replace } from "@fable-org/fable-library-js/RegExp.js";
+
+export type ErrorReason_$union = 
+    | ErrorReason<0>
+    | ErrorReason<1>
+    | ErrorReason<2>
+    | ErrorReason<3>
+    | ErrorReason<4>
+    | ErrorReason<5>
+    | ErrorReason<6>
+    | ErrorReason<7>
+
+export type ErrorReason_$cases = {
+    0: ["BadPrimitive", [string, any]],
+    1: ["BadPrimitiveExtra", [string, any, string]],
+    2: ["BadType", [string, any]],
+    3: ["BadField", [string, any]],
+    4: ["BadPath", [string, any, string]],
+    5: ["TooSmallArray", [string, any]],
+    6: ["FailMessage", [string]],
+    7: ["BadOneOf", [FSharpList<string>]]
+}
+
+export function ErrorReason_BadPrimitive(Item1: string, Item2: any) {
+    return new ErrorReason<0>(0, [Item1, Item2]);
+}
+
+export function ErrorReason_BadPrimitiveExtra(Item1: string, Item2: any, Item3: string) {
+    return new ErrorReason<1>(1, [Item1, Item2, Item3]);
+}
+
+export function ErrorReason_BadType(Item1: string, Item2: any) {
+    return new ErrorReason<2>(2, [Item1, Item2]);
+}
+
+export function ErrorReason_BadField(Item1: string, Item2: any) {
+    return new ErrorReason<3>(3, [Item1, Item2]);
+}
+
+export function ErrorReason_BadPath(Item1: string, Item2: any, Item3: string) {
+    return new ErrorReason<4>(4, [Item1, Item2, Item3]);
+}
+
+export function ErrorReason_TooSmallArray(Item1: string, Item2: any) {
+    return new ErrorReason<5>(5, [Item1, Item2]);
+}
+
+export function ErrorReason_FailMessage(Item: string) {
+    return new ErrorReason<6>(6, [Item]);
+}
+
+export function ErrorReason_BadOneOf(Item: FSharpList<string>) {
+    return new ErrorReason<7>(7, [Item]);
+}
+
+export class ErrorReason<Tag extends keyof ErrorReason_$cases> extends Union<Tag, ErrorReason_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ErrorReason_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["BadPrimitive", "BadPrimitiveExtra", "BadType", "BadField", "BadPath", "TooSmallArray", "FailMessage", "BadOneOf"];
+    }
+}
+
+export function ErrorReason_$reflection(): TypeInfo {
+    return union_type("Thoth.Json.ErrorReason", [], ErrorReason, () => [[["Item1", string_type], ["Item2", obj_type]], [["Item1", string_type], ["Item2", obj_type], ["Item3", string_type]], [["Item1", string_type], ["Item2", obj_type]], [["Item1", string_type], ["Item2", obj_type]], [["Item1", string_type], ["Item2", obj_type], ["Item3", string_type]], [["Item1", string_type], ["Item2", obj_type]], [["Item", string_type]], [["Item", list_type(string_type)]]]);
+}
+
+export type CaseStrategy_$union = 
+    | CaseStrategy<0>
+    | CaseStrategy<1>
+    | CaseStrategy<2>
+
+export type CaseStrategy_$cases = {
+    0: ["PascalCase", []],
+    1: ["CamelCase", []],
+    2: ["SnakeCase", []]
+}
+
+export function CaseStrategy_PascalCase() {
+    return new CaseStrategy<0>(0, []);
+}
+
+export function CaseStrategy_CamelCase() {
+    return new CaseStrategy<1>(1, []);
+}
+
+export function CaseStrategy_SnakeCase() {
+    return new CaseStrategy<2>(2, []);
+}
+
+export class CaseStrategy<Tag extends keyof CaseStrategy_$cases> extends Union<Tag, CaseStrategy_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: CaseStrategy_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["PascalCase", "CamelCase", "SnakeCase"];
+    }
+}
+
+export function CaseStrategy_$reflection(): TypeInfo {
+    return union_type("Thoth.Json.CaseStrategy", [], CaseStrategy, () => [[], [], []]);
+}
+
+export class ExtraCoders extends Record {
+    readonly Hash: string;
+    readonly Coders: FSharpMap<string, [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))]>;
+    constructor(Hash: string, Coders: FSharpMap<string, [((arg0: any) => any), ((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))]>) {
+        super();
+        this.Hash = Hash;
+        this.Coders = Coders;
+    }
+}
+
+export function ExtraCoders_$reflection(): TypeInfo {
+    return record_type("Thoth.Json.ExtraCoders", [], ExtraCoders, () => [["Hash", string_type], ["Coders", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, tuple_type(lambda_type(obj_type, obj_type), lambda_type(string_type, lambda_type(obj_type, union_type("Microsoft.FSharp.Core.FSharpResult`2", [obj_type, tuple_type(string_type, ErrorReason_$reflection())], FSharpResult$2, () => [[["ResultValue", obj_type]], [["ErrorValue", tuple_type(string_type, ErrorReason_$reflection())]]]))))])]]);
+}
+
+export class Util_Cache$1<Value> {
+    readonly cache: IMap<string, Value>;
+    constructor() {
+        this.cache = (new Map<string, Value>([]));
+    }
+}
+
+export function Util_Cache$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return class_type("Thoth.Json.Util.Cache`1", [gen0], Util_Cache$1);
+}
+
+export function Util_Cache$1_$ctor<Value>(): Util_Cache$1<Value> {
+    return new Util_Cache$1();
+}
+
+export function Util_Cache$1__GetOrAdd_43981464<Value>(__: Util_Cache$1<Value>, key: string, factory: (() => Value)): Value {
+    let matchValue: [boolean, Value];
+    let outArg: Value = defaultOf();
+    matchValue = ([tryGetValue(__.cache, key, new FSharpRef<Value>((): Value => outArg, (v: Value): void => {
+        outArg = v;
+    })), outArg] as [boolean, Value]);
+    if (matchValue[0]) {
+        return matchValue[1];
+    }
+    else {
+        const x_1: Value = factory();
+        addToDict(__.cache, key, x_1);
+        return x_1;
+    }
+}
+
+export const Util_CachedEncoders: Util_Cache$1<((arg0: any) => any)> = Util_Cache$1_$ctor<((arg0: any) => any)>();
+
+export const Util_CachedDecoders: Util_Cache$1<((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))> = Util_Cache$1_$ctor<((arg0: string) => ((arg0: any) => FSharpResult$2_$union<any, [string, ErrorReason_$union]>))>();
+
+export function Util_Casing_lowerFirst(str: string): string {
+    return str.slice(undefined, 0 + 1).toLowerCase() + str.slice(1, str.length);
+}
+
+export function Util_Casing_convert(caseStrategy: CaseStrategy_$union, fieldName: string): string {
+    switch (caseStrategy.tag) {
+        case /* SnakeCase */ 2:
+            return replace(Util_Casing_lowerFirst(fieldName), "[A-Z]", "_$0").toLowerCase();
+        case /* PascalCase */ 0:
+            return fieldName;
+        default:
+            return Util_Casing_lowerFirst(fieldName);
+    }
+}
+
+//# sourceMappingURL=Types.ts.map