@nmnmcc/ability 0.3.0 → 1.0.1

package/dist/Condition.d.ts

@@ -1,9 +1,20 @@
 import { PathSegment } from "./Resource.js";
-import { Untranslatable as Untranslatable$1 } from "./internal/condition.js";
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 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 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 Redacted from "effect/Redacted";
+import * as Result from "effect/Result";
 declare namespace Condition_d_exports {
-  export { And, Any, Ast, Builder, Compare, CompareOperator, Condition, Encoded, EncodedAnd, EncodedNot, EncodedOr, Error, Exists, False, FieldPath, In, Input, Interpreter, Literal, Not, Opaque, OpaqueOf, Operand, OperandOf, Or, PathValue, Predicate, PrincipalRef, Ref, Scalar, Services, True, Under, Untranslatable, Variance, always, and, builder, evaluate, evaluateSync, fields, fold, never, not, or, partial, schema, simplify };
+  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 };
 }
 /**
  * A value that a condition can compare.
@@ -42,14 +53,20 @@ export interface PrincipalRef {
   readonly path: string;
 }
 /**
- * A field of the principal with a known value type.
+ * 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.
  *
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export type Ref<A> = PrincipalRef & {
-  readonly "~Ref"?: () => A;
+export type Ref<A, P = never> = PrincipalRef & {
+  readonly "~Ref": () => A;
+  readonly "~Principal": (principal: P) => void;
 };
 /**
  * @stability stable
@@ -170,7 +187,7 @@ export interface Not {
 export interface Predicate {
   readonly _tag: "Predicate";
   readonly name: string;
-  readonly run: (value: any, principal: any) => Effect.Effect<boolean, unknown, unknown>;
+  run(value: any, principal: any): Effect.Effect<boolean, unknown, unknown>;
 }
 /**
  * The nodes of a condition, without types.
@@ -198,18 +215,112 @@ export interface Variance<E, R, O> {
   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;
+}
+/**
+ * The type fields of a condition. They are only in the types.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.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;
+}
+/**
+ * An `And` node with the types of its children.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.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>>;
+}
+/**
+ * An `Or` node with the types of its children.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.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>>;
+}
+/**
+ * A `Not` node with the types of its child.
+ *
+ * @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>;
+}
+/**
+ * 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}.
+ *
+ * @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.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.0.0
+ */
+export type PredicateRun<E, R, I> = ((value: never, principal: never) => Effect.Effect<boolean, E, R>) & {
+  readonly "~Reads": (reads: I) => void;
+};
 /**
  * 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.
+ * `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> = Ast & {
-  readonly "~Condition"?: Variance<E, R, O>;
-};
+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.
  *
@@ -217,7 +328,7 @@ export type Condition<E = never, R = never, O = never> = Ast & {
  * @category models
  * @since 0.3.0
  */
-export type Any = Condition<any, any, any>;
+export type Any = Condition<any, any, any, any>;
 /**
  * The error type of a condition.
  *
@@ -238,6 +349,34 @@ export type Error<C> = C extends {
 export type Services<C> = C extends {
   readonly "~Condition"?: Variance<infer _E, infer R, infer _O>;
 } ? R : never;
+/**
+ * What the predicates of a condition read. For a union of conditions, it is
+ * what all of them read.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 1.0.0
+ */
+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.
  *
@@ -249,11 +388,19 @@ export type OpaqueOf<C> = C extends {
   readonly "~Condition"?: Variance<infer _E, infer _R, infer O>;
 } ? O : 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 PreviousDepth = [never, 0, 1, 2, 3];
-type FieldPathInternal<T, Depth extends number> = [Depth] extends [never] ? never : { [K in keyof T & string]-?: NonNullable<T[K]> extends Leaf ? K : NonNullable<T[K]> extends ReadonlyArray<unknown> | Function ? never : NonNullable<T[K]> extends object ? `${K}.${FieldPathInternal<NonNullable<T[K]>, PreviousDepth[Depth]>}` : never; }[keyof T & string];
+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];
 /**
  * The paths of the fields of `T` that hold one value, with dots for nested
- * fields. Arrays are left out. The type goes down four levels, so type
+ * fields. Arrays are left out. A map, a set, a date, a URL, a byte array, an
+ * `Option` and the other value types of Effect, such as `BigDecimal` and
+ * `Duration`, are one field, and a path does not go into them. The type goes down four levels, so type
  * checking stays fast. For a union of types, only the common fields are
  * paths.
  *
@@ -261,7 +408,30 @@ type FieldPathInternal<T, Depth extends number> = [Depth] extends [never] ? neve
  * @category utility types
  * @since 0.3.0
  */
-export type FieldPath<T> = [T] extends [object] ? FieldPathInternal<T, 4> : never;
+export type FieldPath<T> = [T] extends [object] ? FieldPathInternal<T, 4, false> : never;
+/**
+ * The paths of the fields of `T` that a rule or a request may name, as in
+ * `Rule.Options.fields`. They are the paths of {@link FieldPath}, and the
+ * paths of arrays too: a rule may allow or deny a whole array field, and
+ * `permittedFields` lists it.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 1.0.0
+ */
+export type FieldSelector<T> = [T] extends [object] ? FieldPathInternal<T, 4, 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
+ * hold, so a value of a union type can not test a field of another type. For
+ * a union of data types, as for a rule on two kinds, it is the values that
+ * the field can hold in each of them.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 1.0.0
+ */
+export type FieldValue<Data, F extends string> = (Data extends unknown ? F extends unknown ? (value: PathValue<Data, F>) => void : never : never) extends ((value: infer V) => void) ? V : never;
 type Normalize<A> = Exclude<A, undefined> | (undefined extends A ? null : never);
 /**
  * The type of the field of `T` at `Path`. A field that may be missing may also
@@ -280,8 +450,28 @@ export type PathValue<T, Path extends string> = Path extends `${infer Head}.${in
  * @category models
  * @since 0.3.0
  */
-export type OperandOf<A> = Extract<A, Scalar> | Ref<A>;
+export type OperandOf<A, P = never> = Extract<A, Scalar> | Ref<A, P>;
+type ScalarPath<T> = { [F in FieldPath<T>]: PathValue<T, F> extends Scalar ? F : never; }[FieldPath<T>];
 type OrderedPath<T> = { [F in FieldPath<T>]: Exclude<PathValue<T, F>, null> extends number | string ? F : never; }[FieldPath<T>];
+/**
+ * A test made by a {@link Builder}. It runs no code, but it keeps the value
+ * type of its resource, so a test on the fields of one resource can not go
+ * into a rule for another resource. A test with a field of the principal
+ * keeps the principal type `P` too.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.0.0
+ */
+export type Test<Value, P = unknown> = Condition<never, never, never, 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
+ * from another builder keeps the principal of that builder.
+ */
+type PrincipalOf<V, _P> = [Extract<V, PrincipalRef>] extends [never] ? unknown : [Extract<V, PrincipalRef>] extends [{
+  readonly "~Principal": (principal: infer Q) => void;
+}] ? Q : unknown;
 /**
  * Makes conditions for a resource with the data type `Data` and the value type
  * `Value`, and a principal with the type `P`.
@@ -292,29 +482,32 @@ type OrderedPath<T> = { [F in FieldPath<T>]: Exclude<PathValue<T, F>, null> exte
  */
 export interface Builder<Data, Value, P> {
   /** The field is equal to the value. */
-  readonly eq: <const F extends FieldPath<Data>>(field: F, value: OperandOf<PathValue<Data, F>>) => Condition;
+  readonly eq: <const F extends FieldPath<Data>, const V extends OperandOf<FieldValue<Data, F>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
   /** The field is not equal to the value. */
-  readonly ne: <const F extends FieldPath<Data>>(field: F, value: OperandOf<PathValue<Data, F>>) => Condition;
-  readonly lt: <const F extends OrderedPath<Data>>(field: F, value: OperandOf<Exclude<PathValue<Data, F>, null>>) => Condition;
-  readonly lte: <const F extends OrderedPath<Data>>(field: F, value: OperandOf<Exclude<PathValue<Data, F>, null>>) => Condition;
-  readonly gt: <const F extends OrderedPath<Data>>(field: F, value: OperandOf<Exclude<PathValue<Data, F>, null>>) => Condition;
-  readonly gte: <const F extends OrderedPath<Data>>(field: F, value: OperandOf<Exclude<PathValue<Data, F>, null>>) => Condition;
+  readonly ne: <const F extends FieldPath<Data>, const V extends OperandOf<FieldValue<Data, F>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly lt: <const F extends OrderedPath<Data>, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly lte: <const F extends OrderedPath<Data>, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly gt: <const F extends OrderedPath<Data>, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
+  readonly gte: <const F extends OrderedPath<Data>, const V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>>(field: F, value: V) => Test<Value, PrincipalOf<V, P>>;
   /** The field is equal to one of the values. */
-  readonly in: <const F extends FieldPath<Data>>(field: F, values: ReadonlyArray<OperandOf<PathValue<Data, F>>>) => Condition;
+  readonly in: <const F extends FieldPath<Data>, const Vs extends ReadonlyArray<OperandOf<FieldValue<Data, F>, any>>>(field: F, values: Vs) => Test<Value, PrincipalOf<Vs[number], P>>;
   /** The field has a value that is not `null`. */
-  readonly exists: <const F extends FieldPath<Data>>(field: F) => Condition;
+  readonly exists: <const F extends FieldPath<Data>>(field: F) => Test<Value>;
   /** The path of the resource starts with these parts. */
-  readonly under: (...prefix: ReadonlyArray<string | null | Ref<string | null>>) => Condition;
-  /** A field of the principal, to use as a value. */
-  readonly principal: <const F extends FieldPath<P>>(field: F) => Ref<PathValue<P, F>>;
-  readonly and: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>;
-  readonly or: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>;
-  readonly not: <C extends Any>(condition: C) => Condition<Error<C>, Services<C>, OpaqueOf<C>>;
+  readonly under: <const Ps extends ReadonlyArray<string | null | Ref<string | null, any>>>(...prefix: Ps) => Test<Value, PrincipalOf<Ps[number], P>>;
+  /**
+   * A field of the principal, to use as a value. The field must have a
+   * {@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>>;
   /**
    * 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>;
+  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>>;
 }
 /**
  * Makes a builder. Rules give you a builder with the right types, so you do not
@@ -348,7 +541,25 @@ export declare const never: Condition;
  * @category combinators
  * @since 0.3.0
  */
-export declare const and: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>;
+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]>>;
+/**
+ * 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.
+ *
+ * @stability stable
+ * @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>>;
+/**
+ * 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.
+ *
+ * @stability stable
+ * @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>>;
 /**
  * True when one of the conditions is true. With no conditions, it is false.
  *
@@ -356,13 +567,13 @@ export declare const and: <const Cs extends ReadonlyArray<Any>>(...conditions: C
  * @category combinators
  * @since 0.3.0
  */
-export declare const or: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>;
+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]>>;
 /**
  * @stability stable
  * @category combinators
  * @since 0.3.0
  */
-export declare const not: <C extends Any>(condition: C) => Condition<Error<C>, Services<C>, OpaqueOf<C>>;
+export declare const not: <C extends Any>(condition: C & Checked<C>) => Condition<Error<C>, Services<C>, OpaqueOf<C>, ReadsOf<C>>;
 /**
  * The data that a condition needs for a test.
  *
@@ -382,15 +593,51 @@ export interface Input {
   readonly path?: ReadonlyArray<PathSegment> | undefined;
 }
 /**
- * Tests a condition on a value. A predicate may fail with its error.
+ * 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.
+ *
+ * @stability stable
+ * @category services
+ * @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>;
+};
+/**
+ * The input of {@link evaluate} that the predicates of a condition need: a
+ * value and a principal of the types in `I`. See {@link Reads}.
+ */
+type ReadsInput<I> = I extends Reads<infer V, infer P> ? {
+  readonly value: V;
+} & (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
+ * that the predicate reads.
  *
  * @stability stable
  * @category evaluation
  * @since 0.3.0
  */
 export declare const evaluate: {
-  (input: Input): <E, R, O>(condition: Condition<E, R, O>) => Effect.Effect<boolean, E, R>;
-  <E, R, O>(condition: Condition<E, R, O>, input: Input): Effect.Effect<boolean, E, R>;
+  <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>;
 };
 /**
  * Tests a condition with no predicate on a value, at once.
@@ -400,39 +647,60 @@ export declare const evaluate: {
  * @since 0.3.0
  */
 export declare const evaluateSync: {
-  (input: Input): (condition: Condition) => boolean;
-  (condition: Condition, input: Input): boolean;
+  <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;
 };
 /**
- * Puts the principal into a condition and expands `Under` with the path of the
- * resource. The result is simplified. It has no principal fields and no
- * `Under` nodes. It is `True` or `False` when the answer does not depend on the
- * resource value.
+ * 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.
  *
  * @stability stable
  * @category evaluation
  * @since 0.3.0
  */
-export declare const partial: {
-  (input: {
-    readonly principal?: object | undefined;
-    readonly path?: ReadonlyArray<PathSegment> | undefined;
-  }): <E, R, O>(condition: Condition<E, R, O>) => Condition<E, R, O>;
-  <E, R, O>(condition: Condition<E, R, O>, input: {
-    readonly principal?: object | undefined;
-    readonly path?: ReadonlyArray<PathSegment> | undefined;
-  }): Condition<E, R, O>;
-};
+export declare const simplify: <E, R, O, I>(condition: Condition<E, R, O, I>) => Condition<E, R, O, I>;
 /**
- * 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.
+ * 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>);
+interface PartialInput {
+  readonly principal?: object | undefined;
+  readonly path?: ReadonlyArray<PathSegment> | undefined;
+}
+/**
+ * The principal that {@link partial} must get for the predicates of a
+ * condition. A predicate keeps the principal that it gets, so the principal
+ * must have the type that the predicate reads.
+ */
+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;
+/**
+ * Puts the principal into a condition and expands `Under` with the path of the
+ * resource. The result is simplified. It has no principal fields and no
+ * `Under` nodes. It is `True` or `False` when the answer does not depend on the
+ * resource value.
  *
  * @stability stable
  * @category evaluation
  * @since 0.3.0
  */
-export declare const simplify: <E, R, O>(condition: Condition<E, R, O>) => Condition<E, R, O>;
+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>>;
+};
 /**
  * The functions that change each node of a condition into another form, such
  * as a database query.
@@ -453,6 +721,9 @@ export interface Interpreter<A> {
   /** Optional. Without it, a predicate makes `fold` fail. */
   readonly predicate?: (name: string) => A;
 }
+declare const Untranslatable_base: Schema.Class<Untranslatable, Schema.TaggedStruct<"Untranslatable", {
+  readonly reason: Schema.String;
+}>, Cause.YieldableError>;
 /**
  * The error when `fold` can not change a node.
  *
@@ -460,13 +731,7 @@ export interface Interpreter<A> {
  * @category errors
  * @since 0.3.0
  */
-export declare const Untranslatable: typeof Untranslatable$1;
-/**
- * @stability stable
- * @category errors
- * @since 0.3.0
- */
-export type Untranslatable = Untranslatable$1;
+export declare class Untranslatable extends Untranslatable_base {}
 /**
  * Changes a condition into another form with an interpreter. Call
  * {@link partial} first: `fold` fails on principal fields and on `Under`
@@ -487,7 +752,100 @@ export declare const fold: {
  * @category getters
  * @since 0.3.0
  */
-export declare const fields: (condition: Any) => ReadonlyArray<string>;
+export declare const fields: (condition: Ast) => ReadonlyArray<string>;
+/**
+ * Values of fields, as a nested object. A field that is not in it may have any
+ * value. A value with parts that the search does not look into, such as a
+ * date, is an empty object.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.0.0
+ */
+export interface Example {
+  readonly [field: string]: unknown;
+}
+/**
+ * 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.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.0.0
+ */
+export type Satisfiability = Data.TaggedEnum<{
+  Satisfiable: {
+    readonly example: Example;
+  };
+  Unsatisfiable: {};
+  Unknown: {
+    readonly reason: "predicate" | "budget" | "schema";
+  };
+}>;
+/**
+ * The options of {@link satisfiable}.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.0.0
+ */
+export interface SatisfiableOptions {
+  /**
+   * The Schema of the values. It gives the domain 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. */
+  readonly budget?: number | undefined;
+}
+/**
+ * Tests if some value makes a condition true, and gives such a value.
+ *
+ * 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.
+ *
+ * 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 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.
+ *
+ * @stability stable
+ * @category evaluation
+ * @since 1.0.0
+ */
+export declare const satisfiable: {
+  (options?: SatisfiableOptions): (condition: Any) => Satisfiability;
+  (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.
+ *
+ * @stability stable
+ * @category conversions
+ * @since 1.0.0
+ */
+export declare const toJsonValue: (condition: Ast) => unknown;
 /**
  * The JSON form of a condition with no predicate.
  *
@@ -523,6 +881,17 @@ 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
+ * any plain condition, such as one from a builder or a residual, may be
+ * encoded.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.0.0
+ */
+export type PlainCondition = Condition<never, never, never, 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.
@@ -531,6 +900,16 @@ export interface EncodedNot {
  * @category schemas
  * @since 0.3.0
  */
-export declare const schema: Schema.Codec<Condition, Encoded>;
+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