ballerina-core 1.0.256 → 1.0.257

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/types/state.js

@@ -1,639 +1,1100 @@
 import { List, Map } from "immutable";
 import { ValueOrErrors } from "../../../../../../../../collections/domains/valueOrErrors/state";
-import { DispatchGenericTypes, MapRepo, } from "../../../../../../../../../main";
+import {
+  DispatchGenericTypes,
+  MapRepo,
+  isString,
+} from "../../../../../../../../../main";
 export const DispatchisString = (_) => typeof _ == "string";
 export const DispatchIsObject = (_) => typeof _ == "object";
-export const DispatchIsGenericType = (_) => _ && DispatchGenericTypes.includes(_);
-export const DispatchHasFun = (_) => DispatchIsObject(_) && "fun" in _ && DispatchisString(_.fun);
-export const DispatchHasArgs = (_) => DispatchIsObject(_) && "args" in _ && Array.isArray(_.args);
+export const DispatchIsGenericType = (_) =>
+  _ && DispatchGenericTypes.includes(_);
+export const DispatchHasFun = (_) =>
+  DispatchIsObject(_) && "fun" in _ && DispatchisString(_.fun);
+export const DispatchHasArgs = (_) =>
+  DispatchIsObject(_) && "args" in _ && Array.isArray(_.args);
 export const DispatchPrimitiveTypeNames = [
-    "unit",
-    "guid", //resolves to string
-    "entityIdString", //resolves to string
-    "entityIdUUID", //resolves to string
-    "calculatedDisplayValue", //resolves to string
-    "string",
-    "number",
-    "boolean",
-    "Date",
-    "base64File",
-    "secret",
+  "unit",
+  "guid", //resolves to string
+  "entityIdString", //resolves to string
+  "entityIdUUID", //resolves to string
+  "calculatedDisplayValue", //resolves to string
+  "string",
+  "number",
+  "boolean",
+  "Date",
+  "base64File",
+  "secret",
+];
+const STRINGY_TYPES = [
+  "guid",
+  "entityIdUUID",
+  "entityIdString",
+  "calculatedDisplayValue",
 ];
 export const SerializedType = {
-    isExtendedType: (type) => typeof type == "object" &&
-        "extends" in type &&
-        Array.isArray(type.extends) &&
-        type.extends.length > 0 &&
-        type.extends.every(DispatchisString),
-    hasFields: (type) => typeof type == "object" && "fields" in type,
-    isPrimitive: (_, injectedPrimitives) => Boolean(DispatchPrimitiveTypeNames.some((__) => _ == __) ||
-        (injectedPrimitives === null || injectedPrimitives === void 0 ? void 0 : injectedPrimitives.has(_))),
-    isApplication: (_) => DispatchHasFun(_) && DispatchIsGenericType(_.fun) && DispatchHasArgs(_),
-    isLookup: (_, forms) => DispatchisString(_) && forms.has(_),
-    isList: (_) => SerializedType.isApplication(_) && _.fun == "List" && _.args.length == 1,
-    isMap: (_) => SerializedType.isApplication(_) && _.fun == "Map" && _.args.length == 2,
-    isSum: (_) => SerializedType.isApplication(_) && _.fun == "Sum" && _.args.length == 2,
-    isSumUnitDate: (_) => typeof _ == "string" && _ == "SumUnitDate",
-    isSingleSelection: (_) => SerializedType.isApplication(_) &&
-        _.fun == "SingleSelection" &&
-        _.args.length == 1,
-    isMultiSelection: (_) => SerializedType.isApplication(_) &&
-        _.fun == "MultiSelection" &&
-        _.args.length == 1,
-    isUnion: (_) => DispatchHasFun(_) &&
-        DispatchIsGenericType(_.fun) &&
-        DispatchHasArgs(_) &&
-        _.fun == "Union" &&
-        _.args.length > 0 &&
-        _.args.every((arg) => (DispatchIsObject(arg) && "caseName" in arg && !("fields" in arg)) ||
-            ("fields" in arg &&
-                (DispatchisString(arg.fields) || DispatchIsObject(arg.fields)))),
-    isTuple: (_) => SerializedType.isApplication(_) && _.fun == "Tuple",
-    isRecord: (_) => _ != null &&
-        typeof _ == "object" &&
-        "fields" in _ &&
-        (DispatchIsObject(_.fields) || DispatchisString(_.fields)),
-    isTable: (_) => SerializedType.isApplication(_) && _.fun == "Table" && _.args.length == 1,
-    isOption: (_) => typeof _ == "object" &&
-        "fun" in _ &&
-        _.fun == "Option" &&
-        "args" in _ &&
-        Array.isArray(_.args) &&
-        _.args.length == 1,
-    isUnit: (_) => _ == "unit",
-    isKeyOf: (_) => typeof _ == "object" &&
-        "fun" in _ &&
-        _.fun == "KeyOf" &&
-        "args" in _ &&
-        Array.isArray(_.args) &&
-        (_.args.length == 1 || (_.args.length == 2 && Array.isArray(_.args[1]))) &&
-        DispatchisString(_.args[0]),
-    isOne: (_) => SerializedType.isApplication(_) && _.fun == "One" && _.args.length == 1,
-    isReadOnly: (_) => SerializedType.isApplication(_) &&
-        _.fun == "ReadOnly" &&
-        _.args.length == 1,
-    isRecordFields: (_) => typeof _ == "object" && _ != null && !("fun" in _) && !("args" in _),
-    isTranslationOverride: (_) => typeof _ == "object" &&
-        _ != null &&
-        "fun" in _ &&
-        _.fun == "TranslationOverride" &&
-        "args" in _ &&
-        Array.isArray(_.args) &&
-        _.args.length == 2 &&
-        DispatchisString(_.args[0]),
+  isExtendedType: (type) =>
+    typeof type == "object" &&
+    "extends" in type &&
+    Array.isArray(type.extends) &&
+    type.extends.length > 0 &&
+    type.extends.every(DispatchisString),
+  hasFields: (type) => typeof type == "object" && "fields" in type,
+  isPrimitive: (_, injectedPrimitives) =>
+    Boolean(
+      DispatchPrimitiveTypeNames.some((__) => _ == __) ||
+        (injectedPrimitives === null || injectedPrimitives === void 0
+          ? void 0
+          : injectedPrimitives.has(_)),
+    ),
+  isApplication: (_) =>
+    DispatchHasFun(_) && DispatchIsGenericType(_.fun) && DispatchHasArgs(_),
+  isLookup: (_, injectedPrimitives) =>
+    DispatchisString(_) &&
+    !(injectedPrimitives === null || injectedPrimitives === void 0
+      ? void 0
+      : injectedPrimitives.has(_)) &&
+    !(_ in DispatchPrimitiveTypeNames),
+  isList: (_) =>
+    SerializedType.isApplication(_) && _.fun == "List" && _.args.length == 1,
+  isMap: (_) =>
+    SerializedType.isApplication(_) && _.fun == "Map" && _.args.length == 2,
+  isSum: (_) =>
+    SerializedType.isApplication(_) && _.fun == "Sum" && _.args.length == 2,
+  isSumUnitDate: (_) => typeof _ == "string" && _ == "SumUnitDate",
+  isSingleSelection: (_) =>
+    SerializedType.isApplication(_) &&
+    _.fun == "SingleSelection" &&
+    _.args.length == 1,
+  isMultiSelection: (_) =>
+    SerializedType.isApplication(_) &&
+    _.fun == "MultiSelection" &&
+    _.args.length == 1,
+  isUnion: (_) =>
+    DispatchHasFun(_) &&
+    DispatchIsGenericType(_.fun) &&
+    DispatchHasArgs(_) &&
+    _.fun == "Union" &&
+    _.args.length > 0 &&
+    _.args.every(
+      (arg) =>
+        (DispatchIsObject(arg) && "caseName" in arg && !("fields" in arg)) ||
+        ("fields" in arg &&
+          (DispatchisString(arg.fields) || DispatchIsObject(arg.fields))),
+    ),
+  isTuple: (_) => SerializedType.isApplication(_) && _.fun == "Tuple",
+  isRecord: (_) =>
+    _ != null &&
+    typeof _ == "object" &&
+    "fields" in _ &&
+    (DispatchIsObject(_.fields) || DispatchisString(_.fields)),
+  isTable: (_) =>
+    SerializedType.isApplication(_) && _.fun == "Table" && _.args.length == 1,
+  isOption: (_) =>
+    typeof _ == "object" &&
+    "fun" in _ &&
+    _.fun == "Option" &&
+    "args" in _ &&
+    Array.isArray(_.args) &&
+    _.args.length == 1,
+  isUnit: (_) => _ == "unit",
+  isKeyOf: (_) =>
+    typeof _ == "object" &&
+    "fun" in _ &&
+    _.fun == "KeyOf" &&
+    "args" in _ &&
+    Array.isArray(_.args) &&
+    (_.args.length == 1 || (_.args.length == 2 && Array.isArray(_.args[1]))) &&
+    DispatchisString(_.args[0]),
+  isOne: (_) =>
+    SerializedType.isApplication(_) && _.fun == "One" && _.args.length == 1,
+  isReadOnly: (_) =>
+    SerializedType.isApplication(_) &&
+    _.fun == "ReadOnly" &&
+    _.args.length == 1,
+  isRecordFields: (_) =>
+    typeof _ == "object" && _ != null && !("fun" in _) && !("args" in _),
+  isTranslationOverride: (_) =>
+    typeof _ == "object" &&
+    _ != null &&
+    "fun" in _ &&
+    _.fun == "TranslationOverride" &&
+    "args" in _ &&
+    Array.isArray(_.args) &&
+    _.args.length == 2 &&
+    DispatchisString(_.args[0]),
 };
 export const UnionType = {
-    SerializeToString: (serializedArgs) => {
-        return `[union; cases: {${serializedArgs.map((v, k) => `${k}: ${v}`).join(", ")}}]`;
-    },
+  SerializeToString: (serializedArgs) => {
+    return `[union; cases: {${serializedArgs.map((v, k) => `${k}: ${v}`).join(", ")}}]`;
+  },
 };
 export const RecordType = {
-    SerializeToString: (serializedFields) => {
-        return `[record; fields: {${serializedFields.map((v, k) => `${k}: ${v}`).join(", ")}}]`;
-    },
+  SerializeToString: (serializedFields) => {
+    return `[record; fields: {${serializedFields.map((v, k) => `${k}: ${v}`).join(", ")}}]`;
+  },
 };
 export const LookupType = {
-    SerializeToString: (name) => {
-        return `${name}`;
-    },
+  SerializeToString: (name) => {
+    return `${name}`;
+  },
 };
 export const DispatchPrimitiveType = {
-    SerializeToString: (name) => {
-        return `[primitive; name: ${String(name)}]`;
-    },
+  SerializeToString: (name) => {
+    return `[primitive; name: ${String(name)}]`;
+  },
 };
 export const SingleSelectionType = {
-    SerializeToString: (serializedArgs) => {
-        return `[singleSelection; args: [${serializedArgs.join(", ")}]]`;
-    },
+  SerializeToString: (serializedArgs) => {
+    return `[singleSelection; args: [${serializedArgs.join(", ")}]]`;
+  },
 };
 export const MultiSelectionType = {
-    SerializeToString: (serializedArgs) => {
-        return `[multiSelection; args: [${serializedArgs.join(", ")}]]`;
-    },
+  SerializeToString: (serializedArgs) => {
+    return `[multiSelection; args: [${serializedArgs.join(", ")}]]`;
+  },
 };
 export const ListType = {
-    SerializeToString: (serializedArgs) => {
-        return `[list; args: [${serializedArgs.join(", ")}]]`;
-    },
+  SerializeToString: (serializedArgs) => {
+    return `[list; args: [${serializedArgs.join(", ")}]]`;
+  },
 };
 export const TupleType = {
-    SerializeToString: (serializedArgs) => {
-        return `[tuple; args: [${serializedArgs.join(", ")}]]`;
-    },
+  SerializeToString: (serializedArgs) => {
+    return `[tuple; args: [${serializedArgs.join(", ")}]]`;
+  },
 };
 export const SumType = {
-    SerializeToString: (serializedArgs) => {
-        return `[sum; args: [${serializedArgs.join(", ")}]]`;
-    },
+  SerializeToString: (serializedArgs) => {
+    return `[sum; args: [${serializedArgs.join(", ")}]]`;
+  },
 };
 export const SumNType = {
-    SerializeToString: (serializedArgs, arity) => {
-        return `[sumN; arity: ${arity}; args: [${serializedArgs.join(", ")}]]`;
-    },
+  SerializeToString: (serializedArgs, arity) => {
+    return `[sumN; arity: ${arity}; args: [${serializedArgs.join(", ")}]]`;
+  },
 };
 export const MapType = {
-    SerializeToString: (serializedArgs) => {
-        return `[map; args: [${serializedArgs.join(", ")}]]`;
-    },
+  SerializeToString: (serializedArgs) => {
+    return `[map; args: [${serializedArgs.join(", ")}]]`;
+  },
 };
 export const TableType = {
-    SerializeToString: (serializedArg) => {
-        return `[table; arg: ${serializedArg}]`;
-    },
+  SerializeToString: (serializedArg) => {
+    return `[table; arg: ${serializedArg}]`;
+  },
 };
 export const ReadOnlyType = {
-    SerializeToString: (serializedArg) => {
-        return `[readOnly; arg: ${serializedArg}]`;
-    },
+  SerializeToString: (serializedArg) => {
+    return `[readOnly; arg: ${serializedArg}]`;
+  },
 };
 export const OneType = {
-    SerializeToString: (serializedArg) => {
-        return `[one; arg: ${serializedArg}]`;
-    },
+  SerializeToString: (serializedArg) => {
+    return `[one; arg: ${serializedArg}]`;
+  },
 };
 export const FilterContainsType = {
-    SerializeToString: (serializedContains) => {
-        return `[filter; contains: ${serializedContains}]`;
-    },
+  SerializeToString: (serializedContains) => {
+    return `[filter; contains: ${serializedContains}]`;
+  },
 };
 export const FilterEqualsToType = {
-    SerializeToString: (serializedEqualsTo) => {
-        return `[filter; equalsTo: ${serializedEqualsTo}]`;
-    },
+  SerializeToString: (serializedEqualsTo) => {
+    return `[filter; equalsTo: ${serializedEqualsTo}]`;
+  },
 };
 export const FilterNotEqualsToType = {
-    SerializeToString: (serializedNotEqualsTo) => {
-        return `[filter; != ${serializedNotEqualsTo}]`;
-    },
+  SerializeToString: (serializedNotEqualsTo) => {
+    return `[filter; != ${serializedNotEqualsTo}]`;
+  },
 };
 export const FilterGreaterThanOrEqualsToType = {
-    SerializeToString: (serializedGreaterThanOrEqualsTo) => {
-        return `[filter; >= ${serializedGreaterThanOrEqualsTo}]`;
-    },
+  SerializeToString: (serializedGreaterThanOrEqualsTo) => {
+    return `[filter; >= ${serializedGreaterThanOrEqualsTo}]`;
+  },
 };
 export const FilterGreaterThanType = {
-    SerializeToString: (serializedGreaterThan) => {
-        return `[filter; > ${serializedGreaterThan}]`;
-    },
+  SerializeToString: (serializedGreaterThan) => {
+    return `[filter; > ${serializedGreaterThan}]`;
+  },
 };
 export const FilterIsNotNullType = {
-    SerializeToString: () => {
-        return `[filter; !=null]`;
-    },
+  SerializeToString: () => {
+    return `[filter; !=null]`;
+  },
 };
 export const FilterIsNullType = {
-    SerializeToString: () => {
-        return `[filter; =null]`;
-    },
+  SerializeToString: () => {
+    return `[filter; =null]`;
+  },
 };
 export const FilterSmallerThanOrEqualsToType = {
-    SerializeToString: (serializedSmallerThanOrEqualsTo) => {
-        return `[filter; <= ${serializedSmallerThanOrEqualsTo}]`;
-    },
+  SerializeToString: (serializedSmallerThanOrEqualsTo) => {
+    return `[filter; <= ${serializedSmallerThanOrEqualsTo}]`;
+  },
 };
 export const FilterSmallerThanType = {
-    SerializeToString: (serializedSmallerThan) => {
-        return `[filter; < ${serializedSmallerThan}]`;
-    },
+  SerializeToString: (serializedSmallerThan) => {
+    return `[filter; < ${serializedSmallerThan}]`;
+  },
 };
 export const FilterStartsWithType = {
-    SerializeToString: (serializedStartsWith) => {
-        return `[filter; startsWith ${serializedStartsWith}]`;
-    },
+  SerializeToString: (serializedStartsWith) => {
+    return `[filter; startsWith ${serializedStartsWith}]`;
+  },
 };
 export const FilterTypeKinds = [
-    "contains",
-    "=",
-    "!=",
-    ">=",
-    ">",
-    "!=null",
-    "=null",
-    "<=",
-    "<",
-    "startsWith",
+  "contains",
+  "=",
+  "!=",
+  ">=",
+  ">",
+  "!=null",
+  "=null",
+  "<=",
+  "<",
+  "startsWith",
 ];
 export const DispatchParsedType = {
-    Default: {
-        table: (arg) => ({
-            kind: "table",
-            arg,
-            asString: () => TableType.SerializeToString(arg.asString()),
-        }),
-        record: (fields) => ({
-            kind: "record",
-            fields,
-            asString: () => RecordType.SerializeToString(fields.map((v) => v.asString())),
-        }),
-        primitive: (name) => ({
-            kind: "primitive",
-            name,
-            asString: () => DispatchPrimitiveType.SerializeToString(name),
-        }),
-        singleSelection: (args) => ({
-            kind: "singleSelection",
-            args,
-            asString: () => SingleSelectionType.SerializeToString(args.map((v) => v.asString())),
-        }),
-        multiSelection: (args) => ({
-            kind: "multiSelection",
-            args,
-            asString: () => MultiSelectionType.SerializeToString(args.map((v) => v.asString())),
-        }),
-        list: (args) => ({
-            kind: "list",
-            args,
-            asString: () => ListType.SerializeToString(args.map((v) => v.asString())),
-        }),
-        tuple: (args) => ({
-            kind: "tuple",
-            args,
-            asString: () => TupleType.SerializeToString(args.map((v) => v.asString())),
-        }),
-        sum: (args) => ({
-            kind: "sum",
-            args,
-            asString: () => SumType.SerializeToString(args.map((v) => v.asString())),
-        }),
-        sumN: (args) => ({
-            kind: "sumN",
-            args,
-            asString: () => SumNType.SerializeToString(args.map((v) => v.asString()), args.length),
-        }),
-        map: (args) => ({
-            kind: "map",
-            args,
-            asString: () => MapType.SerializeToString(args.map((v) => v.asString())),
-        }),
-        union: (args) => ({
-            kind: "union",
-            args,
-            asString: () => UnionType.SerializeToString(args.map((v) => v.asString())),
-        }),
-        readOnly: (arg) => ({
-            kind: "readOnly",
-            arg,
-            asString: () => ReadOnlyType.SerializeToString(arg.asString()),
-        }),
-        lookup: (name) => ({
-            kind: "lookup",
-            name,
-            asString: () => LookupType.SerializeToString(name),
-        }),
-        one: (arg) => ({
-            kind: "one",
-            arg,
-            asString: () => OneType.SerializeToString(arg.asString()),
-        }),
-        filterContains: (contains) => ({
-            kind: "contains",
-            contains,
-            asString: () => FilterContainsType.SerializeToString(contains.asString()),
-        }),
-        filterEqualsTo: (equalsTo) => ({
-            kind: "=",
-            equalsTo,
-            asString: () => FilterEqualsToType.SerializeToString(equalsTo.asString()),
-        }),
-        filterNotEqualsTo: (notEqualsTo) => ({
-            kind: "!=",
-            notEqualsTo,
-            asString: () => FilterNotEqualsToType.SerializeToString(notEqualsTo.asString()),
-        }),
-        filterGreaterThanOrEqualsTo: (greaterThanOrEqualsTo) => ({
-            kind: ">=",
-            greaterThanOrEqualsTo,
-            asString: () => FilterGreaterThanOrEqualsToType.SerializeToString(greaterThanOrEqualsTo.asString()),
-        }),
-        filterGreaterThan: (greaterThan) => ({
-            kind: ">",
-            greaterThan,
-            asString: () => FilterGreaterThanType.SerializeToString(greaterThan.asString()),
-        }),
-        filterIsNotNull: () => ({
-            kind: "!=null",
-            asString: () => FilterIsNotNullType.SerializeToString(),
-        }),
-        filterIsNull: () => ({
-            kind: "=null",
-            asString: () => FilterIsNullType.SerializeToString(),
-        }),
-        filterSmallerThanOrEqualsTo: (smallerThanOrEqualsTo) => ({
-            kind: "<=",
-            smallerThanOrEqualsTo,
-            asString: () => FilterSmallerThanOrEqualsToType.SerializeToString(smallerThanOrEqualsTo.asString()),
-        }),
-        filterSmallerThan: (smallerThan) => ({
-            kind: "<",
-            smallerThan,
-            asString: () => FilterSmallerThanType.SerializeToString(smallerThan.asString()),
-        }),
-        filterStartsWith: (startsWith) => ({
-            kind: "startsWith",
-            startsWith,
-            asString: () => FilterStartsWithType.SerializeToString(startsWith.asString()),
-        }),
-    },
-    Operations: {
-        // We don't use this at the moment, if we need it, then we can fix
-        // Equals: <T>(
-        //   fst: DispatchParsedType<T>,
-        //   snd: DispatchParsedType<T>,
-        // ): boolean =>
-        //   fst.kind == "record" && snd.kind == "record"
-        //     ? fst.name == snd.name
-        //     : fst.kind == "table" && snd.kind == "table"
-        //       ? fst.name == snd.name
-        //       : fst.kind == "one" && snd.kind == "one"
-        //         ? fst.name == snd.name
-        //         : fst.kind == "lookup" && snd.kind == "lookup"
-        //           ? fst.name == snd.name
-        //           : fst.kind == "primitive" && snd.kind == "primitive"
-        //             ? fst.name == snd.name
-        //             : fst.kind == "list" && snd.kind == "list"
-        //               ? fst.name == snd.name
-        //               : fst.kind == "singleSelection" &&
-        //                   snd.kind == "singleSelection"
-        //                 ? fst.name == snd.name
-        //                 : fst.kind == "multiSelection" &&
-        //                     snd.kind == "multiSelection"
-        //                   ? fst.name == snd.name
-        //                   : fst.kind == "map" && snd.kind == "map"
-        //                     ? fst.name == snd.name
-        //                     : fst.kind == "sum" && snd.kind == "sum"
-        //                       ? fst.name == snd.name
-        //                       : fst.kind == "tuple" && snd.kind == "tuple"
-        //                         ? fst.name == snd.name &&
-        //                           fst.args.length == snd.args.length &&
-        //                           fst.args.every((v, i) =>
-        //                             DispatchParsedType.Operations.Equals(
-        //                               v,
-        //                               snd.args[i],
-        //                             ),
-        //                           )
-        //                         : fst.kind == "union" && snd.kind == "union"
-        //                           ? fst.args.size == snd.args.size &&
-        //                             fst.args.every(
-        //                               (v, i) => v.name == snd.args.get(i)!.name,
-        //                             )
-        //                           : false,
-        ParseRawKeyOf: (rawType, typeNames, serializedTypes, alreadyParsedTypes) => (alreadyParsedTypes.has(rawType.args[0])
-            ? alreadyParsedTypes
-                .get(rawType.args[0])
-                .Then((parsedType) => ValueOrErrors.Default.return([parsedType, alreadyParsedTypes]))
-            : DispatchParsedType.Operations.ParseRawType(rawType.args[0], serializedTypes[rawType.args[0]], typeNames, serializedTypes, alreadyParsedTypes))
-            .Then((parsingResult) => parsingResult[0].kind != "record"
-            ? ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(parsingResult[0])} is not a record type`)
+  Default: {
+    table: (arg) => ({
+      kind: "table",
+      arg,
+      asString: () => TableType.SerializeToString(arg.asString()),
+    }),
+    record: (fields) => ({
+      kind: "record",
+      fields,
+      asString: () =>
+        RecordType.SerializeToString(fields.map((v) => v.asString())),
+    }),
+    primitive: (name) => ({
+      kind: "primitive",
+      name,
+      asString: () => DispatchPrimitiveType.SerializeToString(name),
+    }),
+    singleSelection: (args) => ({
+      kind: "singleSelection",
+      args,
+      asString: () =>
+        SingleSelectionType.SerializeToString(args.map((v) => v.asString())),
+    }),
+    multiSelection: (args) => ({
+      kind: "multiSelection",
+      args,
+      asString: () =>
+        MultiSelectionType.SerializeToString(args.map((v) => v.asString())),
+    }),
+    list: (args) => ({
+      kind: "list",
+      args,
+      asString: () => ListType.SerializeToString(args.map((v) => v.asString())),
+    }),
+    tuple: (args) => ({
+      kind: "tuple",
+      args,
+      asString: () =>
+        TupleType.SerializeToString(args.map((v) => v.asString())),
+    }),
+    sum: (args) => ({
+      kind: "sum",
+      args,
+      asString: () => SumType.SerializeToString(args.map((v) => v.asString())),
+    }),
+    sumN: (args) => ({
+      kind: "sumN",
+      args,
+      asString: () =>
+        SumNType.SerializeToString(
+          args.map((v) => v.asString()),
+          args.length,
+        ),
+    }),
+    map: (args) => ({
+      kind: "map",
+      args,
+      asString: () => MapType.SerializeToString(args.map((v) => v.asString())),
+    }),
+    union: (args) => ({
+      kind: "union",
+      args,
+      asString: () =>
+        UnionType.SerializeToString(args.map((v) => v.asString())),
+    }),
+    readOnly: (arg) => ({
+      kind: "readOnly",
+      arg,
+      asString: () => ReadOnlyType.SerializeToString(arg.asString()),
+    }),
+    lookup: (name) => ({
+      kind: "lookup",
+      name,
+      asString: () => LookupType.SerializeToString(name),
+    }),
+    one: (arg) => ({
+      kind: "one",
+      arg,
+      asString: () => OneType.SerializeToString(arg.asString()),
+    }),
+    filterContains: (contains) => ({
+      kind: "contains",
+      contains,
+      asString: () => FilterContainsType.SerializeToString(contains.asString()),
+    }),
+    filterEqualsTo: (equalsTo) => ({
+      kind: "=",
+      equalsTo,
+      asString: () => FilterEqualsToType.SerializeToString(equalsTo.asString()),
+    }),
+    filterNotEqualsTo: (notEqualsTo) => ({
+      kind: "!=",
+      notEqualsTo,
+      asString: () =>
+        FilterNotEqualsToType.SerializeToString(notEqualsTo.asString()),
+    }),
+    filterGreaterThanOrEqualsTo: (greaterThanOrEqualsTo) => ({
+      kind: ">=",
+      greaterThanOrEqualsTo,
+      asString: () =>
+        FilterGreaterThanOrEqualsToType.SerializeToString(
+          greaterThanOrEqualsTo.asString(),
+        ),
+    }),
+    filterGreaterThan: (greaterThan) => ({
+      kind: ">",
+      greaterThan,
+      asString: () =>
+        FilterGreaterThanType.SerializeToString(greaterThan.asString()),
+    }),
+    filterIsNotNull: () => ({
+      kind: "!=null",
+      asString: () => FilterIsNotNullType.SerializeToString(),
+    }),
+    filterIsNull: () => ({
+      kind: "=null",
+      asString: () => FilterIsNullType.SerializeToString(),
+    }),
+    filterSmallerThanOrEqualsTo: (smallerThanOrEqualsTo) => ({
+      kind: "<=",
+      smallerThanOrEqualsTo,
+      asString: () =>
+        FilterSmallerThanOrEqualsToType.SerializeToString(
+          smallerThanOrEqualsTo.asString(),
+        ),
+    }),
+    filterSmallerThan: (smallerThan) => ({
+      kind: "<",
+      smallerThan,
+      asString: () =>
+        FilterSmallerThanType.SerializeToString(smallerThan.asString()),
+    }),
+    filterStartsWith: (startsWith) => ({
+      kind: "startsWith",
+      startsWith,
+      asString: () =>
+        FilterStartsWithType.SerializeToString(startsWith.asString()),
+    }),
+  },
+  Operations: {
+    // We don't use this at the moment, if we need it, then we can fix
+    // Equals: <T>(
+    //   fst: DispatchParsedType<T>,
+    //   snd: DispatchParsedType<T>,
+    // ): boolean =>
+    //   fst.kind == "record" && snd.kind == "record"
+    //     ? fst.name == snd.name
+    //     : fst.kind == "table" && snd.kind == "table"
+    //       ? fst.name == snd.name
+    //       : fst.kind == "one" && snd.kind == "one"
+    //         ? fst.name == snd.name
+    //         : fst.kind == "lookup" && snd.kind == "lookup"
+    //           ? fst.name == snd.name
+    //           : fst.kind == "primitive" && snd.kind == "primitive"
+    //             ? fst.name == snd.name
+    //             : fst.kind == "list" && snd.kind == "list"
+    //               ? fst.name == snd.name
+    //               : fst.kind == "singleSelection" &&
+    //                   snd.kind == "singleSelection"
+    //                 ? fst.name == snd.name
+    //                 : fst.kind == "multiSelection" &&
+    //                     snd.kind == "multiSelection"
+    //                   ? fst.name == snd.name
+    //                   : fst.kind == "map" && snd.kind == "map"
+    //                     ? fst.name == snd.name
+    //                     : fst.kind == "sum" && snd.kind == "sum"
+    //                       ? fst.name == snd.name
+    //                       : fst.kind == "tuple" && snd.kind == "tuple"
+    //                         ? fst.name == snd.name &&
+    //                           fst.args.length == snd.args.length &&
+    //                           fst.args.every((v, i) =>
+    //                             DispatchParsedType.Operations.Equals(
+    //                               v,
+    //                               snd.args[i],
+    //                             ),
+    //                           )
+    //                         : fst.kind == "union" && snd.kind == "union"
+    //                           ? fst.args.size == snd.args.size &&
+    //                             fst.args.every(
+    //                               (v, i) => v.name == snd.args.get(i)!.name,
+    //                             )
+    //                           : false,
+    ParseRawKeyOf: (
+      rawType,
+      serializedTypes,
+      alreadyParsedTypes,
+      injectedPrimitives,
+    ) =>
+      (alreadyParsedTypes.has(rawType.args[0])
+        ? alreadyParsedTypes
+            .get(rawType.args[0])
+            .Then((parsedType) =>
+              ValueOrErrors.Default.return([parsedType, alreadyParsedTypes]),
+            )
+        : DispatchParsedType.Operations.ParseRawType(
+            rawType.args[0],
+            serializedTypes[rawType.args[0]],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          )
+      )
+        .Then((parsingResult) =>
+          parsingResult[0].kind != "record"
+            ? ValueOrErrors.Default.throwOne(
+                `Error: ${JSON.stringify(parsingResult[0])} is not a record type`,
+              )
             : ValueOrErrors.Default.return([
-                DispatchParsedType.Default.union(Map(parsingResult[0].fields
-                    .keySeq()
-                    .filter((key) => rawType.args[1] == undefined ||
-                    !rawType.args[1].includes(key))
-                    .toArray()
-                    .map((key) => [
-                    key,
-                    DispatchParsedType.Default.record(Map()),
-                ]))),
+                DispatchParsedType.Default.union(
+                  Map(
+                    (() => {
+                      const excludedKeys = rawType.args[1]
+                        ? rawType.args[1].reduce((acc, key) => {
+                            acc[key] = true;
+                            return acc;
+                          }, {})
+                        : null;
+                      return parsingResult[0].fields
+                        .keySeq()
+                        .filter(
+                          (key) =>
+                            excludedKeys == null || !(key in excludedKeys),
+                        )
+                        .toArray()
+                        .map((key) => [
+                          key,
+                          DispatchParsedType.Default.record(Map()),
+                        ]);
+                    })(),
+                  ),
+                ),
                 parsingResult[1],
-            ]))
-            .MapErrors((errors) => errors.map((error) => `${error}\n...When parsing keyOf type`)),
-        SerializeToString: (type) => {
-            switch (type.kind) {
-                case "primitive":
-                    return DispatchPrimitiveType.SerializeToString(type.name);
-                case "record":
-                    return RecordType.SerializeToString(type.fields.map((v) => DispatchParsedType.Operations.SerializeToString(v)));
-                case "table":
-                    return TableType.SerializeToString(DispatchParsedType.Operations.SerializeToString(type.arg));
-                case "one":
-                    return OneType.SerializeToString(DispatchParsedType.Operations.SerializeToString(type.arg));
-                case "singleSelection":
-                    return SingleSelectionType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.SerializeToString(v)));
-                case "multiSelection":
-                    return MultiSelectionType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.SerializeToString(v)));
-                case "list":
-                    return ListType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.SerializeToString(v)));
-                case "tuple":
-                    return TupleType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.SerializeToString(v)));
-                case "sum":
-                    return SumType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.SerializeToString(v)));
-                case "sumN":
-                    return SumNType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.SerializeToString(v)), type.args.length);
-                case "map":
-                    return MapType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.SerializeToString(v)));
-                case "union":
-                    return UnionType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.SerializeToString(v)));
-                case "lookup":
-                    return LookupType.SerializeToString(type.name);
-                case "contains":
-                    return FilterContainsType.SerializeToString(type.contains.asString());
-                case "=":
-                    return FilterEqualsToType.SerializeToString(type.equalsTo.asString());
-                case "!=":
-                    return FilterNotEqualsToType.SerializeToString(type.notEqualsTo.asString());
-                case ">=":
-                    return FilterGreaterThanOrEqualsToType.SerializeToString(type.greaterThanOrEqualsTo.asString());
-                case ">":
-                    return FilterGreaterThanType.SerializeToString(type.greaterThan.asString());
-                case "!=null":
-                    return FilterIsNotNullType.SerializeToString();
-                case "=null":
-                    return FilterIsNullType.SerializeToString();
-                case "<=":
-                    return FilterSmallerThanOrEqualsToType.SerializeToString(type.smallerThanOrEqualsTo.asString());
-                case "<":
-                    return FilterSmallerThanType.SerializeToString(type.smallerThan.asString());
-                case "startsWith":
-                    return FilterStartsWithType.SerializeToString(type.startsWith.asString());
-                default:
-                    throw new Error(`Unknown type: ${JSON.stringify(type)}`);
-            }
-        },
-        ParseRecord: (typeName, rawType, typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives) => 
-        // will already been parsed if it was extended by another type which was already parsed
-        alreadyParsedTypes.has(typeName)
-            ? alreadyParsedTypes
-                .get(typeName)
-                .Then((parsedType) => parsedType.kind != "record"
-                ? ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(parsedType)} is not a record type`)
-                : ValueOrErrors.Default.return([
-                    parsedType,
-                    alreadyParsedTypes,
-                ]))
-            : !SerializedType.isRecord(rawType)
-                ? ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(rawType)} is not a valid record`)
-                : (SerializedType.isExtendedType(rawType)
-                    ? ValueOrErrors.Operations.All(List(rawType.extends.map((extendedTypeName) => alreadyParsedTypes.has(extendedTypeName)
-                        ? alreadyParsedTypes
-                            .get(extendedTypeName)
-                            .Then((extendedType) => extendedType.kind != "record"
-                            ? ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(extendedType)} is not a record type`)
-                            : ValueOrErrors.Default.return([extendedTypeName, extendedType]))
+              ]),
+        )
+        .MapErrors((errors) =>
+          errors.map((error) => `${error}\n...When parsing keyOf type`),
+        ),
+    SerializeToString: (type) => {
+      switch (type.kind) {
+        case "primitive":
+          return DispatchPrimitiveType.SerializeToString(type.name);
+        case "record":
+          return RecordType.SerializeToString(
+            type.fields.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+          );
+        case "table":
+          return TableType.SerializeToString(
+            DispatchParsedType.Operations.SerializeToString(type.arg),
+          );
+        case "one":
+          return OneType.SerializeToString(
+            DispatchParsedType.Operations.SerializeToString(type.arg),
+          );
+        case "singleSelection":
+          return SingleSelectionType.SerializeToString(
+            type.args.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+          );
+        case "multiSelection":
+          return MultiSelectionType.SerializeToString(
+            type.args.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+          );
+        case "list":
+          return ListType.SerializeToString(
+            type.args.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+          );
+        case "tuple":
+          return TupleType.SerializeToString(
+            type.args.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+          );
+        case "sum":
+          return SumType.SerializeToString(
+            type.args.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+          );
+        case "sumN":
+          return SumNType.SerializeToString(
+            type.args.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+            type.args.length,
+          );
+        case "map":
+          return MapType.SerializeToString(
+            type.args.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+          );
+        case "union":
+          return UnionType.SerializeToString(
+            type.args.map((v) =>
+              DispatchParsedType.Operations.SerializeToString(v),
+            ),
+          );
+        case "lookup":
+          return LookupType.SerializeToString(type.name);
+        case "contains":
+          return FilterContainsType.SerializeToString(type.contains.asString());
+        case "=":
+          return FilterEqualsToType.SerializeToString(type.equalsTo.asString());
+        case "!=":
+          return FilterNotEqualsToType.SerializeToString(
+            type.notEqualsTo.asString(),
+          );
+        case ">=":
+          return FilterGreaterThanOrEqualsToType.SerializeToString(
+            type.greaterThanOrEqualsTo.asString(),
+          );
+        case ">":
+          return FilterGreaterThanType.SerializeToString(
+            type.greaterThan.asString(),
+          );
+        case "!=null":
+          return FilterIsNotNullType.SerializeToString();
+        case "=null":
+          return FilterIsNullType.SerializeToString();
+        case "<=":
+          return FilterSmallerThanOrEqualsToType.SerializeToString(
+            type.smallerThanOrEqualsTo.asString(),
+          );
+        case "<":
+          return FilterSmallerThanType.SerializeToString(
+            type.smallerThan.asString(),
+          );
+        case "startsWith":
+          return FilterStartsWithType.SerializeToString(
+            type.startsWith.asString(),
+          );
+        default:
+          throw new Error(`Unknown type: ${JSON.stringify(type)}`);
+      }
+    },
+    GetExtendedRecordTypes: (extendedTypeName, alreadyParsedTypes) => {
+      return MapRepo.Operations.tryFindWithError(
+        extendedTypeName,
+        alreadyParsedTypes,
+        () => `cannot find extended type ${extendedTypeName} in types`,
+      ).Then((extendedType) =>
+        extendedType.Then((extendedType) =>
+          extendedType.kind != "record"
+            ? ValueOrErrors.Default.throwOne(
+                `Error: ${JSON.stringify(extendedType)} is not a record type`,
+              )
+            : ValueOrErrors.Default.return([extendedTypeName, extendedType]),
+        ),
+      );
+    },
+    ParseRecord: (
+      typeName,
+      rawType,
+      serializedTypes,
+      alreadyParsedTypes,
+      injectedPrimitives,
+    ) =>
+      !SerializedType.isRecord(rawType)
+        ? ValueOrErrors.Default.throwOne(
+            `Error: ${JSON.stringify(rawType)} is not a valid record`,
+          )
+        : (SerializedType.isExtendedType(rawType)
+            ? rawType.extends
+                .reduce(
+                  (acc, extendedTypeName) =>
+                    acc.Then(([resultMap, accumulatedAlreadyParsedTypes]) =>
+                      accumulatedAlreadyParsedTypes.has(extendedTypeName)
+                        ? DispatchParsedType.Operations.GetExtendedRecordTypes(
+                            extendedTypeName,
+                            accumulatedAlreadyParsedTypes,
+                          ).Then(([extendedTypeName, recordType]) =>
+                            ValueOrErrors.Default.return([
+                              resultMap.set(extendedTypeName, recordType),
+                              accumulatedAlreadyParsedTypes,
+                            ]),
+                          )
                         : serializedTypes[extendedTypeName] == undefined
-                            ? ValueOrErrors.Default.throwOne(`Error: cannot find extended type ${extendedTypeName} in types`)
-                            : DispatchParsedType.Operations.ParseRawType(extendedTypeName, serializedTypes[extendedTypeName], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedType) => parsedType[0].kind == "record"
-                                ? ValueOrErrors.Default.return([extendedTypeName, parsedType[0]])
-                                : ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(parsedType[0])} is not a record type`)))))
-                        .MapErrors((errors) => errors.map((error) => `${error}\n...When parsing extended types`))
-                        .Then((parsedExtendedRecordTypes) => ValueOrErrors.Default.return(parsedExtendedRecordTypes.reduce((acc, type) => acc.set(type[0], type[1]), Map())))
-                    : ValueOrErrors.Default.return(Map())).Then((parsedExtendedRecordTypesMap) => ValueOrErrors.Operations.All(List(Object.entries(rawType.fields).map(([fieldName, fieldType]) => DispatchParsedType.Operations.ParseRawType(fieldName, fieldType, typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedField) => ValueOrErrors.Default.return([fieldName, parsedField])))))
-                    .Then((parsedFields) => ValueOrErrors.Default.return(Map(parsedFields.map(([fieldName, parsedField]) => [
-                    fieldName,
-                    parsedField[0],
-                ]))))
-                    .Then((parsedFieldsMap) => ValueOrErrors.Default.return(DispatchParsedType.Default.record(parsedFieldsMap.merge(parsedExtendedRecordTypesMap.reduce((acc, type) => acc.merge(type.fields), Map())))).Then((parsedRecord) => ValueOrErrors.Default.return([
-                    parsedRecord,
-                    parsedExtendedRecordTypesMap.reduce((acc, type, name) => acc.set(name, ValueOrErrors.Default.return(type)), alreadyParsedTypes),
-                ])))),
-        ParseRawFilterType: (rawFilterType, arg) => {
-            if (typeof rawFilterType != "string") {
-                return ValueOrErrors.Default.throwOne(`rawType is not a string`);
-            }
-            switch (rawFilterType) {
-                case "contains":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterContains(arg));
-                case "equalsTo":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterEqualsTo(arg));
-                case "startswith":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterStartsWith(arg));
-                case "!=":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterNotEqualsTo(arg));
-                case "=":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterEqualsTo(arg));
-                case ">=":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterGreaterThanOrEqualsTo(arg));
-                case ">":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterGreaterThan(arg));
-                case "<=":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterSmallerThanOrEqualsTo(arg));
-                case "<":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterSmallerThan(arg));
-                case "=null":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterIsNull());
-                case "!=null":
-                    return ValueOrErrors.Default.return(DispatchParsedType.Default.filterIsNotNull());
-                default:
-                    return ValueOrErrors.Default.throwOne(`Unknown filter type: ${rawFilterType}`);
-            }
-        },
-        ParseRawType: (typeName, rawType, typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives) => {
-            const result = (() => {
-                const stringyTypes = [
-                    "guid",
-                    "entityIdUUID",
-                    "entityIdString",
-                    "calculatedDisplayValue",
-                ];
-                if (SerializedType.isPrimitive(rawType, injectedPrimitives))
-                    return ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.primitive(typeof rawType === "string" && stringyTypes.includes(rawType)
-                            ? "string"
-                            : rawType),
-                        alreadyParsedTypes,
-                    ]);
-                if (SerializedType.isSingleSelection(rawType))
-                    return DispatchParsedType.Operations.ParseRawType(`SingleSelection:Element`, rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArgs) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.singleSelection([parsedArgs[0]]),
-                        alreadyParsedTypes,
-                    ]));
-                if (SerializedType.isMultiSelection(rawType))
-                    return DispatchParsedType.Operations.ParseRawType(`MultiSelection:Element`, rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArgs) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.multiSelection([parsedArgs[0]]),
-                        alreadyParsedTypes,
-                    ]));
-                if (SerializedType.isList(rawType))
-                    return DispatchParsedType.Operations.ParseRawType(`List:Element`, rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArgs) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.list([parsedArgs[0]]),
-                        alreadyParsedTypes,
-                    ]));
-                if (SerializedType.isTuple(rawType))
-                    return ValueOrErrors.Operations.All(List(rawType.args.map((arg, index) => DispatchParsedType.Operations.ParseRawType(`Tuple:Item ${index + 1}`, arg, typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives)))).Then((parsedArgs) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.tuple(parsedArgs.map(([parsedArg]) => parsedArg).toArray()),
-                        alreadyParsedTypes,
-                    ]));
-                if (SerializedType.isMap(rawType))
-                    return DispatchParsedType.Operations.ParseRawType("Map:Key", rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArgs0) => DispatchParsedType.Operations.ParseRawType("Map:Value", rawType.args[1], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArgs1) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.map([
-                            parsedArgs0[0],
-                            parsedArgs1[0],
-                        ]),
-                        alreadyParsedTypes,
-                    ])));
-                if (SerializedType.isSum(rawType))
-                    return DispatchParsedType.Operations.ParseRawType("Sum:Left", rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArgs0) => DispatchParsedType.Operations.ParseRawType("Sum:Right", rawType.args[1], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArgs1) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.sum([
-                            parsedArgs0[0],
-                            parsedArgs1[0],
-                        ]),
-                        alreadyParsedTypes,
-                    ])));
-                if (SerializedType.isRecord(rawType))
-                    return DispatchParsedType.Operations.ParseRecord(typeName, rawType, typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives);
-                if (SerializedType.isTable(rawType)) {
-                    return DispatchParsedType.Operations.ParseRawType("TableArg", rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArg) => parsedArg[0].kind != "lookup"
-                        ? ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(parsedArg[0])} is not a lookup type`)
-                        : ValueOrErrors.Default.return([
-                            DispatchParsedType.Default.table(parsedArg[0]),
-                            alreadyParsedTypes,
-                        ]));
-                }
-                if (SerializedType.isLookup(rawType, typeNames))
-                    return ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.lookup(rawType),
-                        alreadyParsedTypes,
-                    ]);
-                if (SerializedType.isUnit(rawType)) {
-                    return ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.primitive("unit"),
-                        alreadyParsedTypes,
-                    ]);
-                }
-                if (SerializedType.isUnion(rawType))
-                    // for now we assume all union cases are lookup types
-                    return ValueOrErrors.Operations.All(List(rawType.args.map((unionCase) => DispatchParsedType.Operations.ParseRawType(`Union:Case ${unionCase.caseName}`, unionCase.fields == undefined
+                          ? ValueOrErrors.Default.throwOne(
+                              `Error: cannot find extended type ${extendedTypeName} in types`,
+                            )
+                          : DispatchParsedType.Operations.ParseRawType(
+                              extendedTypeName,
+                              serializedTypes[extendedTypeName],
+                              serializedTypes,
+                              accumulatedAlreadyParsedTypes,
+                              injectedPrimitives,
+                            ).Then((parsedType) =>
+                              parsedType[0].kind == "record"
+                                ? ValueOrErrors.Default.return([
+                                    resultMap.set(
+                                      extendedTypeName,
+                                      parsedType[0],
+                                    ),
+                                    parsedType[1],
+                                  ])
+                                : ValueOrErrors.Default.throwOne(
+                                    `Error: ${JSON.stringify(parsedType[0])} is not a record type`,
+                                  ),
+                            ),
+                    ),
+                  ValueOrErrors.Default.return([Map(), alreadyParsedTypes]),
+                )
+                .MapErrors((errors) =>
+                  errors.map(
+                    (error) => `${error}\n...When parsing extended types`,
+                  ),
+                )
+                .Then(
+                  ([
+                    parsedExtendedRecordTypesMap,
+                    accumulatedAlreadyParsedTypes,
+                  ]) =>
+                    ValueOrErrors.Default.return([
+                      parsedExtendedRecordTypesMap,
+                      accumulatedAlreadyParsedTypes,
+                    ]),
+                )
+            : ValueOrErrors.Default.return([Map(), alreadyParsedTypes])
+          ).Then(
+            ([parsedExtendedRecordTypesMap, accumulatedAlreadyParsedTypes]) =>
+              Object.keys(rawType.fields)
+                .reduce(
+                  (acc, fieldName) =>
+                    acc.Then(
+                      ([
+                        parsedFieldsMap,
+                        accumulatedAlreadyParsedTypesForFields,
+                      ]) =>
+                        DispatchParsedType.Operations.ParseRawType(
+                          `Record field type: ${fieldName}`,
+                          rawType.fields[fieldName],
+                          serializedTypes,
+                          accumulatedAlreadyParsedTypesForFields,
+                          injectedPrimitives,
+                        ).Then((parsedField) =>
+                          ValueOrErrors.Default.return([
+                            parsedFieldsMap.set(fieldName, parsedField[0]),
+                            parsedField[1],
+                          ]),
+                        ),
+                    ),
+                  ValueOrErrors.Default.return([
+                    Map(),
+                    accumulatedAlreadyParsedTypes,
+                  ]),
+                )
+                .Then(
+                  ([
+                    parsedFieldsMap,
+                    accumulatedAlreadyParsedTypesForFields,
+                  ]) => {
+                    const { mergedFields, updatedAccumulatedTypes } =
+                      parsedExtendedRecordTypesMap.reduce(
+                        (acc, type, name) => ({
+                          mergedFields: acc.mergedFields.merge(type.fields),
+                          updatedAccumulatedTypes:
+                            acc.updatedAccumulatedTypes.set(
+                              name,
+                              ValueOrErrors.Default.return(type),
+                            ),
+                        }),
+                        {
+                          mergedFields: Map(),
+                          updatedAccumulatedTypes:
+                            accumulatedAlreadyParsedTypesForFields,
+                        },
+                      );
+                    return ValueOrErrors.Default.return(
+                      DispatchParsedType.Default.record(
+                        parsedFieldsMap.merge(mergedFields),
+                      ),
+                    ).Then((parsedRecord) =>
+                      ValueOrErrors.Default.return([
+                        parsedRecord,
+                        updatedAccumulatedTypes,
+                      ]),
+                    );
+                  },
+                ),
+          ),
+    ParseRawFilterType: (rawFilterType, arg) => {
+      if (typeof rawFilterType != "string") {
+        return ValueOrErrors.Default.throwOne(`rawType is not a string`);
+      }
+      switch (rawFilterType) {
+        case "contains":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterContains(arg),
+          );
+        case "equalsTo":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterEqualsTo(arg),
+          );
+        case "startswith":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterStartsWith(arg),
+          );
+        case "!=":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterNotEqualsTo(arg),
+          );
+        case "=":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterEqualsTo(arg),
+          );
+        case ">=":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterGreaterThanOrEqualsTo(arg),
+          );
+        case ">":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterGreaterThan(arg),
+          );
+        case "<=":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterSmallerThanOrEqualsTo(arg),
+          );
+        case "<":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterSmallerThan(arg),
+          );
+        case "=null":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterIsNull(),
+          );
+        case "!=null":
+          return ValueOrErrors.Default.return(
+            DispatchParsedType.Default.filterIsNotNull(),
+          );
+        default:
+          return ValueOrErrors.Default.throwOne(
+            `Unknown filter type: ${rawFilterType}`,
+          );
+      }
+    },
+    ParseRawType: (
+      typeName,
+      rawType,
+      serializedTypes,
+      alreadyParsedTypes,
+      injectedPrimitives,
+    ) => {
+      if (
+        alreadyParsedTypes.has(typeName) &&
+        !SerializedType.isLookup(rawType, injectedPrimitives)
+      )
+        return alreadyParsedTypes
+          .get(typeName)
+          .Then((parsedType) =>
+            ValueOrErrors.Default.return([parsedType, alreadyParsedTypes]),
+          );
+      const result = (() => {
+        if (SerializedType.isPrimitive(rawType, injectedPrimitives))
+          return ValueOrErrors.Default.return([
+            DispatchParsedType.Default.primitive(
+              typeof rawType === "string" && STRINGY_TYPES.includes(rawType)
+                ? "string"
+                : rawType,
+            ),
+            alreadyParsedTypes,
+          ]);
+        if (SerializedType.isSingleSelection(rawType))
+          return DispatchParsedType.Operations.ParseRawType(
+            `SingleSelection:Element`,
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
+            ValueOrErrors.Default.return([
+              DispatchParsedType.Default.singleSelection([parsedArg]),
+              newAlreadyParsedTypes,
+            ]),
+          );
+        if (SerializedType.isMultiSelection(rawType))
+          return DispatchParsedType.Operations.ParseRawType(
+            `MultiSelection:Element`,
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
+            ValueOrErrors.Default.return([
+              DispatchParsedType.Default.multiSelection([parsedArg]),
+              newAlreadyParsedTypes,
+            ]),
+          );
+        if (SerializedType.isList(rawType))
+          return DispatchParsedType.Operations.ParseRawType(
+            `List:Element`,
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
+            ValueOrErrors.Default.return([
+              DispatchParsedType.Default.list([parsedArg]),
+              newAlreadyParsedTypes,
+            ]),
+          );
+        if (SerializedType.isTuple(rawType))
+          return rawType.args
+            .reduce(
+              (acc, arg, index) =>
+                acc.Then(([parsedArgsList, accumulatedAlreadyParsedTypes]) =>
+                  DispatchParsedType.Operations.ParseRawType(
+                    `Tuple:Item ${index + 1}`,
+                    arg,
+                    serializedTypes,
+                    accumulatedAlreadyParsedTypes,
+                    injectedPrimitives,
+                  ).Then((parsedArg) =>
+                    ValueOrErrors.Default.return([
+                      parsedArgsList.push(parsedArg[0]),
+                      parsedArg[1],
+                    ]),
+                  ),
+                ),
+              ValueOrErrors.Default.return([List(), alreadyParsedTypes]),
+            )
+            .Then(([parsedArgsList, accumulatedAlreadyParsedTypes]) =>
+              ValueOrErrors.Default.return([
+                DispatchParsedType.Default.tuple(parsedArgsList.toArray()),
+                accumulatedAlreadyParsedTypes,
+              ]),
+            );
+        if (SerializedType.isMap(rawType))
+          return DispatchParsedType.Operations.ParseRawType(
+            "Map:Key",
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg0, newAlreadyParsedTypes]) =>
+            DispatchParsedType.Operations.ParseRawType(
+              "Map:Value",
+              rawType.args[1],
+              serializedTypes,
+              newAlreadyParsedTypes,
+              injectedPrimitives,
+            ).Then(([parsedArg1, newAlreadyParsedTypes2]) =>
+              ValueOrErrors.Default.return([
+                DispatchParsedType.Default.map([parsedArg0, parsedArg1]),
+                newAlreadyParsedTypes2,
+              ]),
+            ),
+          );
+        if (SerializedType.isSum(rawType))
+          return DispatchParsedType.Operations.ParseRawType(
+            "Sum:Left",
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg0, newAlreadyParsedTypes]) =>
+            DispatchParsedType.Operations.ParseRawType(
+              "Sum:Right",
+              rawType.args[1],
+              serializedTypes,
+              newAlreadyParsedTypes,
+              injectedPrimitives,
+            ).Then(([parsedArg1, newAlreadyParsedTypes2]) =>
+              ValueOrErrors.Default.return([
+                DispatchParsedType.Default.sum([parsedArg0, parsedArg1]),
+                newAlreadyParsedTypes2,
+              ]),
+            ),
+          );
+        if (SerializedType.isRecord(rawType))
+          return DispatchParsedType.Operations.ParseRecord(
+            typeName,
+            rawType,
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          );
+        if (SerializedType.isTable(rawType)) {
+          return DispatchParsedType.Operations.ParseRawType(
+            "TableArg",
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
+            parsedArg.kind != "lookup"
+              ? ValueOrErrors.Default.throwOne(
+                  `Error: ${JSON.stringify(parsedArg)} is not a lookup type`,
+                )
+              : ValueOrErrors.Default.return([
+                  DispatchParsedType.Default.table(parsedArg),
+                  newAlreadyParsedTypes,
+                ]),
+          );
+        }
+        if (SerializedType.isLookup(rawType, injectedPrimitives)) {
+          const resolvedType = serializedTypes[rawType];
+          if (alreadyParsedTypes.has(rawType)) {
+            return ValueOrErrors.Default.return([
+              DispatchParsedType.Default.lookup(rawType),
+              alreadyParsedTypes,
+            ]);
+          }
+          return DispatchParsedType.Operations.ParseRawType(
+            typeName,
+            resolvedType,
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedType, newAlreadyParsedTypes]) =>
+            ValueOrErrors.Default.return([
+              DispatchParsedType.Default.lookup(rawType),
+              newAlreadyParsedTypes.set(
+                rawType,
+                ValueOrErrors.Default.return(parsedType),
+              ),
+            ]),
+          );
+        }
+        if (SerializedType.isUnit(rawType)) {
+          return ValueOrErrors.Default.return([
+            DispatchParsedType.Default.primitive("unit"),
+            alreadyParsedTypes,
+          ]);
+        }
+        if (SerializedType.isUnion(rawType))
+          return rawType.args
+            .reduce(
+              (acc, unionCase) =>
+                acc.Then(
+                  ([parsedUnionCasesMap, accumulatedAlreadyParsedTypes]) =>
+                    DispatchParsedType.Operations.ParseRawType(
+                      isString(unionCase.fields)
+                        ? unionCase.fields
+                        : `Union:Case ${unionCase.caseName}`,
+                      unionCase.fields == undefined
                         ? { fields: {} }
                         : // we allow the record fields to be defined directly in the spec instead of
-                            // inside a fields key
-                            SerializedType.isRecordFields(unionCase.fields)
-                                ? { fields: unionCase.fields }
-                                : unionCase.fields, typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedType) => ValueOrErrors.Default.return([
-                        unionCase.caseName,
-                        parsedType[0],
-                    ]))))).Then((parsedUnionCases) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.union(Map(parsedUnionCases)),
-                        alreadyParsedTypes,
-                    ]));
-                if (SerializedType.isOne(rawType))
-                    return DispatchParsedType.Operations.ParseRawType("One:Element", rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then((parsedArg) => parsedArg[0].kind != "lookup"
-                        ? ValueOrErrors.Default.throwOne(`one content type ${JSON.stringify(parsedArg[0])} is not a lookup type`)
-                        : ValueOrErrors.Default.return([
-                            DispatchParsedType.Default.one(parsedArg[0]),
-                            alreadyParsedTypes,
-                        ]));
-                if (SerializedType.isReadOnly(rawType))
-                    return DispatchParsedType.Operations.ParseRawType("ReadOnly:Element", rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then(([parsedArg, _]) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.readOnly(parsedArg),
-                        alreadyParsedTypes,
-                    ]));
-                if (SerializedType.isKeyOf(rawType))
-                    return DispatchParsedType.Operations.ParseRawKeyOf(rawType, typeNames, serializedTypes, alreadyParsedTypes);
-                if (SerializedType.isTranslationOverride(rawType))
-                    return DispatchParsedType.Operations.ParseRawType("TranslationOverride:Language", rawType.args[0], typeNames, serializedTypes, alreadyParsedTypes, injectedPrimitives).Then(([parsedArg0, ..._]) => ValueOrErrors.Default.return([
-                        DispatchParsedType.Default.map([
-                            DispatchParsedType.Default.singleSelection([parsedArg0]),
-                            DispatchParsedType.Default.primitive("string"),
-                        ]),
-                        alreadyParsedTypes,
-                    ]));
-                return ValueOrErrors.Default.throwOne(`Unrecognised type "${typeName}" : ${JSON.stringify(rawType)}`);
-            })();
-            return result.MapErrors((errors) => errors.map((error) => `${error}\n...When parsing type "${typeName}"`));
-        },
-        ResolveLookupType: (typeName, types) => MapRepo.Operations.tryFindWithError(typeName, types, () => `cannot find lookup type ${typeName} in types`),
-        AsResolvedType: (type, types) => type.kind == "lookup"
-            ? DispatchParsedType.Operations.ResolveLookupType(type.name, types)
-            : ValueOrErrors.Default.return(type),
+                          // inside a fields key
+                          SerializedType.isRecordFields(unionCase.fields)
+                          ? { fields: unionCase.fields }
+                          : unionCase.fields,
+                      serializedTypes,
+                      accumulatedAlreadyParsedTypes,
+                      injectedPrimitives,
+                    ).Then(([parsedType, newAlreadyParsedTypes]) =>
+                      ValueOrErrors.Default.return([
+                        parsedUnionCasesMap.set(unionCase.caseName, parsedType),
+                        newAlreadyParsedTypes,
+                      ]),
+                    ),
+                ),
+              ValueOrErrors.Default.return([Map(), alreadyParsedTypes]),
+            )
+            .Then(([parsedUnionCasesMap, accumulatedAlreadyParsedTypes]) =>
+              ValueOrErrors.Default.return([
+                DispatchParsedType.Default.union(parsedUnionCasesMap),
+                accumulatedAlreadyParsedTypes,
+              ]),
+            );
+        if (SerializedType.isOne(rawType)) {
+          return DispatchParsedType.Operations.ParseRawType(
+            rawType.args[0],
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
+            parsedArg.kind != "lookup"
+              ? ValueOrErrors.Default.throwOne(
+                  `one content type ${JSON.stringify(parsedArg)} is not a lookup type`,
+                )
+              : ValueOrErrors.Default.return([
+                  DispatchParsedType.Default.one(parsedArg),
+                  newAlreadyParsedTypes,
+                ]),
+          );
+        }
+        if (SerializedType.isReadOnly(rawType))
+          return DispatchParsedType.Operations.ParseRawType(
+            "ReadOnly:Element",
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
+            ValueOrErrors.Default.return([
+              DispatchParsedType.Default.readOnly(parsedArg),
+              newAlreadyParsedTypes,
+            ]),
+          );
+        if (SerializedType.isKeyOf(rawType))
+          return DispatchParsedType.Operations.ParseRawKeyOf(
+            rawType,
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          );
+        if (SerializedType.isTranslationOverride(rawType))
+          return DispatchParsedType.Operations.ParseRawType(
+            "TranslationOverride:Language",
+            rawType.args[0],
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg0, newAlreadyParsedTypes]) =>
+            ValueOrErrors.Default.return([
+              DispatchParsedType.Default.map([
+                DispatchParsedType.Default.singleSelection([parsedArg0]),
+                DispatchParsedType.Default.primitive("string"),
+              ]),
+              newAlreadyParsedTypes,
+            ]),
+          );
+        return ValueOrErrors.Default.throwOne(
+          `Unrecognised type "${typeName}" : ${JSON.stringify(rawType)}`,
+        );
+      })();
+      return result.MapErrors((errors) =>
+        errors.map((error) => `${error}\n...When parsing type "${typeName}"`),
+      );
     },
+    ResolveLookupType: (typeName, types) =>
+      MapRepo.Operations.tryFindWithError(
+        typeName,
+        types,
+        () => `cannot find lookup type ${typeName} in types`,
+      ),
+    AsResolvedType: (type, types) =>
+      type.kind == "lookup"
+        ? DispatchParsedType.Operations.ResolveLookupType(type.name, types)
+        : ValueOrErrors.Default.return(type),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map