@nmnmcc/ability 1.0.1 → 2.0.1

package/dist/Policy.d.ts

@@ -1,7 +1,8 @@
-import { Descriptor } from "./Resource.js";
-import { Builder, Condition, Encoded, Example, FieldSelector, Reads, Variance } from "./Condition.js";
-import { ActionOf, Any as Any$1, DataOf, Kind, Principal, ValueOf } from "./Domain.js";
-import { Any as Any$2, Builder as Builder$1, Error as Error$1, OpaqueOf as OpaqueOf$1, Rule, Services as Services$1 } from "./Rule.js";
+import { Kind } from "./Resource.js";
+import { Any as Any$1, Builder as Builder$1, Condition, Encoded, ErrorOf, Example, FieldName, FieldSelector, OpaqueOf as OpaqueOf$1, Provided, Reads, ReadsOf, ServicesOf } from "./Condition.js";
+import { ActionOf, Any as Any$2, AnyAction, AnyValue, CommonAction, DataOf, Kind as Kind$1, Meta, Principal, Resources, ValueOf } from "./Domain.js";
+import { All, Any as Any$3, Ceiling, FirstOf, Node as Node$1, Rules } from "./internal/policy-nodes.js";
+import { PolicyData, PolicyError as PolicyError$1 } from "./internal/policy.js";
 import { Decision } from "./Decision.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
@@ -9,7 +10,7 @@ import * as Schema from "effect/Schema";
 import * as Data from "effect/Data";
 import * as Pipeable from "effect/Pipeable";
 declare namespace Policy_d_exports {
-  export { Algorithm, AllNode, Any, AnyKindRequest, AnyNode, AnyRequest, CeilingNode, Coverage, DomainOf, EncodedNode, EncodedRule, Error, Explanation, FieldlessRequest, FieldlessTarget, FirstOfNode, KindRequest, KindTarget, Node, OpaqueOf, Options, Policy, Request, ResidualReads, Residuals, RulesNode, Scope, Services, Step, Target, TypedNode, all, any, ceiling, coverage, decide, decideSync, define, empty, explain, firstOf, fitsKind, isPolicy, permittedFields, provideContext, residual, residuals, rules, schema, scopeHasValue, scopeIsEmpty };
+  export { ActionFor, ActionForTargets, Algorithm, AllNode, Any, AnyNode, AnyRequest, AnyRule, Builder, CeilingNode, ConditionFor, Coverage, DataFor, DomainOf, EncodedNode, EncodedRule, Explanation, FieldFor, FieldlessRequest, FieldlessTarget, FirstOfNode, KindOf, KindRequest, KindTarget, Node, OpaqueOf, Options, Policy, PolicyError, Request, ResidualReads, Rule, RuleOptions, RuleShape, RuleTarget, RulesNode, Scope, Step, Target, TargetOf, ValueFor, all, any, builder, ceiling, coverage, decide, decideSync, define, explain, firstOf, permittedFields, provideContext, residual, rule, schema };
 }
 /**
  * @stability stable
@@ -18,102 +19,56 @@ declare namespace Policy_d_exports {
  */
 export type Algorithm = "denyOverrides" | "permitOverrides" | "firstApplicable" | "lastApplicable";
 /**
+ * A list of rules with a combining algorithm.
+ *
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface RulesNode {
-  readonly _tag: "Rules";
-  readonly algorithm: Algorithm;
-  readonly rules: ReadonlyArray<Any$2>;
-}
+export type RulesNode = Rules;
 /**
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface AllNode {
-  readonly _tag: "All";
-  readonly policies: ReadonlyArray<Node>;
-}
+export type AllNode = All;
 /**
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface AnyNode {
-  readonly _tag: "Any";
-  readonly policies: ReadonlyArray<Node>;
-}
+export type AnyNode = Any$3;
 /**
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface FirstOfNode {
-  readonly _tag: "FirstOf";
-  readonly policies: ReadonlyArray<Node>;
-}
+export type FirstOfNode = FirstOf;
 /**
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface CeilingNode {
-  readonly _tag: "Ceiling";
-  readonly cap: Node;
-  readonly policy: Node;
-}
+export type CeilingNode = Ceiling;
 /**
- * The nodes of a policy tree.
+ * The nodes of a policy tree, without types. Each node is a class, and only
+ * the functions of this module and the Schema make one.
  *
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export type Node = RulesNode | AllNode | AnyNode | FirstOfNode | CeilingNode;
+export type Node = Node$1;
 /**
- * The tree of a policy with the types of its predicates and its domain `D`.
- * Each rule and each child has the types too, and `"~Node"` is only in the types. A node made by
- * hand does not have it. So the node of one policy, or a part of it, can not
- * go into a policy with other types.
- *
- * @stability stable
- * @category models
- * @since 1.0.0
- */
-export type TypedNode<E = never, R = never, O = never, D = any> = ({
-  readonly _tag: "Rules";
-  readonly algorithm: Algorithm;
-  readonly rules: ReadonlyArray<Rule<E, R, O, D, never>>;
-} | {
-  readonly _tag: "All" | "Any" | "FirstOf";
-  readonly policies: ReadonlyArray<TypedNode<E, R, O, D>>;
-} | {
-  readonly _tag: "Ceiling";
-  readonly cap: TypedNode<E, R, O, D>;
-  readonly policy: TypedNode<E, R, O, D>;
-}) & {
-  readonly "~Node": Variance<E, R, O>;
-};
-/**
- * A policy for the domain `D`. `E`, `R` and `O` come from the conditions of
- * its rules. See `Condition.Condition`.
+ * A policy for the domain `D`. `X` is `Condition.Opaque` when a rule of the
+ * policy has a predicate, and `never` when the policy is plain data. A plain
+ * policy can become JSON, and `decideSync` takes it.
  *
  * @stability stable
  * @category models
  * @since 0.3.0
  */
-export interface Policy<D extends Any$1, E = never, R = never, O = never> extends Pipeable.Pipeable {
-  readonly domain: D;
-  readonly node: TypedNode<E, R, O, D>;
-  readonly "~Policy": Variance<E, R, O>;
-  /**
-   * Only in the types. A policy reads the values and the principal of its
-   * domain, so a policy of one domain is not a policy of a wider domain.
-   */
-  readonly "~Domain": (domain: D) => D;
-}
+export type Policy<D extends Any$2, X = never> = PolicyData<D, X>;
 /**
  * Any policy.
  *
@@ -121,7 +76,7 @@ export interface Policy<D extends Any$1, E = never, R = never, O = never> extend
  * @category models
  * @since 0.3.0
  */
-export type Any = Policy<any, any, any, any>;
+export type Any = Policy<any, any>;
 /**
  * The domain of a policy.
  *
@@ -129,37 +84,17 @@ export type Any = Policy<any, any, any, any>;
  * @category utility types
  * @since 0.3.0
  */
-export type DomainOf<P> = P extends Policy<infer D, any, any, any> ? D : never;
+export type DomainOf<P> = P extends Policy<infer D, any> ? D : never;
 /**
- * The error type of a policy.
- *
- * @stability stable
- * @category utility types
- * @since 0.3.0
- */
-export type Error<P> = P extends {
-  readonly "~Policy"?: Variance<infer E, infer _R, infer _O>;
-} ? E : never;
-/**
- * The service type of a policy.
- *
- * @stability stable
- * @category utility types
- * @since 0.3.0
- */
-export type Services<P> = P extends {
-  readonly "~Policy"?: Variance<infer _E, infer R, infer _O>;
-} ? R : never;
-/**
- * `Condition.Opaque` when a policy has a predicate.
+ * The mark of a policy or a rule: `Condition.Opaque` when it has a predicate.
  *
  * @stability stable
  * @category utility types
  * @since 0.3.0
  */
 export type OpaqueOf<P> = P extends {
-  readonly "~Policy"?: Variance<infer _E, infer _R, infer O>;
-} ? O : never;
+  readonly "~Opaque": () => infer X;
+} ? X : never;
 /**
  * One act on one resource value, for each kind of the domain. The action must
  * be an action of the kind, and the field must be a field of the kind.
@@ -168,13 +103,13 @@ export type OpaqueOf<P> = P extends {
  * @category models
  * @since 0.3.0
  */
-export type Target<D> = { [K in Kind<D>]: {
+export type Target<D> = { [K in Kind$1<D>]: {
   readonly action: ActionOf<D, K>;
   readonly resource: ValueOf<D, K>;
   readonly field?: FieldSelector<DataOf<D, K>>;
   /** A target has a resource value or a kind, never both. */
   readonly kind?: never;
-}; }[Kind<D>];
+}; }[Kind$1<D>];
 /**
  * A {@link Target} with no field. Each kind keeps its own actions.
  *
@@ -182,11 +117,11 @@ export type Target<D> = { [K in Kind<D>]: {
  * @category models
  * @since 0.3.0
  */
-export type FieldlessTarget<D> = { [K in Kind<D>]: {
+export type FieldlessTarget<D> = { [K in Kind$1<D>]: {
   readonly action: ActionOf<D, K>;
   readonly resource: ValueOf<D, K>;
   readonly kind?: never;
-}; }[Kind<D>];
+}; }[Kind$1<D>];
 /**
  * A scope: a part of a kind, as a condition on its values. It gets a builder
  * with the types of the kind and of the principal, like the condition of a
@@ -196,7 +131,7 @@ export type FieldlessTarget<D> = { [K in Kind<D>]: {
  * @category models
  * @since 1.0.0
  */
-export type Scope<D, K extends string> = (builder: Builder<DataOf<D, K>, ValueOf<D, K>, Principal<D>>) => Condition<never, never, never, Reads<ValueOf<D, K>, Principal<D>>>;
+export type Scope<D, K extends string> = (builder: Builder$1<DataOf<D, K>, ValueOf<D, K>, Principal<D>>) => Condition<Reads<ValueOf<D, K>, Principal<D>>>;
 /**
  * One act on one kind of resource, with no value. With `within`, the target is
  * only the values of the kind in the scope. Without it, the target is every
@@ -206,7 +141,7 @@ export type Scope<D, K extends string> = (builder: Builder<DataOf<D, K>, ValueOf
  * @category models
  * @since 0.3.0
  */
-export type KindTarget<D> = { [K in Kind<D>]: {
+export type KindTarget<D> = { [K in Kind$1<D>]: {
   readonly action: ActionOf<D, K>;
   readonly kind: K;
   readonly field?: FieldSelector<DataOf<D, K>>;
@@ -214,7 +149,7 @@ export type KindTarget<D> = { [K in Kind<D>]: {
   readonly within?: Scope<D, K>;
   /** A target has a resource value or a kind, never both. */
   readonly resource?: never;
-}; }[Kind<D>];
+}; }[Kind$1<D>];
 /**
  * A request: a principal, an action, and a resource value.
  *
@@ -268,7 +203,7 @@ export interface AnyRequest {
  */
 export interface Step {
   readonly path: ReadonlyArray<number>;
-  readonly rule: Any$2;
+  readonly rule: AnyRule;
   readonly applies: boolean;
 }
 /**
@@ -283,6 +218,191 @@ export interface Explanation {
   readonly decision: Decision;
   readonly steps: ReadonlyArray<Step>;
 }
+/**
+ * A rule for the domain `D`. `I` is what the tests of its condition read, and
+ * `X` is its mark: see `Condition.Condition`. A predicate reads the values and
+ * the principal of its domain, so a rule may go only into a policy of its own
+ * domain. A rule from {@link rule} has the domain `any`.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Rule<D = any, I = unknown, X = never> extends RuleShape<I, X>, Pipeable.Pipeable {
+  readonly "~Opaque": () => X;
+  readonly "~Domain": (domain: D) => D;
+  [Symbol.iterator](): Generator<Rule<D, I, X>, Rule<D, I, X>, unknown>;
+}
+/**
+ * The data of a rule.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.0.0
+ */
+export interface RuleShape<I = unknown, X = never> {
+  readonly _tag: "Allow" | "Deny";
+  readonly actions: ReadonlyArray<string>;
+  readonly resources: ReadonlyArray<string>;
+  readonly when?: Condition<I, X>;
+  readonly fields?: ReadonlyArray<string>;
+  readonly reason?: string;
+  readonly id?: string;
+  readonly meta?: unknown;
+  /**
+   * The domain of the builder that made the rule. Two domains may have the
+   * same types but other paths, so the types can not tell them apart. It is
+   * not in the JSON form of a rule.
+   */
+  readonly domain?: Any$2;
+}
+/**
+ * Any rule.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type AnyRule = Rule<any, never, any>;
+/**
+ * A resource in a rule: a kind name, a resource of the domain, or `"*"`.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type RuleTarget<D> = Kind$1<D> | Resources<D> | "*";
+/**
+ * The kind name of a target.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type KindOf<T> = T extends string ? T : Kind<T>;
+/**
+ * The actions that a rule may use for the kinds `K`.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type ActionFor<D, K> = "*" | ("*" extends K ? AnyAction<D> : ActionOf<D, Extract<K, string>>);
+/**
+ * The targets in the resource argument of a rule: the one target, or the
+ * targets of a list.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 1.0.0
+ */
+export type TargetOf<Res> = Res extends ReadonlyArray<infer X> ? X : Res;
+/**
+ * The actions that a rule may use for its resource argument. A list of
+ * resources may use an action of any of them. One target with a union type
+ * may use only an action of every kind in the union, because its value may be
+ * any one of them. When the argument may be a list or one target, the rule
+ * may use only an action that each of these shapes allows.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 1.0.0
+ */
+export type ActionForTargets<D, Res> = (Res extends ReadonlyArray<infer X> ? (action: ActionFor<D, KindOf<X>>) => void : (action: ActionForTarget<D, Res>) => void) extends ((action: infer A) => void) ? A : never;
+/** The actions for one target that is not a list. */
+type ActionForTarget<D, Res> = "*" | ("*" extends KindOf<Res> ? AnyAction<D> : CommonAction<D, Extract<KindOf<Res>, string>>);
+/**
+ * The data type of the kinds `K`. For `"*"` it has no fields.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type DataFor<D, K> = "*" extends K ? {} : DataOf<D, Extract<K, string>>;
+/**
+ * The value type of the kinds `K`.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type ValueFor<D, K> = "*" extends K ? AnyValue<D> : ValueOf<D, Extract<K, string>>;
+/**
+ * A field name or a field pattern of the kinds `K`.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type FieldFor<D, K> = FieldName<DataFor<D, K>> | `${string}*${string}`;
+/**
+ * A condition that a rule for the kinds `K` may have. Its predicates may read
+ * only the values of these kinds and the principal of the domain.
+ *
+ * @stability stable
+ * @category models
+ * @since 1.0.0
+ */
+export type ConditionFor<D, K> = Condition<Reads<ValueFor<D, K>, Principal<D>>, any>;
+/**
+ * The options of a rule.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface RuleOptions<D, K, C extends Any$1> {
+  /** The condition. It gets a builder with the types of the resource. */
+  readonly when?: (builder: Builder$1<DataFor<D, K>, ValueFor<D, K>, Principal<D>>) => C;
+  readonly fields?: ReadonlyArray<FieldFor<D, K>>;
+  readonly reason?: string;
+  readonly id?: string;
+  readonly meta?: Meta<D>;
+}
+type SingleOrArray<A> = A | ReadonlyArray<A>;
+/**
+ * Makes rules with the types of a domain.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Builder<D> {
+  readonly allow: <const Res extends SingleOrArray<RuleTarget<D>>, const A extends ActionForTargets<D, Res>, const C extends ConditionFor<D, KindOf<TargetOf<Res>>> = Condition>(action: SingleOrArray<A>, resource: Res, options?: RuleOptions<D, KindOf<TargetOf<Res>>, C>) => Rule<D, ReadsOf<C>, OpaqueOf$1<C>>;
+  readonly deny: <const Res extends SingleOrArray<RuleTarget<D>>, const A extends ActionForTargets<D, Res>, const C extends ConditionFor<D, KindOf<TargetOf<Res>>> = Condition>(action: SingleOrArray<A>, resource: Res, options?: RuleOptions<D, KindOf<TargetOf<Res>>, C>) => Rule<D, ReadsOf<C>, OpaqueOf$1<C>>;
+}
+/**
+ * Makes rules with the types of a domain. `Policy.define` gives one to its
+ * generator. Use this one to make rules outside of a generator.
+ *
+ * @example
+ * ```ts
+ * const _ = Policy.builder(App)
+ * const rule = _.allow("read", Document, {
+ *   when: ($) => $.eq("ownerId", $.principal("id")),
+ * })
+ * ```
+ *
+ * @stability stable
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const builder: <D extends Any$2>(domain: D) => Builder<D>;
+/**
+ * Makes a rule from its data, with no types. It does not check the data
+ * against a domain: a policy does that when the rule goes into it. Use
+ * {@link builder} for rules with types, or {@link schema} for rules from JSON.
+ *
+ * The condition may not have a predicate. A policy checks the fields of a
+ * condition against the resources of its rule, but it can not check what
+ * the code of a predicate reads. A rule from the builder keeps that in its
+ * types; this one could give a predicate of one kind to another kind.
+ *
+ * @stability stable
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const rule: <I = unknown>(data: RuleShape<I, never>) => Rule<any, NoInfer<I>>;
 /**
  * The options of a list of rules.
  *
@@ -295,13 +415,26 @@ export interface Options {
   readonly algorithm?: Algorithm;
 }
 /**
- * Makes a policy from a list of rules.
+ * The error when a rule does not fit its domain: it names a kind, an action,
+ * a field or a field of the principal that the domain does not have, or it
+ * tests a field with a value that the field can not hold. It has one issue
+ * for each problem, with its path, and a suggestion when a name has a mistake.
  *
  * @stability stable
- * @category constructors
- * @since 0.3.0
+ * @category errors
+ * @since 2.0.0
+ */
+export declare const PolicyError: typeof PolicyError$1;
+/**
+ * @stability stable
+ * @category errors
+ * @since 2.0.0
  */
-export declare const rules: <D extends Any$1, Rules extends Rule<any, any, any, D, never>>(domain: D, rules: Iterable<Rules>, options?: Options) => Policy<D, Error$1<Rules>, Services$1<Rules>, OpaqueOf$1<Rules>>;
+export type PolicyError = PolicyError$1;
+/** The mark of a union of rules: `Condition.Opaque` when one has a predicate. */
+type RulesOpaque<Rules> = Rules extends {
+  readonly "~Opaque": () => infer X;
+} ? X : never;
 /**
  * Makes a policy from a generator function that gives rules. It is pure and it
  * gives its result at once.
@@ -320,16 +453,8 @@ export declare const rules: <D extends Any$1, Rules extends Rule<any, any, any,
  * @category constructors
  * @since 0.3.0
  */
-export declare const define: <D extends Any$1>(domain: D, options?: Options) => <Rules extends Rule<any, any, any, D, never>, A>(body: (builder: Builder$1<D>) => Generator<Rules, A, unknown>) => Policy<D, Error$1<Rules>, Services$1<Rules>, OpaqueOf$1<Rules>>;
-/**
- * A policy with no rules. It is not applicable to any request.
- *
- * @stability stable
- * @category constructors
- * @since 0.3.0
- */
-export declare const empty: <D extends Any$1>(domain: D) => Policy<D>;
-type Combined<D extends Any$1, Ps extends ReadonlyArray<Any>> = Policy<D, Error<Ps[number]>, Services<Ps[number]>, OpaqueOf<Ps[number]>>;
+export declare const define: <D extends Any$2>(domain: D, options?: Options) => <Rules extends Rule<D, never, any>, A>(body: (builder: Builder<D>) => Generator<Rules, A, unknown>) => Policy<D, RulesOpaque<Rules>>;
+type Combined<D extends Any$2, Ps extends ReadonlyArray<Any>> = Policy<D, OpaqueOf<Ps[number]>>;
 /**
  * Every policy must allow, and one deny is enough to deny. With some policies
  * not applicable and none that deny, the result is not applicable.
@@ -338,7 +463,7 @@ type Combined<D extends Any$1, Ps extends ReadonlyArray<Any>> = Policy<D, Error<
  * @category combinators
  * @since 0.3.0
  */
-export declare const all: <const Ps extends readonly [Policy<any, any, any, any>, ...Array<Any>]>(policies: Ps) => Combined<DomainOf<Ps[0]>, Ps>;
+export declare const all: <const Ps extends readonly [Any, ...Array<Any>]>(policies: Ps) => Combined<DomainOf<Ps[0]>, Ps>;
 /**
  * One allow is enough. Without an allow, one deny gives a deny.
  *
@@ -346,7 +471,7 @@ export declare const all: <const Ps extends readonly [Policy<any, any, any, any>
  * @category combinators
  * @since 0.3.0
  */
-export declare const any: <const Ps extends readonly [Policy<any, any, any, any>, ...Array<Any>]>(policies: Ps) => Combined<DomainOf<Ps[0]>, Ps>;
+export declare const any: <const Ps extends readonly [Any, ...Array<Any>]>(policies: Ps) => Combined<DomainOf<Ps[0]>, Ps>;
 /**
  * The first policy that allows or denies gives the answer.
  *
@@ -354,7 +479,7 @@ export declare const any: <const Ps extends readonly [Policy<any, any, any, any>
  * @category combinators
  * @since 0.3.0
  */
-export declare const firstOf: <const Ps extends readonly [Policy<any, any, any, any>, ...Array<Any>]>(policies: Ps) => Combined<DomainOf<Ps[0]>, Ps>;
+export declare const firstOf: <const Ps extends readonly [Any, ...Array<Any>]>(policies: Ps) => Combined<DomainOf<Ps[0]>, Ps>;
 /**
  * Puts a limit on a policy. A deny from `cap` always wins. An allow from `cap`
  * does nothing.
@@ -364,8 +489,8 @@ export declare const firstOf: <const Ps extends readonly [Policy<any, any, any,
  * @since 0.3.0
  */
 export declare const ceiling: {
-  <D extends Any$1, E2, R2, O2>(cap: Policy<D, E2, R2, O2>): <E, R, O>(policy: Policy<D, E, R, O>) => Policy<D, E | E2, R | R2, O | O2>;
-  <D extends Any$1, E, R, O, E2, R2, O2>(policy: Policy<D, E, R, O>, cap: Policy<D, E2, R2, O2>): Policy<D, E | E2, R | R2, O | O2>;
+  <D extends Any$2, X2>(cap: Policy<D, X2>): <X>(policy: Policy<D, X>) => Policy<D, X | X2>;
+  <D extends Any$2, X, X2>(policy: Policy<D, X>, cap: Policy<D, X2>): Policy<D, X | X2>;
 };
 /**
  * Gives the services in `context` to every predicate of a policy, so the
@@ -376,24 +501,9 @@ export declare const ceiling: {
  * @since 1.0.0
  */
 export declare const provideContext: {
-  <R>(context: Context.Context<R>): <D extends Any$1, E, O>(policy: Policy<D, E, R, O>) => Policy<D, E, never, O>;
-  <D extends Any$1, E, R, O>(policy: Policy<D, E, R, O>, context: Context.Context<R>): Policy<D, E, never, O>;
+  <R>(context: Context.Context<R>): <D extends Any$2, X>(policy: Policy<D, X> & ([ServicesOf<X>] extends [R] ? unknown : never)) => Policy<D, Provided<X>>;
+  <D extends Any$2, X>(policy: Policy<D, X>, context: Context.Context<ServicesOf<X>>): Policy<D, Provided<X>>;
 };
-/**
- * Tests if a request fits its kind: the action is an action of the kind, and
- * the field, if there is one, is a field of the kind. The types check this,
- * but a value with a union type, or a value from outside, may get past them.
- * A rule for every action (`"*"`) must not cover an action that the kind does
- * not have, so such a request is not applicable.
- *
- * @stability stable
- * @category predicates
- * @since 1.0.0
- */
-export declare const fitsKind: (descriptor: Descriptor, request: {
-  readonly action: string;
-  readonly field?: string | undefined;
-}) => boolean;
 /**
  * Gives the decision of a policy for a request.
  *
@@ -401,10 +511,7 @@ export declare const fitsKind: (descriptor: Descriptor, request: {
  * @category evaluation
  * @since 0.3.0
  */
-export declare const decide: {
-  <D extends Any$1 = never>(request: Request<D>): <E, R, O>(policy: Policy<D, E, R, O>) => Effect.Effect<Decision, E, R>;
-  <D extends Any$1, E, R, O>(policy: Policy<D, E, R, O>, request: Request<NoInfer<D>>): Effect.Effect<Decision, E, R>;
-};
+export declare const decide: <D extends Any$2, X>(policy: Policy<D, X>, request: Request<NoInfer<D>>) => Effect.Effect<Decision, ErrorOf<X>, ServicesOf<X>>;
 /**
  * Gives the decision of a policy with no predicates, at once.
  *
@@ -412,29 +519,22 @@ export declare const decide: {
  * @category evaluation
  * @since 0.3.0
  */
-export declare const decideSync: {
-  <D extends Any$1 = never>(request: Request<D>): (policy: Policy<D>) => Decision;
-  <D extends Any$1>(policy: Policy<D>, request: Request<NoInfer<D>>): Decision;
-};
+export declare const decideSync: <D extends Any$2>(policy: Policy<D>, request: Request<NoInfer<D>>) => Decision;
 /**
  * Gives the decision of a policy and the rules that were tested to make it.
  *
- * One node may be a child of many nodes. A node with no predicate that the
- * request may use gives the same decision each time, so its rules are tested,
- * and are in the steps, only the first time. So a small tree with many shared
- * nodes gives a short list of steps.
+ * One node may be a child of many nodes. Its rules are tested, and are in the
+ * steps, each time that the decision comes to it.
  *
  * @stability stable
  * @category evaluation
  * @since 0.3.0
  */
-export declare const explain: {
-  <D extends Any$1 = never>(request: Request<D>): <E, R, O>(policy: Policy<D, E, R, O>) => Effect.Effect<Explanation, E, R>;
-  <D extends Any$1, E, R, O>(policy: Policy<D, E, R, O>, request: Request<NoInfer<D>>): Effect.Effect<Explanation, E, R>;
-};
+export declare const explain: <D extends Any$2, X>(policy: Policy<D, X>, request: Request<NoInfer<D>>) => Effect.Effect<Explanation, ErrorOf<X>, ServicesOf<X>>;
 /**
  * Gives the fields of a resource value that the policy lets a request use. It
- * tests each field of the resource Schema, with dots for nested fields.
+ * tests each field that a list of fields shows: each scalar, record or array
+ * of the resource Schema, with dots for nested fields.
  *
  * A field that holds more than one value, such as a record, is left out when a
  * deny rule names a part of it. The list can not name that part, and the whole
@@ -444,48 +544,7 @@ export declare const explain: {
  * @category evaluation
  * @since 0.3.0
  */
-export declare const permittedFields: {
-  <D extends Any$1 = never>(request: FieldlessRequest<D>): <E, R, O>(policy: Policy<D, E, R, O>) => Effect.Effect<ReadonlyArray<string>, E, R>;
-  <D extends Any$1, E, R, O>(policy: Policy<D, E, R, O>, request: FieldlessRequest<NoInfer<D>>): Effect.Effect<ReadonlyArray<string>, E, R>;
-};
-/**
- * The two residual conditions of a request. See {@link residuals}.
- *
- * @stability stable
- * @category models
- * @since 1.0.0
- */
-export interface Residuals<E = never, R = never, O = never, I = unknown> {
-  /** The condition on resource values for which the policy allows. */
-  readonly allow: Condition<E, R, O, I>;
-  /** The condition on resource values for which the policy denies. */
-  readonly deny: Condition<E, R, O, I>;
-}
-/**
- * A request about a kind of resource, with no types.
- *
- * @stability stable
- * @category models
- * @since 1.0.0
- */
-export interface AnyKindRequest {
-  readonly principal: object;
-  readonly action: string;
-  readonly kind: string;
-  readonly field?: string | undefined;
-  /**
-   * A scope needs the types of the domain for its builder. With the request
-   * first, the domain is not known yet, so give the policy first.
-   */
-  readonly within?: never;
-}
-/**
- * `unknown` when the request `Req` is a request of the type `T`, and `never`
- * when it is not. With the request first and the policy later, the request is
- * checked when the policy, and so the domain, is known. For a union, each
- * member must be such a request.
- */
-type Fits<Req, T> = [Req] extends [T] ? unknown : never;
+export declare const permittedFields: <D extends Any$2, X>(policy: Policy<D, X>, request: FieldlessRequest<NoInfer<D>>) => Effect.Effect<ReadonlyArray<string>, ErrorOf<X>, ServicesOf<X>>;
 /**
  * What a residual condition reads: a value of the kind `K`. The principal is
  * already in it. A residual is for one kind, so when `K` is a union of kinds,
@@ -497,14 +556,6 @@ type Fits<Req, T> = [Req] extends [T] ? unknown : never;
  * @since 1.0.0
  */
 export type ResidualReads<D, K> = Reads<(K extends unknown ? (value: ValueOf<D, K & string>) => void : never) extends ((value: infer V) => void) ? V : never, unknown>;
-/** A request about a kind with no types, with the scope of a target. */
-interface ScopedRequest {
-  readonly principal: object;
-  readonly action: string;
-  readonly kind: string;
-  readonly field?: string | undefined;
-  readonly within?: unknown;
-}
 /**
  * Gives the condition on resource values for which the policy allows a
  * request. It has no principal fields and no `Under` nodes, so you can give it
@@ -524,31 +575,14 @@ interface ScopedRequest {
  *
  * A policy tree may use the condition of a child two times, so a small policy
  * may give a very large condition. When the condition would have more than
- * 10000 nodes or 500 levels, this function throws an error. In an
- * `Authorizer`, the error is
- * a defect, so the check fails.
+ * 10000 nodes, this function throws an error. In an `Authorizer`, the error
+ * is a defect, so the check fails.
  *
  * @stability stable
  * @category evaluation
  * @since 0.3.0
  */
-export declare const residual: {
-  <const Req extends AnyKindRequest>(request: Req): <D extends Any$1, E, R, O>(policy: Policy<D, E, R, O> & Fits<Req, KindRequest<D>>) => Condition<E, R, O, ResidualReads<D, Req["kind"]>>;
-  <D extends Any$1, E, R, O, const Req extends KindRequest<NoInfer<D>>>(policy: Policy<D, E, R, O>, request: Req): Condition<E, R, O, ResidualReads<D, Req["kind"]>>;
-};
-/**
- * Gives both residual conditions of a request: the values that the policy
- * allows, and the values that it denies. A value in neither is not
- * applicable. See {@link residual}.
- *
- * @stability stable
- * @category evaluation
- * @since 1.0.0
- */
-export declare const residuals: {
-  <const Req extends AnyKindRequest>(request: Req): <D extends Any$1, E, R, O>(policy: Policy<D, E, R, O> & Fits<Req, KindRequest<D>>) => Residuals<E, R, O, ResidualReads<D, Req["kind"]>>;
-  <D extends Any$1, E, R, O, const Req extends KindRequest<NoInfer<D>>>(policy: Policy<D, E, R, O>, request: Req): Residuals<E, R, O, ResidualReads<D, Req["kind"]>>;
-};
+export declare const residual: <D extends Any$2, X, const Req extends KindRequest<NoInfer<D>>>(policy: Policy<D, X>, request: Req) => Condition<ResidualReads<D, Req["kind"]>, X>;
 /**
  * How much of a scope a policy allows. In each case, `condition` is the exact
  * condition on the values in the scope that the policy allows: give it to
@@ -568,67 +602,43 @@ export declare const residuals: {
  * @category models
  * @since 1.0.0
  */
-export type Coverage<E = never, R = never, O = never, I = unknown> = Data.TaggedEnum<{
+export type Coverage<I = unknown, X = never> = Data.TaggedEnum<{
   All: {
-    readonly condition: Condition<E, R, O, I>;
+    readonly condition: Condition<I, X>;
   };
   None: {
-    readonly condition: Condition<E, R, O, I>;
+    readonly condition: Condition<I, X>;
   };
   Some: {
-    readonly condition: Condition<E, R, O, I>;
+    readonly condition: Condition<I, X>;
     readonly allowed: Example;
     readonly refused: Example;
   };
   Unknown: {
-    readonly condition: Condition<E, R, O, I>;
-    readonly reason: "predicate" | "budget" | "schema";
+    readonly condition: Condition<I, X>;
+    readonly reason: "predicate" | "budget";
   };
 }>;
-/**
- * Tests if the scope of a request has a value of the Schema of its kind. The
- * answer is `true` only when the search finds such a value. When the search
- * can not say, the answer is `false`. So a "yes" from it is safe to act on,
- * as for the question "may the decider answer for this scope?".
- *
- * @stability stable
- * @category evaluation
- * @since 1.0.0
- */
-export declare const scopeHasValue: (policy: Any, request: ScopedRequest) => boolean;
-/**
- * Tests if the scope of a request has no value of the Schema of its kind. A
- * scope with a mistake, such as two values for one field, is empty. With no
- * scope, the answer is `false` when the kind has a value. When the search can
- * not say, the answer is `false`.
- *
- * @stability stable
- * @category evaluation
- * @since 1.0.0
- */
-export declare const scopeIsEmpty: (policy: Any, request: ScopedRequest) => boolean;
 /**
  * Tells how much of a scope the policy allows: all of it, none of it, or some
  * of it. See {@link Coverage}. With no scope (`within`), the scope is every
  * value of the kind.
  *
- * The answer comes from {@link Condition.satisfiable} with the Schema of the
- * resource, so it is exact for the values of the Schema. When a condition
- * tests a field that is not a plain scalar (see `Resource.isPlainField`),
- * such as a field with a check other than a finite or integer check, the
- * answer is `Unknown`, and a check on the kind says no.
+ * The answer comes from {@link Condition.satisfiable} with the shape of the
+ * Schema of the resource. `All` and `None` hold for every value of the
+ * Schema. `Some` means that, by the shape of the Schema, a value may get
+ * either answer: a check such as a minimum length may still stop one of the
+ * examples. `Unknown` comes only from a predicate or from the budget of the
+ * search.
  *
- * `Some` means that some value of the Schema is allowed. It does not mean that
- * such a value is in your database. To know that, run `condition` as a query.
+ * `Some` does not mean that such a value is in your database. To know that,
+ * run `condition` as a query.
  *
  * @stability stable
  * @category evaluation
  * @since 1.0.0
  */
-export declare const coverage: {
-  <const Req extends AnyKindRequest>(request: Req): <D extends Any$1, E, R, O>(policy: Policy<D, E, R, O> & Fits<Req, KindRequest<D>>) => Coverage<E, R, O, ResidualReads<D, Req["kind"]>>;
-  <D extends Any$1, E, R, O, const Req extends KindRequest<NoInfer<D>>>(policy: Policy<D, E, R, O>, request: Req): Coverage<E, R, O, ResidualReads<D, Req["kind"]>>;
-};
+export declare const coverage: <D extends Any$2, X, const Req extends KindRequest<NoInfer<D>>>(policy: Policy<D, X>, request: Req) => Coverage<ResidualReads<D, Req["kind"]>, X>;
 /**
  * The JSON form of a rule.
  *
@@ -665,23 +675,20 @@ export type EncodedNode = {
   readonly cap: EncodedNode;
   readonly policy: EncodedNode;
 };
-/**
- * Tests if a value is a policy.
- *
- * @stability stable
- * @category guards
- * @since 0.3.0
- */
-export declare const isPolicy: (u: unknown) => u is Any;
 /**
  * The Schema of the policies of a domain with no predicates. Decoding checks
  * every kind, action, field and principal field against the domain, and the
  * `meta` of each rule against the `meta` Schema of the domain.
  *
+ * The decoder takes at most 256 levels of policies and 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: <D extends Any$1>(domain: D) => Schema.Codec<Policy<D>, EncodedNode>;
+export declare const schema: <D extends Any$2>(domain: D) => Schema.Codec<Policy<D>, EncodedNode>;
 export { Policy_d_exports };
 //# sourceMappingURL=Policy.d.ts.map