ballerina-core 1.0.200 → 1.0.201

package/bin/src/forms/domains/parser/domains/predicates/state.d.ts

@@ -1,320 +1,611 @@
 import { Map, Set, List, OrderedMap } from "immutable";
-import { ValueOrErrors, FieldName, ParsedType, Updater, Sum, BasicUpdater, Guid } from "../../../../../../main";
+import {
+  ValueOrErrors,
+  FieldName,
+  ParsedType,
+  Updater,
+  Sum,
+  BasicUpdater,
+  Guid,
+} from "../../../../../../main";
 export type TuplePredicateExpression = {
-    kind: "tuple";
-    value: Expr;
-    elementExpressions: FieldPredicateExpression[];
-};
-export type FieldPredicateExpression = {
-    kind: "unit";
-    value: Expr;
-} | {
-    kind: "primitive";
-    value: Expr;
-} | {
-    kind: "record";
-    value: Expr;
-    fields: FieldPredicateExpressions;
-} | {
-    kind: "list";
-    value: Expr;
-    elementExpression: FieldPredicateExpression;
-} | {
-    kind: "map";
-    value: Expr;
-    keyExpression: FieldPredicateExpression;
-    valueExpression: FieldPredicateExpression;
-} | TuplePredicateExpression | {
-    kind: "sum";
-    value: Expr;
-    leftExpression: FieldPredicateExpression;
-    rightExpression: FieldPredicateExpression;
-};
-export declare const FieldPredicateExpression: {
-    Default: {
-        unit: (value: Expr) => FieldPredicateExpression;
-        primitive: (value: Expr) => FieldPredicateExpression;
-        record: (value: Expr, fields: FieldPredicateExpressions) => FieldPredicateExpression;
-        list: (value: Expr, elementExpression: FieldPredicateExpression) => FieldPredicateExpression;
-        map: (value: Expr, keyExpression: FieldPredicateExpression, valueExpression: FieldPredicateExpression) => FieldPredicateExpression;
-        tuple: (value: Expr, elementExpressions: FieldPredicateExpression[]) => FieldPredicateExpression;
-        sum: (value: Expr, leftExpression?: FieldPredicateExpression, rightExpression?: FieldPredicateExpression) => FieldPredicateExpression;
+  kind: "tuple";
+  value: Expr;
+  elementExpressions: FieldPredicateExpression[];
+};
+export type FieldPredicateExpression =
+  | {
+      kind: "unit";
+      value: Expr;
+    }
+  | {
+      kind: "primitive";
+      value: Expr;
+    }
+  | {
+      kind: "record";
+      value: Expr;
+      fields: FieldPredicateExpressions;
+    }
+  | {
+      kind: "list";
+      value: Expr;
+      elementExpression: FieldPredicateExpression;
+    }
+  | {
+      kind: "map";
+      value: Expr;
+      keyExpression: FieldPredicateExpression;
+      valueExpression: FieldPredicateExpression;
+    }
+  | TuplePredicateExpression
+  | {
+      kind: "sum";
+      value: Expr;
+      leftExpression: FieldPredicateExpression;
+      rightExpression: FieldPredicateExpression;
     };
-};
-export type FieldPredicateExpressions = Map<FieldName, FieldPredicateExpression>;
+export declare const FieldPredicateExpression: {
+  Default: {
+    unit: (value: Expr) => FieldPredicateExpression;
+    primitive: (value: Expr) => FieldPredicateExpression;
+    record: (
+      value: Expr,
+      fields: FieldPredicateExpressions,
+    ) => FieldPredicateExpression;
+    list: (
+      value: Expr,
+      elementExpression: FieldPredicateExpression,
+    ) => FieldPredicateExpression;
+    map: (
+      value: Expr,
+      keyExpression: FieldPredicateExpression,
+      valueExpression: FieldPredicateExpression,
+    ) => FieldPredicateExpression;
+    tuple: (
+      value: Expr,
+      elementExpressions: FieldPredicateExpression[],
+    ) => FieldPredicateExpression;
+    sum: (
+      value: Expr,
+      leftExpression?: FieldPredicateExpression,
+      rightExpression?: FieldPredicateExpression,
+    ) => FieldPredicateExpression;
+  };
+};
+export type FieldPredicateExpressions = Map<
+  FieldName,
+  FieldPredicateExpression
+>;
 export type TupleFieldPredicateEvaluation = {
-    kind: "tuple";
-    value: boolean;
-    elementValues: FormFieldPredicateEvaluation[];
+  kind: "tuple";
+  value: boolean;
+  elementValues: FormFieldPredicateEvaluation[];
 };
 export type ListFieldPredicateEvaluation = {
-    kind: "list";
-    value: boolean;
-    elementValues: FormFieldPredicateEvaluation[];
+  kind: "list";
+  value: boolean;
+  elementValues: FormFieldPredicateEvaluation[];
 };
 export type MapFieldPredicateEvaluation = {
-    kind: "map";
-    value: boolean;
-    elementValues: {
-        key: FormFieldPredicateEvaluation;
-        value: FormFieldPredicateEvaluation;
-    }[];
+  kind: "map";
+  value: boolean;
+  elementValues: {
+    key: FormFieldPredicateEvaluation;
+    value: FormFieldPredicateEvaluation;
+  }[];
 };
 export type SumFieldPredicateEvaluation = {
-    kind: "sum";
-    value: boolean;
-    innerValue: FormFieldPredicateEvaluation;
+  kind: "sum";
+  value: boolean;
+  innerValue: FormFieldPredicateEvaluation;
 };
 export type FormsFieldPredicateEvaluation = {
-    kind: "form";
-    value: boolean;
-    fields: FormFieldPredicateEvaluations;
-};
-export type FormFieldPredicateEvaluation = {
-    kind: "primitive";
-    value: boolean;
-} | {
-    kind: "unit";
-    value: boolean;
-} | FormsFieldPredicateEvaluation | ListFieldPredicateEvaluation | MapFieldPredicateEvaluation | TupleFieldPredicateEvaluation | SumFieldPredicateEvaluation;
+  kind: "form";
+  value: boolean;
+  fields: FormFieldPredicateEvaluations;
+};
+export type FormFieldPredicateEvaluation =
+  | {
+      kind: "primitive";
+      value: boolean;
+    }
+  | {
+      kind: "unit";
+      value: boolean;
+    }
+  | FormsFieldPredicateEvaluation
+  | ListFieldPredicateEvaluation
+  | MapFieldPredicateEvaluation
+  | TupleFieldPredicateEvaluation
+  | SumFieldPredicateEvaluation;
 export declare const FormFieldPredicateEvaluation: {
-    Default: {
-        unit: (value: boolean) => FormFieldPredicateEvaluation;
-        primitive: (value: boolean) => FormFieldPredicateEvaluation;
-        form: (value: boolean, fields: FormFieldPredicateEvaluations) => FormFieldPredicateEvaluation;
-        list: (value: boolean, elementValues: FormFieldPredicateEvaluation[]) => FormFieldPredicateEvaluation;
-        map: (value: boolean, elementValues: {
-            key: FormFieldPredicateEvaluation;
-            value: FormFieldPredicateEvaluation;
-        }[]) => FormFieldPredicateEvaluation;
-        tuple: (value: boolean, elementValues: FormFieldPredicateEvaluation[]) => FormFieldPredicateEvaluation;
-        sum: (value: boolean, innerValue: FormFieldPredicateEvaluation) => FormFieldPredicateEvaluation;
-    };
-};
-export type FormFieldPredicateEvaluations = Map<FieldName, FormFieldPredicateEvaluation>;
+  Default: {
+    unit: (value: boolean) => FormFieldPredicateEvaluation;
+    primitive: (value: boolean) => FormFieldPredicateEvaluation;
+    form: (
+      value: boolean,
+      fields: FormFieldPredicateEvaluations,
+    ) => FormFieldPredicateEvaluation;
+    list: (
+      value: boolean,
+      elementValues: FormFieldPredicateEvaluation[],
+    ) => FormFieldPredicateEvaluation;
+    map: (
+      value: boolean,
+      elementValues: {
+        key: FormFieldPredicateEvaluation;
+        value: FormFieldPredicateEvaluation;
+      }[],
+    ) => FormFieldPredicateEvaluation;
+    tuple: (
+      value: boolean,
+      elementValues: FormFieldPredicateEvaluation[],
+    ) => FormFieldPredicateEvaluation;
+    sum: (
+      value: boolean,
+      innerValue: FormFieldPredicateEvaluation,
+    ) => FormFieldPredicateEvaluation;
+  };
+};
+export type FormFieldPredicateEvaluations = Map<
+  FieldName,
+  FormFieldPredicateEvaluation
+>;
 export type EvaluationPredicateValue = {
-    kind: "expression";
+  kind: "expression";
 };
 export type ValueRecord = {
-    kind: "record";
-    fields: OrderedMap<string, PredicateValue>;
+  kind: "record";
+  fields: OrderedMap<string, PredicateValue>;
 };
 export declare const ValueRecord: {
-    Default: {
-        empty: () => ValueRecord;
-        fromJSON: (json: object) => ValueRecord;
-        fromMap: (map: OrderedMap<string, PredicateValue>) => ValueRecord;
-    };
-    Operations: {
-        has: (record: ValueRecord, key: string) => boolean;
-    };
-    Updaters: {
-        update: (key: string, updater: BasicUpdater<PredicateValue>) => Updater<ValueRecord>;
-        set: (key: string, value: PredicateValue) => Updater<ValueRecord>;
-        remove: (key: string) => BasicUpdater<ValueRecord>;
-        clear: () => BasicUpdater<ValueRecord>;
-        fields: import("../../../../../../main").Widening<ValueRecord, "fields">;
-    };
+  Default: {
+    empty: () => ValueRecord;
+    fromJSON: (json: object) => ValueRecord;
+    fromMap: (map: OrderedMap<string, PredicateValue>) => ValueRecord;
+  };
+  Operations: {
+    has: (record: ValueRecord, key: string) => boolean;
+  };
+  Updaters: {
+    update: (
+      key: string,
+      updater: BasicUpdater<PredicateValue>,
+    ) => Updater<ValueRecord>;
+    set: (key: string, value: PredicateValue) => Updater<ValueRecord>;
+    remove: (key: string) => BasicUpdater<ValueRecord>;
+    clear: () => BasicUpdater<ValueRecord>;
+    fields: import("../../../../../../main").Widening<ValueRecord, "fields">;
+  };
 };
 export type ValueCustom = {
-    kind: "custom";
-    value: any;
+  kind: "custom";
+  value: any;
 };
 export type ValueUnionCase = {
-    kind: "unionCase";
-    caseName: string;
-    fields: PredicateValue;
+  kind: "unionCase";
+  caseName: string;
+  fields: PredicateValue;
 };
 export declare const ValueUnionCase: {
-    Default: (caseName: string, fields: PredicateValue) => ValueUnionCase;
-    Updaters: {
-        fields: import("../../../../../../main").Widening<ValueUnionCase, "fields">;
-        case: (caseName: string) => (upd: BasicUpdater<PredicateValue>) => Updater<ValueUnionCase>;
-    };
+  Default: (caseName: string, fields: PredicateValue) => ValueUnionCase;
+  Updaters: {
+    fields: import("../../../../../../main").Widening<ValueUnionCase, "fields">;
+    case: (
+      caseName: string,
+    ) => (upd: BasicUpdater<PredicateValue>) => Updater<ValueUnionCase>;
+  };
 };
 export type ValuePrimitive = number | string | boolean | Date;
 export type ValueUnit = {
-    kind: "unit";
+  kind: "unit";
 };
 export declare const ValueUnit: {
-    Default: () => ValueUnit;
+  Default: () => ValueUnit;
 };
 export type ValueTuple = {
-    kind: "tuple";
-    values: List<PredicateValue>;
+  kind: "tuple";
+  values: List<PredicateValue>;
 };
 export type ValueOption = {
-    kind: "option";
-    isSome: boolean;
-    value: PredicateValue;
+  kind: "option";
+  isSome: boolean;
+  value: PredicateValue;
 };
 export declare const ValueOption: {
-    Default: {
-        some: (value: PredicateValue) => ValueOption;
-        none: () => ValueOption;
-    };
-    Updaters: {
-        value: (_: BasicUpdater<ValueOption>) => Updater<ValueOption>;
-    };
+  Default: {
+    some: (value: PredicateValue) => ValueOption;
+    none: () => ValueOption;
+  };
+  Updaters: {
+    value: (_: BasicUpdater<ValueOption>) => Updater<ValueOption>;
+  };
 };
 export type ValueVarLookup = {
-    kind: "varLookup";
-    varName: string;
+  kind: "varLookup";
+  varName: string;
 };
 export type ValueSum = {
-    kind: "sum";
-    value: Sum<PredicateValue, PredicateValue>;
+  kind: "sum";
+  value: Sum<PredicateValue, PredicateValue>;
 };
 export declare const ValueSum: {
-    Default: (value: Sum<PredicateValue, PredicateValue>) => ValueSum;
-    Updaters: {
-        value: import("../../../../../../main").Widening<ValueSum, "value">;
-    };
+  Default: (value: Sum<PredicateValue, PredicateValue>) => ValueSum;
+  Updaters: {
+    value: import("../../../../../../main").Widening<ValueSum, "value">;
+  };
+};
+export type ValueSumN = {
+  kind: "sumN";
+  caseIndex: number;
+  arity: number;
+  value: PredicateValue;
+};
+export declare const ValueSumN: {
+  Default: (
+    caseIndex: number,
+    arity: number,
+    value: PredicateValue,
+  ) => ValueSumN;
+  Updaters: {
+    value: import("../../../../../../main").Widening<ValueSumN, "value">;
+    case: (
+      caseIndex: number,
+    ) => (upd: BasicUpdater<PredicateValue>) => Updater<ValueSumN>;
+  };
 };
 export declare const ValueTuple: {
-    Default: () => ValueTuple;
-    Updaters: {
-        values: import("../../../../../../main").Widening<ValueTuple, "values">;
-    };
+  Default: () => ValueTuple;
+  Updaters: {
+    values: import("../../../../../../main").Widening<ValueTuple, "values">;
+  };
 };
 export type ValueTable = {
-    kind: "table";
-    from: number;
-    to: number;
-    data: OrderedMap<Guid, ValueRecord>;
-    hasMoreValues: boolean;
+  kind: "table";
+  from: number;
+  to: number;
+  data: OrderedMap<Guid, ValueRecord>;
+  hasMoreValues: boolean;
 };
 export type ValueReadOnly = {
-    kind: "readOnly";
-    ReadOnly: PredicateValue;
+  kind: "readOnly";
+  ReadOnly: PredicateValue;
 };
 export declare const ValueTable: {
-    Default: {
-        empty: () => ValueTable;
-        fromParsed: (from: number, to: number, hasMoreValues: boolean, data: OrderedMap<Guid, ValueRecord>) => ValueTable;
-    };
-    Updaters: {
-        data: import("../../../../../../main").Widening<ValueTable, "data">;
-    };
-};
-export type PredicateValue = ValuePrimitive | ValueUnit | ValueTuple | ValueRecord | ValueUnionCase | ValueOption | ValueVarLookup | ValueSum | ValueCustom | ValueTable | ValueReadOnly;
+  Default: {
+    empty: () => ValueTable;
+    fromParsed: (
+      from: number,
+      to: number,
+      hasMoreValues: boolean,
+      data: OrderedMap<Guid, ValueRecord>,
+    ) => ValueTable;
+  };
+  Updaters: {
+    data: import("../../../../../../main").Widening<ValueTable, "data">;
+  };
+};
+export type ValueFilterContains = {
+  kind: "contains";
+  contains: PredicateValue;
+};
+export declare const ValueFilterContains: {
+  Default: (contains: PredicateValue) => ValueFilterContains;
+};
+export type ValueFilterEqualsTo = {
+  kind: "=";
+  equalsTo: PredicateValue;
+};
+export declare const ValueFilterEqualsTo: {
+  Default: (equalsTo: PredicateValue) => ValueFilterEqualsTo;
+};
+export type ValueFilterNotEqualsTo = {
+  kind: "!=";
+  notEqualsTo: PredicateValue;
+};
+export declare const ValueFilterNotEqualsTo: {
+  Default: (notEqualsTo: PredicateValue) => ValueFilterNotEqualsTo;
+};
+export type ValueFilterGreaterThanOrEqualsTo = {
+  kind: ">=";
+  greaterThanOrEqualsTo: PredicateValue;
+};
+export declare const ValueFilterGreaterThanOrEqualsTo: {
+  Default: (
+    greaterThanOrEqualsTo: PredicateValue,
+  ) => ValueFilterGreaterThanOrEqualsTo;
+};
+export type ValueFilterGreaterThan = {
+  kind: ">";
+  greaterThan: PredicateValue;
+};
+export declare const ValueFilterGreaterThan: {
+  Default: (greaterThan: PredicateValue) => ValueFilterGreaterThan;
+};
+export type ValueFilterIsNotNull = {
+  kind: "!=null";
+};
+export declare const ValueFilterIsNotNull: {
+  Default: () => ValueFilterIsNotNull;
+};
+export type ValueFilterIsNull = {
+  kind: "=null";
+};
+export declare const ValueFilterIsNull: {
+  Default: () => ValueFilterIsNull;
+};
+export type ValueFilterSmallerThanOrEqualsTo = {
+  kind: "<=";
+  smallerThanOrEqualsTo: PredicateValue;
+};
+export declare const ValueFilterSmallerThanOrEqualsTo: {
+  Default: (
+    smallerThanOrEqualsTo: PredicateValue,
+  ) => ValueFilterSmallerThanOrEqualsTo;
+};
+export type ValueFilterSmallerThan = {
+  kind: "<";
+  smallerThan: PredicateValue;
+};
+export declare const ValueFilterSmallerThan: {
+  Default: (smallerThan: PredicateValue) => ValueFilterSmallerThan;
+};
+export type ValueFilterStartsWith = {
+  kind: "startsWith";
+  startsWith: PredicateValue;
+};
+export declare const ValueFilterStartsWith: {
+  Default: (startsWith: PredicateValue) => ValueFilterStartsWith;
+};
+export type ValueFilter =
+  | ValueFilterContains
+  | ValueFilterEqualsTo
+  | ValueFilterNotEqualsTo
+  | ValueFilterGreaterThanOrEqualsTo
+  | ValueFilterGreaterThan
+  | ValueFilterIsNotNull
+  | ValueFilterIsNull
+  | ValueFilterSmallerThanOrEqualsTo
+  | ValueFilterSmallerThan
+  | ValueFilterStartsWith;
+export type PredicateValue =
+  | ValuePrimitive
+  | ValueUnit
+  | ValueTuple
+  | ValueRecord
+  | ValueUnionCase
+  | ValueOption
+  | ValueVarLookup
+  | ValueSum
+  | ValueSumN
+  | ValueCustom
+  | ValueTable
+  | ValueReadOnly
+  | ValueFilter;
 export type ExprLambda = {
-    kind: "lambda";
-    parameter: string;
-    body: Expr;
+  kind: "lambda";
+  parameter: string;
+  body: Expr;
 };
 export type ExprMatchCase = {
-    kind: "matchCase";
-    operands: Expr[];
+  kind: "matchCase";
+  operands: Expr[];
 };
 export type ExprCase = {
-    kind: "caseName";
-    caseName: string;
-    handler: ExprLambda;
+  kind: "caseName";
+  caseName: string;
+  handler: ExprLambda;
 };
 export type ExprItemLookup = {
-    kind: "itemLookup";
-    operands: [Expr, number];
+  kind: "itemLookup";
+  operands: [Expr, number];
 };
 export type ExprFieldLookup = {
-    kind: "fieldLookup";
-    operands: [Expr, string];
+  kind: "fieldLookup";
+  operands: [Expr, string];
 };
 export type ExprIsCase = {
-    kind: "isCase";
-    operands: [Expr, string];
+  kind: "isCase";
+  operands: [Expr, string];
 };
 export type ExprBinaryOperator = {
-    kind: BinaryOperator;
-    operands: [Expr, Expr];
-};
-export type Expr = PredicateValue | ExprItemLookup | ExprFieldLookup | ExprIsCase | ExprBinaryOperator | ExprLambda | ExprMatchCase | ExprCase;
+  kind: BinaryOperator;
+  operands: [Expr, Expr];
+};
+export type Expr =
+  | PredicateValue
+  | ExprItemLookup
+  | ExprFieldLookup
+  | ExprIsCase
+  | ExprBinaryOperator
+  | ExprLambda
+  | ExprMatchCase
+  | ExprCase;
 export declare const BinaryOperators: readonly ["or", "equals"];
 export declare const BinaryOperatorsSet: Set<"or" | "equals">;
 export type BinaryOperator = (typeof BinaryOperators)[number];
 export type Bindings = Map<string, PredicateValue>;
 export declare const PredicateValue: {
-    Default: {
-        string: () => string;
-        number: () => number;
-        boolean: () => boolean;
-        date: () => Date;
-        unit: () => ValueUnit;
-        tuple: (values: List<PredicateValue>) => ValueTuple;
-        record: (fields: OrderedMap<string, PredicateValue>) => ValueRecord;
-        unionCase: (caseName: string, fields: PredicateValue) => ValueUnionCase;
-        option: (isSome: boolean, value: PredicateValue) => ValueOption;
-        varLookup: (varName: string) => ValueVarLookup;
-        sum: (value: Sum<PredicateValue, PredicateValue>) => ValueSum;
-        table: (from: number, to: number, data: OrderedMap<Guid, ValueRecord>, hasMoreValues: boolean) => ValueTable;
-        readonly: (value: PredicateValue) => ValueReadOnly;
-    };
-    Operations: {
-        GetKind: (value: PredicateValue) => ValueOrErrors<string, string>;
-        IsPrimitive: (value: PredicateValue | Expr) => value is boolean | number | string | Date;
-        IsBoolean: (value: PredicateValue | Expr) => value is boolean;
-        IsNumber: (value: PredicateValue | Expr) => value is number;
-        IsString: (value: PredicateValue | Expr) => value is string;
-        IsDate: (value: PredicateValue | Expr) => value is Date;
-        IsUnit: (value: PredicateValue | Expr) => value is ValueUnit;
-        IsUnionCase: (value: PredicateValue | Expr) => value is ValueUnionCase;
-        IsRecord: (value: PredicateValue | Expr) => value is ValueRecord;
-        IsTuple: (value: PredicateValue | Expr) => value is ValueTuple;
-        IsOption: (value: PredicateValue | Expr) => value is ValueOption;
-        IsTable: (value: PredicateValue | Expr) => value is ValueTable;
-        IsSum: (value: PredicateValue | Expr) => value is ValueSum;
-        IsVarLookup: (value: PredicateValue | Expr) => value is ValueVarLookup;
-        IsCustom: (value: PredicateValue | Expr) => value is ValueCustom;
-        IsReadOnly: (value: PredicateValue | Expr) => value is ValueReadOnly;
-        ParseAsDate: (json: any) => ValueOrErrors<PredicateValue, string>;
-        ParseAsVarLookup: (json: any) => ValueOrErrors<PredicateValue, string>;
-        ParseAsUnionCase: (json: any) => ValueOrErrors<PredicateValue, string>;
-        ParseAsRecord: (json: any, types: Map<string, ParsedType<any>>) => ValueOrErrors<PredicateValue, string>;
-        ParseAsTuple: (json: any, types: Map<string, ParsedType<any>>) => ValueOrErrors<PredicateValue, string>;
-        parse: <T>(json: any, type: ParsedType<T> | EvaluationPredicateValue, types: Map<string, ParsedType<T>>) => ValueOrErrors<PredicateValue, string>;
-        recordToTuple: (r: ValueRecord) => ValueTuple;
-        Equals: (vars: Bindings) => (v1: PredicateValue, v2: PredicateValue) => ValueOrErrors<boolean, string>;
-    };
+  Default: {
+    string: () => string;
+    number: () => number;
+    boolean: () => boolean;
+    date: () => Date;
+    unit: () => ValueUnit;
+    tuple: (values: List<PredicateValue>) => ValueTuple;
+    record: (fields: OrderedMap<string, PredicateValue>) => ValueRecord;
+    unionCase: (caseName: string, fields: PredicateValue) => ValueUnionCase;
+    option: (isSome: boolean, value: PredicateValue) => ValueOption;
+    varLookup: (varName: string) => ValueVarLookup;
+    sum: (value: Sum<PredicateValue, PredicateValue>) => ValueSum;
+    sumN: (
+      caseIndex: number,
+      arity: number,
+      value: PredicateValue,
+    ) => ValueSumN;
+    table: (
+      from: number,
+      to: number,
+      data: OrderedMap<Guid, ValueRecord>,
+      hasMoreValues: boolean,
+    ) => ValueTable;
+    readonly: (value: PredicateValue) => ValueReadOnly;
+    filterContains: (contains: PredicateValue) => ValueFilterContains;
+    filterEqualsTo: (equalsTo: PredicateValue) => ValueFilterEqualsTo;
+    filterNotEqualsTo: (notEqualsTo: PredicateValue) => ValueFilterNotEqualsTo;
+    filterGreaterThanOrEqualsTo: (
+      greaterThanOrEqualsTo: PredicateValue,
+    ) => ValueFilterGreaterThanOrEqualsTo;
+    filterGreaterThan: (greaterThan: PredicateValue) => ValueFilterGreaterThan;
+    filterIsNotNull: () => ValueFilterIsNotNull;
+    filterIsNull: () => ValueFilterIsNull;
+    filterSmallerThanOrEqualsTo: (
+      smallerThanOrEqualsTo: PredicateValue,
+    ) => ValueFilterSmallerThanOrEqualsTo;
+    filterSmallerThan: (smallerThan: PredicateValue) => ValueFilterSmallerThan;
+    filterStartsWith: (startsWith: PredicateValue) => ValueFilterStartsWith;
+  };
+  Operations: {
+    GetKind: (value: PredicateValue) => ValueOrErrors<string, string>;
+    IsPrimitive: (
+      value: PredicateValue | Expr,
+    ) => value is boolean | number | string | Date;
+    IsBoolean: (value: PredicateValue | Expr) => value is boolean;
+    IsNumber: (value: PredicateValue | Expr) => value is number;
+    IsString: (value: PredicateValue | Expr) => value is string;
+    IsDate: (value: PredicateValue | Expr) => value is Date;
+    IsUnit: (value: PredicateValue | Expr) => value is ValueUnit;
+    IsUnionCase: (value: PredicateValue | Expr) => value is ValueUnionCase;
+    IsRecord: (value: PredicateValue | Expr) => value is ValueRecord;
+    IsTuple: (value: PredicateValue | Expr) => value is ValueTuple;
+    IsOption: (value: PredicateValue | Expr) => value is ValueOption;
+    IsTable: (value: PredicateValue | Expr) => value is ValueTable;
+    IsSum: (value: PredicateValue | Expr) => value is ValueSum;
+    IsSumN: (value: PredicateValue | Expr) => value is ValueSumN;
+    IsVarLookup: (value: PredicateValue | Expr) => value is ValueVarLookup;
+    IsCustom: (value: PredicateValue | Expr) => value is ValueCustom;
+    IsReadOnly: (value: PredicateValue | Expr) => value is ValueReadOnly;
+    IsFilterContains: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterContains;
+    IsFilterEqualsTo: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterEqualsTo;
+    IsFilterNotEqualsTo: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterNotEqualsTo;
+    IsFilterGreaterThanOrEqualsTo: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterGreaterThanOrEqualsTo;
+    IsFilterGreaterThan: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterGreaterThan;
+    IsFilterIsNotNull: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterIsNotNull;
+    IsFilterIsNull: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterIsNull;
+    IsFilterSmallerThanOrEqualsTo: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterSmallerThanOrEqualsTo;
+    IsFilterSmallerThan: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterSmallerThan;
+    IsFilterStartsWith: (
+      value: PredicateValue | Expr,
+    ) => value is ValueFilterStartsWith;
+    KindAndValueToFilter: (kind: string, value: PredicateValue) => ValueFilter;
+    ParseAsDate: (json: any) => ValueOrErrors<PredicateValue, string>;
+    ParseAsVarLookup: (json: any) => ValueOrErrors<PredicateValue, string>;
+    ParseAsUnionCase: (json: any) => ValueOrErrors<PredicateValue, string>;
+    ParseAsRecord: (
+      json: any,
+      types: Map<string, ParsedType<any>>,
+    ) => ValueOrErrors<PredicateValue, string>;
+    ParseAsTuple: (
+      json: any,
+      types: Map<string, ParsedType<any>>,
+    ) => ValueOrErrors<PredicateValue, string>;
+    parse: <T>(
+      json: any,
+      type: ParsedType<T> | EvaluationPredicateValue,
+      types: Map<string, ParsedType<T>>,
+    ) => ValueOrErrors<PredicateValue, string>;
+    recordToTuple: (r: ValueRecord) => ValueTuple;
+    Equals: (
+      vars: Bindings,
+    ) => (
+      v1: PredicateValue,
+      v2: PredicateValue,
+    ) => ValueOrErrors<boolean, string>;
+  };
 };
 export declare const Expr: {
-    Default: {
-        itemLookup: (e: Expr, i: number) => Expr;
-        fieldLookup: (e: Expr, f: string) => Expr;
-        isCase: (e: Expr, c: string) => Expr;
-        binaryOperator: (op: BinaryOperator, e1: Expr, e2: Expr) => Expr;
-        matchCase: (operands: Expr[]) => ExprMatchCase;
-        lambda: (parameter: string, body: Expr) => Expr;
-        case: (caseName: string, handler: ExprLambda) => Expr;
-    };
-    Operations: {
-        IsItemLookup: (e: Expr) => e is ExprItemLookup;
-        IsFieldLookup: (e: Expr) => e is ExprFieldLookup;
-        IsIsCase: (e: Expr) => e is ExprIsCase;
-        IsBinaryOperator: (e: Expr) => e is ExprBinaryOperator;
-        IsCase: (e: Expr) => e is ExprCase;
-        IsCaseArray: (e: Expr[]) => e is ExprCase[];
-        AsCaseArray: (e: Expr[]) => ValueOrErrors<ExprCase[], string>;
-        IsMatchCase: (e: Expr) => e is ExprMatchCase;
-        IsLambda: (e: Expr) => e is ExprLambda;
-        parseAsVisibilityExpression: (json: any) => ValueOrErrors<Expr, string>;
-        parseAsDisabledExpression: (json: any) => ValueOrErrors<Expr, string>;
-        parse: (json: any) => ValueOrErrors<Expr, string>;
-        EvaluateAsTuple: (vars: Bindings) => (e: Expr) => ValueOrErrors<ValueTuple, string>;
-        EvaluateAsRecord: (vars: Bindings) => (e: Expr) => ValueOrErrors<ValueRecord, string>;
-        EvaluateAsUnionCase: (vars: Bindings) => (e: Expr) => ValueOrErrors<ValueUnionCase, string>;
-        EvaluateAsBoolean: (vars: Bindings) => (e: Expr) => ValueOrErrors<boolean, string>;
-        MatchCase: (vars: Bindings) => (e: Expr, cases: Map<string, ExprLambda>) => ValueOrErrors<PredicateValue, string>;
-        ComputePredicateEvaluation: (vars: Bindings) => (expr: Expr) => ValueOrErrors<boolean, string>;
-        EvaluateAs: (as: string) => (vars: Bindings) => (e: Expr) => ValueOrErrors<PredicateValue, string>;
-        Evaluate: (vars: Bindings) => (e: Expr) => ValueOrErrors<PredicateValue, string>;
-    };
-};
-export declare const evaluatePredicates: <T>(context: {
+  Default: {
+    itemLookup: (e: Expr, i: number) => Expr;
+    fieldLookup: (e: Expr, f: string) => Expr;
+    isCase: (e: Expr, c: string) => Expr;
+    binaryOperator: (op: BinaryOperator, e1: Expr, e2: Expr) => Expr;
+    matchCase: (operands: Expr[]) => ExprMatchCase;
+    lambda: (parameter: string, body: Expr) => Expr;
+    case: (caseName: string, handler: ExprLambda) => Expr;
+  };
+  Operations: {
+    IsItemLookup: (e: Expr) => e is ExprItemLookup;
+    IsFieldLookup: (e: Expr) => e is ExprFieldLookup;
+    IsIsCase: (e: Expr) => e is ExprIsCase;
+    IsBinaryOperator: (e: Expr) => e is ExprBinaryOperator;
+    IsCase: (e: Expr) => e is ExprCase;
+    IsCaseArray: (e: Expr[]) => e is ExprCase[];
+    AsCaseArray: (e: Expr[]) => ValueOrErrors<ExprCase[], string>;
+    IsMatchCase: (e: Expr) => e is ExprMatchCase;
+    IsLambda: (e: Expr) => e is ExprLambda;
+    parseAsVisibilityExpression: (json: any) => ValueOrErrors<Expr, string>;
+    parseAsDisabledExpression: (json: any) => ValueOrErrors<Expr, string>;
+    parse: (json: any) => ValueOrErrors<Expr, string>;
+    EvaluateAsTuple: (
+      vars: Bindings,
+    ) => (e: Expr) => ValueOrErrors<ValueTuple, string>;
+    EvaluateAsRecord: (
+      vars: Bindings,
+    ) => (e: Expr) => ValueOrErrors<ValueRecord, string>;
+    EvaluateAsUnionCase: (
+      vars: Bindings,
+    ) => (e: Expr) => ValueOrErrors<ValueUnionCase, string>;
+    EvaluateAsBoolean: (
+      vars: Bindings,
+    ) => (e: Expr) => ValueOrErrors<boolean, string>;
+    MatchCase: (
+      vars: Bindings,
+    ) => (
+      e: Expr,
+      cases: Map<string, ExprLambda>,
+    ) => ValueOrErrors<PredicateValue, string>;
+    ComputePredicateEvaluation: (
+      vars: Bindings,
+    ) => (expr: Expr) => ValueOrErrors<boolean, string>;
+    EvaluateAs: (
+      as: string,
+    ) => (vars: Bindings) => (e: Expr) => ValueOrErrors<PredicateValue, string>;
+    Evaluate: (
+      vars: Bindings,
+    ) => (e: Expr) => ValueOrErrors<PredicateValue, string>;
+  };
+};
+export declare const evaluatePredicates: <T>(
+  context: {
     global: PredicateValue;
     visibilityPredicateExpressions: FieldPredicateExpressions;
     disabledPredicatedExpressions: FieldPredicateExpressions;
-}, root: PredicateValue) => ValueOrErrors<{
+  },
+  root: PredicateValue,
+) => ValueOrErrors<
+  {
     visiblityPredicateEvaluations: FormFieldPredicateEvaluation;
     disabledPredicateEvaluations: FormFieldPredicateEvaluation;
-}, string>;
-//# sourceMappingURL=state.d.ts.map
+  },
+  string
+>;
+//# sourceMappingURL=state.d.ts.map