ballerina-core 1.0.205 → 1.0.206

package/bin/src/forms/domains/dispatched-forms/built-ins/state.js

@@ -0,0 +1,2013 @@
+import { Map, List, OrderedMap } from "immutable";
+import {
+  CollectionReference,
+  EnumReference,
+} from "../../collection/domains/reference/state";
+import { ValueOrErrors } from "../../../../collections/domains/valueOrErrors/state";
+import {
+  PredicateValue,
+  replaceWith,
+  Sum,
+  unit,
+  RecordAbstractRendererState,
+  TableAbstractRendererState,
+  MapRepo,
+  ValueTable,
+  DispatchCommonFormState,
+  UnionAbstractRendererState,
+  OneAbstractRendererState,
+} from "../../../../../main";
+import { DispatchParsedType } from "../deserializer/domains/specification/domains/types/state";
+import { UnitAbstractRendererState } from "../runner/domains/abstract-renderers/unit/state";
+import { StringAbstractRendererState } from "../runner/domains/abstract-renderers/string/state";
+import { NumberAbstractRendererState } from "../runner/domains/abstract-renderers/number/state";
+import { BoolAbstractRendererState } from "../runner/domains/abstract-renderers/boolean/state";
+import { DateAbstractRendererState } from "../runner/domains/abstract-renderers/date/state";
+import { Base64FileAbstractRendererState } from "../runner/domains/abstract-renderers/base-64-file/state";
+import { SecretAbstractRendererState } from "../runner/domains/abstract-renderers/secret/state";
+import { ReadOnlyAbstractRendererState } from "../runner/domains/abstract-renderers/readOnly/state";
+import { MapAbstractRendererState } from "../runner/domains/abstract-renderers/map/state";
+import { TupleAbstractRendererState } from "../runner/domains/abstract-renderers/tuple/state";
+import { SumAbstractRendererState } from "../runner/domains/abstract-renderers/sum/state";
+import { EnumAbstractRendererState } from "../runner/domains/abstract-renderers/enum/state";
+import { ListAbstractRendererState } from "../runner/domains/abstract-renderers/list/state";
+import { SearchableInfiniteStreamAbstractRendererState } from "../runner/domains/abstract-renderers/searchable-infinite-stream/state";
+import { LookupRenderer } from "../deserializer/domains/specification/domains/forms/domains/renderer/domains/lookup/state";
+const sortObjectKeys = (obj) =>
+  Object.keys(obj)
+    .sort()
+    .reduce((sortedObj, key) => {
+      sortedObj[key] = obj[key];
+      return sortedObj;
+    }, {});
+const simpleMapKeyToIdentifer = (key) => {
+  if (typeof key == "object") return JSON.stringify(sortObjectKeys(key));
+  return JSON.stringify(key);
+};
+export const DispatchGenericTypes = [
+  "SingleSelection",
+  "MultiSelection",
+  "List",
+  "Map",
+  "Union",
+  "Tuple",
+  "Option",
+  "Sum",
+  "KeyOf",
+  "Table",
+  "One",
+  "ReadOnly",
+];
+export const concreteRendererToKind = (concreteRenderers) => (name) => {
+  const viewTypes = Object.keys(concreteRenderers);
+  for (const viewType of viewTypes) {
+    if (name in concreteRenderers[viewType]) {
+      return ValueOrErrors.Default.return(viewType);
+    }
+  }
+  return ValueOrErrors.Default.throwOne(
+    `cannot find view ${name} in concrete renderers`,
+  );
+};
+export const tryGetConcreteRenderer = (concreteRenderers) => (kind, name) => {
+  if (!concreteRenderers[kind]) {
+    return ValueOrErrors.Default.throwOne(
+      `cannot find concrete renderer kind "${kind}" in  concrete renderers`,
+    );
+  }
+  if (concreteRenderers[kind][name]) {
+    return ValueOrErrors.Default.return(concreteRenderers[kind][name]());
+  }
+  return ValueOrErrors.Default.throwOne(
+    `cannot find concrete renderer "${name}" in kind "${kind}"`,
+  );
+};
+export const getDefaultRecordRenderer = (
+  isNested,
+  defaultRecordRenderer,
+  defaultNestedRecordRenderer,
+) => (isNested ? defaultNestedRecordRenderer() : defaultRecordRenderer());
+export const dispatchDefaultState =
+  (
+    infiniteStreamSources,
+    injectedPrimitives,
+    types,
+    forms,
+    converters,
+    lookupSources,
+    tableApiSources,
+    specApis,
+  ) =>
+  (t, renderer) => {
+    const result = (() => {
+      var _a, _b, _c, _d;
+      if (renderer == undefined) {
+        return ValueOrErrors.Default.return(undefined);
+      }
+      if (renderer.kind == "lookupType-lookupRenderer") {
+        return DispatchParsedType.Operations.ResolveLookupType(
+          renderer.type.name,
+          types,
+        ).Then((resolvedType) =>
+          LookupRenderer.Operations.ResolveRenderer(renderer, forms).Then(
+            (resolvedRenderer) =>
+              dispatchDefaultState(
+                infiniteStreamSources,
+                injectedPrimitives,
+                types,
+                forms,
+                converters,
+                lookupSources,
+                tableApiSources,
+                specApis,
+              )(resolvedType, resolvedRenderer),
+          ),
+        );
+      }
+      if (renderer.kind == "lookupType-inlinedRenderer") {
+        return DispatchParsedType.Operations.ResolveLookupType(
+          renderer.type.name,
+          types,
+        ).Then((resolvedType) =>
+          dispatchDefaultState(
+            infiniteStreamSources,
+            injectedPrimitives,
+            types,
+            forms,
+            converters,
+            lookupSources,
+            tableApiSources,
+            specApis,
+          )(resolvedType, renderer.inlinedRenderer),
+        );
+      }
+      if (renderer.kind == "inlinedType-lookupRenderer") {
+        return LookupRenderer.Operations.ResolveRenderer(renderer, forms).Then(
+          (resolvedRenderer) =>
+            dispatchDefaultState(
+              infiniteStreamSources,
+              injectedPrimitives,
+              types,
+              forms,
+              converters,
+              lookupSources,
+              tableApiSources,
+              specApis,
+            )(renderer.type, resolvedRenderer),
+        );
+      }
+      if (t.kind == "primitive")
+        return t.name == "unit"
+          ? ValueOrErrors.Default.return(UnitAbstractRendererState.Default())
+          : t.name == "boolean"
+            ? ValueOrErrors.Default.return(BoolAbstractRendererState.Default())
+            : t.name == "number"
+              ? ValueOrErrors.Default.return(
+                  NumberAbstractRendererState.Default(),
+                )
+              : t.name == "string" ||
+                  t.name == "entityIdString" ||
+                  t.name == "calculatedDisplayValue"
+                ? ValueOrErrors.Default.return(
+                    StringAbstractRendererState.Default(),
+                  )
+                : t.name == "base64File"
+                  ? ValueOrErrors.Default.return(
+                      Base64FileAbstractRendererState.Default(),
+                    )
+                  : t.name == "secret"
+                    ? ValueOrErrors.Default.return(
+                        SecretAbstractRendererState.Default(),
+                      )
+                    : t.name == "Date"
+                      ? ValueOrErrors.Default.return(
+                          DateAbstractRendererState.Default(),
+                        )
+                      : (injectedPrimitives === null ||
+                          injectedPrimitives === void 0
+                            ? void 0
+                            : injectedPrimitives.get(t.name)) != undefined
+                        ? ValueOrErrors.Default.return(
+                            Object.assign(
+                              {
+                                commonFormState:
+                                  DispatchCommonFormState.Default(),
+                              },
+                              injectedPrimitives === null ||
+                                injectedPrimitives === void 0
+                                ? void 0
+                                : injectedPrimitives.get(t.name).defaultState,
+                            ),
+                          )
+                        : ValueOrErrors.Default.throwOne(
+                            `could not resolve defaultState for primitive renderer kind "${t.name}"`,
+                          );
+      if (t.kind == "singleSelection")
+        return renderer.kind == "enumRenderer"
+          ? ValueOrErrors.Default.return(EnumAbstractRendererState().Default())
+          : renderer.kind == "streamRenderer"
+            ? infiniteStreamSources(renderer.stream).Then((streamSource) =>
+                ValueOrErrors.Default.return(
+                  SearchableInfiniteStreamAbstractRendererState.Default(
+                    streamSource,
+                  ),
+                ),
+              )
+            : ValueOrErrors.Default.throwOne(
+                `received non singleSelection renderer kind "${renderer.kind}" when resolving defaultState for singleSelection`,
+              );
+      if (t.kind == "multiSelection")
+        return renderer.kind == "enumRenderer"
+          ? ValueOrErrors.Default.return(EnumAbstractRendererState().Default())
+          : renderer.kind == "streamRenderer"
+            ? infiniteStreamSources(renderer.stream).Then((streamSource) =>
+                ValueOrErrors.Default.return(
+                  SearchableInfiniteStreamAbstractRendererState.Default(
+                    streamSource,
+                  ),
+                ),
+              )
+            : ValueOrErrors.Default.throwOne(
+                `received non multiSelection renderer kind "${renderer.kind}" when resolving defaultState for multiSelection`,
+              );
+      if (t.kind == "list")
+        return renderer.kind == "listRenderer"
+          ? ValueOrErrors.Default.return(
+              ListAbstractRendererState.Default.zero(),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non list renderer kind "${renderer.kind}" when resolving defaultState for list`,
+            );
+      if (t.kind == "map")
+        return renderer.kind == "mapRenderer"
+          ? ValueOrErrors.Default.return(
+              MapAbstractRendererState.Default.zero(),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non map renderer kind "${renderer.kind}" when resolving defaultState for map`,
+            );
+      if (t.kind == "tuple")
+        return renderer.kind == "tupleRenderer"
+          ? ValueOrErrors.Operations.All(
+              List(
+                t.args.map((_, index) =>
+                  dispatchDefaultState(
+                    infiniteStreamSources,
+                    injectedPrimitives,
+                    types,
+                    forms,
+                    converters,
+                    lookupSources,
+                    tableApiSources,
+                    specApis,
+                  )(_, renderer.itemRenderers[index].renderer).Then(
+                    (itemState) =>
+                      ValueOrErrors.Default.return([index, itemState]),
+                  ),
+                ),
+              ),
+            ).Then((itemStates) =>
+              ValueOrErrors.Default.return(
+                TupleAbstractRendererState.Default(Map(itemStates)),
+              ),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non tuple renderer kind "${renderer.kind}" when resolving defaultState for tuple`,
+            );
+      if (t.kind == "sum")
+        return renderer.kind == "sumRenderer"
+          ? dispatchDefaultState(
+              infiniteStreamSources,
+              injectedPrimitives,
+              types,
+              forms,
+              converters,
+              lookupSources,
+              tableApiSources,
+              specApis,
+            )(t.args[0], renderer.leftRenderer.renderer).Then((left) =>
+              renderer.rightRenderer == undefined
+                ? ValueOrErrors.Default.throwOne(
+                    `rightRenderer is undefined when resolving defaultState sum view ${renderer.concreteRenderer}`,
+                  )
+                : dispatchDefaultState(
+                    infiniteStreamSources,
+                    injectedPrimitives,
+                    types,
+                    forms,
+                    converters,
+                    lookupSources,
+                    tableApiSources,
+                    specApis,
+                  )(t.args[1], renderer.rightRenderer.renderer).Then((right) =>
+                    ValueOrErrors.Default.return(
+                      SumAbstractRendererState.Default({
+                        left,
+                        right,
+                      }),
+                    ),
+                  ),
+            )
+          : renderer.kind == "sumUnitDateRenderer"
+            ? ValueOrErrors.Default.return(
+                SumAbstractRendererState.Default({
+                  left: UnitAbstractRendererState.Default(),
+                  right: DateAbstractRendererState.Default(),
+                }),
+              )
+            : ValueOrErrors.Default.throwOne(
+                `renderer kind "${renderer.kind}" not supported for sum`,
+              );
+      if (t.kind == "one")
+        return renderer.kind != "oneRenderer"
+          ? ValueOrErrors.Default.throwOne(
+              `received non one renderer kind "${renderer.kind}" when resolving defaultState for one`,
+            )
+          : specApis.lookups != undefined &&
+              specApis.lookups.get(renderer.api[0]) != undefined &&
+              ((_a = specApis.lookups.get(renderer.api[0])) === null ||
+              _a === void 0
+                ? void 0
+                : _a.one) != undefined &&
+              ((_b = specApis.lookups.get(renderer.api[0])) === null ||
+              _b === void 0
+                ? void 0
+                : _b.one.get(renderer.api[1])) != undefined &&
+              ((_d =
+                (_c = specApis.lookups.get(renderer.api[0])) === null ||
+                _c === void 0
+                  ? void 0
+                  : _c.one.get(renderer.api[1])) === null || _d === void 0
+                ? void 0
+                : _d.methods.getManyUnlinked)
+            ? lookupSources == undefined
+              ? ValueOrErrors.Default.throwOne(
+                  `lookup sources referenced but no lookup sources are provided`,
+                )
+              : lookupSources(renderer.api[0]) == undefined
+                ? ValueOrErrors.Default.throwOne(
+                    `cannot find lookup source for ${renderer.api[0]}`,
+                  )
+                : lookupSources(renderer.api[0]).Then((lookupSource) =>
+                    lookupSource.one == undefined
+                      ? ValueOrErrors.Default.throwOne(
+                          `one source not provided for ${renderer.api[0]}`,
+                        )
+                      : lookupSource
+                          .one(renderer.api[1]) // safe because we check for undefined above but type system doesn't know that
+                          .Then((oneSource) =>
+                            oneSource.getManyUnlinked == undefined
+                              ? ValueOrErrors.Default.throwOne(
+                                  `getManyUnlinked not provided for ${renderer.api[0]}-${renderer.api[1]}`,
+                                )
+                              : MapRepo.Operations.tryFindWithError(
+                                  t.arg.name,
+                                  types,
+                                  () =>
+                                    `cannot find lookup type ${JSON.stringify(t.arg.name)} in ${JSON.stringify(t)}`,
+                                ).Then((lookupType) =>
+                                  ValueOrErrors.Default.return(
+                                    OneAbstractRendererState.Default(
+                                      oneSource.getManyUnlinked(
+                                        // safe because we check for undefined above but type system doesn't know that
+                                        dispatchFromAPIRawValue(
+                                          lookupType,
+                                          types,
+                                          converters,
+                                          injectedPrimitives,
+                                        ),
+                                      ),
+                                    ),
+                                  ),
+                                ),
+                          ),
+                  )
+            : ValueOrErrors.Default.return(
+                OneAbstractRendererState.Default(undefined),
+              );
+      if (t.kind == "readOnly")
+        return renderer.kind != "readOnlyRenderer"
+          ? ValueOrErrors.Default.throwOne(
+              `received non readOnly renderer kind "${renderer.kind}" when resolving defaultState for readOnly`,
+            )
+          : dispatchDefaultState(
+              infiniteStreamSources,
+              injectedPrimitives,
+              types,
+              forms,
+              converters,
+              lookupSources,
+              tableApiSources,
+              specApis,
+            )(t.arg, renderer.childRenderer.renderer).Then((childState) =>
+              ValueOrErrors.Default.return(
+                ReadOnlyAbstractRendererState.Default.childFormState(
+                  childState,
+                ),
+              ),
+            );
+      if (t.kind == "record")
+        return renderer.kind == "recordRenderer"
+          ? ValueOrErrors.Operations.All(
+              List(
+                renderer.fields
+                  .entrySeq()
+                  .map(([fieldName, fieldRenderer]) =>
+                    MapRepo.Operations.tryFindWithError(
+                      fieldName,
+                      t.fields,
+                      () =>
+                        `field ${fieldName} not found in renderer ${JSON.stringify(renderer.fields)} fields`,
+                    ).Then((fieldType) =>
+                      dispatchDefaultState(
+                        infiniteStreamSources,
+                        injectedPrimitives,
+                        types,
+                        forms,
+                        converters,
+                        lookupSources,
+                        tableApiSources,
+                        specApis,
+                      )(fieldType, fieldRenderer.renderer).Then((value) =>
+                        ValueOrErrors.Default.return([fieldName, value]),
+                      ),
+                    ),
+                  ),
+              ),
+            ).Then((res) =>
+              ValueOrErrors.Default.return(
+                RecordAbstractRendererState.Default.fieldState(Map(res)),
+              ),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non record renderer kind "${renderer.kind}" when resolving defaultValue for record`,
+            );
+      if (t.kind == "union") {
+        return renderer.kind == "unionRenderer"
+          ? ValueOrErrors.Operations.All(
+              List(
+                renderer.cases
+                  .entrySeq()
+                  .map(([caseName, caseRenderer]) =>
+                    MapRepo.Operations.tryFindWithError(
+                      caseName,
+                      t.args,
+                      () =>
+                        `case ${caseName} not found in type ${JSON.stringify(t)}`,
+                    ).Then((caseType) =>
+                      dispatchDefaultState(
+                        infiniteStreamSources,
+                        injectedPrimitives,
+                        types,
+                        forms,
+                        converters,
+                        lookupSources,
+                        tableApiSources,
+                        specApis,
+                      )(caseType, caseRenderer).Then((caseState) =>
+                        ValueOrErrors.Default.return([caseName, caseState]),
+                      ),
+                    ),
+                  ),
+              ),
+            ).Then((caseStates) =>
+              ValueOrErrors.Default.return(
+                UnionAbstractRendererState.Default(Map(caseStates)),
+              ),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non union renderer kind "${renderer.kind}" when resolving defaultState for union`,
+            );
+      }
+      if (t.kind == "table") {
+        return renderer.kind == "tableRenderer"
+          ? ValueOrErrors.Default.return(TableAbstractRendererState.Default())
+          : ValueOrErrors.Default.throwOne(
+              `received non table renderer kind "${renderer.kind}" when resolving defaultState for table`,
+            );
+      }
+      return ValueOrErrors.Default.throwOne(
+        `type of kind "${JSON.stringify(t)}" not supported by defaultState`,
+      );
+    })();
+    return result.MapErrors((errors) =>
+      errors.map(
+        (error) =>
+          `${error}\n...When resolving defaultState for ${t.kind} and renderer kind ${renderer.kind}`,
+      ),
+    );
+  };
+export const dispatchDefaultValue =
+  (injectedPrimitives, types, forms) => (t, renderer) => {
+    const result = (() => {
+      if (renderer == undefined) {
+        return ValueOrErrors.Default.return(PredicateValue.Default.unit());
+      }
+      if (renderer.kind == "lookupType-lookupRenderer")
+        return DispatchParsedType.Operations.ResolveLookupType(
+          renderer.type.name,
+          types,
+        ).Then((resolvedType) =>
+          LookupRenderer.Operations.ResolveRenderer(renderer, forms).Then(
+            (resolvedRenderer) =>
+              dispatchDefaultValue(
+                injectedPrimitives,
+                types,
+                forms,
+              )(resolvedType, resolvedRenderer),
+          ),
+        );
+      if (renderer.kind == "lookupType-inlinedRenderer")
+        return DispatchParsedType.Operations.ResolveLookupType(
+          renderer.type.name,
+          types,
+        ).Then((resolvedType) =>
+          dispatchDefaultValue(
+            injectedPrimitives,
+            types,
+            forms,
+          )(resolvedType, renderer.inlinedRenderer),
+        );
+      if (renderer.kind == "inlinedType-lookupRenderer")
+        return LookupRenderer.Operations.ResolveRenderer(renderer, forms).Then(
+          (resolvedRenderer) =>
+            dispatchDefaultValue(
+              injectedPrimitives,
+              types,
+              forms,
+            )(renderer.type, resolvedRenderer),
+        );
+      if (t.kind == "primitive")
+        return t.name == "unit"
+          ? ValueOrErrors.Default.return(PredicateValue.Default.unit())
+          : t.name == "boolean"
+            ? ValueOrErrors.Default.return(PredicateValue.Default.boolean())
+            : t.name == "number"
+              ? ValueOrErrors.Default.return(PredicateValue.Default.number())
+              : t.name == "string"
+                ? ValueOrErrors.Default.return(PredicateValue.Default.string())
+                : t.name == "base64File"
+                  ? ValueOrErrors.Default.return(
+                      PredicateValue.Default.string(),
+                    )
+                  : t.name == "secret"
+                    ? ValueOrErrors.Default.return(
+                        PredicateValue.Default.string(),
+                      )
+                    : t.name == "Date"
+                      ? ValueOrErrors.Default.return(
+                          PredicateValue.Default.date(),
+                        )
+                      : (injectedPrimitives === null ||
+                          injectedPrimitives === void 0
+                            ? void 0
+                            : injectedPrimitives.get(t.name)) != undefined
+                        ? ValueOrErrors.Default.return(
+                            injectedPrimitives === null ||
+                              injectedPrimitives === void 0
+                              ? void 0
+                              : injectedPrimitives.get(t.name).defaultValue,
+                          )
+                        : ValueOrErrors.Default.throwOne(
+                            `could not resolve defaultValue for primitive renderer type "${t.name}"`,
+                          );
+      if (t.kind == "singleSelection")
+        return renderer.kind == "enumRenderer" ||
+          renderer.kind == "streamRenderer"
+          ? ValueOrErrors.Default.return(
+              PredicateValue.Default.option(
+                false,
+                PredicateValue.Default.unit(),
+              ),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non singleSelection renderer kind "${renderer.kind}" when resolving defaultValue for singleSelection`,
+            );
+      if (t.kind == "multiSelection")
+        return renderer.kind == "enumRenderer" ||
+          renderer.kind == "streamRenderer"
+          ? ValueOrErrors.Default.return(
+              PredicateValue.Default.record(OrderedMap()),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non multiSelection renderer kind "${renderer.kind}" when resolving defaultValue for multiSelection`,
+            );
+      if (t.kind == "list")
+        return renderer.kind == "listRenderer"
+          ? ValueOrErrors.Default.return(PredicateValue.Default.tuple(List()))
+          : ValueOrErrors.Default.throwOne(
+              `received non list renderer kind "${renderer.kind}" when resolving defaultValue for list`,
+            );
+      if (t.kind == "map")
+        return renderer.kind == "mapRenderer"
+          ? ValueOrErrors.Default.return(PredicateValue.Default.tuple(List()))
+          : ValueOrErrors.Default.throwOne(
+              `received non map renderer kind "${renderer.kind}" when resolving defaultValue for map`,
+            );
+      if (t.kind == "tuple")
+        return renderer.kind == "tupleRenderer"
+          ? ValueOrErrors.Operations.All(
+              List(
+                t.args.map((_, index) =>
+                  dispatchDefaultValue(
+                    injectedPrimitives,
+                    types,
+                    forms,
+                  )(_, renderer.itemRenderers[index].renderer),
+                ),
+              ),
+            ).Then((values) =>
+              ValueOrErrors.Default.return(
+                PredicateValue.Default.tuple(List(values)),
+              ),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non tuple renderer kind "${renderer.kind}" when resolving defaultValue for tuple`,
+            );
+      if (t.kind == "sum")
+        return renderer.kind == "sumRenderer"
+          ? dispatchDefaultValue(
+              injectedPrimitives,
+              types,
+              forms,
+            )(t.args[1], renderer.rightRenderer.renderer).Then((right) =>
+              ValueOrErrors.Default.return(
+                PredicateValue.Default.sum(Sum.Default.right(right)),
+              ),
+            )
+          : renderer.kind == "sumUnitDateRenderer"
+            ? ValueOrErrors.Default.return(
+                PredicateValue.Default.sum(
+                  Sum.Default.left(PredicateValue.Default.unit()),
+                ),
+              )
+            : ValueOrErrors.Default.throwOne(
+                `received non sum renderer kind "${renderer.kind}" when resolving defaultValue for sum`,
+              );
+      if (t.kind == "one") {
+        return renderer.kind == "oneRenderer"
+          ? ValueOrErrors.Default.return(
+              PredicateValue.Default.option(
+                false,
+                PredicateValue.Default.unit(),
+              ),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non one renderer kind "${renderer.kind}" when resolving defaultValue for one`,
+            );
+      }
+      if (t.kind == "readOnly") {
+        return renderer.kind == "readOnlyRenderer"
+          ? dispatchDefaultValue(
+              injectedPrimitives,
+              types,
+              forms,
+            )(t.arg, renderer.childRenderer.renderer).Then((childValue) =>
+              ValueOrErrors.Default.return(
+                PredicateValue.Default.readonly(childValue),
+              ),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non readOnly renderer kind "${renderer.kind}" when resolving defaultValue for readOnly`,
+            );
+      }
+      if (t.kind == "record")
+        return renderer.kind == "recordRenderer"
+          ? ValueOrErrors.Operations.All(
+              List(
+                renderer.fields
+                  .entrySeq()
+                  .map(([fieldName, fieldRenderer]) =>
+                    MapRepo.Operations.tryFindWithError(
+                      fieldName,
+                      t.fields,
+                      () =>
+                        `field ${fieldName} not found in type ${JSON.stringify(t)} fields`,
+                    ).Then((fieldType) =>
+                      dispatchDefaultValue(
+                        injectedPrimitives,
+                        types,
+                        forms,
+                      )(fieldType, fieldRenderer.renderer).Then((value) =>
+                        ValueOrErrors.Default.return([fieldName, value]),
+                      ),
+                    ),
+                  ),
+              ),
+            ).Then((res) =>
+              ValueOrErrors.Default.return(
+                PredicateValue.Default.record(OrderedMap(res)),
+              ),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non record renderer kind "${renderer.kind}" when resolving defaultValue for record`,
+            );
+      if (t.kind == "union") {
+        return renderer.kind != "unionRenderer"
+          ? ValueOrErrors.Default.throwOne(
+              `received non union renderer kind "${renderer.kind}" when resolving defaultValue for union`,
+            )
+          : MapRepo.Operations.tryFirstWithError(
+              t.args,
+              () => `union type ${JSON.stringify(t, null, 2)} has no cases`,
+            ).Then((firstCaseType) =>
+              MapRepo.Operations.tryFirstWithError(
+                renderer.cases,
+                () => `union renderer has no cases`,
+              ).Then((firstCaseRenderer) =>
+                dispatchDefaultValue(
+                  injectedPrimitives,
+                  types,
+                  forms,
+                )(firstCaseType, firstCaseRenderer),
+              ),
+            );
+      }
+      if (t.kind == "table") {
+        return renderer.kind == "tableRenderer"
+          ? ValueOrErrors.Default.return(
+              PredicateValue.Default.table(0, 0, Map(), false),
+            )
+          : ValueOrErrors.Default.throwOne(
+              `received non table renderer kind "${renderer.kind}" when resolving defaultValue for table`,
+            );
+      }
+      return ValueOrErrors.Default.throwOne(
+        `type ${t} not supported by defaultValue`,
+      );
+    })();
+    return result.MapErrors((errors) =>
+      errors.map(
+        (error) =>
+          `${error}\n...When resolving defaultValue for type "${JSON.stringify(t, null, 2)}" and renderer kind "${renderer.kind}"`,
+      ),
+    );
+  };
+export const dispatchFromAPIRawValue =
+  (t, types, converters, injectedPrimitives) => (raw) => {
+    console.debug("dispatchFromAPIRawValue", t, raw);
+    const result = (() => {
+      if (t.kind == "primitive") {
+        // unit is a special kind of primitive
+        if (t.name == "unit") {
+          return ValueOrErrors.Default.return(PredicateValue.Default.unit());
+        }
+        if (
+          !PredicateValue.Operations.IsPrimitive(raw) &&
+          !(injectedPrimitives === null || injectedPrimitives === void 0
+            ? void 0
+            : injectedPrimitives.keySeq().contains(t.name))
+        ) {
+          return ValueOrErrors.Default.throwOne(
+            `primitive expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return ValueOrErrors.Default.return(
+          converters[t.name].fromAPIRawValue(raw),
+        );
+      }
+      if (t.kind == "union") {
+        const result = converters["union"].fromAPIRawValue(raw);
+        const caseType = t.args.get(result.caseName);
+        if (caseType == undefined)
+          return ValueOrErrors.Default.throwOne(
+            `union case ${result.caseName} not found in type ${JSON.stringify(t)}`,
+          );
+        return dispatchFromAPIRawValue(
+          caseType,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.fields).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.unionCase(result.caseName, value),
+          ),
+        );
+      }
+      if (t.kind == "singleSelection") {
+        const result = converters["SingleSelection"].fromAPIRawValue(raw);
+        const isSome = result.kind == "l";
+        const value = isSome
+          ? PredicateValue.Default.record(OrderedMap(result.value))
+          : PredicateValue.Default.unit();
+        return ValueOrErrors.Default.return(
+          PredicateValue.Default.option(isSome, value),
+        );
+      }
+      if (t.kind == "multiSelection") {
+        const result = converters["MultiSelection"].fromAPIRawValue(raw);
+        const values = result.map((_) =>
+          PredicateValue.Default.record(OrderedMap(_)),
+        );
+        return ValueOrErrors.Default.return(
+          PredicateValue.Default.record(OrderedMap(values)),
+        );
+      }
+      if (t.kind == "list") {
+        const result = converters["List"].fromAPIRawValue(raw);
+        return ValueOrErrors.Operations.All(
+          result.map((_) =>
+            dispatchFromAPIRawValue(
+              t.args[0],
+              types,
+              converters,
+              injectedPrimitives,
+            )(_),
+          ),
+        ).Then((values) =>
+          ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
+        );
+      }
+      if (t.kind == "map" && t.args.length == 2) {
+        const result = converters["Map"].fromAPIRawValue(raw);
+        return ValueOrErrors.Operations.All(
+          List(
+            result.map((_) =>
+              dispatchFromAPIRawValue(
+                t.args[0],
+                types,
+                converters,
+                injectedPrimitives,
+              )(_[0]).Then((key) =>
+                dispatchFromAPIRawValue(
+                  t.args[1],
+                  types,
+                  converters,
+                  injectedPrimitives,
+                )(_[1]).Then((value) =>
+                  ValueOrErrors.Default.return(
+                    PredicateValue.Default.tuple(List([key, value])),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ).Then((values) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.tuple(List(values)),
+          ),
+        );
+      }
+      if (t.kind == "tuple") {
+        const result = converters["Tuple"].fromAPIRawValue(raw);
+        return ValueOrErrors.Operations.All(
+          List(
+            result.map((_, index) =>
+              dispatchFromAPIRawValue(
+                t.args[index],
+                types,
+                converters,
+                injectedPrimitives,
+              )(_),
+            ),
+          ),
+        ).Then((values) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.tuple(List(values)),
+          ),
+        );
+      }
+      if (t.kind == "sum" && t.args.length === 2) {
+        const result = converters["Sum"].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          result.kind == "l" ? t.args[0] : t.args[1],
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.value).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.sum(
+              Sum.Updaters.map2(replaceWith(value), replaceWith(value))(result),
+            ),
+          ),
+        );
+      }
+      if (t.kind == "sumN") {
+        const result = converters["SumN"].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.args[result.caseIndex],
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.value).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.sumN(result.caseIndex, result.arity, value),
+          ),
+        );
+      }
+      if (t.kind == "lookup")
+        return MapRepo.Operations.tryFindWithError(
+          t.name, // TODO -- double check this is correct instead of typeName, and maybe remove typeName
+          types,
+          () => `type ${t.name} not found in types`,
+        ).Then((type) =>
+          dispatchFromAPIRawValue(
+            type,
+            types,
+            converters,
+            injectedPrimitives,
+          )(raw),
+        );
+      // TODO -- this can be more functional
+      if (t.kind == "table") {
+        // move to the converter
+        if (typeof raw != "object") {
+          return ValueOrErrors.Default.throwOne(
+            `object expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        const converterResult = converters["Table"].fromAPIRawValue(raw);
+        const argType = t.arg;
+        return DispatchParsedType.Operations.ResolveLookupType(
+          argType.name,
+          types,
+        ).Then((resolvedType) =>
+          ValueOrErrors.Operations.All(
+            List(
+              converterResult.data
+                .toArray()
+                .map(([key, record]) =>
+                  dispatchFromAPIRawValue(
+                    resolvedType,
+                    types,
+                    converters,
+                    injectedPrimitives,
+                  )(record).Then((value) =>
+                    PredicateValue.Operations.IsRecord(value)
+                      ? ValueOrErrors.Default.return([key, value])
+                      : ValueOrErrors.Default.throwOne(
+                          `record expected but got ${PredicateValue.Operations.GetKind(value)}`,
+                        ),
+                  ),
+                ),
+            ),
+          ).Then((values) =>
+            ValueOrErrors.Default.return(
+              ValueTable.Default.fromParsed(
+                converterResult.from,
+                converterResult.to,
+                converterResult.hasMoreValues,
+                OrderedMap(values),
+              ),
+            ),
+          ),
+        );
+      }
+      if (t.kind == "one") {
+        const result = converters["One"].fromAPIRawValue(raw);
+        if (!result.isSome) {
+          return ValueOrErrors.Default.return(result);
+        }
+        return dispatchFromAPIRawValue(
+          t.arg,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.value).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.option(true, value),
+          ),
+        );
+      }
+      if (t.kind == "readOnly") {
+        const readOnlyResult = converters["ReadOnly"].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.arg,
+          types,
+          converters,
+          injectedPrimitives,
+        )(readOnlyResult.ReadOnly).Then((value) =>
+          ValueOrErrors.Default.return(PredicateValue.Default.readonly(value)),
+        );
+      }
+      // TODO -- this can be more functional
+      if (t.kind == "record") {
+        if (typeof raw != "object") {
+          return ValueOrErrors.Default.throwOne(
+            `object expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        let result = OrderedMap();
+        let errors = List();
+        t.fields.forEach((fieldType, fieldName) => {
+          const fieldValue = raw[fieldName];
+          if (fieldValue !== null && fieldValue === undefined) {
+            return;
+          }
+          const parsedValue = dispatchFromAPIRawValue(
+            fieldType,
+            types,
+            converters,
+            injectedPrimitives,
+          )(fieldValue);
+          if (parsedValue.kind == "errors") {
+            errors = errors.concat(parsedValue.errors);
+          } else {
+            result = result.set(fieldName, parsedValue.value);
+          }
+        });
+        if (errors.size > 0) {
+          return ValueOrErrors.Default.throw(errors);
+        }
+        return ValueOrErrors.Default.return(
+          PredicateValue.Default.record(result),
+        );
+      }
+      // Filters
+      if (t.kind == "contains") {
+        const result = converters["Contains"].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.contains,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.contains).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.filterContains(value),
+          ),
+        );
+      }
+      if (t.kind == "=") {
+        const result = converters["="].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.equalsTo,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.equalsTo).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.filterEqualsTo(value),
+          ),
+        );
+      }
+      if (t.kind == "!=") {
+        const result = converters["!="].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.notEqualsTo,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.notEqualsTo).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.filterNotEqualsTo(value),
+          ),
+        );
+      }
+      if (t.kind == ">=") {
+        const result = converters[">="].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.greaterThanOrEqualsTo,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.greaterThanOrEqualsTo).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.filterGreaterThanOrEqualsTo(value),
+          ),
+        );
+      }
+      if (t.kind == ">") {
+        const result = converters[">"].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.greaterThan,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.greaterThan).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.filterGreaterThan(value),
+          ),
+        );
+      }
+      if (t.kind == "!=null")
+        return ValueOrErrors.Operations.Return(
+          converters["!=null"].fromAPIRawValue(raw),
+        );
+      if (t.kind == "=null")
+        return ValueOrErrors.Operations.Return(
+          converters["=null"].fromAPIRawValue(raw),
+        );
+      if (t.kind == "<=") {
+        const result = converters["<="].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.smallerThanOrEqualsTo,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.smallerThanOrEqualsTo).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.filterSmallerThanOrEqualsTo(value),
+          ),
+        );
+      }
+      if (t.kind == "<") {
+        const result = converters["<"].fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.smallerThan,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.smallerThan).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.filterSmallerThan(value),
+          ),
+        );
+      }
+      if (t.kind == "startsWith") {
+        const result = converters.StartsWith.fromAPIRawValue(raw);
+        return dispatchFromAPIRawValue(
+          t.startsWith,
+          types,
+          converters,
+          injectedPrimitives,
+        )(result.startsWith).Then((value) =>
+          ValueOrErrors.Default.return(
+            PredicateValue.Default.filterStartsWith(value),
+          ),
+        );
+      }
+      return ValueOrErrors.Default.throwOne(
+        `unsupported type ${JSON.stringify(t)} for raw: `,
+      );
+    })();
+    return result.MapErrors((errors) =>
+      errors.map(
+        (error) =>
+          `${error}\n...When converting type ${JSON.stringify(t, null, 2)} and value ${JSON.stringify(raw, null, 2)} from API raw value`,
+      ),
+    );
+  };
+export const dispatchToAPIRawValue =
+  (t, types, converters, injectedPrimitives) => (raw, formState) => {
+    const result = (() => {
+      var _a,
+        _b,
+        _c,
+        _d,
+        _e,
+        _f,
+        _g,
+        _h,
+        _j,
+        _k,
+        _l,
+        _m,
+        _o,
+        _p,
+        _q,
+        _r,
+        _s,
+        _t,
+        _u;
+      if (t.kind == "primitive") {
+        if (t.name == "unit") {
+          return ValueOrErrors.Default.return(unit);
+        }
+        return ValueOrErrors.Operations.Return(
+          converters[t.name].toAPIRawValue([
+            raw,
+            (_b =
+              (_a =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.commonFormState) === null || _a === void 0
+                ? void 0
+                : _a.modifiedByUser) !== null && _b !== void 0
+              ? _b
+              : false,
+          ]),
+        );
+      }
+      if (t.kind == "union") {
+        if (!PredicateValue.Operations.IsUnionCase(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Union case expected but got ${JSON.stringify(raw)}\n...when converting union to API raw value`,
+          );
+        }
+        const caseName = raw.caseName;
+        if (
+          caseName == undefined ||
+          !PredicateValue.Operations.IsString(caseName)
+        ) {
+          return ValueOrErrors.Default.throwOne(
+            `caseName expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        const caseType = t.args.get(caseName);
+        if (caseType == undefined) {
+          return ValueOrErrors.Default.throwOne(
+            `union case ${caseName} not found in type ${JSON.stringify(t)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          caseType,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.fields, formState);
+      }
+      if (t.kind == "singleSelection") {
+        if (!PredicateValue.Operations.IsOption(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Option expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        if (raw.isSome) {
+          if (!PredicateValue.Operations.IsRecord(raw.value)) {
+            return ValueOrErrors.Default.throwOne(
+              `Record expected but got ${JSON.stringify(raw.value)}`,
+            );
+          }
+          const rawValue = raw.value.fields.toJS();
+          if (
+            !CollectionReference.Operations.IsCollectionReference(rawValue) &&
+            !EnumReference.Operations.IsEnumReference(rawValue)
+          ) {
+            return ValueOrErrors.Default.throwOne(
+              `CollectionReference or EnumReference expected but got ${rawValue}`,
+            );
+          }
+          return ValueOrErrors.Operations.Return(
+            converters["SingleSelection"].toAPIRawValue([
+              Sum.Default.left(rawValue),
+              (_d =
+                (_c =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _c === void 0
+                  ? void 0
+                  : _c.modifiedByUser) !== null && _d !== void 0
+                ? _d
+                : false,
+            ]),
+          );
+        } else {
+          return ValueOrErrors.Operations.Return(
+            converters["SingleSelection"].toAPIRawValue([
+              Sum.Default.right("no selection"),
+              (_f =
+                (_e =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _e === void 0
+                  ? void 0
+                  : _e.modifiedByUser) !== null && _f !== void 0
+                ? _f
+                : false,
+            ]),
+          );
+        }
+      }
+      if (t.kind == "multiSelection") {
+        if (!PredicateValue.Operations.IsRecord(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Record expected but got multi selection of ${JSON.stringify(raw)}`,
+          );
+        }
+        const rawValue = raw.fields.map((value) => {
+          if (!PredicateValue.Operations.IsRecord(value)) {
+            return ValueOrErrors.Default.throwOne(
+              `Record expected but got ${JSON.stringify(value)}`,
+            );
+          }
+          const fieldsObject = value.fields.toJS();
+          if (
+            !CollectionReference.Operations.IsCollectionReference(
+              fieldsObject,
+            ) &&
+            !EnumReference.Operations.IsEnumReference(fieldsObject)
+          ) {
+            return ValueOrErrors.Default.throwOne(
+              `CollectionReference or EnumReference expected but got ${JSON.stringify(fieldsObject)}`,
+            );
+          }
+          return ValueOrErrors.Default.return(fieldsObject);
+        });
+        return ValueOrErrors.Operations.All(rawValue.valueSeq().toList()).Then(
+          (values) => {
+            var _a, _b;
+            return ValueOrErrors.Default.return(
+              converters["MultiSelection"].toAPIRawValue([
+                OrderedMap(
+                  values
+                    .map((v) => {
+                      if (
+                        CollectionReference.Operations.IsCollectionReference(v)
+                      ) {
+                        return [v.Id, v];
+                      }
+                      return [v.Value, v];
+                    })
+                    .toArray(),
+                ),
+                (_b =
+                  (_a =
+                    formState === null || formState === void 0
+                      ? void 0
+                      : formState.commonFormState) === null || _a === void 0
+                    ? void 0
+                    : _a.modifiedByUser) !== null && _b !== void 0
+                  ? _b
+                  : false,
+              ]),
+            );
+          },
+        );
+      }
+      if (t.kind == "list") {
+        if (!PredicateValue.Operations.IsTuple(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Tuple expected but got list of ${JSON.stringify(raw)}`,
+          );
+        }
+        return ValueOrErrors.Operations.All(
+          List(
+            raw.values.map((value, index) => {
+              var _a;
+              return dispatchToAPIRawValue(
+                t.args[0],
+                types,
+                converters,
+                injectedPrimitives,
+              )(
+                value,
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.elementFormStates) === null || _a === void 0
+                  ? void 0
+                  : _a.get(index),
+              );
+            }),
+          ),
+        ).Then((values) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["List"].toAPIRawValue([
+              values,
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "map" && t.args.length == 2) {
+        const keyValues = raw.values.map((keyValue, index) => {
+          var _a, _b;
+          return dispatchToAPIRawValue(
+            t.args[0],
+            types,
+            converters,
+            injectedPrimitives,
+          )(
+            keyValue.values.get(0),
+            (_b =
+              (_a =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.elementFormStates) === null || _a === void 0
+                ? void 0
+                : _a.get(index)) === null || _b === void 0
+              ? void 0
+              : _b.KeyFormState,
+          )
+            .Then((possiblyUndefinedKey) => {
+              if (
+                possiblyUndefinedKey == undefined ||
+                possiblyUndefinedKey == null ||
+                possiblyUndefinedKey == "" ||
+                (typeof possiblyUndefinedKey == "object" &&
+                  (Object.keys(possiblyUndefinedKey).length == 0 ||
+                    ("IsSome" in possiblyUndefinedKey &&
+                      !possiblyUndefinedKey.IsSome)))
+              ) {
+                return ValueOrErrors.Default.throwOne(
+                  `A mapped key is undefined for type ${JSON.stringify(t.args[0])}`,
+                );
+              } else {
+                return ValueOrErrors.Default.return(possiblyUndefinedKey);
+              }
+            })
+            .Then((key) => {
+              var _a, _b;
+              return dispatchToAPIRawValue(
+                t.args[1],
+                types,
+                converters,
+                injectedPrimitives,
+              )(
+                keyValue.values.get(1),
+                (_b =
+                  (_a =
+                    formState === null || formState === void 0
+                      ? void 0
+                      : formState.elementFormStates) === null || _a === void 0
+                    ? void 0
+                    : _a.get(index)) === null || _b === void 0
+                  ? void 0
+                  : _b.ValueFormState,
+              ).Then((value) => ValueOrErrors.Default.return([key, value]));
+            });
+        });
+        return ValueOrErrors.Operations.All(List(keyValues)).Then((values) => {
+          var _a, _b;
+          if (
+            values.map((kv) => JSON.stringify(kv[0])).toSet().size !=
+            values.size
+          ) {
+            return ValueOrErrors.Default.throwOne(
+              "Keys in the map are not unique",
+            );
+          }
+          return ValueOrErrors.Operations.Return(
+            converters["Map"].toAPIRawValue([
+              values,
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "sum" && t.args.length === 2) {
+        if (!PredicateValue.Operations.IsSum(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Sum expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          raw.value.kind == "l" ? t.args[0] : t.args[1],
+          types,
+          converters,
+          injectedPrimitives,
+        )(
+          raw.value.value,
+          raw.value.kind == "l"
+            ? (_g =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.commonFormState) === null || _g === void 0
+              ? void 0
+              : _g.left
+            : (_h =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _h === void 0
+              ? void 0
+              : _h.right,
+        ).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["Sum"].toAPIRawValue([
+              raw.value.kind == "l"
+                ? Sum.Default.left(value)
+                : Sum.Default.right(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "sumN") {
+        if (!PredicateValue.Operations.IsSumN(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `SumN expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.args[raw.caseIndex],
+          types,
+          converters,
+          injectedPrimitives,
+        )(
+          raw.value,
+          (_j =
+            formState === null || formState === void 0
+              ? void 0
+              : formState.commonFormState) === null || _j === void 0
+            ? void 0
+            : _j.modifiedByUser,
+        ).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["SumN"].toAPIRawValue([
+              PredicateValue.Default.sumN(raw.caseIndex, raw.arity, value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "tuple") {
+        if (!PredicateValue.Operations.IsTuple(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Tuple expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return ValueOrErrors.Operations.All(
+          List(
+            raw.values.map((value, index) => {
+              var _a;
+              return dispatchToAPIRawValue(
+                t.args[index],
+                types,
+                converters,
+                injectedPrimitives,
+              )(
+                value,
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.itemFormStates) === null || _a === void 0
+                  ? void 0
+                  : _a.get(index),
+              );
+            }),
+          ),
+        ).Then((values) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["Tuple"].toAPIRawValue([
+              values,
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "lookup")
+        return dispatchToAPIRawValue(
+          types.get(t.name),
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw, formState);
+      if (t.kind == "record") {
+        if (!PredicateValue.Operations.IsRecord(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Record expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        const res = [];
+        t.fields.forEach((fieldType, fieldName) => {
+          var _a;
+          const rawField = raw.fields.get(fieldName);
+          if (rawField == undefined) {
+            return;
+          }
+          res.push([
+            fieldName,
+            dispatchToAPIRawValue(
+              fieldType,
+              types,
+              converters,
+              injectedPrimitives,
+            )(
+              raw.fields.get(fieldName),
+              (_a =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.fieldStates) === null || _a === void 0
+                ? void 0
+                : _a.get(fieldName),
+            ),
+          ]);
+        });
+        const errors = ValueOrErrors.Operations.All(
+          List(res.map(([_, value]) => value)),
+        );
+        if (errors.kind == "errors") return errors;
+        return ValueOrErrors.Operations.Return(
+          res.reduce((acc, [fieldName, value]) => {
+            acc[fieldName] = value.value;
+            return acc;
+          }, {}),
+        );
+      }
+      if (t.kind == "one") {
+        if (!PredicateValue.Operations.IsOption(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Option expected but got ${JSON.stringify(raw)}\n...when converting one to API raw value`,
+          );
+        }
+        if (!raw.isSome) {
+          return ValueOrErrors.Default.return(
+            converters["One"].toAPIRawValue([
+              raw,
+              (_l =
+                (_k =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _k === void 0
+                  ? void 0
+                  : _k.modifiedByUser) !== null && _l !== void 0
+                ? _l
+                : false,
+            ]),
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.arg,
+          types,
+          converters,
+          injectedPrimitives,
+        )(
+          raw.value,
+          (_o =
+            (_m =
+              formState === null || formState === void 0
+                ? void 0
+                : formState.commonFormState) === null || _m === void 0
+              ? void 0
+              : _m.modifiedByUser) !== null && _o !== void 0
+            ? _o
+            : false,
+        ).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["One"].toAPIRawValue([
+              PredicateValue.Default.option(true, value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "readOnly") {
+        if (!PredicateValue.Operations.IsReadOnly(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `ReadOnly expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.arg,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.ReadOnly, formState).Then((childValue) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["ReadOnly"].toAPIRawValue([
+              { ReadOnly: childValue },
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "table") {
+        if (!PredicateValue.Operations.IsTable(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `Table expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return ValueOrErrors.Default.return(
+          converters["Table"].toAPIRawValue([
+            raw,
+            (_q =
+              (_p =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.commonFormState) === null || _p === void 0
+                ? void 0
+                : _p.modifiedByUser) !== null && _q !== void 0
+              ? _q
+              : false,
+          ]),
+        );
+      }
+      // Filters
+      if (t.kind == "contains") {
+        if (!PredicateValue.Operations.IsFilterContains(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterContains expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.contains,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.contains, formState).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["Contains"].toAPIRawValue([
+              PredicateValue.Default.filterContains(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "=") {
+        if (!PredicateValue.Operations.IsFilterEqualsTo(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterEqualsTo expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.equalsTo,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.equalsTo, formState).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["="].toAPIRawValue([
+              PredicateValue.Default.filterEqualsTo(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "!=") {
+        if (!PredicateValue.Operations.IsFilterNotEqualsTo(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterNotEqualsTo expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.notEqualsTo,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.notEqualsTo, formState).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["!="].toAPIRawValue([
+              PredicateValue.Default.filterNotEqualsTo(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == ">=") {
+        if (!PredicateValue.Operations.IsFilterGreaterThanOrEqualsTo(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterGreaterThanOrEqualsTo expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.greaterThanOrEqualsTo,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.greaterThanOrEqualsTo, formState).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters[">="].toAPIRawValue([
+              PredicateValue.Default.filterGreaterThanOrEqualsTo(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == ">") {
+        if (!PredicateValue.Operations.IsFilterGreaterThan(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterGreaterThan expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.greaterThan,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.greaterThan, formState).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters[">"].toAPIRawValue([
+              PredicateValue.Default.filterGreaterThan(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "!=null") {
+        if (!PredicateValue.Operations.IsFilterIsNotNull(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterIsNotNull expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return ValueOrErrors.Default.return(
+          converters["!=null"].toAPIRawValue([
+            raw,
+            (_s =
+              (_r =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.commonFormState) === null || _r === void 0
+                ? void 0
+                : _r.modifiedByUser) !== null && _s !== void 0
+              ? _s
+              : false,
+          ]),
+        );
+      }
+      if (t.kind == "=null") {
+        if (!PredicateValue.Operations.IsFilterIsNull(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterIsNull expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return ValueOrErrors.Default.return(
+          converters["=null"].toAPIRawValue([
+            raw,
+            (_u =
+              (_t =
+                formState === null || formState === void 0
+                  ? void 0
+                  : formState.commonFormState) === null || _t === void 0
+                ? void 0
+                : _t.modifiedByUser) !== null && _u !== void 0
+              ? _u
+              : false,
+          ]),
+        );
+      }
+      if (t.kind == "<=") {
+        if (!PredicateValue.Operations.IsFilterSmallerThanOrEqualsTo(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterSmallerThanOrEqualsTo expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.smallerThanOrEqualsTo,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.smallerThanOrEqualsTo, formState).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["<="].toAPIRawValue([
+              PredicateValue.Default.filterSmallerThanOrEqualsTo(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "<") {
+        if (!PredicateValue.Operations.IsFilterSmallerThan(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterSmallerThan expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.smallerThan,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.smallerThan, formState).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["<"].toAPIRawValue([
+              PredicateValue.Default.filterSmallerThan(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      if (t.kind == "startsWith") {
+        if (!PredicateValue.Operations.IsFilterStartsWith(raw)) {
+          return ValueOrErrors.Default.throwOne(
+            `FilterStartsWith expected but got ${JSON.stringify(raw)}`,
+          );
+        }
+        return dispatchToAPIRawValue(
+          t.startsWith,
+          types,
+          converters,
+          injectedPrimitives,
+        )(raw.startsWith, formState).Then((value) => {
+          var _a, _b;
+          return ValueOrErrors.Default.return(
+            converters["StartsWith"].toAPIRawValue([
+              PredicateValue.Default.filterStartsWith(value),
+              (_b =
+                (_a =
+                  formState === null || formState === void 0
+                    ? void 0
+                    : formState.commonFormState) === null || _a === void 0
+                  ? void 0
+                  : _a.modifiedByUser) !== null && _b !== void 0
+                ? _b
+                : false,
+            ]),
+          );
+        });
+      }
+      return ValueOrErrors.Default.throwOne(
+        `Unsupported type ${JSON.stringify(t)}`,
+      );
+    })();
+    return result.MapErrors((errors) =>
+      errors.map(
+        (error) =>
+          `${error}\n...When converting type ${JSON.stringify(t, null, 2)} and value ${JSON.stringify(raw, null, 2)} to API raw value`,
+      ),
+    );
+  };
+//# sourceMappingURL=state.js.map