ballerina-core 1.0.225 → 1.0.227

package/bin/src/value-infinite-data-stream/state.js

@@ -3,95 +3,217 @@ import { Updater } from "../fun/domains/updater/state";
 import { replaceWith } from "../fun/domains/updater/domains/replaceWith/state";
 import { simpleUpdater } from "../fun/domains/updater/domains/simpleUpdater/state";
 import { AsyncState } from "../async/state";
-import { MapRepo, ValueOrErrors, ValueRecord, } from "../../main";
+import { MapRepo, ValueOrErrors, ValueRecord } from "../../main";
 export const ValueStreamPosition = {
-    Default: (initialChunkSize, shouldLoad = false) => ({
-        nextStart: 0,
-        chunkSize: initialChunkSize,
-        chunkIndex: 0,
-        shouldLoad,
-        lastModifiedTime: Date.now(),
-    }),
-    Updaters: {
-        Template: {
-            changeChunkSize: (chunkSize) => ValueStreamPosition.Updaters.Core.chunkSize(replaceWith(chunkSize)).then(ValueStreamPosition.Updaters.Template.reload()),
-            reload: () => ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now()))
-                .then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")))
-                .then(ValueStreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
-            loadMore: () => ValueStreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")))),
-            initLoad: () => ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore"))),
-        },
-        Core: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("lastModifiedTime")), simpleUpdater()("shouldLoad")), simpleUpdater()("chunkIndex")), simpleUpdater()("chunkSize")), simpleUpdater()("nextStart")),
-        Coroutine: {},
+  Default: (initialChunkSize, shouldLoad = false) => ({
+    nextStart: 0,
+    chunkSize: initialChunkSize,
+    chunkIndex: 0,
+    shouldLoad,
+    lastModifiedTime: Date.now(),
+  }),
+  Updaters: {
+    Template: {
+      changeChunkSize: (chunkSize) =>
+        ValueStreamPosition.Updaters.Core.chunkSize(
+          replaceWith(chunkSize),
+        ).then(ValueStreamPosition.Updaters.Template.reload()),
+      reload: () =>
+        ValueStreamPosition.Updaters.Core.lastModifiedTime(
+          replaceWith(Date.now()),
+        )
+          .then(
+            ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")),
+          )
+          .then(ValueStreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
+      loadMore: () =>
+        ValueStreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(
+          ValueStreamPosition.Updaters.Core.lastModifiedTime(
+            replaceWith(Date.now()),
+          ).then(
+            ValueStreamPosition.Updaters.Core.shouldLoad(
+              replaceWith("loadMore"),
+            ),
+          ),
+        ),
+      initLoad: () =>
+        ValueStreamPosition.Updaters.Core.lastModifiedTime(
+          replaceWith(Date.now()),
+        ).then(
+          ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")),
+        ),
     },
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign(
+            Object.assign({}, simpleUpdater()("lastModifiedTime")),
+            simpleUpdater()("shouldLoad"),
+          ),
+          simpleUpdater()("chunkIndex"),
+        ),
+        simpleUpdater()("chunkSize"),
+      ),
+      simpleUpdater()("nextStart"),
+    ),
+    Coroutine: {},
+  },
 };
 export const ValueChunk = {
-    Default: (hasMoreValues, data, from, to) => ({
-        hasMoreValues,
-        data,
-        from,
-        to,
-    }),
-    Updaters: {
-        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("hasMoreValues")), simpleUpdater()("data")), simpleUpdater()("from")), simpleUpdater()("to")),
-        Template: {
-            updateValue: (valueId, valueUpdater) => ValueChunk.Updaters.Core.data(MapRepo.Updaters.update(valueId, valueUpdater)),
-            updateValueItem: (valueId, itemId, valueUpdater) => ValueChunk.Updaters.Core.data(MapRepo.Updaters.update(valueId, ValueRecord.Updaters.update(itemId, valueUpdater))),
-        },
+  Default: (hasMoreValues, data, from, to) => ({
+    hasMoreValues,
+    data,
+    from,
+    to,
+  }),
+  Updaters: {
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign({}, simpleUpdater()("hasMoreValues")),
+          simpleUpdater()("data"),
+        ),
+        simpleUpdater()("from"),
+      ),
+      simpleUpdater()("to"),
+    ),
+    Template: {
+      updateValue: (valueId, valueUpdater) =>
+        ValueChunk.Updaters.Core.data(
+          MapRepo.Updaters.update(valueId, valueUpdater),
+        ),
+      updateValueItem: (valueId, itemId, valueUpdater) =>
+        ValueChunk.Updaters.Core.data(
+          MapRepo.Updaters.update(
+            valueId,
+            ValueRecord.Updaters.update(itemId, valueUpdater),
+          ),
+        ),
     },
+  },
 };
 export const StateChunkItem = {
-    Default: (state) => Map(state),
+  Default: (state) => Map(state),
 };
 export const StateChunk = {
-    Default: (state) => Map(state),
+  Default: (state) => Map(state),
 };
 export const ValueInfiniteStreamState = {
-    Default: (initialChunkSize, getChunk, shouldLoad) => ({
-        loadingMore: AsyncState.Default.unloaded(),
-        loadedElements: OrderedMap(),
-        position: ValueStreamPosition.Default(initialChunkSize, shouldLoad),
-        getChunk,
-    }),
-    Operations: {
-        shouldCoroutineRun: (current) => current.position.shouldLoad != false,
-        loadNextPage: (current) => {
-            var _a;
-            return current.position.shouldLoad !== false &&
-                ((_a = current.loadedElements.last()) === null || _a === void 0 ? void 0 : _a.hasMoreValues) !== false;
-        },
-        getChunkIndexForValue: (current, valueId) => ValueOrErrors.Default.return(current.loadedElements.findLastKey((chunk) => chunk.data.has(valueId))).Then((chunkIndex) => chunkIndex == undefined
-            ? ValueOrErrors.Default.throwOne("value not found in any chunks")
-            : ValueOrErrors.Default.return(chunkIndex)),
+  Default: (initialChunkSize, getChunk, shouldLoad) => ({
+    loadingMore: AsyncState.Default.unloaded(),
+    loadedElements: OrderedMap(),
+    position: ValueStreamPosition.Default(initialChunkSize, shouldLoad),
+    getChunk,
+  }),
+  Operations: {
+    shouldCoroutineRun: (current) => current.position.shouldLoad != false,
+    loadNextPage: (current) => {
+      var _a;
+      return (
+        current.position.shouldLoad !== false &&
+        ((_a = current.loadedElements.last()) === null || _a === void 0
+          ? void 0
+          : _a.hasMoreValues) !== false
+      );
     },
-    Updaters: {
-        Coroutine: {
-            addLoadedChunk: (chunkIndex, newChunk) => ValueInfiniteStreamState.Updaters.Core.loadedElements((_) => _.set(chunkIndex, newChunk)),
-        },
-        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("getChunk")), simpleUpdater()("loadingMore")), simpleUpdater()("loadedElements")), { whenNotAlreadyLoading: (_) => {
-                return Updater((current) => {
-                    if (ValueInfiniteStreamState.Operations.loadNextPage(current)) {
-                        return current;
-                    }
-                    return _(current);
-                });
-            }, position: (positionUpdater) => Updater((current) => {
-                const newPosition = positionUpdater(current.position);
-                let newState = current;
-                if (newPosition.chunkSize != current.position.chunkSize)
-                    newState =
-                        ValueInfiniteStreamState.Updaters.Core.clearLoadedElements()(newState);
-                return Object.assign(Object.assign({}, newState), { position: newPosition });
-            }), clearLoadedElements: () => ValueInfiniteStreamState.Updaters.Core.loadedElements((_) => OrderedMap()) }),
-        Template: {
-            reload: (getChunk) => ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.reload())
-                .then(ValueInfiniteStreamState.Updaters.Core.clearLoadedElements())
-                .then(ValueInfiniteStreamState.Updaters.Core.getChunk(replaceWith(getChunk))),
-            loadMore: () => ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.loadMore())),
-            initLoad: () => ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.initLoad())),
-            updateChunkValue: (chunkIndex, chunkValueKey) => (valueUpdater) => ValueInfiniteStreamState.Updaters.Core.loadedElements(MapRepo.Updaters.update(chunkIndex, ValueChunk.Updaters.Template.updateValue(chunkValueKey, valueUpdater))),
-            updateChunkValueItem: (chunkIndex, chunkValueKey, chunkValueItemKey) => (valueUpdater) => ValueInfiniteStreamState.Updaters.Core.loadedElements(MapRepo.Updaters.update(chunkIndex, ValueChunk.Updaters.Template.updateValueItem(chunkValueKey, chunkValueItemKey, valueUpdater))),
+    getChunkIndexForValue: (current, valueId) =>
+      ValueOrErrors.Default.return(
+        current.loadedElements.findLastKey((chunk) => chunk.data.has(valueId)),
+      ).Then((chunkIndex) =>
+        chunkIndex == undefined
+          ? ValueOrErrors.Default.throwOne("value not found in any chunks")
+          : ValueOrErrors.Default.return(chunkIndex),
+      ),
+  },
+  Updaters: {
+    Coroutine: {
+      addLoadedChunk: (chunkIndex, newChunk) =>
+        ValueInfiniteStreamState.Updaters.Core.loadedElements((_) =>
+          _.set(chunkIndex, newChunk),
+        ),
+    },
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign({}, simpleUpdater()("getChunk")),
+          simpleUpdater()("loadingMore"),
+        ),
+        simpleUpdater()("loadedElements"),
+      ),
+      {
+        whenNotAlreadyLoading: (_) => {
+          return Updater((current) => {
+            if (ValueInfiniteStreamState.Operations.loadNextPage(current)) {
+              return current;
+            }
+            return _(current);
+          });
         },
+        position: (positionUpdater) =>
+          Updater((current) => {
+            const newPosition = positionUpdater(current.position);
+            let newState = current;
+            if (newPosition.chunkSize != current.position.chunkSize)
+              newState =
+                ValueInfiniteStreamState.Updaters.Core.clearLoadedElements()(
+                  newState,
+                );
+            return Object.assign(Object.assign({}, newState), {
+              position: newPosition,
+            });
+          }),
+        clearLoadedElements: () =>
+          ValueInfiniteStreamState.Updaters.Core.loadedElements((_) =>
+            OrderedMap(),
+          ),
+      },
+    ),
+    Template: {
+      reload: (getChunk) =>
+        ValueInfiniteStreamState.Updaters.Core.position(
+          ValueStreamPosition.Updaters.Template.reload(),
+        )
+          .then(ValueInfiniteStreamState.Updaters.Core.clearLoadedElements())
+          .then(
+            ValueInfiniteStreamState.Updaters.Core.getChunk(
+              replaceWith(getChunk),
+            ),
+          ),
+      loadMore: () =>
+        ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(
+          ValueInfiniteStreamState.Updaters.Core.position(
+            ValueStreamPosition.Updaters.Template.loadMore(),
+          ),
+        ),
+      initLoad: () =>
+        ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(
+          ValueInfiniteStreamState.Updaters.Core.position(
+            ValueStreamPosition.Updaters.Template.initLoad(),
+          ),
+        ),
+      updateChunkValue: (chunkIndex, chunkValueKey) => (valueUpdater) =>
+        ValueInfiniteStreamState.Updaters.Core.loadedElements(
+          MapRepo.Updaters.update(
+            chunkIndex,
+            ValueChunk.Updaters.Template.updateValue(
+              chunkValueKey,
+              valueUpdater,
+            ),
+          ),
+        ),
+      updateChunkValueItem:
+        (chunkIndex, chunkValueKey, chunkValueItemKey) => (valueUpdater) =>
+          ValueInfiniteStreamState.Updaters.Core.loadedElements(
+            MapRepo.Updaters.update(
+              chunkIndex,
+              ValueChunk.Updaters.Template.updateValueItem(
+                chunkValueKey,
+                chunkValueItemKey,
+                valueUpdater,
+              ),
+            ),
+          ),
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/value-infinite-data-stream/template.d.ts

@@ -1,4 +1,9 @@
 import { Unit } from "../fun/domains/unit/state";
 import { Template } from "../template/state";
-export declare const ValueInfiniteStreamTemplate: Template<import("./state").ValueInfiniteStreamState, import("./state").ValueInfiniteStreamState, Unit, Unit>;
-//# sourceMappingURL=template.d.ts.map
+export declare const ValueInfiniteStreamTemplate: Template<
+  import("./state").ValueInfiniteStreamState,
+  import("./state").ValueInfiniteStreamState,
+  Unit,
+  Unit
+>;
+//# sourceMappingURL=template.d.ts.map

package/bin/src/value-infinite-data-stream/template.js

@@ -1,5 +1,7 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { Template } from "../template/state";
 import { ValueStreamDataLoader } from "./coroutines/runner";
-export const ValueInfiniteStreamTemplate = Template.Default((_props) => _jsx(_Fragment, {})).any([ValueStreamDataLoader()]);
-//# sourceMappingURL=template.js.map
+export const ValueInfiniteStreamTemplate = Template.Default((_props) =>
+  _jsx(_Fragment, {}),
+).any([ValueStreamDataLoader()]);
+//# sourceMappingURL=template.js.map

package/bin/src/visibility/state.d.ts

@@ -1,2 +1,5 @@
-export type Visibility = "fully-visible" | "fully-invisible" | "partially-visible";
-//# sourceMappingURL=state.d.ts.map
+export type Visibility =
+  | "fully-visible"
+  | "fully-invisible"
+  | "partially-visible";
+//# sourceMappingURL=state.d.ts.map

package/bin/src/visibility/state.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.225",
+  "version": "1.0.227",
   "main": "main.ts",
   "scripts": {
     "prettier": "prettier --write ."

package/src/forms/domains/dispatched-forms/built-ins/state.ts

@@ -1877,10 +1877,37 @@ export const dispatchToAPIRawValue =
           );
         }
 
+        const filteredRawValues = raw.fields.filter((value) => {
+          if (!PredicateValue.Operations.IsRecord(value)) {
+            console.warn(
+              "Received a non-record value in a multi selection, ignoring: ",
+              JSON.stringify(value),
+            );
+            return false;
+          }
+
+          const fieldsObject = value.fields.toJS();
+
+          if (
+            !CollectionReference.Operations.IsCollectionReference(
+              fieldsObject,
+            ) &&
+            !EnumReference.Operations.IsEnumReference(fieldsObject)
+          ) {
+            console.warn(
+              "Received a non-collection or enum reference value in a multi selection, ignoring: ",
+              JSON.stringify(value),
+            );
+            return false;
+          }
+          return true;
+        });
+
         const rawValue: Map<
           string,
           ValueOrErrors<CollectionReference | EnumReference, string>
-        > = raw.fields.map((value) => {
+        > = filteredRawValues.map((value) => {
+          // should never happen due to the filter above but is a type check
           if (!PredicateValue.Operations.IsRecord(value)) {
             return ValueOrErrors.Default.throwOne(
               `Record expected but got ${JSON.stringify(value)}`,
@@ -1900,6 +1927,7 @@ export const dispatchToAPIRawValue =
               )}`,
             );
           }
+
           return ValueOrErrors.Default.return(fieldsObject);
         });
 

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

@@ -47,6 +47,11 @@ export type SerializedKeyOfType<T> = {
   args?: Array<string>;
 };
 
+export type SerializedTranslationOverrideType = {
+  fun?: "TranslationOverride";
+  args?: Array<string>;
+};
+
 export type ValidatedSerializedKeyOfType<T> = {
   fun: "KeyOf";
   args: [string, Array<string>?];
@@ -62,7 +67,8 @@ export type SerializedType<T> =
   | SerializedUnionType
   | SerializedRecordType
   | SerializedOptionType
-  | SerializedKeyOfType<T>;
+  | SerializedKeyOfType<T>
+  | SerializedTranslationOverrideType;
 
 export const DispatchPrimitiveTypeNames = [
   "unit",
@@ -197,6 +203,17 @@ export const SerializedType = {
     _.args.length == 1,
   isRecordFields: (_: unknown) =>
     typeof _ == "object" && _ != null && !("fun" in _) && !("args" in _),
+  isTranslationOverride: (
+    _: unknown,
+  ): _ is { fun: "TranslationOverride"; args: Array<string> } =>
+    typeof _ == "object" &&
+    _ != null &&
+    "fun" in _ &&
+    _.fun == "TranslationOverride" &&
+    "args" in _ &&
+    Array.isArray(_.args) &&
+    _.args.length == 2 &&
+    DispatchisString(_.args[0]),
 };
 
 export type StringSerializedType = string;
@@ -1489,6 +1506,23 @@ export const DispatchParsedType = {
             serializedTypes,
             alreadyParsedTypes,
           );
+        if (SerializedType.isTranslationOverride(rawType))
+          return DispatchParsedType.Operations.ParseRawType(
+            "TranslationOverride:Language",
+            rawType.args[0],
+            typeNames,
+            serializedTypes,
+            alreadyParsedTypes,
+            injectedPrimitives,
+          ).Then(([parsedArg0, ..._]) =>
+            ValueOrErrors.Default.return([
+              DispatchParsedType.Default.map([
+                DispatchParsedType.Default.singleSelection([parsedArg0]),
+                DispatchParsedType.Default.primitive("string"),
+              ]),
+              alreadyParsedTypes,
+            ]),
+          );
         return ValueOrErrors.Default.throwOne(
           `Unrecognised type "${typeName}" : ${JSON.stringify(rawType)}`,
         );

package/bin/src/forms/domains/collection/domains/unionCase/state.d.ts

@@ -1,14 +0,0 @@
-export type UnionCase = {
-  Value: string;
-  isSome: boolean;
-};
-export declare const UnionCase: {
-  Default: ((Value: string, isSome: boolean) => UnionCase) & {
-    empty: () => UnionCase;
-  };
-  Updaters: {
-    isSome: import("../../../../../../main").Widening<UnionCase, "isSome">;
-    Value: import("../../../../../../main").Widening<UnionCase, "Value">;
-  };
-};
-//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/collection/domains/unionCase/state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../src/forms/domains/collection/domains/unionCase/state.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AACF,eAAO,MAAM,SAAS;sBAEV,MAAM,UAAU,OAAO,KAAG,SAAS;qBAK9B,SAAS;;;;;;CAOzB,CAAC"}

package/bin/src/forms/domains/collection/domains/unionCase/state.js

@@ -1,17 +0,0 @@
-import { simpleUpdater } from "../../../../../../main";
-export const UnionCase = {
-  Default: Object.assign(
-    (Value, isSome) => ({
-      Value,
-      isSome,
-    }),
-    {
-      empty: () => UnionCase.Default("", false),
-    },
-  ),
-  Updaters: Object.assign(
-    Object.assign({}, simpleUpdater()("Value")),
-    simpleUpdater()("isSome"),
-  ),
-};
-//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/collection/domains/unionCase/state.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.js","sourceRoot":"","sources":["../../../../../../../src/forms/domains/collection/domains/unionCase/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAMvD,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,CACpB,CAAC,KAAa,EAAE,MAAe,EAAa,EAAE,CAAC,CAAC;QAC9C,KAAK;QACL,MAAM;KACP,CAAC,EACF;QACE,KAAK,EAAE,GAAc,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,CAAC;KACrD,CACF;IACD,QAAQ,kCACH,aAAa,EAAa,CAAC,OAAO,CAAC,GACnC,aAAa,EAAa,CAAC,QAAQ,CAAC,CACxC;CACF,CAAC"}

package/bin/src/forms/domains/dispatched-forms/deserializer/built-ins/state.d.ts

@@ -1,164 +0,0 @@
-import { Map, List, Set, OrderedMap } from "immutable";
-import {
-  CollectionReference,
-  EnumReference,
-} from "../../../collection/domains/reference/state";
-import { CollectionSelection } from "../../../collection/domains/selection/state";
-import { BasicFun } from "../../../../../fun/state";
-import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
-import {
-  PredicateValue,
-  Unit,
-  InjectedPrimitives,
-  TypeName,
-} from "../../../../../../main";
-import { Sum } from "../../../../../../main";
-import { DispatchParsedType } from "../specification/domains/types/state";
-export declare const BuiltInPrimitiveTypes: readonly [
-  "unit",
-  "guid",
-  "string",
-  "number",
-  "boolean",
-  "Date",
-  "base64File",
-  "secret",
-];
-export type BuiltInPrimitiveType = (typeof BuiltInPrimitiveTypes)[number];
-export declare const BuiltInGenericTypes: readonly [
-  "SingleSelection",
-  "MultiSelection",
-  "List",
-  "Map",
-  "Union",
-  "Tuple",
-  "Sum",
-  "Record",
-];
-export type BuiltInGenericType = (typeof BuiltInGenericTypes)[number];
-export type ApiConverter<T> = {
-  fromAPIRawValue: BasicFun<any, T>;
-  toAPIRawValue: BasicFun<[T, boolean], any>;
-};
-export type ApiConverters<
-  T extends {
-    [key in keyof T]: {
-      type: any;
-      state: any;
-    };
-  },
-> = {
-  [key in keyof T]: ApiConverter<T[key]["type"]>;
-} & BuiltInApiConverters;
-export type UnionCase = {
-  caseName: string;
-  fields: Record<string, any>;
-};
-export type BuiltInApiConverters = {
-  string: ApiConverter<string>;
-  number: ApiConverter<number>;
-  boolean: ApiConverter<boolean>;
-  base64File: ApiConverter<string>;
-  secret: ApiConverter<string>;
-  Date: ApiConverter<Date>;
-  union: ApiConverter<UnionCase>;
-  SingleSelection: ApiConverter<
-    CollectionSelection<CollectionReference | EnumReference>
-  >;
-  MultiSelection: ApiConverter<
-    OrderedMap<string, CollectionReference | EnumReference>
-  >;
-  List: ApiConverter<List<any>>;
-  Map: ApiConverter<List<[any, any]>>;
-  Tuple: ApiConverter<List<any>>;
-  Sum: ApiConverter<Sum<any, any>>;
-  SumUnitDate: ApiConverter<Sum<Unit, Date>>;
-};
-export type CommonFormState = {
-  modifiedByUser: boolean;
-};
-export declare const CommonFormState: {
-  Default: () => CommonFormState;
-};
-export type PrimitiveBuiltIn = {
-  renderers: Set<keyof BuiltIns["renderers"]>;
-  defaultValue: PredicateValue;
-  defaultState: {
-    commonFormState: CommonFormState;
-    customFormState: object;
-  };
-};
-export type GenericBuiltIn = {
-  defaultValue: any;
-  defaultState?: any;
-};
-export type SpecificBuiltIn = {
-  defaultValue: any;
-  defaultState?: any;
-};
-export type BuiltIns = {
-  primitives: Map<string, PrimitiveBuiltIn>;
-  generics: Map<string, GenericBuiltIn>;
-  specifics: Map<string, SpecificBuiltIn>;
-  renderers: {
-    unit: Set<string>;
-    boolean: Set<string>;
-    number: Set<string>;
-    string: Set<string>;
-    base64File: Set<string>;
-    secret: Set<string>;
-    date: Set<string>;
-    enumSingleSelection: Set<string>;
-    enumMultiSelection: Set<string>;
-    streamSingleSelection: Set<string>;
-    streamMultiSelection: Set<string>;
-    list: Set<string>;
-    map: Set<string>;
-    tuple: Set<string>;
-    sum: Set<string>;
-    sumUnitDate: Set<string>;
-  };
-};
-export declare const builtInsFromFieldViews: (fieldViews: any) => BuiltIns;
-export declare const defaultState: <T>(
-  types: Map<TypeName, DispatchParsedType<T>>,
-  builtIns: BuiltIns,
-  injectedPrimitives?: InjectedPrimitives<T>,
-) => (t: DispatchParsedType<T>) => {
-  commonFormState: CommonFormState;
-  customFormState: object;
-};
-export declare const defaultValue: <T>(
-  types: Map<TypeName, DispatchParsedType<T>>,
-  builtIns: BuiltIns,
-  injectedPrimitives?: InjectedPrimitives<T>,
-) => (t: DispatchParsedType<T>) => PredicateValue;
-export declare const fromAPIRawValue: <
-  T extends {
-    [key in keyof T]: {
-      type: any;
-      state: any;
-    };
-  },
->(
-  t: DispatchParsedType<T>,
-  types: Map<TypeName, DispatchParsedType<T>>,
-  builtIns: BuiltIns,
-  converters: ApiConverters<T>,
-  injectedPrimitives?: InjectedPrimitives<T>,
-) => (raw: any) => ValueOrErrors<PredicateValue, string>;
-export declare const toAPIRawValue: <
-  T extends {
-    [key in keyof T]: {
-      type: any;
-      state: any;
-    };
-  },
->(
-  t: DispatchParsedType<T>,
-  types: Map<TypeName, DispatchParsedType<T>>,
-  builtIns: BuiltIns,
-  converters: ApiConverters<T>,
-  injectedPrimitives?: InjectedPrimitives<T>,
-) => (raw: PredicateValue, formState: any) => ValueOrErrors<any, string>;
-//# sourceMappingURL=state.d.ts.map