ballerina-core 1.0.200 → 1.0.201

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

@@ -1,244 +1,534 @@
 import { Set, Map, OrderedMap } from "immutable";
 import { ValueOrErrors } from "../../../../../../../../collections/domains/valueOrErrors/state";
-import { Unit, DispatchGenericType, DispatchInjectedPrimitives } from "../../../../../../../../../main";
+import {
+  Unit,
+  DispatchGenericType,
+  DispatchInjectedPrimitives,
+} from "../../../../../../../../../main";
 export declare const DispatchisString: (_: any) => _ is string;
 export declare const DispatchIsObject: (_: any) => _ is object;
-export declare const DispatchIsGenericType: (_: any) => _ is DispatchGenericType;
+export declare const DispatchIsGenericType: (
+  _: any,
+) => _ is DispatchGenericType;
 export declare const DispatchHasFun: (_: any) => _ is {
-    fun: string;
+  fun: string;
 };
 export declare const DispatchHasArgs: (_: any) => _ is {
-    args: Array<any>;
+  args: Array<any>;
 };
 export type DispatchCaseName = string;
 export type DispatchFieldName = string;
 export type DispatchTypeName = string;
 export type SerializedApplicationType<T> = {
-    fun?: DispatchGenericType;
-    args?: Array<SerializedType<T>>;
+  fun?: DispatchGenericType;
+  args?: Array<SerializedType<T>>;
 };
 export type SerializedUnionType = {
-    fun?: "Union";
-    args?: Array<string>;
+  fun?: "Union";
+  args?: Array<string>;
 };
 export type SerializedOptionType = {
-    fun?: "Option";
-    args?: Array<SerializedType<any>>;
+  fun?: "Option";
+  args?: Array<SerializedType<any>>;
 };
 export type SerializedRecordType = {
-    extends?: Array<DispatchTypeName>;
-    fields?: object;
+  extends?: Array<DispatchTypeName>;
+  fields?: object;
 };
 export type SerializedKeyOfType<T> = {
-    fun?: "KeyOf";
-    args?: Array<string>;
+  fun?: "KeyOf";
+  args?: Array<string>;
 };
 export type ValidatedSerializedKeyOfType<T> = {
-    fun: "KeyOf";
-    args: Array<string>;
+  fun: "KeyOf";
+  args: Array<string>;
 };
 export type SerializedLookupType = string;
-export type SerializedType<T> = Unit | DispatchPrimitiveTypeName<T> | SerializedApplicationType<T> | SerializedLookupType | SerializedUnionType | SerializedRecordType | SerializedOptionType | SerializedKeyOfType<T>;
-export declare const DispatchPrimitiveTypeNames: readonly ["unit", "guid", "string", "number", "boolean", "Date", "base64File", "secret"];
-export type DispatchPrimitiveTypeName<T> = (typeof DispatchPrimitiveTypeNames)[number] | keyof T;
+export type SerializedType<T> =
+  | Unit
+  | DispatchPrimitiveTypeName<T>
+  | SerializedApplicationType<T>
+  | SerializedLookupType
+  | SerializedUnionType
+  | SerializedRecordType
+  | SerializedOptionType
+  | SerializedKeyOfType<T>;
+export declare const DispatchPrimitiveTypeNames: readonly [
+  "unit",
+  "guid",
+  "entityIdString",
+  "entityIdUUID",
+  "calculatedDisplayValue",
+  "string",
+  "number",
+  "boolean",
+  "Date",
+  "base64File",
+  "secret",
+];
+export type DispatchPrimitiveTypeName<T> =
+  | (typeof DispatchPrimitiveTypeNames)[number]
+  | keyof T;
 export declare const SerializedType: {
-    isExtendedType: <T>(type: SerializedType<T>) => type is SerializedType<T> & {
-        extends: Array<DispatchTypeName>;
-    };
-    hasFields: <T>(type: SerializedType<T>) => type is {
-        fields: any;
-    };
-    isPrimitive: <T>(_: SerializedType<T>, injectedPrimitives: DispatchInjectedPrimitives<T> | undefined) => _ is DispatchPrimitiveTypeName<T>;
-    isApplication: <T>(_: SerializedType<T>) => _ is {
-        fun: DispatchGenericType;
-        args: Array<SerializedType<T>>;
-    };
-    isLookup: (_: unknown, forms: Set<DispatchTypeName>) => _ is DispatchTypeName;
-    isList: <T>(_: SerializedType<T>) => _ is {
-        fun: "List";
-        args: Array<SerializedType<T>>;
-    };
-    isMap: <T>(_: SerializedType<T>) => _ is {
-        fun: "Map";
-        args: Array<SerializedType<T>>;
-    };
-    isSum: <T>(_: SerializedType<T>) => _ is {
-        fun: "Sum";
-        args: Array<SerializedType<T>>;
-    };
-    isSumUnitDate: <T>(_: SerializedType<T>) => _ is "SumUnitDate";
-    isSingleSelection: <T>(_: SerializedType<T>) => _ is {
-        fun: "SingleSelection";
-        args: Array<SerializedType<T>>;
-    };
-    isMultiSelection: <T>(_: SerializedType<T>) => _ is {
-        fun: "MultiSelection";
-        args: Array<SerializedType<T>>;
-    };
-    isUnion: <T>(_: SerializedType<T>) => _ is {
-        fun: "Union";
-        args: Array<{
-            caseName: string;
-            fields: string | SerializedType<T>;
-        }>;
-    };
-    isTuple: <T>(_: SerializedType<T>) => _ is {
-        fun: "Tuple";
-        args: Array<SerializedType<T>>;
-    };
-    isRecord: <T>(_: unknown) => _ is {
-        fields: Object;
-        extends?: Array<DispatchTypeName>;
-    };
-    isTable: <T>(_: SerializedType<T>) => _ is {
-        fun: "Table";
-        args: Array<SerializedType<T>>;
-    };
-    isOption: <T>(_: SerializedType<T>) => _ is {
-        fun: "Option";
-        args: Array<SerializedType<T>>;
-    };
-    isUnit: <T>(_: SerializedType<T>) => _ is string;
-    isKeyOf: <T>(_: SerializedType<T>) => _ is ValidatedSerializedKeyOfType<T>;
-    isOne: <T>(_: SerializedType<T>) => _ is {
-        fun: "One";
-        args: Array<SerializedType<T>>;
-    };
-    isReadOnly: <T>(_: SerializedType<T>) => _ is {
-        fun: "ReadOnly";
-        args: Array<SerializedType<T>>;
-    };
-    isRecordFields: (_: unknown) => boolean;
+  isExtendedType: <T>(type: SerializedType<T>) => type is SerializedType<T> & {
+    extends: Array<DispatchTypeName>;
+  };
+  hasFields: <T>(type: SerializedType<T>) => type is {
+    fields: any;
+  };
+  isPrimitive: <T>(
+    _: SerializedType<T>,
+    injectedPrimitives: DispatchInjectedPrimitives<T> | undefined,
+  ) => _ is DispatchPrimitiveTypeName<T>;
+  isApplication: <T>(_: SerializedType<T>) => _ is {
+    fun: DispatchGenericType;
+    args: Array<SerializedType<T>>;
+  };
+  isLookup: (_: unknown, forms: Set<DispatchTypeName>) => _ is DispatchTypeName;
+  isList: <T>(_: SerializedType<T>) => _ is {
+    fun: "List";
+    args: Array<SerializedType<T>>;
+  };
+  isMap: <T>(_: SerializedType<T>) => _ is {
+    fun: "Map";
+    args: Array<SerializedType<T>>;
+  };
+  isSum: <T>(_: SerializedType<T>) => _ is {
+    fun: "Sum";
+    args: Array<SerializedType<T>>;
+  };
+  isSumUnitDate: <T>(_: SerializedType<T>) => _ is "SumUnitDate";
+  isSingleSelection: <T>(_: SerializedType<T>) => _ is {
+    fun: "SingleSelection";
+    args: Array<SerializedType<T>>;
+  };
+  isMultiSelection: <T>(_: SerializedType<T>) => _ is {
+    fun: "MultiSelection";
+    args: Array<SerializedType<T>>;
+  };
+  isUnion: <T>(_: SerializedType<T>) => _ is {
+    fun: "Union";
+    args: Array<{
+      caseName: string;
+      fields: string | SerializedType<T>;
+    }>;
+  };
+  isTuple: <T>(_: SerializedType<T>) => _ is {
+    fun: "Tuple";
+    args: Array<SerializedType<T>>;
+  };
+  isRecord: <T>(_: unknown) => _ is {
+    fields: Object;
+    extends?: Array<DispatchTypeName>;
+  };
+  isTable: <T>(_: SerializedType<T>) => _ is {
+    fun: "Table";
+    args: Array<SerializedType<T>>;
+  };
+  isOption: <T>(_: SerializedType<T>) => _ is {
+    fun: "Option";
+    args: Array<SerializedType<T>>;
+  };
+  isUnit: <T>(_: SerializedType<T>) => _ is string;
+  isKeyOf: <T>(_: SerializedType<T>) => _ is ValidatedSerializedKeyOfType<T>;
+  isOne: <T>(_: SerializedType<T>) => _ is {
+    fun: "One";
+    args: Array<SerializedType<T>>;
+  };
+  isReadOnly: <T>(_: SerializedType<T>) => _ is {
+    fun: "ReadOnly";
+    args: Array<SerializedType<T>>;
+  };
+  isRecordFields: (_: unknown) => boolean;
 };
 export type StringSerializedType = string;
 export type UnionType<T> = {
-    kind: "union";
-    args: Map<DispatchCaseName, DispatchParsedType<T>>;
-    asString: () => StringSerializedType;
+  kind: "union";
+  args: Map<DispatchCaseName, DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
 };
 export declare const UnionType: {
-    SerializeToString: (serializedArgs: Map<DispatchCaseName, StringSerializedType>) => StringSerializedType;
+  SerializeToString: (
+    serializedArgs: Map<DispatchCaseName, StringSerializedType>,
+  ) => StringSerializedType;
 };
 export type RecordType<T> = {
-    kind: "record";
-    fields: OrderedMap<DispatchFieldName, DispatchParsedType<T>>;
-    asString: () => StringSerializedType;
+  kind: "record";
+  fields: OrderedMap<DispatchFieldName, DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
 };
 export declare const RecordType: {
-    SerializeToString: (serializedFields: OrderedMap<DispatchFieldName, StringSerializedType>) => StringSerializedType;
+  SerializeToString: (
+    serializedFields: OrderedMap<DispatchFieldName, StringSerializedType>,
+  ) => StringSerializedType;
 };
 export type LookupType = {
-    kind: "lookup";
-    name: string;
-    asString: () => StringSerializedType;
+  kind: "lookup";
+  name: string;
+  asString: () => StringSerializedType;
 };
 export declare const LookupType: {
-    SerializeToString: (name: string) => StringSerializedType;
+  SerializeToString: (name: string) => StringSerializedType;
 };
 export type DispatchPrimitiveType<T> = {
-    kind: "primitive";
-    name: DispatchPrimitiveTypeName<T>;
-    asString: () => StringSerializedType;
+  kind: "primitive";
+  name: DispatchPrimitiveTypeName<T>;
+  asString: () => StringSerializedType;
 };
 export declare const DispatchPrimitiveType: {
-    SerializeToString: <T>(name: DispatchPrimitiveTypeName<T>) => StringSerializedType;
+  SerializeToString: <T>(
+    name: DispatchPrimitiveTypeName<T>,
+  ) => StringSerializedType;
 };
 export type SingleSelectionType<T> = {
-    kind: "singleSelection";
-    args: Array<DispatchParsedType<T>>;
-    asString: () => StringSerializedType;
+  kind: "singleSelection";
+  args: Array<DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
 };
 export declare const SingleSelectionType: {
-    SerializeToString: (serializedArgs: Array<StringSerializedType>) => StringSerializedType;
+  SerializeToString: (
+    serializedArgs: Array<StringSerializedType>,
+  ) => StringSerializedType;
 };
 export type MultiSelectionType<T> = {
-    kind: "multiSelection";
-    args: Array<DispatchParsedType<T>>;
-    asString: () => StringSerializedType;
+  kind: "multiSelection";
+  args: Array<DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
 };
 export declare const MultiSelectionType: {
-    SerializeToString: (serializedArgs: Array<StringSerializedType>) => StringSerializedType;
+  SerializeToString: (
+    serializedArgs: Array<StringSerializedType>,
+  ) => StringSerializedType;
 };
 export type ListType<T> = {
-    kind: "list";
-    args: Array<DispatchParsedType<T>>;
-    asString: () => StringSerializedType;
+  kind: "list";
+  args: Array<DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
 };
 export declare const ListType: {
-    SerializeToString: (serializedArgs: Array<StringSerializedType>) => StringSerializedType;
+  SerializeToString: (
+    serializedArgs: Array<StringSerializedType>,
+  ) => StringSerializedType;
 };
 export type TupleType<T> = {
-    kind: "tuple";
-    args: Array<DispatchParsedType<T>>;
-    asString: () => StringSerializedType;
+  kind: "tuple";
+  args: Array<DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
 };
 export declare const TupleType: {
-    SerializeToString: (serializedArgs: Array<StringSerializedType>) => StringSerializedType;
+  SerializeToString: (
+    serializedArgs: Array<StringSerializedType>,
+  ) => StringSerializedType;
 };
 export type SumType<T> = {
-    kind: "sum";
-    args: Array<DispatchParsedType<T>>;
-    asString: () => StringSerializedType;
+  kind: "sum";
+  args: Array<DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
 };
 export declare const SumType: {
-    SerializeToString: (serializedArgs: Array<StringSerializedType>) => StringSerializedType;
+  SerializeToString: (
+    serializedArgs: Array<StringSerializedType>,
+  ) => StringSerializedType;
+};
+export type SumNType<T> = {
+  kind: "sumN";
+  args: Array<DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
+};
+export declare const SumNType: {
+  SerializeToString: (
+    serializedArgs: Array<StringSerializedType>,
+    arity: number,
+  ) => StringSerializedType;
 };
 export type MapType<T> = {
-    kind: "map";
-    args: Array<DispatchParsedType<T>>;
-    asString: () => StringSerializedType;
+  kind: "map";
+  args: Array<DispatchParsedType<T>>;
+  asString: () => StringSerializedType;
 };
 export declare const MapType: {
-    SerializeToString: (serializedArgs: Array<StringSerializedType>) => StringSerializedType;
+  SerializeToString: (
+    serializedArgs: Array<StringSerializedType>,
+  ) => StringSerializedType;
 };
 export type TableType<T> = {
-    kind: "table";
-    arg: LookupType;
-    asString: () => StringSerializedType;
+  kind: "table";
+  arg: LookupType;
+  asString: () => StringSerializedType;
 };
 export declare const TableType: {
-    SerializeToString: (serializedArg: StringSerializedType) => StringSerializedType;
+  SerializeToString: (
+    serializedArg: StringSerializedType,
+  ) => StringSerializedType;
 };
 export type ReadOnlyType<T> = {
-    kind: "readOnly";
-    arg: DispatchParsedType<T>;
-    asString: () => StringSerializedType;
+  kind: "readOnly";
+  arg: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
 };
 export declare const ReadOnlyType: {
-    SerializeToString: (serializedArg: StringSerializedType) => StringSerializedType;
+  SerializeToString: (
+    serializedArg: StringSerializedType,
+  ) => StringSerializedType;
 };
 export type OneType<T> = {
-    kind: "one";
-    arg: LookupType;
-    asString: () => StringSerializedType;
+  kind: "one";
+  arg: LookupType;
+  asString: () => StringSerializedType;
 };
 export declare const OneType: {
-    SerializeToString: (serializedArg: StringSerializedType) => StringSerializedType;
-};
-export type DispatchParsedType<T> = RecordType<T> | LookupType | DispatchPrimitiveType<T> | UnionType<T> | SingleSelectionType<T> | MultiSelectionType<T> | ListType<T> | TupleType<T> | SumType<T> | MapType<T> | TableType<T> | OneType<T> | ReadOnlyType<T>;
+  SerializeToString: (
+    serializedArg: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterContainsType<T> = {
+  kind: "contains";
+  contains: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
+};
+export declare const FilterContainsType: {
+  SerializeToString: (
+    serializedContains: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterEqualsToType<T> = {
+  kind: "=";
+  equalsTo: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
+};
+export declare const FilterEqualsToType: {
+  SerializeToString: (
+    serializedEqualsTo: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterNotEqualsToType<T> = {
+  kind: "!=";
+  notEqualsTo: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
+};
+export declare const FilterNotEqualsToType: {
+  SerializeToString: (
+    serializedNotEqualsTo: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterGreaterThanOrEqualsToType<T> = {
+  kind: ">=";
+  greaterThanOrEqualsTo: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
+};
+export declare const FilterGreaterThanOrEqualsToType: {
+  SerializeToString: (
+    serializedGreaterThanOrEqualsTo: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterGreaterThanType<T> = {
+  kind: ">";
+  greaterThan: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
+};
+export declare const FilterGreaterThanType: {
+  SerializeToString: (
+    serializedGreaterThan: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterIsNotNullType<T> = {
+  kind: "!=null";
+  asString: () => StringSerializedType;
+};
+export declare const FilterIsNotNullType: {
+  SerializeToString: () => StringSerializedType;
+};
+export type FilterIsNullType<T> = {
+  kind: "=null";
+  asString: () => StringSerializedType;
+};
+export declare const FilterIsNullType: {
+  SerializeToString: () => StringSerializedType;
+};
+export type FilterSmallerThanOrEqualsToType<T> = {
+  kind: "<=";
+  smallerThanOrEqualsTo: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
+};
+export declare const FilterSmallerThanOrEqualsToType: {
+  SerializeToString: (
+    serializedSmallerThanOrEqualsTo: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterSmallerThanType<T> = {
+  kind: "<";
+  smallerThan: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
+};
+export declare const FilterSmallerThanType: {
+  SerializeToString: (
+    serializedSmallerThan: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterStartsWithType<T> = {
+  kind: "startsWith";
+  startsWith: DispatchParsedType<T>;
+  asString: () => StringSerializedType;
+};
+export declare const FilterStartsWithType: {
+  SerializeToString: (
+    serializedStartsWith: StringSerializedType,
+  ) => StringSerializedType;
+};
+export type FilterType<T> =
+  | FilterContainsType<T>
+  | FilterEqualsToType<T>
+  | FilterNotEqualsToType<T>
+  | FilterGreaterThanOrEqualsToType<T>
+  | FilterGreaterThanType<T>
+  | FilterIsNotNullType<T>
+  | FilterIsNullType<T>
+  | FilterSmallerThanOrEqualsToType<T>
+  | FilterSmallerThanType<T>
+  | FilterStartsWithType<T>;
+export declare const FilterTypeKinds: readonly [
+  "contains",
+  "=",
+  "!=",
+  ">=",
+  ">",
+  "!=null",
+  "=null",
+  "<=",
+  "<",
+  "startsWith",
+];
+export type FilterTypeKind = (typeof FilterTypeKinds)[number];
+export type DispatchParsedType<T> =
+  | RecordType<T>
+  | LookupType
+  | DispatchPrimitiveType<T>
+  | UnionType<T>
+  | SingleSelectionType<T>
+  | MultiSelectionType<T>
+  | ListType<T>
+  | TupleType<T>
+  | SumType<T>
+  | SumNType<T>
+  | MapType<T>
+  | TableType<T>
+  | OneType<T>
+  | ReadOnlyType<T>
+  | FilterType<T>;
 export declare const DispatchParsedType: {
-    Default: {
-        table: <T>(arg: LookupType) => TableType<T>;
-        record: <T>(fields: Map<DispatchFieldName, DispatchParsedType<T>>) => RecordType<T>;
-        primitive: <T>(name: DispatchPrimitiveTypeName<T>) => DispatchParsedType<T>;
-        singleSelection: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
-        multiSelection: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
-        list: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
-        tuple: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
-        sum: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
-        map: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
-        union: <T>(args: Map<DispatchCaseName, DispatchParsedType<T>>) => DispatchParsedType<T>;
-        readOnly: <T>(arg: DispatchParsedType<T>) => ReadOnlyType<T>;
-        lookup: <T>(name: string) => LookupType;
-        one: <T>(arg: LookupType) => OneType<T>;
-    };
-    Operations: {
-        ParseRawKeyOf: <T>(rawType: ValidatedSerializedKeyOfType<T>, typeNames: Set<DispatchTypeName>, serializedTypes: Record<string, SerializedType<T>>, alreadyParsedTypes: Map<string, ValueOrErrors<DispatchParsedType<T>, string>>) => ValueOrErrors<[DispatchParsedType<T>, Map<DispatchTypeName, ValueOrErrors<DispatchParsedType<T>, string>>], string>;
-        SerializeToString: <T>(type: DispatchParsedType<T>) => StringSerializedType;
-        ParseRecord: <T>(typeName: DispatchTypeName, rawType: unknown, typeNames: Set<DispatchTypeName>, serializedTypes: Record<string, SerializedType<T>>, alreadyParsedTypes: Map<DispatchTypeName, ValueOrErrors<DispatchParsedType<T>, string>>, injectedPrimitives?: DispatchInjectedPrimitives<T>) => ValueOrErrors<[RecordType<T>, Map<DispatchTypeName, ValueOrErrors<DispatchParsedType<T>, string>>], string>;
-        ParseRawType: <T>(typeName: DispatchTypeName, rawType: SerializedType<T>, typeNames: Set<DispatchTypeName>, serializedTypes: Record<string, SerializedType<T>>, alreadyParsedTypes: Map<DispatchTypeName, ValueOrErrors<DispatchParsedType<T>, string>>, injectedPrimitives?: DispatchInjectedPrimitives<T>) => ValueOrErrors<[DispatchParsedType<T>, Map<DispatchTypeName, ValueOrErrors<DispatchParsedType<T>, string>>], string>;
-        ResolveLookupType: <T>(typeName: string, types: Map<DispatchTypeName, DispatchParsedType<T>>) => ValueOrErrors<DispatchParsedType<T>, string>;
-        AsResolvedType: <T>(type: DispatchParsedType<T>, types: Map<DispatchTypeName, DispatchParsedType<T>>) => ValueOrErrors<DispatchParsedType<T>, string>;
-    };
-};
-//# sourceMappingURL=state.d.ts.map
+  Default: {
+    table: <T>(arg: LookupType) => TableType<T>;
+    record: <T>(
+      fields: Map<DispatchFieldName, DispatchParsedType<T>>,
+    ) => RecordType<T>;
+    primitive: <T>(name: DispatchPrimitiveTypeName<T>) => DispatchParsedType<T>;
+    singleSelection: <T>(
+      args: Array<DispatchParsedType<T>>,
+    ) => DispatchParsedType<T>;
+    multiSelection: <T>(
+      args: Array<DispatchParsedType<T>>,
+    ) => DispatchParsedType<T>;
+    list: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
+    tuple: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
+    sum: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
+    sumN: <T>(args: Array<DispatchParsedType<T>>) => SumNType<T>;
+    map: <T>(args: Array<DispatchParsedType<T>>) => DispatchParsedType<T>;
+    union: <T>(
+      args: Map<DispatchCaseName, DispatchParsedType<T>>,
+    ) => DispatchParsedType<T>;
+    readOnly: <T>(arg: DispatchParsedType<T>) => ReadOnlyType<T>;
+    lookup: <T>(name: string) => LookupType;
+    one: <T>(arg: LookupType) => OneType<T>;
+    filterContains: <T>(
+      contains: DispatchParsedType<T>,
+    ) => FilterContainsType<T>;
+    filterEqualsTo: <T>(
+      equalsTo: DispatchParsedType<T>,
+    ) => FilterEqualsToType<T>;
+    filterNotEqualsTo: <T>(
+      notEqualsTo: DispatchParsedType<T>,
+    ) => FilterNotEqualsToType<T>;
+    filterGreaterThanOrEqualsTo: <T>(
+      greaterThanOrEqualsTo: DispatchParsedType<T>,
+    ) => FilterGreaterThanOrEqualsToType<T>;
+    filterGreaterThan: <T>(
+      greaterThan: DispatchParsedType<T>,
+    ) => FilterGreaterThanType<T>;
+    filterIsNotNull: <T>() => FilterIsNotNullType<T>;
+    filterIsNull: <T>() => FilterIsNullType<T>;
+    filterSmallerThanOrEqualsTo: <T>(
+      smallerThanOrEqualsTo: DispatchParsedType<T>,
+    ) => FilterSmallerThanOrEqualsToType<T>;
+    filterSmallerThan: <T>(
+      smallerThan: DispatchParsedType<T>,
+    ) => FilterSmallerThanType<T>;
+    filterStartsWith: <T>(
+      startsWith: DispatchParsedType<T>,
+    ) => FilterStartsWithType<T>;
+  };
+  Operations: {
+    ParseRawKeyOf: <T>(
+      rawType: ValidatedSerializedKeyOfType<T>,
+      typeNames: Set<DispatchTypeName>,
+      serializedTypes: Record<string, SerializedType<T>>,
+      alreadyParsedTypes: Map<
+        string,
+        ValueOrErrors<DispatchParsedType<T>, string>
+      >,
+    ) => ValueOrErrors<
+      [
+        DispatchParsedType<T>,
+        Map<DispatchTypeName, ValueOrErrors<DispatchParsedType<T>, string>>,
+      ],
+      string
+    >;
+    SerializeToString: <T>(type: DispatchParsedType<T>) => StringSerializedType;
+    ParseRecord: <T>(
+      typeName: DispatchTypeName,
+      rawType: unknown,
+      typeNames: Set<DispatchTypeName>,
+      serializedTypes: Record<string, SerializedType<T>>,
+      alreadyParsedTypes: Map<
+        DispatchTypeName,
+        ValueOrErrors<DispatchParsedType<T>, string>
+      >,
+      injectedPrimitives?: DispatchInjectedPrimitives<T>,
+    ) => ValueOrErrors<
+      [
+        RecordType<T>,
+        Map<DispatchTypeName, ValueOrErrors<DispatchParsedType<T>, string>>,
+      ],
+      string
+    >;
+    ParseRawFilterType: <T>(
+      rawFilterType: unknown,
+      arg: DispatchParsedType<T>,
+    ) => ValueOrErrors<FilterType<T>, string>;
+    ParseRawType: <T>(
+      typeName: DispatchTypeName,
+      rawType: SerializedType<T>,
+      typeNames: Set<DispatchTypeName>,
+      serializedTypes: Record<string, SerializedType<T>>,
+      alreadyParsedTypes: Map<
+        DispatchTypeName,
+        ValueOrErrors<DispatchParsedType<T>, string>
+      >,
+      injectedPrimitives?: DispatchInjectedPrimitives<T>,
+    ) => ValueOrErrors<
+      [
+        DispatchParsedType<T>,
+        Map<DispatchTypeName, ValueOrErrors<DispatchParsedType<T>, string>>,
+      ],
+      string
+    >;
+    ResolveLookupType: <T>(
+      typeName: string,
+      types: Map<DispatchTypeName, DispatchParsedType<T>>,
+    ) => ValueOrErrors<DispatchParsedType<T>, string>;
+    AsResolvedType: <T>(
+      type: DispatchParsedType<T>,
+      types: Map<DispatchTypeName, DispatchParsedType<T>>,
+    ) => ValueOrErrors<DispatchParsedType<T>, string>;
+  };
+};
+//# sourceMappingURL=state.d.ts.map