ballerina-core 1.0.218 → 1.0.220

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

@@ -1,449 +1,435 @@
 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, FilterTypeKind } 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;
-    };
+    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;
-  };
-};
-export type FieldPredicateExpressions = Map<
-  FieldName,
-  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;
 };
 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;
+    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 ExprPrepend = {
+    kind: "prepend";
+    operands: [Array<string>, Expr];
+};
+export type Expr = PredicateValue | ExprItemLookup | ExprFieldLookup | ExprIsCase | ExprBinaryOperator | ExprLambda | ExprMatchCase | ExprCase | ExprPrepend;
 export declare const BinaryOperators: readonly ["or", "equals"];
-export declare const BinaryOperatorsSet: Set<"or" | "equals">;
+export declare const BinaryOperatorsSet: Set<"equals" | "or">;
 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: ValueRecord) => 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;
-  };
-  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;
-    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;
+        FilterToKindAndValue: (filter: ValueFilter) => {
+            kind: FilterTypeKind;
+            value: PredicateValue;
+        };
+        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: {
+        prepend: (prependCases: Array<string>, e: Expr) => Expr;
+        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: {
+        IsPrepend: (e: Expr) => e is ExprPrepend;
+        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