ballerina-core 1.0.197 → 1.0.199

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

@@ -1,456 +1,320 @@
 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;
-    };
+    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 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 PredicateValue = ValuePrimitive | ValueUnit | ValueTuple | ValueRecord | ValueUnionCase | ValueOption | ValueVarLookup | ValueSum | ValueCustom | ValueTable | ValueReadOnly;
 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;
+        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>;
+    };
 };
 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