ballerina-core 1.0.258 → 1.0.260

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

@@ -1,1165 +1,719 @@
 import { List, Map } from "immutable";
 import { ValueOrErrors } from "../../../../../../../../collections/domains/valueOrErrors/state";
-import {
-  DispatchGenericTypes,
-  MapRepo,
-  isString,
-} 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",
+    "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: (_, 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]),
+    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,
-    }),
-    record: (fields) => ({
-      kind: "record",
-      fields,
-    }),
-    primitive: (name) => ({
-      kind: "primitive",
-      name,
-    }),
-    singleSelection: (args) => ({
-      kind: "singleSelection",
-      args,
-    }),
-    multiSelection: (args) => ({
-      kind: "multiSelection",
-      args,
-    }),
-    list: (args) => ({
-      kind: "list",
-      args,
-    }),
-    tuple: (args) => ({
-      kind: "tuple",
-      args,
-    }),
-    sum: (args) => ({
-      kind: "sum",
-      args,
-    }),
-    sumN: (args) => ({
-      kind: "sumN",
-      args,
-    }),
-    map: (args) => ({
-      kind: "map",
-      args,
-    }),
-    union: (args) => ({
-      kind: "union",
-      args,
-    }),
-    readOnly: (arg) => ({
-      kind: "readOnly",
-      arg,
-    }),
-    lookup: (name) => ({
-      kind: "lookup",
-      name,
-    }),
-    one: (arg) => ({
-      kind: "one",
-      arg,
-    }),
-    filterContains: (contains) => ({
-      kind: "contains",
-      contains,
-    }),
-    filterEqualsTo: (equalsTo) => ({
-      kind: "=",
-      equalsTo,
-    }),
-    filterNotEqualsTo: (notEqualsTo) => ({
-      kind: "!=",
-      notEqualsTo,
-    }),
-    filterGreaterThanOrEqualsTo: (greaterThanOrEqualsTo) => ({
-      kind: ">=",
-      greaterThanOrEqualsTo,
-    }),
-    filterGreaterThan: (greaterThan) => ({
-      kind: ">",
-      greaterThan,
-    }),
-    filterIsNotNull: () => ({
-      kind: "!=null",
-    }),
-    filterIsNull: () => ({
-      kind: "=null",
-    }),
-    filterSmallerThanOrEqualsTo: (smallerThanOrEqualsTo) => ({
-      kind: "<=",
-      smallerThanOrEqualsTo,
-    }),
-    filterSmallerThan: (smallerThan) => ({
-      kind: "<",
-      smallerThan,
-    }),
-    filterStartsWith: (startsWith) => ({
-      kind: "startsWith",
-      startsWith,
-    }),
-  },
-  Operations: {
-    AsString: (type) => {
-      switch (type.kind) {
-        case "record":
-          return RecordType.SerializeToString(
-            type.fields.map((v) => DispatchParsedType.Operations.AsString(v)),
-          );
-        case "table":
-          return TableType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.arg),
-          );
-        case "one":
-          return OneType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.arg),
-          );
-        case "singleSelection":
-          return SingleSelectionType.SerializeToString(
-            type.args.map((v) => DispatchParsedType.Operations.AsString(v)),
-          );
-        case "multiSelection":
-          return MultiSelectionType.SerializeToString(
-            type.args.map((v) => DispatchParsedType.Operations.AsString(v)),
-          );
-        case "list":
-          return ListType.SerializeToString(
-            type.args.map((v) => DispatchParsedType.Operations.AsString(v)),
-          );
-        case "tuple":
-          return TupleType.SerializeToString(
-            type.args.map((v) => DispatchParsedType.Operations.AsString(v)),
-          );
-        case "sum":
-          return SumType.SerializeToString(
-            type.args.map((v) => DispatchParsedType.Operations.AsString(v)),
-          );
-        case "sumN":
-          return SumNType.SerializeToString(
-            type.args.map((v) => DispatchParsedType.Operations.AsString(v)),
-            type.args.length,
-          );
-        case "map":
-          return MapType.SerializeToString(
-            type.args.map((v) => DispatchParsedType.Operations.AsString(v)),
-          );
-        case "union":
-          return UnionType.SerializeToString(
-            type.args.map((v) => DispatchParsedType.Operations.AsString(v)),
-          );
-        case "lookup":
-          return LookupType.SerializeToString(type.name);
-        case "contains":
-          return FilterContainsType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.contains),
-          );
-        case "=":
-          return FilterEqualsToType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.equalsTo),
-          );
-        case "!=":
-          return FilterNotEqualsToType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.notEqualsTo),
-          );
-        case ">=":
-          return FilterGreaterThanOrEqualsToType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.greaterThanOrEqualsTo),
-          );
-        case ">":
-          return FilterGreaterThanType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.greaterThan),
-          );
-        case "!=null":
-          return FilterIsNotNullType.SerializeToString();
-        case "=null":
-          return FilterIsNullType.SerializeToString();
-        case "<=":
-          return FilterSmallerThanOrEqualsToType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.smallerThanOrEqualsTo),
-          );
-        case "<":
-          return FilterSmallerThanType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.smallerThan),
-          );
-        case "startsWith":
-          return FilterStartsWithType.SerializeToString(
-            DispatchParsedType.Operations.AsString(type.startsWith),
-          );
-        default:
-          throw new Error(`Unknown type: ${JSON.stringify(type)}`);
-      }
+    Default: {
+        table: (arg) => ({
+            kind: "table",
+            arg,
+        }),
+        record: (fields) => ({
+            kind: "record",
+            fields,
+        }),
+        primitive: (name) => ({
+            kind: "primitive",
+            name,
+        }),
+        singleSelection: (args) => ({
+            kind: "singleSelection",
+            args,
+        }),
+        multiSelection: (args) => ({
+            kind: "multiSelection",
+            args,
+        }),
+        list: (args) => ({
+            kind: "list",
+            args,
+        }),
+        tuple: (args) => ({
+            kind: "tuple",
+            args,
+        }),
+        sum: (args) => ({
+            kind: "sum",
+            args,
+        }),
+        sumN: (args) => ({
+            kind: "sumN",
+            args,
+        }),
+        map: (args) => ({
+            kind: "map",
+            args,
+        }),
+        union: (args) => ({
+            kind: "union",
+            args,
+        }),
+        readOnly: (arg) => ({
+            kind: "readOnly",
+            arg,
+        }),
+        lookup: (name) => ({
+            kind: "lookup",
+            name,
+        }),
+        one: (arg) => ({
+            kind: "one",
+            arg,
+        }),
+        filterContains: (contains) => ({
+            kind: "contains",
+            contains,
+        }),
+        filterEqualsTo: (equalsTo) => ({
+            kind: "=",
+            equalsTo,
+        }),
+        filterNotEqualsTo: (notEqualsTo) => ({
+            kind: "!=",
+            notEqualsTo,
+        }),
+        filterGreaterThanOrEqualsTo: (greaterThanOrEqualsTo) => ({
+            kind: ">=",
+            greaterThanOrEqualsTo,
+        }),
+        filterGreaterThan: (greaterThan) => ({
+            kind: ">",
+            greaterThan,
+        }),
+        filterIsNotNull: () => ({
+            kind: "!=null",
+        }),
+        filterIsNull: () => ({
+            kind: "=null",
+        }),
+        filterSmallerThanOrEqualsTo: (smallerThanOrEqualsTo) => ({
+            kind: "<=",
+            smallerThanOrEqualsTo,
+        }),
+        filterSmallerThan: (smallerThan) => ({
+            kind: "<",
+            smallerThan,
+        }),
+        filterStartsWith: (startsWith) => ({
+            kind: "startsWith",
+            startsWith,
+        }),
     },
-    // 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`,
-              )
+    Operations: {
+        AsString: (type) => {
+            switch (type.kind) {
+                case "record":
+                    return RecordType.SerializeToString(type.fields.map((v) => DispatchParsedType.Operations.AsString(v)));
+                case "table":
+                    return TableType.SerializeToString(DispatchParsedType.Operations.AsString(type.arg));
+                case "one":
+                    return OneType.SerializeToString(DispatchParsedType.Operations.AsString(type.arg));
+                case "singleSelection":
+                    return SingleSelectionType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.AsString(v)));
+                case "multiSelection":
+                    return MultiSelectionType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.AsString(v)));
+                case "list":
+                    return ListType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.AsString(v)));
+                case "tuple":
+                    return TupleType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.AsString(v)));
+                case "sum":
+                    return SumType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.AsString(v)));
+                case "sumN":
+                    return SumNType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.AsString(v)), type.args.length);
+                case "map":
+                    return MapType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.AsString(v)));
+                case "union":
+                    return UnionType.SerializeToString(type.args.map((v) => DispatchParsedType.Operations.AsString(v)));
+                case "lookup":
+                    return LookupType.SerializeToString(type.name);
+                case "contains":
+                    return FilterContainsType.SerializeToString(DispatchParsedType.Operations.AsString(type.contains));
+                case "=":
+                    return FilterEqualsToType.SerializeToString(DispatchParsedType.Operations.AsString(type.equalsTo));
+                case "!=":
+                    return FilterNotEqualsToType.SerializeToString(DispatchParsedType.Operations.AsString(type.notEqualsTo));
+                case ">=":
+                    return FilterGreaterThanOrEqualsToType.SerializeToString(DispatchParsedType.Operations.AsString(type.greaterThanOrEqualsTo));
+                case ">":
+                    return FilterGreaterThanType.SerializeToString(DispatchParsedType.Operations.AsString(type.greaterThan));
+                case "!=null":
+                    return FilterIsNotNullType.SerializeToString();
+                case "=null":
+                    return FilterIsNullType.SerializeToString();
+                case "<=":
+                    return FilterSmallerThanOrEqualsToType.SerializeToString(DispatchParsedType.Operations.AsString(type.smallerThanOrEqualsTo));
+                case "<":
+                    return FilterSmallerThanType.SerializeToString(DispatchParsedType.Operations.AsString(type.smallerThan));
+                case "startsWith":
+                    return FilterStartsWithType.SerializeToString(DispatchParsedType.Operations.AsString(type.startsWith));
+                default:
+                    throw new Error(`Unknown type: ${JSON.stringify(type)}`);
+            }
+        },
+        // 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(
-                    (() => {
-                      const excludedKeys = rawType.args[1]
+                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
+                    return parsingResult[0].fields
                         .keySeq()
-                        .filter(
-                          (key) =>
-                            excludedKeys == null || !(key in excludedKeys),
-                        )
+                        .filter((key) => excludedKeys == null || !(key in excludedKeys))
                         .toArray()
                         .map((key) => [
-                          key,
-                          DispatchParsedType.Default.record(Map()),
-                        ]);
-                    })(),
-                  ),
-                ),
+                        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("");
-        case "!=null":
-          return FilterIsNotNullType.SerializeToString();
-        case "=null":
-          return FilterIsNullType.SerializeToString();
-        case "<=":
-          return FilterSmallerThanOrEqualsToType.SerializeToString("");
-        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: (
-      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],
-                              serializedTypes,
-                              accumulatedAlreadyParsedTypes,
-                              injectedPrimitives,
-                            ).Then((parsedType) =>
-                              parsedType[0].kind == "record"
-                                ? ValueOrErrors.Default.return([
-                                    resultMap.set(
-                                      extendedTypeName,
-                                      parsedType[0],
-                                    ),
-                                    parsedType[1].set(
-                                      extendedTypeName,
-                                      ValueOrErrors.Default.return(
-                                        parsedType[0],
-                                      ),
-                                    ),
-                                  ])
-                                : 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([
+            ]))
+            .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("");
+                case "!=null":
+                    return FilterIsNotNullType.SerializeToString();
+                case "=null":
+                    return FilterIsNullType.SerializeToString();
+                case "<=":
+                    return FilterSmallerThanOrEqualsToType.SerializeToString("");
+                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: (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], serializedTypes, accumulatedAlreadyParsedTypes, injectedPrimitives).Then((parsedType) => parsedType[0].kind == "record"
+                            ? ValueOrErrors.Default.return([
+                                resultMap.set(extendedTypeName, parsedType[0]),
+                                parsedType[1].set(extendedTypeName, ValueOrErrors.Default.return(parsedType[0])),
+                            ])
+                            : 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,
-                  ]),
-                )
-                .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()),
+                ]))
+                : 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,
-              ]),
-            );
-        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(
-            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 (!resolvedType) {
-            return ValueOrErrors.Default.throwOne(
-              `Error: ${JSON.stringify(rawType)} is not a valid lookup type (not found in serializedTypes)`,
-            );
-          }
-          if (!isString(rawType)) {
-            return ValueOrErrors.Default.throwOne(
-              `Error: ${JSON.stringify(rawType)} is not a valid lookup type (not a string)`,
-            );
-          }
-          if (alreadyParsedTypes.has(rawType)) {
-            return ValueOrErrors.Default.return([
-              DispatchParsedType.Default.lookup(rawType),
-              alreadyParsedTypes,
-            ]);
-          }
-          return DispatchParsedType.Operations.ParseRawType(
-            rawType,
-            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)
+            ]))
+                .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(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 (!resolvedType) {
+                        return ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(rawType)} is not a valid lookup type (not found in serializedTypes)`);
+                    }
+                    if (!isString(rawType)) {
+                        return ValueOrErrors.Default.throwOne(`Error: ${JSON.stringify(rawType)} is not a valid lookup type (not a string)`);
+                    }
+                    if (alreadyParsedTypes.has(rawType)) {
+                        return ValueOrErrors.Default.return([
+                            DispatchParsedType.Default.lookup(rawType),
+                            alreadyParsedTypes,
+                        ]);
+                    }
+                    return DispatchParsedType.Operations.ParseRawType(rawType, 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
+                        : `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,
-                      serializedTypes,
-                      accumulatedAlreadyParsedTypes,
-                      injectedPrimitives,
-                    ).Then(([parsedType, newAlreadyParsedTypes]) =>
-                      ValueOrErrors.Default.return([
+                            // 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}"`),
-      );
+                    ]))), 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),
     },
-    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