@nmnmcc/ability 1.0.1 → 2.0.1

package/dist/Condition.d.ts

@@ -1,20 +1,22 @@
+import { And as And$1, Compare as Compare$1, CompareOperator as CompareOperator$1, Exists as Exists$1, False as False$1, In as In$1, Literal as Literal$1, Node, Not as Not$1, Or as Or$1, Predicate as Predicate$1, PrincipalRef as PrincipalRef$1, Scalar as Scalar$1, True as True$1, Under as Under$1 } from "./internal/nodes.js";
+import { Example as Example$1, Satisfiability as Satisfiability$1 } from "./internal/search.js";
 import { PathSegment } from "./Resource.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
+import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import * as Data from "effect/Data";
-import * as HashMap from "effect/HashMap";
 import * as HashSet from "effect/HashSet";
+import * as Option from "effect/Option";
+import * as HashMap from "effect/HashMap";
 import * as Chunk from "effect/Chunk";
 import * as Duration from "effect/Duration";
 import * as BigDecimal from "effect/BigDecimal";
 import * as Cause from "effect/Cause";
 import * as DateTime from "effect/DateTime";
+import * as Exit from "effect/Exit";
 import * as Redacted from "effect/Redacted";
-import * as Result from "effect/Result";
 declare namespace Condition_d_exports {
-  export { And, AndCondition, Any, Ast, Builder, Checked, Compare, CompareOperator, Condition, Encoded, EncodedAnd, EncodedNot, EncodedOr, Error, Example, Exists, False, FieldPath, FieldSelector, FieldValue, In, Input, Interpreter, Literal, Marks, Not, NotCondition, Opaque, OpaqueOf, Operand, OperandOf, Or, OrCondition, PathValue, PlainCondition, Predicate, PredicateCondition, PredicateRun, PrincipalRef, Reads, ReadsOf, Ref, Satisfiability, SatisfiableOptions, Scalar, Services, Test, True, Under, Untranslatable, Variance, always, and, andAll, builder, evaluate, evaluateSync, fields, fold, hasPredicate, isAst, never, not, or, orAll, partial, provideContext, satisfiable, schema, simplifier, simplify, toJsonValue };
+  export { And, Any, Ast, Builder, Compare, CompareOperator, Condition, Encoded, EncodedOperand, ErrorOf, Example, Exists, False, FieldName, FieldPath, FieldSelector, FieldValue, In, Input, Interpreter, Literal, Not, Opaque, OpaqueOf, Operand, OperandOf, Or, PathValue, PlainCondition, Predicate, PrincipalRef, Provided, Reads, ReadsOf, Ref, Satisfiability, SatisfiableOptions, Scalar, ServicesOf, Test, True, Under, Untranslatable, always, and, andAll, builder, evaluate, evaluateSync, fields, fold, never, not, or, orAll, partial, provideContext, satisfiable, schema, simplify };
 }
 /**
  * A value that a condition can compare.
@@ -23,7 +25,7 @@ declare namespace Condition_d_exports {
  * @category models
  * @since 0.3.0
  */
-export type Scalar = string | number | boolean | null;
+export type Scalar = Scalar$1;
 /**
  * A fixed value in a condition.
  *
@@ -31,10 +33,7 @@ export type Scalar = string | number | boolean | null;
  * @category models
  * @since 0.3.0
  */
-export interface Literal {
-  readonly _tag: "Literal";
-  readonly value: Scalar;
-}
+export type Literal = Literal$1;
 /**
  * A field of the principal. {@link partial} puts the value of the field in its
  * place.
@@ -48,17 +47,12 @@ export interface Literal {
  * @category models
  * @since 0.3.0
  */
-export interface PrincipalRef {
-  readonly _tag: "Principal";
-  readonly path: string;
-}
+export type PrincipalRef = PrincipalRef$1;
 /**
  * A field of the principal with a known value type `A`, from a principal of
- * the type `P`. The type fields are only in the types. A reference with no
- * type does not have them, so it can not stand for a field of any type. A
- * test with the reference reads a principal of the type `P`, so it can not go
- * into a rule of a domain with another principal. With no `P`, it is `never`,
- * and a test with the reference fits no rule.
+ * the type `P`. The type fields are only in the types. A test with the
+ * reference reads a principal of the type `P`, so it can not go into a rule
+ * of a domain with another principal.
  *
  * @stability stable
  * @category models
@@ -79,7 +73,7 @@ export type Operand = Literal | PrincipalRef;
  * @category models
  * @since 0.3.0
  */
-export type CompareOperator = "eq" | "ne" | "lt" | "lte" | "gt" | "gte";
+export type CompareOperator = CompareOperator$1;
 /**
  * Always true.
  *
@@ -87,9 +81,7 @@ export type CompareOperator = "eq" | "ne" | "lt" | "lte" | "gt" | "gte";
  * @category models
  * @since 0.3.0
  */
-export interface True {
-  readonly _tag: "True";
-}
+export type True = True$1;
 /**
  * Always false.
  *
@@ -97,9 +89,7 @@ export interface True {
  * @category models
  * @since 0.3.0
  */
-export interface False {
-  readonly _tag: "False";
-}
+export type False = False$1;
 /**
  * Compares a field with a value. A missing field has the value `null`. `lt`,
  * `lte`, `gt` and `gte` are false when the two sides are not both numbers or
@@ -109,12 +99,7 @@ export interface False {
  * @category models
  * @since 0.3.0
  */
-export interface Compare {
-  readonly _tag: "Compare";
-  readonly op: CompareOperator;
-  readonly field: string;
-  readonly value: Operand;
-}
+export type Compare = Compare$1;
 /**
  * True when a field is equal to one of the values.
  *
@@ -122,11 +107,7 @@ export interface Compare {
  * @category models
  * @since 0.3.0
  */
-export interface In {
-  readonly _tag: "In";
-  readonly field: string;
-  readonly values: ReadonlyArray<Operand>;
-}
+export type In = In$1;
 /**
  * True when a field is not `null` and not missing.
  *
@@ -134,10 +115,7 @@ export interface In {
  * @category models
  * @since 0.3.0
  */
-export interface Exists {
-  readonly _tag: "Exists";
-  readonly field: string;
-}
+export type Exists = Exists$1;
 /**
  * True when the path of the resource starts with the prefix. A resource with
  * no path is never under a prefix.
@@ -146,37 +124,25 @@ export interface Exists {
  * @category models
  * @since 0.3.0
  */
-export interface Under {
-  readonly _tag: "Under";
-  readonly prefix: ReadonlyArray<Operand>;
-}
+export type Under = Under$1;
 /**
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface And {
-  readonly _tag: "And";
-  readonly conditions: ReadonlyArray<Ast>;
-}
+export type And = And$1;
 /**
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface Or {
-  readonly _tag: "Or";
-  readonly conditions: ReadonlyArray<Ast>;
-}
+export type Or = Or$1;
 /**
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface Not {
-  readonly _tag: "Not";
-  readonly condition: Ast;
-}
+export type Not = Not$1;
 /**
  * A test that runs an `Effect`. It can not become JSON or a query.
  *
@@ -184,143 +150,87 @@ export interface Not {
  * @category models
  * @since 0.3.0
  */
-export interface Predicate {
-  readonly _tag: "Predicate";
-  readonly name: string;
-  run(value: any, principal: any): Effect.Effect<boolean, unknown, unknown>;
-}
+export type Predicate = Predicate$1;
 /**
- * The nodes of a condition, without types.
+ * The nodes of a condition, without types. Each node is a class, and only the
+ * builder, the functions of this module and the Schema make one. So a plain
+ * object, or a spread of a node, is not a node.
  *
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export type Ast = True | False | Compare | In | Exists | Under | And | Or | Not | Predicate;
+export type Ast = Node;
 /**
- * The type marker for a condition with a {@link Predicate}.
+ * The mark of a condition with a predicate. `E` and `R` are the error type
+ * and the service type of its predicates.
  *
  * @stability stable
  * @category models
- * @since 0.3.0
- */
-export type Opaque = "Opaque";
-/**
- * @stability stable
- * @category models
- * @since 0.3.0
+ * @since 2.0.0
  */
-export interface Variance<E, R, O> {
-  readonly E: () => E;
-  readonly R: () => R;
-  readonly O: () => O;
-}
-/**
- * What the predicates of a condition read: a resource value of the type `V`
- * and a principal of the type `P`. It is only in the types.
- *
- * @stability stable
- * @category models
- * @since 1.0.0
- */
-export interface Reads<V, P> {
-  readonly value: V;
-  readonly principal: P;
+export interface Opaque<out E = never, out R = never> {
+  readonly "~Opaque": {
+    readonly E: E;
+    readonly R: R;
+  };
 }
 /**
- * The type fields of a condition. They are only in the types.
+ * The error type of the predicates of a mark `X`. A mark that may be
+ * anything, as `unknown`, may have any error.
  *
  * @stability stable
- * @category models
- * @since 1.0.0
+ * @category utility types
+ * @since 2.0.0
  */
-export interface Marks<E, R, O, I> {
-  readonly "~Condition": Variance<E, R, O>;
-  /** `I` is what the predicates read. See {@link Reads}. */
-  readonly "~Reads": (reads: I) => void;
-}
+export type ErrorOf<X> = unknown extends X ? unknown : X extends Opaque<infer E, infer _R> ? E : never;
 /**
- * An `And` node with the types of its children.
+ * The service type of the predicates of a mark `X`. A mark that may be
+ * anything, as `unknown`, may need any service.
  *
  * @stability stable
- * @category models
- * @since 1.0.0
+ * @category utility types
+ * @since 2.0.0
  */
-export interface AndCondition<E, R, O, I> extends Marks<E, R, O, I> {
-  readonly _tag: "And";
-  readonly conditions: ReadonlyArray<Condition<E, R, O, I>>;
-}
+export type ServicesOf<X> = unknown extends X ? unknown : X extends Opaque<infer _E, infer R> ? R : never;
 /**
- * An `Or` node with the types of its children.
+ * The mark `X` with no services.
  *
  * @stability stable
- * @category models
- * @since 1.0.0
+ * @category utility types
+ * @since 2.0.0
  */
-export interface OrCondition<E, R, O, I> extends Marks<E, R, O, I> {
-  readonly _tag: "Or";
-  readonly conditions: ReadonlyArray<Condition<E, R, O, I>>;
-}
+export type Provided<X> = unknown extends X ? Opaque<unknown> : X extends Opaque<infer E, infer _R> ? Opaque<E> : never;
 /**
- * A `Not` node with the types of its child.
+ * What the predicates of a condition read: a resource value of the type `V`
+ * and a principal of the type `P`. It is only in the types.
  *
  * @stability stable
  * @category models
  * @since 1.0.0
  */
-export interface NotCondition<E, R, O, I> extends Marks<E, R, O, I> {
-  readonly _tag: "Not";
-  readonly condition: Condition<E, R, O, I>;
+export interface Reads<V, P> {
+  readonly value: V;
+  readonly principal: P;
 }
 /**
- * A predicate node with its types. `"~Predicate"` is only in the types. It has
- * the type `O`, so a plain condition, with `O` as `never`, can not be a
- * predicate. The builder makes predicates with `O` as {@link Opaque}.
+ * A condition. `I` is what its tests read: see {@link Reads}. `X` is
+ * {@link Opaque} when the condition has a predicate, and `never` when it is
+ * plain data. A plain condition can become JSON or a query.
  *
- * @stability stable
- * @category models
- * @since 1.0.0
- */
-export interface PredicateCondition<E, R, O, I> extends Marks<E, R, O, I> {
-  readonly _tag: "Predicate";
-  readonly name: string;
-  /**
-   * The test. Its inputs have the type `never`, so it can not be called with
-   * a value that it does not read. Use {@link evaluate}, which checks the
-   * input against `I`.
-   */
-  readonly run: PredicateRun<E, R, I>;
-  readonly "~Predicate": O;
-}
-/**
- * The test of a predicate node. The type field `"~Reads"` is only in the
- * types. It ties the test to what it reads, so the test of one predicate can
- * not go into a node that says it reads other values.
+ * The two type fields are only in the types. `I` goes into a function as an
+ * input, so a condition that reads a `Post` does not fit a rule for a
+ * `Comment`. `X` comes out of a function, so a plain condition fits where a
+ * condition with predicates may go.
  *
  * @stability stable
  * @category models
- * @since 1.0.0
+ * @since 0.3.0
  */
-export type PredicateRun<E, R, I> = ((value: never, principal: never) => Effect.Effect<boolean, E, R>) & {
+export type Condition<I = unknown, X = never> = Ast & {
   readonly "~Reads": (reads: I) => void;
+  readonly "~Opaque": () => X;
 };
-/**
- * A condition. `E` and `R` are the error type and the service type of its
- * predicates. `O` is {@link Opaque} when the condition has a predicate, and
- * `never` when it is plain data. `I` is what its predicates read. See
- * {@link Reads}.
- *
- * The type fields are only in the types. A plain node made by hand does not
- * have them, so it is not a condition. Use the builder. Each child of a node
- * is a condition with the same types, so a node can not hide the types of a
- * predicate inside it. A predicate is a condition only when `O` is
- * {@link Opaque}.
- *
- * @stability stable
- * @category models
- * @since 0.3.0
- */
-export type Condition<E = never, R = never, O = never, I = unknown> = ((True | False | Compare | In | Exists | Under) & Marks<E, R, O, I>) | AndCondition<E, R, O, I> | OrCondition<E, R, O, I> | NotCondition<E, R, O, I> | PredicateCondition<E, R, O, I>;
 /**
  * Any condition.
  *
@@ -328,30 +238,10 @@ export type Condition<E = never, R = never, O = never, I = unknown> = ((True | F
  * @category models
  * @since 0.3.0
  */
-export type Any = Condition<any, any, any, any>;
-/**
- * The error type of a condition.
- *
- * @stability stable
- * @category utility types
- * @since 0.3.0
- */
-export type Error<C> = C extends {
-  readonly "~Condition"?: Variance<infer E, infer _R, infer _O>;
-} ? E : never;
-/**
- * The service type of a condition.
- *
- * @stability stable
- * @category utility types
- * @since 0.3.0
- */
-export type Services<C> = C extends {
-  readonly "~Condition"?: Variance<infer _E, infer R, infer _O>;
-} ? R : never;
+export type Any = Condition<any, any>;
 /**
- * What the predicates of a condition read. For a union of conditions, it is
- * what all of them read.
+ * What the tests of a condition read. For a union of conditions, it is what
+ * all of them read.
  *
  * @stability stable
  * @category utility types
@@ -361,41 +251,32 @@ export type ReadsOf<C> = [C] extends [{
   readonly "~Reads": (reads: infer I) => void;
 }] ? I : unknown;
 /**
- * `unknown` when a condition is a condition of its own type fields: each of
- * its children has them too. A node made with a spread may keep the type
- * fields of another node, and then it is `never`, so the call stops.
- *
- * @stability stable
- * @category utility types
- * @since 1.0.0
- */
-export type Checked<C> = [NotChecked<C>] extends [never] ? unknown : never;
-/**
- * The members of a union of conditions that do not fit their own type fields.
- * Each member is checked alone, so a good member does not hide a bad one.
- */
-type NotChecked<C> = C extends Condition<Error<C>, Services<C>, OpaqueOf<C>, ReadsOf<C>> ? never : C;
-/** Each condition, checked with {@link Checked}. */
-type Consistent<Cs extends ReadonlyArray<Any>> = { readonly [K in keyof Cs]: Cs[K] & Checked<Cs[K]>; };
-/**
- * {@link Opaque} when a condition has a predicate.
+ * The mark of a condition: {@link Opaque} when it has a predicate.
  *
  * @stability stable
  * @category utility types
  * @since 0.3.0
  */
 export type OpaqueOf<C> = C extends {
-  readonly "~Condition"?: Variance<infer _E, infer _R, infer O>;
-} ? O : never;
+  readonly "~Opaque": () => infer X;
+} ? X : never;
 type Leaf = string | number | boolean | bigint | symbol | null | undefined;
 /**
  * Values of a class that keeps its data inside. A path does not go into them,
  * as in the field paths of a resource, so a field with such a value is one
  * field. A condition can test only if it exists.
  */
-type Whole = ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | HashMap.HashMap<unknown, unknown> | HashSet.HashSet<unknown> | Date | URL | Uint8Array | Option.Option<unknown> | BigDecimal.BigDecimal | Duration.Duration | DateTime.DateTime | Redacted.Redacted<unknown> | Chunk.Chunk<unknown> | Cause.Cause<unknown> | Result.Result<unknown, unknown> | File | FormData | RegExp;
+type Whole = ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | HashMap.HashMap<unknown, unknown> | HashSet.HashSet<unknown> | Date | URL | Uint8Array | Option.Option<unknown> | BigDecimal.BigDecimal | Duration.Duration | DateTime.DateTime | Redacted.Redacted<unknown> | Chunk.Chunk<unknown> | Cause.Cause<unknown> | Result.Result<unknown, unknown> | Exit.Exit<unknown, unknown> | File | FormData | RegExp | URLSearchParams;
 type PreviousDepth = [never, 0, 1, 2, 3];
-type FieldPathInternal<T, Depth extends number, Arrays extends boolean> = [Depth] extends [never] ? never : { [K in keyof T & string]-?: NonNullable<T[K]> extends Leaf | Whole ? K : NonNullable<T[K]> extends Function ? never : NonNullable<T[K]> extends ReadonlyArray<unknown> ? Arrays extends true ? K : never : NonNullable<T[K]> extends object ? `${K}.${FieldPathInternal<NonNullable<T[K]>, PreviousDepth[Depth], Arrays>}` : never; }[keyof T & string];
+type FieldPathInternal<T, Depth extends number, Arrays extends boolean, Parents extends boolean = false> = [Depth] extends [never] ? never : { [K in keyof T & string]-?: PathsOf<K, NonNullable<T[K]>, Depth, Arrays, Parents>; }[keyof T & string];
+/**
+ * The paths of one field `K` with the values `V`. Each kind of value in `V`
+ * gives its own paths, so a field that holds a string or a struct is a field,
+ * and the fields of the struct are fields too. A function is no field.
+ */
+type PathsOf<K extends string, V, Depth extends number, Arrays extends boolean, Parents extends boolean> = ([V] extends [never] ? K : never) | ([Extract<V, Leaf | Whole>] extends [never] ? never : K) | ([Extract<V, ReadonlyArray<unknown>>] extends [never] ? never : Arrays extends true ? K : never) | ObjectPaths<K, Exclude<V, Leaf | Whole | Function | ReadonlyArray<unknown>>, Depth, Arrays, Parents>;
+/** The paths of a field `K` that holds the objects `O`, and of the fields below. */
+type ObjectPaths<K extends string, O, Depth extends number, Arrays extends boolean, Parents extends boolean> = [O] extends [never] ? never : (Parents extends true ? K : Arrays extends true ? string extends keyof O ? K : never : never) | `${K}.${FieldPathInternal<O, PreviousDepth[Depth], Arrays, Parents>}`;
 /**
  * The paths of the fields of `T` that hold one value, with dots for nested
  * fields. Arrays are left out. A map, a set, a date, a URL, a byte array, an
@@ -420,6 +301,16 @@ export type FieldPath<T> = [T] extends [object] ? FieldPathInternal<T, 4, false>
  * @since 1.0.0
  */
 export type FieldSelector<T> = [T] extends [object] ? FieldPathInternal<T, 4, true> : never;
+/**
+ * The names that the `fields` of a rule may have: the paths of
+ * {@link FieldSelector}, and the paths of the structs above them. A name of a
+ * struct covers the fields below it.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 2.0.0
+ */
+export type FieldName<T> = [T] extends [object] ? FieldPathInternal<T, 4, true, true> : never;
 /**
  * The value type that fits every field in `F`. For one field, it is the type
  * of the field. For a union of fields, it is the values that each of them can
@@ -463,7 +354,7 @@ type OrderedPath<T> = { [F in FieldPath<T>]: Exclude<PathValue<T, F>, null> exte
  * @category models
  * @since 1.0.0
  */
-export type Test<Value, P = unknown> = Condition<never, never, never, Reads<Value, P>>;
+export type Test<Value, P = unknown> = Condition<Reads<Value, P>>;
 /**
  * The principal type that a test reads: the principal of each field of the
  * principal in the values `V`, and `unknown` when there is none. A reference
@@ -500,14 +391,14 @@ export interface Builder<Data, Value, P> {
    * {@link Scalar} type.
    */
   readonly principal: <const F extends ScalarPath<P>>(field: F) => Ref<PathValue<P, F>, P>;
-  readonly and: <const Cs extends ReadonlyArray<Any>>(...conditions: Consistent<Cs>) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>, ReadsOf<Cs[number]>>;
-  readonly or: <const Cs extends ReadonlyArray<Any>>(...conditions: Consistent<Cs>) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>, ReadsOf<Cs[number]>>;
-  readonly not: <C extends Any>(condition: C & Checked<C>) => Condition<Error<C>, Services<C>, OpaqueOf<C>, ReadsOf<C>>;
+  readonly and: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>;
+  readonly or: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>;
+  readonly not: <C extends Any>(condition: C) => Condition<ReadsOf<C>, OpaqueOf<C>>;
   /**
    * A test that runs any code. It may give a boolean or an `Effect`. A
    * condition with a predicate can not become JSON or a query.
    */
-  readonly predicate: <E = never, R = never>(name: string, test: (value: Value, principal: P) => boolean | Effect.Effect<boolean, E, R>) => Condition<E, R, Opaque, Reads<Value, P>>;
+  readonly predicate: <E = never, R = never>(name: string, test: (value: Value, principal: P) => boolean | Effect.Effect<boolean, E, R>) => Condition<Reads<Value, P>, Opaque<E, R>>;
 }
 /**
  * Makes a builder. Rules give you a builder with the right types, so you do not
@@ -541,7 +432,7 @@ export declare const never: Condition;
  * @category combinators
  * @since 0.3.0
  */
-export declare const and: <const Cs extends ReadonlyArray<Any>>(...conditions: Consistent<Cs>) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>, ReadsOf<Cs[number]>>;
+export declare const and: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>;
 /**
  * The same as {@link and}, for a list of conditions of one type. Use it for a
  * long list: a function call may take only so many arguments.
@@ -550,7 +441,7 @@ export declare const and: <const Cs extends ReadonlyArray<Any>>(...conditions: C
  * @category combinators
  * @since 1.0.0
  */
-export declare const andAll: <C extends Any>(conditions: ReadonlyArray<C & Checked<C>>) => Condition<Error<C>, Services<C>, OpaqueOf<C>, ReadsOf<C>>;
+export declare const andAll: <C extends Any>(conditions: ReadonlyArray<C>) => Condition<ReadsOf<C>, OpaqueOf<C>>;
 /**
  * The same as {@link or}, for a list of conditions of one type. Use it for a
  * long list: a function call may take only so many arguments.
@@ -559,7 +450,7 @@ export declare const andAll: <C extends Any>(conditions: ReadonlyArray<C & Check
  * @category combinators
  * @since 1.0.0
  */
-export declare const orAll: <C extends Any>(conditions: ReadonlyArray<C & Checked<C>>) => Condition<Error<C>, Services<C>, OpaqueOf<C>, ReadsOf<C>>;
+export declare const orAll: <C extends Any>(conditions: ReadonlyArray<C>) => Condition<ReadsOf<C>, OpaqueOf<C>>;
 /**
  * True when one of the conditions is true. With no conditions, it is false.
  *
@@ -567,13 +458,13 @@ export declare const orAll: <C extends Any>(conditions: ReadonlyArray<C & Checke
  * @category combinators
  * @since 0.3.0
  */
-export declare const or: <const Cs extends ReadonlyArray<Any>>(...conditions: Consistent<Cs>) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>, ReadsOf<Cs[number]>>;
+export declare const or: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>;
 /**
  * @stability stable
  * @category combinators
  * @since 0.3.0
  */
-export declare const not: <C extends Any>(condition: C & Checked<C>) => Condition<Error<C>, Services<C>, OpaqueOf<C>, ReadsOf<C>>;
+export declare const not: <C extends Any>(condition: C) => Condition<ReadsOf<C>, OpaqueOf<C>>;
 /**
  * The data that a condition needs for a test.
  *
@@ -592,14 +483,6 @@ export interface Input {
   /** The path of the resource. Without it, `Under` is false. */
   readonly path?: ReadonlyArray<PathSegment> | undefined;
 }
-/**
- * True when a condition has a {@link Predicate}.
- *
- * @stability stable
- * @category predicates
- * @since 1.0.0
- */
-export declare const hasPredicate: (condition: Ast) => boolean;
 /**
  * Gives the services in `context` to every predicate of a condition, so the
  * condition needs no services when it runs.
@@ -609,8 +492,8 @@ export declare const hasPredicate: (condition: Ast) => boolean;
  * @since 1.0.0
  */
 export declare const provideContext: {
-  <R>(context: Context.Context<R>): <E, O, I>(condition: Condition<E, R, O, I>) => Condition<E, never, O, I>;
-  <E, R, O, I>(condition: Condition<E, R, O, I>, context: Context.Context<R>): Condition<E, never, O, I>;
+  <R>(context: Context.Context<R>): <I, X>(condition: Condition<I, X> & ([ServicesOf<X>] extends [R] ? unknown : never)) => Condition<I, Provided<X>>;
+  <I, X>(condition: Condition<I, X>, context: Context.Context<ServicesOf<X>>): Condition<I, Provided<X>>;
 };
 /**
  * The input of {@link evaluate} that the predicates of a condition need: a
@@ -621,11 +504,6 @@ type ReadsInput<I> = I extends Reads<infer V, infer P> ? {
 } & (unknown extends P ? unknown : {
   readonly principal: P;
 }) : unknown;
-/**
- * `unknown` when `In` gives what `I` reads, and `never` when it does not. For
- * a union, each member must give it, so the test is not split over the union.
- */
-type ReadsFrom<I, In> = [In] extends [ReadsInput<I>] ? unknown : never;
 /**
  * Tests a condition on a value. A predicate may fail with its error. When the
  * condition has a predicate, the input must have the value and the principal
@@ -635,10 +513,7 @@ type ReadsFrom<I, In> = [In] extends [ReadsInput<I>] ? unknown : never;
  * @category evaluation
  * @since 0.3.0
  */
-export declare const evaluate: {
-  <In extends Input>(input: In): <E, R, O, I>(condition: Condition<E, R, O, I> & ReadsFrom<I, In>) => Effect.Effect<boolean, E, R>;
-  <E, R, O, I, In extends Input>(condition: Condition<E, R, O, I>, input: In & ReadsInput<I>): Effect.Effect<boolean, E, R>;
-};
+export declare const evaluate: <I, X, In extends Input>(condition: Condition<I, X>, input: In & ReadsInput<I>) => Effect.Effect<boolean, ErrorOf<X>, ServicesOf<X>>;
 /**
  * Tests a condition with no predicate on a value, at once.
  *
@@ -646,31 +521,17 @@ export declare const evaluate: {
  * @category evaluation
  * @since 0.3.0
  */
-export declare const evaluateSync: {
-  <In extends Input>(input: In): <I>(condition: Condition<never, never, never, I> & ReadsFrom<I, In>) => boolean;
-  <I, In extends Input>(condition: Condition<never, never, never, I>, input: In & ReadsInput<I>): boolean;
-};
+export declare const evaluateSync: <I, In extends Input>(condition: Condition<I>, input: In & ReadsInput<I>) => boolean;
 /**
  * Makes a condition smaller without a change to its meaning. It removes `True`
  * and `False` from `And` and `Or`, joins nested `And` and `Or` nodes, and
- * removes double `Not` nodes.
+ * removes double `Not` nodes and copies of a child.
  *
  * @stability stable
  * @category evaluation
  * @since 0.3.0
  */
-export declare const simplify: <E, R, O, I>(condition: Condition<E, R, O, I>) => Condition<E, R, O, I>;
-/**
- * Makes a {@link simplify} function that keeps its work for the parts it has
- * seen. Use one for many calls on conditions that share parts, such as the
- * steps of one residual condition. Do not keep it for long: it keeps every
- * part that it has seen.
- *
- * @stability stable
- * @category evaluation
- * @since 1.0.0
- */
-export declare const simplifier: () => (<E, R, O, I>(condition: Condition<E, R, O, I>) => Condition<E, R, O, I>);
+export declare const simplify: <I, X>(condition: Condition<I, X>) => Condition<I, X>;
 interface PartialInput {
   readonly principal?: object | undefined;
   readonly path?: ReadonlyArray<PathSegment> | undefined;
@@ -683,8 +544,6 @@ interface PartialInput {
 type PrincipalInput<I> = I extends Reads<infer _V, infer P> ? unknown extends P ? unknown : {
   readonly principal: P;
 } : unknown;
-/** `unknown` when `In` gives what `I` reads, and `never` when it does not. */
-type PrincipalFrom<I, In> = [In] extends [PrincipalInput<I>] ? unknown : never;
 /** What a condition reads after {@link partial}: the value, and no principal. */
 type Bound<I> = I extends Reads<infer V, infer _P> ? Reads<V, unknown> : I;
 /**
@@ -697,10 +556,7 @@ type Bound<I> = I extends Reads<infer V, infer _P> ? Reads<V, unknown> : I;
  * @category evaluation
  * @since 0.3.0
  */
-export declare const partial: {
-  <In extends PartialInput>(input: In): <E, R, O, I>(condition: Condition<E, R, O, I> & PrincipalFrom<I, In>) => Condition<E, R, O, Bound<I>>;
-  <E, R, O, I>(condition: Condition<E, R, O, I>, input: PartialInput & PrincipalInput<I>): Condition<E, R, O, Bound<I>>;
-};
+export declare const partial: <I, X>(condition: Condition<I, X>, input: PartialInput & PrincipalInput<I>) => Condition<Bound<I>, X>;
 /**
  * The functions that change each node of a condition into another form, such
  * as a database query.
@@ -746,7 +602,7 @@ export declare const fold: {
   <A>(condition: Any, interpreter: Interpreter<A>): Effect.Effect<A, Untranslatable>;
 };
 /**
- * The fields that a condition uses.
+ * The fields that a condition uses, in the order that they first come.
  *
  * @stability stable
  * @category getters
@@ -762,30 +618,19 @@ export declare const fields: (condition: Ast) => ReadonlyArray<string>;
  * @category models
  * @since 1.0.0
  */
-export interface Example {
-  readonly [field: string]: unknown;
-}
+export type Example = Example$1;
 /**
  * The answer of {@link satisfiable}:
  * - `Satisfiable`: some value makes the condition true. `example` is one.
  * - `Unsatisfiable`: no value makes the condition true.
- * - `Unknown`: the search can not say. The condition has a predicate, the
- *   search went past its budget, or it set two fields that the Schema ties
- *   together, as below a union or a field that may be missing.
+ * - `Unknown`: the search can not say. The condition has a predicate, or
+ *   the search went past its budget.
  *
  * @stability stable
  * @category models
  * @since 1.0.0
  */
-export type Satisfiability = Data.TaggedEnum<{
-  Satisfiable: {
-    readonly example: Example;
-  };
-  Unsatisfiable: {};
-  Unknown: {
-    readonly reason: "predicate" | "budget" | "schema";
-  };
-}>;
+export type Satisfiability = Satisfiability$1;
 /**
  * The options of {@link satisfiable}.
  *
@@ -795,11 +640,11 @@ export type Satisfiability = Data.TaggedEnum<{
  */
 export interface SatisfiableOptions {
   /**
-   * The Schema of the values. It gives the domain of each field. Without
-   * it, a field may have any value.
+   * The Schema of the values. Its shape gives the kinds of values of each
+   * field. Without it, a field may have any value.
    */
   readonly schema?: Schema.Top | undefined;
-  /** The most nodes that the search may visit. The default is 1000000. */
+  /** The most steps that the search may take. The default is 1000000. */
   readonly budget?: number | undefined;
 }
 /**
@@ -808,44 +653,39 @@ export interface SatisfiableOptions {
  * Call {@link partial} first: the condition must have no principal fields and
  * no `Under` nodes. A condition with a predicate gives `Unknown`.
  *
- * With `options.schema`, each field of the condition must be a plain scalar
- * field of the Schema (see `Resource.isPlainField`). Else the answer is
- * `Unknown` with the reason `"schema"`: for another field, a value may have
- * data that the Schema does not show, so the model of its values is not
- * exact.
+ * Each test of a condition compares one field with constants, so the
+ * constants cut the values of each field into a few cells. The search tries
+ * one value from each cell, one field at a time. The values of a field come
+ * from the shape of the Schema in `options.schema`: its literals, `null` for
+ * a nullable or optional field, and finite or integer numbers.
  *
- * The answer is exact. Each test of a condition compares one field with
- * constants, so the constants cut the values of each field into a few cells.
- * The search tries one value from each cell, one field at a time. The values
- * of a field come from the Schema in `options.schema`: its literals, `null`
- * for a nullable or optional field, and finite or integer numbers. A field
- * with another Schema check is not a plain field, so the search never tries a
- * value that such a check stops.
+ * The search reads the shape of the Schema, not its other checks, such as a
+ * minimum length. So `Unsatisfiable` holds for every value of the Schema. A
+ * `Satisfiable` example fits the shape, but a check may still stop it.
  *
  * The problem is as hard as boolean satisfiability, so the search has a
  * budget. Past it, the answer is `Unknown`. A condition with more than 256
- * fields, or with a field path of more than 256 parts, gives `Unknown` too.
+ * fields gives `Unknown` too.
  *
  * @stability stable
  * @category evaluation
  * @since 1.0.0
  */
-export declare const satisfiable: {
-  (options?: SatisfiableOptions): (condition: Any) => Satisfiability;
-  (condition: Any, options?: SatisfiableOptions): Satisfiability;
-};
+export declare const satisfiable: (condition: Any, options?: SatisfiableOptions) => Satisfiability;
 /**
- * Gives a condition as a value that `JSON.stringify` keeps with no loss. JSON
- * has no `Infinity`, `-Infinity` or `NaN`: it writes `null` in their place,
- * and a test with `null` has another meaning. Such a number becomes an object
- * that {@link schema} does not decode, so a policy with it fails to load and
- * never gives a wrong answer.
+ * The JSON form of an operand.
  *
  * @stability stable
- * @category conversions
- * @since 1.0.0
+ * @category models
+ * @since 2.0.0
  */
-export declare const toJsonValue: (condition: Ast) => unknown;
+export type EncodedOperand = {
+  readonly _tag: "Literal";
+  readonly value: Scalar;
+} | {
+  readonly _tag: "Principal";
+  readonly path: string;
+};
 /**
  * The JSON form of a condition with no predicate.
  *
@@ -853,34 +693,32 @@ export declare const toJsonValue: (condition: Ast) => unknown;
  * @category models
  * @since 0.3.0
  */
-export type Encoded = Exclude<Ast, Predicate | And | Or | Not> | EncodedAnd | EncodedOr | EncodedNot;
-/**
- * @stability stable
- * @category models
- * @since 0.3.0
- */
-export interface EncodedAnd {
-  readonly _tag: "And";
-  readonly conditions: ReadonlyArray<Encoded>;
-}
-/**
- * @stability stable
- * @category models
- * @since 0.3.0
- */
-export interface EncodedOr {
-  readonly _tag: "Or";
+export type Encoded = {
+  readonly _tag: "True";
+} | {
+  readonly _tag: "False";
+} | {
+  readonly _tag: "Compare";
+  readonly op: CompareOperator;
+  readonly field: string;
+  readonly value: EncodedOperand;
+} | {
+  readonly _tag: "In";
+  readonly field: string;
+  readonly values: ReadonlyArray<EncodedOperand>;
+} | {
+  readonly _tag: "Exists";
+  readonly field: string;
+} | {
+  readonly _tag: "Under";
+  readonly prefix: ReadonlyArray<EncodedOperand>;
+} | {
+  readonly _tag: "And" | "Or";
   readonly conditions: ReadonlyArray<Encoded>;
-}
-/**
- * @stability stable
- * @category models
- * @since 0.3.0
- */
-export interface EncodedNot {
+} | {
   readonly _tag: "Not";
   readonly condition: Encoded;
-}
+};
 /**
  * A condition with no predicate, that may read any values. It is the type of
  * {@link schema}: a decoded condition reads nothing, so it fits any rule, and
@@ -891,25 +729,19 @@ export interface EncodedNot {
  * @category models
  * @since 1.0.0
  */
-export type PlainCondition = Condition<never, never, never, any>;
+export type PlainCondition = Condition<any>;
 /**
  * The Schema of a condition with no predicate. It checks the shape only. Use
  * `Policy.schema` to check the field names against a domain too.
  *
+ * The decoder takes at most 500 levels of conditions, and at most 1000000
+ * objects and array items, with a shared object counted for each place. It
+ * reads only the own data fields of the input.
+ *
  * @stability stable
  * @category schemas
  * @since 0.3.0
  */
 export declare const schema: Schema.Codec<PlainCondition, Encoded>;
-/**
- * Tests if a value is a whole condition tree: each node has a known tag and
- * the fields of that tag. A predicate node needs a name and a test. A tree
- * deeper than 1000 levels is not taken.
- *
- * @stability stable
- * @category guards
- * @since 1.0.0
- */
-export declare const isAst: (u: unknown) => u is Ast;
 export { Condition_d_exports };
 //# sourceMappingURL=Condition.d.ts.map