@nmnmcc/ability 2.0.4 → 2.0.6

package/README.md

@@ -211,13 +211,13 @@ resource of the rule. Did you mean "title"?
 
 A condition reads only the data fields of a value: an own field that a loop over
 the keys sees. A rule that names a getter of a class is a `PolicyError`. Use a
-predicate for a value that comes from code. A condition may not read a field
-below a value that may not be plain data: a class in a union that does not have
-the field, a list, a date, or a value of `Schema.Unknown`. Such a rule is a
-`PolicyError` too. A struct without the field is fine: a decode or a `make`
-copies it into a plain object, so the field reads `null`. A test reads only the
-fields that the simple form of its condition needs, as the residual does: in
-`x AND False`, it does not read `x`.
+predicate for a value that comes from code. A condition may not read a field, of
+a resource or of the principal, below a value that may not be plain data: a
+class in a union that does not have the field, a list, a date, or a value of
+`Schema.Unknown`. Such a rule is a `PolicyError` too. A struct without the field
+is fine: a decode or a `make` copies it into a plain object, so the field reads
+`null`. A test reads only the fields that the simple form of its condition
+needs, as the residual does: in `x AND False`, it does not read `x`.
 
 ## Conditions
 

package/dist/Condition.d.ts

@@ -1,14 +1,14 @@
 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 Chunk from "effect/Chunk";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-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";
@@ -276,7 +276,7 @@ type FieldPathInternal<T, Depth extends number, Arrays extends boolean, Parents
  */
 type PathsOf<K extends string, V, Depth extends number, Arrays extends boolean, Parents extends boolean> = ([V] extends [never] ? K : {} extends V ? K : never) | ([Extract<V, Leaf | Whole>] extends [never] ? never : K) | ([Extract<V, ReadonlyArray<unknown>>] extends [never] ? never : Arrays extends true ? K : never) | (Arrays extends true ? ObjectPaths<K, Exclude<V, Leaf | Whole | Function | ReadonlyArray<unknown>>, Depth, Arrays, Parents> : [Extract<V, Whole | Function | ReadonlyArray<unknown>>] extends [never] ? ObjectPaths<K, Exclude<V, Leaf>, Depth, Arrays, Parents> : never);
 /** 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 : number extends keyof O ? K : never : never) | `${K}.${FieldPathInternal<O, PreviousDepth[Depth], Arrays, Parents>}`;
+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 : number extends keyof O ? K : [Depth] extends [0] ? 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

package/dist/Condition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Condition.d.ts","names":["Nodes.Scalar","Nodes.Literal","Nodes.PrincipalRef","Nodes.CompareOperator","Nodes.True","Nodes.False","Nodes.Compare","Nodes.In","Nodes.Exists","Nodes.Under","Nodes.And","Nodes.Or","Nodes.Not","Nodes.Predicate","Nodes.Node","Resource.PathSegment","Search.Example","Search.Satisfiability"],"sources":["../src/Condition.ts"],"mappings":"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"}
+{"version":3,"file":"Condition.d.ts","names":["Nodes.Scalar","Nodes.Literal","Nodes.PrincipalRef","Nodes.CompareOperator","Nodes.True","Nodes.False","Nodes.Compare","Nodes.In","Nodes.Exists","Nodes.Under","Nodes.And","Nodes.Or","Nodes.Not","Nodes.Predicate","Nodes.Node","Resource.PathSegment","Search.Example","Search.Satisfiability"],"sources":["../src/Condition.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;YA4DY,SAASA;;;;;;;;YAST,UAAUC;;;;;;;;;;;;;;YAeV,eAAeC;;;;;;;;;;;YAYf,IAAI,GAAG,aAAa;WACtB,cAAc;WACd,eAAe,WAAW;;;;;;;YAQxB,UAAU,UAAU;;;;;;YAOpB,kBAAkBC;;;;;;;;YASlB,OAAOC;;;;;;;;YASP,QAAQC;;;;;;;;;;YAWR,UAAUC;;;;;;;;YASV,KAAKC;;;;;;;;YASL,SAASC;;;;;;;;;YAUT,QAAQC;;;;;;YAOR,MAAMC;;;;;;YAON,KAAKC;;;;;;YAOL,MAAMC;;;;;;;;YASN,YAAYC;;;;;;;;;;YAWZ,MAAMC;;;;;;;;;iBAUD,WAAW,eAAe;WACjC;aAAsB,GAAG;aAAY,GAAG;;;;;;;;;;;YAWtC,QAAQ,KAAK,UAAU,aAAa,SAAS,MAAM;;;;;;;;;YAUnD,WAAW,KAAK,UAAU,aAAa,UAAU,KAAK;;;;;;;;YAStD,SAAS,KACpB,UAAU,aAAa,SAAS,MAAM,OAAO,KAAK;;;;;;;;;iBAUlC,MAAM,GAAG;WAChB,OAAO;WACP,WAAW;;;;;;;;;;;;;;;;YAiBT,UAAU,aAAa,aAAa;WACtC,WAAW,OAAO;WAClB,iBAAiB;;;;;;;;;YAUf,MAAM;;;;;;;;;YAUN,QAAQ,MAAM;WACd,WAAW,aAAa;KAEjC;;;;;;;;YAUS,SAAS,KAAK;WAAqB,uBAAuB;IACnE;KAGE;;;;;;KAMA,QACF,gCACA,uBACA,QAAQ,4BACR,QAAQ,mBACR,OACA,MACA,aACA,OAAO,kBACP,WAAW,aACX,SAAS,WACT,SAAS,WACT,SAAS,oBACT,MAAM,iBACN,MAAM,iBACN,OAAO,2BACP,KAAK,yBACL,OACA,WACA,SACA;KACE;KACA,kBACJ,GACA,sBACA,wBACA,oCACI,oCAID,WAAW,0BAA0B,WAClC,KACH,YAAY,EAAE,KACd,OACA,QACA,kBAEM;;;;;;KAOL,QACJ,kBACA,GACA,sBACA,wBACA,6BAII,qBAAqB,eAAe,IAAI,eACxC,QAAQ,GAAG,OAAO,kCAAkC,OACpD,QAAQ,GAAG,mDAEX,sBACC,cAMF,sBACC,YACA,GACA,QAAQ,GAAG,OAAO,QAAQ,WAAW,yBACrC,OACA,QACA,YAEC,QAAQ,GAAG,QAAQ,WAAW,2CAC9B,YAAY,GAAG,QAAQ,GAAG,OAAO,OAAO,QAAQ;;KAIjD,YACJ,kBACA,GACA,sBACA,wBACA,4BACI,8BAKA,uBACC,IACA,2CACsB,IACpB,yBACqB,IACpB,KACC,qBACA,wBAGH,KAAK,kBAAkB,GAAG,cAAc,QAAQ,QAAQ;;;;;;;;;;;;;;YAenD,UAAU,MAAM,sBACzB,kBAAkB;;;;;;;;;;;YAaT,cAAc,MAAM,sBAC7B,kBAAkB;;;;;;;;;;YAYT,UAAU,MAAM,sBACzB,kBAAkB;;;;;;;;;;;;YAcT,WAAW,MAAM,qBAC5B,uBACG,qBACE,OAAO,UAAU,MAAM,uCAGlB,aAAa,cACrB;KAGE,UAAU,KAAK,QAAQ,mCAAmC;;;;;;;;;;YAWnD,UAAU,GAAG,uBAAuB,oBAC7C,YAAY,GAAG;;KAIb,YAAY,GAAG,uBAAuB,mBACxC,sBAAsB,cAAc,SACnC,UAAU,QAAQ,GAAG,OAAO,QAC5B,UAAU,QAAQ,GAAG;;;;;KAOpB,QAAQ,GAAG,uBAAuB,mBAAmB,IACvD,EAAE,QACF,sBAAsB,qBACrB,gBAAgB,IACf,EAAE,0BACmB,IACpB;;;;;;;;;YAYM,UAAU,GAAG,aAAa,QAAQ,GAAG,UAAU,IAAI,GAAG;KAE7D,WAAW,QACd,KAAK,UAAU,KAAK,UAAU,GAAG,WAAW,SAAS,aACrD,UAAU;KAEP,YAAY,QACf,KAAK,UAAU,KAAK,QAAQ,UAAU,GAAG,oCACvC,aAEF,UAAU;;;;;;;;;;;YAYA,KAAK,OAAO,eAAe,UAAU,MAAM,OAAO;;;;;;KAOzD,YAAY,GAAG,OAAO,QAAQ,GAAG,4CAElC,QAAQ,GAAG;WACA,eAAe,iBAAiB;KAE3C;;;;;;;;;iBAWa,QAAQ,MAAM,OAAO;;WAE5B,WACF,UAAU,UAAU,aACpB,UAAU,UAAU,WAAW,MAAM,UAE3C,OAAO,GACP,OAAO,MACH,KAAK,OAAO,YAAY,GAAG;;WAEvB,WACF,UAAU,UAAU,aACpB,UAAU,UAAU,WAAW,MAAM,UAE3C,OAAO,GACP,OAAO,MACH,KAAK,OAAO,YAAY,GAAG;WACvB,WACF,UAAU,YAAY,aACtB,UAAU,UAAU,QAAQ,WAAW,MAAM,iBAEnD,OAAO,GACP,OAAO,MACH,KAAK,OAAO,YAAY,GAAG;WACvB,YACF,UAAU,YAAY,aACtB,UAAU,UAAU,QAAQ,WAAW,MAAM,iBAEnD,OAAO,GACP,OAAO,MACH,KAAK,OAAO,YAAY,GAAG;WACvB,WACF,UAAU,YAAY,aACtB,UAAU,UAAU,QAAQ,WAAW,MAAM,iBAEnD,OAAO,GACP,OAAO,MACH,KAAK,OAAO,YAAY,GAAG;WACvB,YACF,UAAU,YAAY,aACtB,UAAU,UAAU,QAAQ,WAAW,MAAM,iBAEnD,OAAO,GACP,OAAO,MACH,KAAK,OAAO,YAAY,GAAG;;WAEvB,WACF,UAAU,UAAU,aACpB,WAAW,cAAc,UAAU,WAAW,MAAM,WAE1D,OAAO,GACP,QAAQ,OACJ,KAAK,OAAO,YAAY,YAAY;;WAEhC,eAAe,UAAU,UAAU,OAAO,OAAO,MAAM,KAAK;;WAE5D,cACF,WAAW,8BAA8B,6BAE5C,QAAQ,OACP,KAAK,OAAO,YAAY,YAAY;;;;;WAKhC,kBAAkB,UAAU,WAAW,IAC/C,OAAO,MACH,IAAI,UAAU,GAAG,IAAI;WACjB,YAAY,WAAW,cAAc,SAC1C,YAAY,OACX,UAAU,QAAQ,aAAa,SAAS;WACpC,WAAW,WAAW,cAAc,SACzC,YAAY,OACX,UAAU,QAAQ,aAAa,SAAS;WACpC,MAAM,UAAU,KACxB,WAAW,MACP,UAAU,QAAQ,IAAI,SAAS;;;;;WAK3B,YAAY,WAAW,WAC/B,cACA,OACC,OAAO,OACP,WAAW,gBACG,OAAO,gBAAgB,GAAG,OACrC,UAAU,MAAM,OAAO,IAAI,OAAO,GAAG;;;;;;;;;;qBAmE9B,UAAW,MAAM,OAAO,QAAM,QAAQ,MAAM,OAAO;;;;;;;;qBAUnD,QAAQ;;;;;;;;qBASR,OAAO;;;;;;;;qBASP,YAAY,WAAW,cAAc,SAC9C,YAAY,OACX,UAAU,QAAQ,aAAa,SAAS;;;;;;;;;qBAYhC,SAAS,UAAU,KAC/B,YAAY,cAAc,OACtB,UAAU,QAAQ,IAAI,SAAS;;;;;;;;;qBAUvB,QAAQ,UAAU,KAC9B,YAAY,cAAc,OACtB,UAAU,QAAQ,IAAI,SAAS;;;;;;;;qBASvB,WAAW,WAAW,cAAc,SAC7C,YAAY,OACX,UAAU,QAAQ,aAAa,SAAS;;;;;;qBAShC,MAAM,UAAU,KAC5B,WAAW,MACP,UAAU,QAAQ,IAAI,SAAS;;;;;;;;iBASnB;;WAEP;;;;;WAKA;;WAEA,OAAO,cAAcC;;;;;;;;;;qBAclB;GACX,GACA,SAAS,QAAQ,QAAQ,MACtB,GAAG,GACN,WAAW,UAAU,GAAG,OACrB,WAAW,aAAa,0BACvB,UAAU,GAAG,SAAS;GAC1B,GAAG,GACH,WAAW,UAAU,GAAG,IACxB,SAAS,QAAQ,QAAQ,WAAW,MAClC,UAAU,GAAG,SAAS;;;;;;KASrB,WAAW,KACf,UAAU,YAAY,SAAS;WACjB,OAAO;qBAAuB;WAE5B,WAAW;;;;;;;;;;;;qBAaf,WAAW,GAAG,GAAG,WAAW,OACxC,WAAW,UAAU,GAAG,IACxB,OAAO,KAAK,WAAW,OACnB,OAAO,gBAAgB,QAAQ,IAAI,WAAW;;;;;;;;qBAatC,eAAe,GAAG,WAAW,OACzC,WAAW,UAAU,IACrB,OAAO,KAAK,WAAW;;;;;;;;;;qBAaX,WAAW,GAAG,GAAG,WAAW,UAAU,GAAG,OAAO,UAAU,GAAG;UAGhE;WACA;WACA,OAAO,cAAcA;;;;;;;KAQ1B,eAAe,KACnB,UAAU,YAAY,UAAU,qBACb;WAEJ,WAAW;;;KAItB,MAAM,KAAK,UAAU,YAAY,SAAS,MAAM,MAAM,cAAc;;;;;;;;;;;qBAY5D,UAAU,GAAG,GACzB,WAAW,UAAU,GAAG,IACxB,OAAO,eAAe,eAAe,OACjC,UAAU,MAAM,IAAI;;;;;;;;;iBAWR,YAAY;WACnB,YAAY;WACZ,aAAa;WACb,UAAU,IAAI,iBAAiB,eAAe,OAAO,WAAW;WAChE,KAAK,eAAe,QAAQ,cAAc,YAAY;WACtD,SAAS,kBAAkB;WAC3B,MAAM,YAAY,cAAc,OAAO;WACvC,KAAK,YAAY,cAAc,OAAO;WACtC,MAAM,WAAW,MAAM;;WAEvB,aAAa,iBAAiB;;;;;;;;;;;;qBAU3B,uBAAuB;;;;;;;;;;qBAmEvB;GACX,GACA,aAAa,YAAY,MACtB,WAAW,QAAQ,OAAO,OAAO,GAAG;GACvC,GACA,WAAW,KACX,aAAa,YAAY,KACvB,OAAO,OAAO,GAAG;;;;;;;;;qBAyBR,SAAM,WAAe,QAAM;;;;;;;;;;YAc5B,UAAUC;;;;;;;;;;;;YAaV,iBAAiBC;;;;;;;;iBASZ;;;;;WAKP,SAAS,OAAO;;WAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2BG,cAAW,WACZ,KAAG,UACL,uBACP;;;;;;;;YAkBS;WACE;WAA0B,OAAO;;WACjC;WAA4B;;;;;;;;;YAS9B;WACE;;WACA;;WAEF;WACA,IAAI;WACJ;WACA,OAAO;;WAGP;WACA;WACA,QAAQ,cAAc;;WAEpB;WAAyB;;WACzB;WAAwB,QAAQ,cAAc;;WAEhD;WACA,YAAY,cAAc;;WAExB;WAAsB,WAAW;;;;;;;;;;;;YAcnC,iBAAiB;;;;;;;;;;;;;qBAchB,QAAQ,OAAO,MAAM,gBAAgB"}

package/dist/Condition.js.map

@@ -1 +1 @@
-{"version":3,"file":"Condition.js","names":["Nodes.literal","Nodes.Compare","Nodes.And","Nodes.Or","Nodes.Not","Nodes.In","Nodes.Exists","Nodes.Under","Nodes.principalRef","Nodes.Predicate","Nodes.always","Nodes.never","Nodes.toNode","Algebra.provide","Algebra.evaluate","Algebra.evaluateSync","Algebra.simplify","Algebra.partial","Algebra.fields","Search.satisfiable","Search.kindsIn","Catalog.catalogOf","Nodes.isNode","Json.decode","Json.toJson"],"sources":["../src/Condition.ts"],"sourcesContent":["/**\n * A condition is a test on a resource value. A rule applies only when its\n * condition is true.\n *\n * A condition is plain data: a tree of nodes. So you can:\n * - test it on a value with {@link evaluate};\n * - put the principal into it and make it smaller with {@link partial}, which\n *   gives a \"residual\" condition: the part that still depends on the\n *   resource;\n * - change it into a database query with {@link fold};\n * - keep it as JSON with {@link schema}.\n *\n * Make conditions with a {@link Builder}. A rule gives you a builder for its\n * resource, so the field names and the value types are checked.\n *\n * {@link Builder.predicate} is the one way out of plain data. A predicate runs\n * any `Effect`. Its error type and its service type go into the type of the\n * check. A rule with a predicate can not become JSON, and the type system\n * stops you when you try.\n *\n * @stability stable\n * @since 0.3.0\n */\n// A predicate keeps its error type and service type in the public types. The\n// code below works on the nodes with no types, where they are `unknown`, so\n// the language service check for `unknown` in an Effect is off here.\n// @effect-diagnostics anyUnknownInErrorContext:off\nimport * as Arr from \"effect/Array\"\nimport type * as BigDecimal from \"effect/BigDecimal\"\nimport type * as Cause from \"effect/Cause\"\nimport type * as Chunk from \"effect/Chunk\"\nimport type * as DateTime from \"effect/DateTime\"\nimport type * as Duration from \"effect/Duration\"\nimport type * as Exit from \"effect/Exit\"\nimport type * as HashMap from \"effect/HashMap\"\nimport type * as HashSet from \"effect/HashSet\"\nimport type * as Option from \"effect/Option\"\nimport type * as Redacted from \"effect/Redacted\"\nimport type * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport { dual } from \"effect/Function\"\nimport { hasProperty } from \"effect/Predicate\"\nimport * as Schema from \"effect/Schema\"\nimport * as SchemaIssue from \"effect/SchemaIssue\"\nimport * as SchemaTransformation from \"effect/SchemaTransformation\"\nimport * as Result from \"effect/Result\"\nimport * as Algebra from \"./internal/algebra.ts\"\nimport * as Catalog from \"./internal/catalog.ts\"\nimport * as Json from \"./internal/json.ts\"\nimport * as Nodes from \"./internal/nodes.ts\"\nimport * as Search from \"./internal/search.ts\"\nimport * as Resource from \"./Resource.ts\"\n\n/**\n * A value that a condition can compare.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Scalar = Nodes.Scalar\n\n/**\n * A fixed value in a condition.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Literal = Nodes.Literal\n\n/**\n * A field of the principal. {@link partial} puts the value of the field in its\n * place.\n *\n * A principal field that is `null` or missing has no value. A `Compare`, `In`\n * or `Under` test with it is always false, also with `ne`. So a principal with\n * no id never matches a resource with no owner. `not` still turns false into\n * true.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type PrincipalRef = Nodes.PrincipalRef\n\n/**\n * A field of the principal with a known value type `A`, from a principal of\n * the type `P`. The type fields are only in the types. A test with the\n * reference reads a principal of the type `P`, so it can not go into a rule\n * of a domain with another principal.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Ref<A, P = never> = PrincipalRef & {\n\treadonly \"~Ref\": () => A\n\treadonly \"~Principal\": (principal: P) => void\n}\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Operand = Literal | PrincipalRef\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type CompareOperator = Nodes.CompareOperator\n\n/**\n * Always true.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type True = Nodes.True\n\n/**\n * Always false.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type False = Nodes.False\n\n/**\n * Compares a field with a value. A missing field has the value `null`. `lt`,\n * `lte`, `gt` and `gte` are false when the two sides are not both numbers or\n * both strings.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Compare = Nodes.Compare\n\n/**\n * True when a field is equal to one of the values.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type In = Nodes.In\n\n/**\n * True when a field is not `null` and not missing.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Exists = Nodes.Exists\n\n/**\n * True when the path of the resource starts with the prefix. A resource with\n * no path is never under a prefix.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Under = Nodes.Under\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type And = Nodes.And\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Or = Nodes.Or\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Not = Nodes.Not\n\n/**\n * A test that runs an `Effect`. It can not become JSON or a query.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Predicate = Nodes.Predicate\n\n/**\n * The nodes of a condition, without types. Each node is a class, and only the\n * builder, the functions of this module and the Schema make one. So a plain\n * object, or a spread of a node, is not a node.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Ast = Nodes.Node\n\n/**\n * The mark of a condition with a predicate. `E` and `R` are the error type\n * and the service type of its predicates.\n *\n * @stability stable\n * @category models\n * @since 2.0.0\n */\nexport interface Opaque<out E = never, out R = never> {\n\treadonly \"~Opaque\": { readonly E: E; readonly R: R }\n}\n\n/**\n * The error type of the predicates of a mark `X`. A mark that is not an\n * {@link Opaque}, as `unknown` or `object`, may have any error.\n *\n * @stability stable\n * @category utility types\n * @since 2.0.0\n */\nexport type ErrorOf<X> = X extends Opaque<infer E, infer _R> ? E : unknown\n\n/**\n * The service type of the predicates of a mark `X`. A mark that is not an\n * {@link Opaque}, as `unknown` or `object`, may need any service.\n *\n * @stability stable\n * @category utility types\n * @since 2.0.0\n */\nexport type ServicesOf<X> = X extends Opaque<infer _E, infer R> ? R : unknown\n\n/**\n * The mark `X` with no services.\n *\n * @stability stable\n * @category utility types\n * @since 2.0.0\n */\nexport type Provided<X> =\n\tX extends Opaque<infer E, infer _R> ? Opaque<E> : Opaque<unknown>\n\n/**\n * What the predicates of a condition read: a resource value of the type `V`\n * and a principal of the type `P`. It is only in the types.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport interface Reads<V, P> {\n\treadonly value: V\n\treadonly principal: P\n}\n\n/**\n * A condition. `I` is what its tests read: see {@link Reads}. `X` is\n * {@link Opaque} when the condition has a predicate, and `never` when it is\n * plain data. A plain condition can become JSON or a query.\n *\n * The two type fields are only in the types. `I` goes into a function as an\n * input, so a condition that reads a `Post` does not fit a rule for a\n * `Comment`. `X` comes out of a function, so a plain condition fits where a\n * condition with predicates may go.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Condition<I = unknown, X = never> = Ast & {\n\treadonly \"~Reads\": (reads: I) => void\n\treadonly \"~Opaque\": () => X\n}\n\n/**\n * Any condition.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Any = Condition<any, any>\n\n/**\n * What the tests of a condition read. For a union of conditions, it is what\n * all of them read.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type ReadsOf<C> = [C] extends [\n\t{ readonly \"~Reads\": (reads: infer I) => void },\n]\n\t? I\n\t: unknown\n\n/**\n * The mark of a condition: {@link Opaque} when it has a predicate.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type OpaqueOf<C> = C extends { readonly \"~Opaque\": () => infer X }\n\t? X\n\t: never\n\ntype Leaf = string | number | boolean | bigint | symbol | null | undefined\n/**\n * Values of a class that keeps its data inside. A path does not go into them,\n * as in the field paths of a resource, so a field with such a value is one\n * field. A condition can test only if it exists.\n */\ntype Whole =\n\t| ReadonlyMap<unknown, unknown>\n\t| ReadonlySet<unknown>\n\t| HashMap.HashMap<unknown, unknown>\n\t| HashSet.HashSet<unknown>\n\t| Date\n\t| URL\n\t| Uint8Array\n\t| Option.Option<unknown>\n\t| BigDecimal.BigDecimal\n\t| Duration.Duration\n\t| DateTime.DateTime\n\t| Redacted.Redacted<unknown>\n\t| Chunk.Chunk<unknown>\n\t| Cause.Cause<unknown>\n\t| Result.Result<unknown, unknown>\n\t| Exit.Exit<unknown, unknown>\n\t| File\n\t| FormData\n\t| RegExp\n\t| URLSearchParams\ntype PreviousDepth = [never, 0, 1, 2, 3]\ntype FieldPathInternal<\n\tT,\n\tDepth extends number,\n\tArrays extends boolean,\n\tParents extends boolean = false,\n> = [Depth] extends [never]\n\t? never\n\t: {\n\t\t\t// A record with number keys has number keys, as `counts.1`.\n\t\t\t[K in keyof T & (string | number)]-?: PathsOf<\n\t\t\t\t`${K}`,\n\t\t\t\tNonNullable<T[K]>,\n\t\t\t\tDepth,\n\t\t\t\tArrays,\n\t\t\t\tParents\n\t\t\t>\n\t\t}[keyof T & (string | number)]\n\n/**\n * The paths of one field `K` with the values `V`. Each kind of value in `V`\n * gives its own paths, so a field that holds a string or a struct is a field,\n * and the fields of the struct are fields too. A function is no field.\n */\ntype PathsOf<\n\tK extends string,\n\tV,\n\tDepth extends number,\n\tArrays extends boolean,\n\tParents extends boolean,\n> =\n\t// A field that is only ever `null` or missing is a field too, and so is a\n\t// field that may hold any value, as one of `Schema.Unknown` may.\n\t| ([V] extends [never] ? K : {} extends V ? K : never)\n\t| ([Extract<V, Leaf | Whole>] extends [never] ? never : K)\n\t| ([Extract<V, ReadonlyArray<unknown>>] extends [never]\n\t\t\t? never\n\t\t\t: Arrays extends true\n\t\t\t\t? K\n\t\t\t\t: never)\n\t// A condition reads a field below `K` only when `K` holds plain data: a\n\t// list, a whole value such as a date, or a function may have a getter or a\n\t// method with the name, so the binding does not take such a read. A rule\n\t// or a request names a field and does not read it, so it may.\n\t| (Arrays extends true\n\t\t\t? ObjectPaths<\n\t\t\t\t\tK,\n\t\t\t\t\tExclude<V, Leaf | Whole | Function | ReadonlyArray<unknown>>,\n\t\t\t\t\tDepth,\n\t\t\t\t\tArrays,\n\t\t\t\t\tParents\n\t\t\t\t>\n\t\t\t: [Extract<V, Whole | Function | ReadonlyArray<unknown>>] extends [never]\n\t\t\t\t? ObjectPaths<K, Exclude<V, Leaf>, Depth, Arrays, Parents>\n\t\t\t\t: never)\n\n/** The paths of a field `K` that holds the objects `O`, and of the fields below. */\ntype ObjectPaths<\n\tK extends string,\n\tO,\n\tDepth extends number,\n\tArrays extends boolean,\n\tParents extends boolean,\n> = [O] extends [never]\n\t? never\n\t: // A record is one field to a rule or a request, as `permittedFields`\n\t\t// lists it.\n\t\t| (Parents extends true\n\t\t\t\t? K\n\t\t\t\t: Arrays extends true\n\t\t\t\t\t? string extends keyof O\n\t\t\t\t\t\t? K\n\t\t\t\t\t\t: number extends keyof O\n\t\t\t\t\t\t\t? K\n\t\t\t\t\t\t\t: never\n\t\t\t\t\t: never)\n\t\t| `${K}.${FieldPathInternal<O, PreviousDepth[Depth], Arrays, Parents>}`\n\n/**\n * The paths of the fields of `T` that hold one value, with dots for nested\n * fields. Arrays are left out. A map, a set, a date, a URL, a byte array, an\n * `Option` and the other value types of Effect, such as `BigDecimal` and\n * `Duration`, are one field, and a path does not go into them. A path does\n * not go into a field that may hold one of them or a list either. The type\n * goes down four levels, so type checking stays fast. For a union of types,\n * only the common fields are paths.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type FieldPath<T> = [T] extends [object]\n\t? FieldPathInternal<T, 4, false>\n\t: never\n\n/**\n * The paths of the fields of `T` that a rule or a request may name, as in\n * `Rule.Options.fields`. They are the paths of {@link FieldPath}, and the\n * paths of arrays too: a rule may allow or deny a whole array field, and\n * `permittedFields` lists it.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type FieldSelector<T> = [T] extends [object]\n\t? FieldPathInternal<T, 4, true>\n\t: never\n\n/**\n * The names that the `fields` of a rule may have: the paths of\n * {@link FieldSelector}, and the paths of the structs above them. A name of a\n * struct covers the fields below it.\n *\n * @stability stable\n * @category utility types\n * @since 2.0.0\n */\nexport type FieldName<T> = [T] extends [object]\n\t? FieldPathInternal<T, 4, true, true>\n\t: never\n\n/**\n * The value type that fits every field in `F`. For one field, it is the type\n * of the field. For a union of fields, it is the values that each of them can\n * hold, so a value of a union type can not test a field of another type. For\n * a union of data types, as for a rule on two kinds, it is the values that\n * the field can hold in each of them.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type FieldValue<Data, F extends string> = (\n\tData extends unknown\n\t\t? F extends unknown\n\t\t\t? (value: PathValue<Data, F>) => void\n\t\t\t: never\n\t\t: never\n) extends (value: infer V) => void\n\t? V\n\t: never\n\ntype Normalize<A> = Exclude<A, undefined> | (undefined extends A ? null : never)\n\n/**\n * The type of the field of `T` at `Path`. A field that may be missing may also\n * be `null`. Each type of a union gives its own value: a field below a value\n * that is not an object, as below a string, is `null`, as a read of it is.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type PathValue<T, Path extends string> = T extends unknown\n\t? PathValueIn<T, Path>\n\t: never\n\n/** The type of the field at `Path` of `T`, which is not a union. */\ntype PathValueIn<T, Path extends string> = T extends object\n\t? Path extends `${infer Head}.${infer Rest}`\n\t\t? PathValue<ChildOf<T, Head>, Rest>\n\t\t: Normalize<ChildOf<T, Path>>\n\t: null\n\n/**\n * The type of the part `Name` of `T`. A part of a path is text, so the part\n * `\"1\"` names the number key `1` too, as of a record with number keys.\n */\ntype ChildOf<T, Name extends string> = Name extends keyof T\n\t? T[Name]\n\t: Name extends `${infer N extends number}`\n\t\t? N extends keyof T\n\t\t\t? T[N]\n\t\t\t: number extends keyof T\n\t\t\t\t? T[number]\n\t\t\t\t: never\n\t\t: never\n\n/**\n * A value for a field of type `A`: a fixed value, or a field of the principal\n * with the same type.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type OperandOf<A, P = never> = Extract<A, Scalar> | Ref<A, P>\n\ntype ScalarPath<T> = {\n\t[F in FieldPath<T>]: PathValue<T, F> extends Scalar ? F : never\n}[FieldPath<T>]\n\ntype OrderedPath<T> = {\n\t[F in FieldPath<T>]: Exclude<PathValue<T, F>, null> extends number | string\n\t\t? F\n\t\t: never\n}[FieldPath<T>]\n\n/**\n * A test made by a {@link Builder}. It runs no code, but it keeps the value\n * type of its resource, so a test on the fields of one resource can not go\n * into a rule for another resource. A test with a field of the principal\n * keeps the principal type `P` too.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Test<Value, P = unknown> = Condition<Reads<Value, P>>\n\n/**\n * The principal type that a test reads: the principal of each field of the\n * principal in the values `V`, and `unknown` when there is none. A reference\n * from another builder keeps the principal of that builder.\n */\ntype PrincipalOf<V, _P> = [Extract<V, PrincipalRef>] extends [never]\n\t? unknown\n\t: [Extract<V, PrincipalRef>] extends [\n\t\t\t\t{ readonly \"~Principal\": (principal: infer Q) => void },\n\t\t  ]\n\t\t? Q\n\t\t: unknown\n\n/**\n * Makes conditions for a resource with the data type `Data` and the value type\n * `Value`, and a principal with the type `P`.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Builder<Data, Value, P> {\n\t/** The field is equal to the value. */\n\treadonly eq: <\n\t\tconst F extends FieldPath<Data>,\n\t\tconst V extends OperandOf<FieldValue<Data, F>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\t/** The field is not equal to the value. */\n\treadonly ne: <\n\t\tconst F extends FieldPath<Data>,\n\t\tconst V extends OperandOf<FieldValue<Data, F>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\treadonly lt: <\n\t\tconst F extends OrderedPath<Data>,\n\t\tconst V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\treadonly lte: <\n\t\tconst F extends OrderedPath<Data>,\n\t\tconst V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\treadonly gt: <\n\t\tconst F extends OrderedPath<Data>,\n\t\tconst V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\treadonly gte: <\n\t\tconst F extends OrderedPath<Data>,\n\t\tconst V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\t/** The field is equal to one of the values. */\n\treadonly in: <\n\t\tconst F extends FieldPath<Data>,\n\t\tconst Vs extends ReadonlyArray<OperandOf<FieldValue<Data, F>, any>>,\n\t>(\n\t\tfield: F,\n\t\tvalues: Vs,\n\t) => Test<Value, PrincipalOf<Vs[number], P>>\n\t/** The field has a value that is not `null`. */\n\treadonly exists: <const F extends FieldPath<Data>>(field: F) => Test<Value>\n\t/** The path of the resource starts with these parts. */\n\treadonly under: <\n\t\tconst Ps extends ReadonlyArray<string | null | Ref<string | null, any>>,\n\t>(\n\t\t...prefix: Ps\n\t) => Test<Value, PrincipalOf<Ps[number], P>>\n\t/**\n\t * A field of the principal, to use as a value. The field must have a\n\t * {@link Scalar} type.\n\t */\n\treadonly principal: <const F extends ScalarPath<P>>(\n\t\tfield: F,\n\t) => Ref<PathValue<P, F>, P>\n\treadonly and: <const Cs extends ReadonlyArray<Any>>(\n\t\t...conditions: Cs\n\t) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>\n\treadonly or: <const Cs extends ReadonlyArray<Any>>(\n\t\t...conditions: Cs\n\t) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>\n\treadonly not: <C extends Any>(\n\t\tcondition: C,\n\t) => Condition<ReadsOf<C>, OpaqueOf<C>>\n\t/**\n\t * A test that runs any code. It may give a boolean or an `Effect`. A\n\t * condition with a predicate can not become JSON or a query.\n\t */\n\treadonly predicate: <E = never, R = never>(\n\t\tname: string,\n\t\ttest: (\n\t\t\tvalue: Value,\n\t\t\tprincipal: P,\n\t\t) => boolean | Effect.Effect<boolean, E, R>,\n\t) => Condition<Reads<Value, P>, Opaque<E, R>>\n}\n\nconst isOperand = (u: unknown): u is Operand =>\n\thasProperty(u, \"_tag\") && (u._tag === \"Literal\" || u._tag === \"Principal\")\n\nconst toOperand = (value: unknown): Operand =>\n\tisOperand(value) ? value : Nodes.literal(value as Scalar)\n\nconst compare =\n\t(op: CompareOperator) =>\n\t(field: string, value: unknown): Ast =>\n\t\tnew Nodes.Compare({ op, field, value: toOperand(value) })\n\n// A list of conditions goes in as an array, not as arguments: a call may take\n// only so many arguments, and a decoded condition may have more children.\n// The constructor copies the list, so a later change to the array of a caller\n// does not change the condition.\nconst andOf = (conditions: ReadonlyArray<Ast>): Ast =>\n\tnew Nodes.And(conditions as ReadonlyArray<Nodes.Node>)\n\nconst orOf = (conditions: ReadonlyArray<Ast>): Ast =>\n\tnew Nodes.Or(conditions as ReadonlyArray<Nodes.Node>)\n\nconst makeNot = (condition: Ast): Ast => new Nodes.Not(condition as Nodes.Node)\n\nconst sharedBuilder: Builder<any, any, any> = {\n\teq: compare(\"eq\"),\n\tne: compare(\"ne\"),\n\tlt: compare(\"lt\"),\n\tlte: compare(\"lte\"),\n\tgt: compare(\"gt\"),\n\tgte: compare(\"gte\"),\n\tin: (field: string, values: ReadonlyArray<unknown>) =>\n\t\tnew Nodes.In({ field, values: Arr.map(Array.from(values), toOperand) }),\n\texists: (field: string) => new Nodes.Exists({ field }),\n\tunder: (...prefix: ReadonlyArray<unknown>) =>\n\t\tnew Nodes.Under({ prefix: Arr.map(prefix, toOperand) }),\n\tprincipal: (path: string) => Nodes.principalRef(path),\n\tand: (...conditions: ReadonlyArray<Ast>) => andOf(conditions),\n\tor: (...conditions: ReadonlyArray<Ast>) => orOf(conditions),\n\tnot: makeNot,\n\tpredicate: (\n\t\tname: string,\n\t\ttest: (\n\t\t\tvalue: unknown,\n\t\t\tprincipal: unknown,\n\t\t) => boolean | Effect.Effect<boolean, unknown, unknown>,\n\t) =>\n\t\tnew Nodes.Predicate({\n\t\t\tname,\n\t\t\trun: (value, principal) =>\n\t\t\t\tEffect.suspend(() => {\n\t\t\t\t\tconst result = test(value, principal)\n\t\t\t\t\treturn Effect.isEffect(result) ? result : Effect.succeed(result)\n\t\t\t\t}),\n\t\t}),\n} as never\n\n/**\n * Makes a builder. Rules give you a builder with the right types, so you do not\n * often need this.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const builder = <Data, Value, P>(): Builder<Data, Value, P> =>\n\tsharedBuilder\n\n/**\n * Always true.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const always: Condition = Nodes.always as never\n\n/**\n * Always false.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const never: Condition = Nodes.never as never\n\n/**\n * True when all the conditions are true. With no conditions, it is true.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const and: <const Cs extends ReadonlyArray<Any>>(\n\t...conditions: Cs\n) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>> = ((\n\t...conditions: ReadonlyArray<Ast>\n) => andOf(conditions)) as never\n\n/**\n * The same as {@link and}, for a list of conditions of one type. Use it for a\n * long list: a function call may take only so many arguments.\n *\n * @stability stable\n * @category combinators\n * @since 1.0.0\n */\nexport const andAll: <C extends Any>(\n\tconditions: ReadonlyArray<C>,\n) => Condition<ReadsOf<C>, OpaqueOf<C>> = andOf as never\n\n/**\n * The same as {@link or}, for a list of conditions of one type. Use it for a\n * long list: a function call may take only so many arguments.\n *\n * @stability stable\n * @category combinators\n * @since 1.0.0\n */\nexport const orAll: <C extends Any>(\n\tconditions: ReadonlyArray<C>,\n) => Condition<ReadsOf<C>, OpaqueOf<C>> = orOf as never\n\n/**\n * True when one of the conditions is true. With no conditions, it is false.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const or: <const Cs extends ReadonlyArray<Any>>(\n\t...conditions: Cs\n) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>> = ((\n\t...conditions: ReadonlyArray<Ast>\n) => orOf(conditions)) as never\n\n/**\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const not: <C extends Any>(\n\tcondition: C,\n) => Condition<ReadsOf<C>, OpaqueOf<C>> = makeNot as never\n\n/**\n * The data that a condition needs for a test.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Input {\n\t/** The resource value. */\n\treadonly value: object\n\t/**\n\t * The principal. Without it, a principal field has no value. See\n\t * {@link PrincipalRef}.\n\t */\n\treadonly principal?: object | undefined\n\t/** The path of the resource. Without it, `Under` is false. */\n\treadonly path?: ReadonlyArray<Resource.PathSegment> | undefined\n}\n\n/** Gives a condition as a node. A value that no constructor made is a defect. */\nconst nodeOf = (condition: Ast): Nodes.Node => Nodes.toNode(condition)\n\n/**\n * Gives the services in `context` to every predicate of a condition, so the\n * condition needs no services when it runs.\n *\n * @stability stable\n * @category services\n * @since 1.0.0\n */\nexport const provideContext: {\n\t<R>(\n\t\tcontext: Context.Context<R>,\n\t): <I, X>(\n\t\tcondition: Condition<I, X> &\n\t\t\t([ServicesOf<X>] extends [R] ? unknown : never),\n\t) => Condition<I, Provided<X>>\n\t<I, X>(\n\t\tcondition: Condition<I, X>,\n\t\tcontext: Context.Context<ServicesOf<X>>,\n\t): Condition<I, Provided<X>>\n} = dual(2, (condition: Ast, context: Context.Context<never>): Ast =>\n\tAlgebra.provide(nodeOf(condition), context),\n) as never\n\n/**\n * The input of {@link evaluate} that the predicates of a condition need: a\n * value and a principal of the types in `I`. See {@link Reads}.\n */\ntype ReadsInput<I> =\n\tI extends Reads<infer V, infer P>\n\t\t? { readonly value: V } & (unknown extends P\n\t\t\t\t? unknown\n\t\t\t\t: { readonly principal: P })\n\t\t: unknown\n\n/**\n * Tests a condition on a value. A predicate may fail with its error. When the\n * condition has a predicate, the input must have the value and the principal\n * that the predicate reads. The test runs on the simple form of the condition\n * with the principal in it, so it reads only the fields that a residual reads.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const evaluate: <I, X, In extends Input>(\n\tcondition: Condition<I, X>,\n\tinput: In & ReadsInput<I>,\n) => Effect.Effect<boolean, ErrorOf<X>, ServicesOf<X>> = ((\n\tcondition: Ast,\n\tinput: Input,\n): Effect.Effect<boolean, unknown, unknown> =>\n\tEffect.suspend(() => Algebra.evaluate(nodeOf(condition), input))) as never\n\n/**\n * Tests a condition with no predicate on a value, at once.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const evaluateSync: <I, In extends Input>(\n\tcondition: Condition<I>,\n\tinput: In & ReadsInput<I>,\n) => boolean = (condition: Ast, input: Input): boolean =>\n\tAlgebra.evaluateSync(nodeOf(condition), input)\n\n/**\n * Makes a condition smaller without a change to its meaning. It removes `True`\n * and `False` from `And` and `Or`, joins nested `And` and `Or` nodes, and\n * removes double `Not` nodes and copies of a child.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const simplify: <I, X>(condition: Condition<I, X>) => Condition<I, X> =\n\t((condition: Ast) => condition.pipe(nodeOf, Algebra.simplify)) as never\n\ninterface PartialInput {\n\treadonly principal?: object | undefined\n\treadonly path?: ReadonlyArray<Resource.PathSegment> | undefined\n}\n\n/**\n * The principal that {@link partial} must get for the predicates of a\n * condition. A predicate keeps the principal that it gets, so the principal\n * must have the type that the predicate reads.\n */\ntype PrincipalInput<I> =\n\tI extends Reads<infer _V, infer P>\n\t\t? unknown extends P\n\t\t\t? unknown\n\t\t\t: { readonly principal: P }\n\t\t: unknown\n\n/** What a condition reads after {@link partial}: the value, and no principal. */\ntype Bound<I> = I extends Reads<infer V, infer _P> ? Reads<V, unknown> : I\n\n/**\n * Puts the principal into a condition and expands `Under` with the path of the\n * resource. The result is simplified. It has no principal fields and no\n * `Under` nodes. It is `True` or `False` when the answer does not depend on the\n * resource value.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const partial: <I, X>(\n\tcondition: Condition<I, X>,\n\tinput: PartialInput & PrincipalInput<I>,\n) => Condition<Bound<I>, X> = ((condition: Ast, input: PartialInput): Ast =>\n\tAlgebra.partial(nodeOf(condition), input)) as never\n\n/**\n * The functions that change each node of a condition into another form, such\n * as a database query.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Interpreter<A> {\n\treadonly true: () => A\n\treadonly false: () => A\n\treadonly compare: (op: CompareOperator, field: string, value: Scalar) => A\n\treadonly in: (field: string, values: ReadonlyArray<Scalar>) => A\n\treadonly exists: (field: string) => A\n\treadonly and: (conditions: ReadonlyArray<A>) => A\n\treadonly or: (conditions: ReadonlyArray<A>) => A\n\treadonly not: (condition: A) => A\n\t/** Optional. Without it, a predicate makes `fold` fail. */\n\treadonly predicate?: (name: string) => A\n}\n\n/**\n * The error when `fold` can not change a node.\n *\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport class Untranslatable extends Schema.TaggedError<Untranslatable>(\n\t\"@nmnmcc/ability/Condition/Untranslatable\",\n)(\"Untranslatable\", { reason: Schema.String }) {}\n\nconst literalValue = (operand: Operand, field: string): Scalar => {\n\tif (operand._tag !== \"Literal\") {\n\t\tthrow Untranslatable.make({\n\t\t\treason: `The field \"${field}\" uses a principal field. Call Condition.partial first.`,\n\t\t})\n\t}\n\treturn operand.value\n}\n\n/** Folds a condition. A shared child is folded again for each place. */\nconst foldNode = <A>(node: Nodes.Node, interpreter: Interpreter<A>): A => {\n\tswitch (node._tag) {\n\t\tcase \"True\":\n\t\t\treturn interpreter.true()\n\t\tcase \"False\":\n\t\t\treturn interpreter.false()\n\t\tcase \"Compare\":\n\t\t\treturn interpreter.compare(\n\t\t\t\tnode.op,\n\t\t\t\tnode.field,\n\t\t\t\tliteralValue(node.value, node.field),\n\t\t\t)\n\t\tcase \"In\":\n\t\t\treturn interpreter.in(\n\t\t\t\tnode.field,\n\t\t\t\tArr.map(node.values, (operand) => literalValue(operand, node.field)),\n\t\t\t)\n\t\tcase \"Exists\":\n\t\t\treturn interpreter.exists(node.field)\n\t\tcase \"Under\":\n\t\t\tthrow Untranslatable.make({\n\t\t\t\treason:\n\t\t\t\t\t\"An Under node needs the resource path. Call Condition.partial first.\",\n\t\t\t})\n\t\tcase \"And\":\n\t\t\treturn interpreter.and(\n\t\t\t\tArr.map(node.conditions, (child) => foldNode(child, interpreter)),\n\t\t\t)\n\t\tcase \"Or\":\n\t\t\treturn interpreter.or(\n\t\t\t\tArr.map(node.conditions, (child) => foldNode(child, interpreter)),\n\t\t\t)\n\t\tcase \"Not\":\n\t\t\treturn interpreter.not(foldNode(node.condition, interpreter))\n\t\tcase \"Predicate\":\n\t\t\tif (interpreter.predicate === undefined) {\n\t\t\t\tthrow Untranslatable.make({\n\t\t\t\t\treason: `The predicate \"${node.name}\" can not become a query`,\n\t\t\t\t})\n\t\t\t}\n\t\t\treturn interpreter.predicate(node.name)\n\t}\n}\n\n/**\n * Changes a condition into another form with an interpreter. Call\n * {@link partial} first: `fold` fails on principal fields and on `Under`\n * nodes, and on predicates when the interpreter has no `predicate` function.\n *\n * @stability stable\n * @category converting\n * @since 0.3.0\n */\nexport const fold: {\n\t<A>(\n\t\tinterpreter: Interpreter<A>,\n\t): (condition: Any) => Effect.Effect<A, Untranslatable>\n\t<A>(\n\t\tcondition: Any,\n\t\tinterpreter: Interpreter<A>,\n\t): Effect.Effect<A, Untranslatable>\n} = dual(\n\t2,\n\t<A>(\n\t\tcondition: Ast,\n\t\tinterpreter: Interpreter<A>,\n\t): Effect.Effect<A, Untranslatable> =>\n\t\tEffect.try({\n\t\t\ttry: () => foldNode(nodeOf(condition), interpreter),\n\t\t\tcatch: (cause) => {\n\t\t\t\tif (cause instanceof Untranslatable) {\n\t\t\t\t\treturn cause\n\t\t\t\t}\n\t\t\t\tthrow cause\n\t\t\t},\n\t\t}),\n)\n\n/**\n * The fields that a condition uses, in the order that they first come.\n *\n * @stability stable\n * @category getters\n * @since 0.3.0\n */\nexport const fields = (condition: Ast): ReadonlyArray<string> =>\n\tcondition.pipe(nodeOf, Algebra.fields)\n\n// Satisfiability\n\n/**\n * Values of fields, as a nested object. A field that is not in it may have any\n * value. A value with parts that the search does not look into, such as a\n * date, is an empty object.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Example = Search.Example\n\n/**\n * The answer of {@link satisfiable}:\n * - `Satisfiable`: some value makes the condition true. `example` is one.\n * - `Unsatisfiable`: no value makes the condition true.\n * - `Unknown`: the search can not say. The condition has a predicate, or\n *   the search went past its budget.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Satisfiability = Search.Satisfiability\n\n/**\n * The options of {@link satisfiable}.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport interface SatisfiableOptions {\n\t/**\n\t * The Schema of the values. Its shape gives the kinds of values of each\n\t * field. Without it, a field may have any value.\n\t */\n\treadonly schema?: Schema.Top | undefined\n\t/** The most steps that the search may take. The default is 1000000. */\n\treadonly budget?: number | undefined\n}\n\n/**\n * Tests if some value makes a condition true, and gives such a value.\n *\n * Call {@link partial} first: the condition must have no principal fields and\n * no `Under` nodes. A condition with a predicate gives `Unknown`.\n *\n * Each test of a condition compares one field with constants, so the\n * constants cut the values of each field into a few cells. The search tries\n * one value from each cell, one field at a time. The values of a field come\n * from the shape of the Schema in `options.schema`: its literals, `null` for\n * a nullable or optional field, and finite or integer numbers.\n *\n * The search reads the shape of the Schema, not its other checks, such as a\n * minimum length. So `Unsatisfiable` holds for every value of the Schema. A\n * `Satisfiable` example fits the shape, but a check may still stop it.\n *\n * The problem is as hard as boolean satisfiability, so the search has a\n * budget. Past it, the answer is `Unknown`. A condition with more than 256\n * fields gives `Unknown` too.\n *\n * @stability stable\n * @category evaluation\n * @since 1.0.0\n */\nexport const satisfiable = (\n\tcondition: Any,\n\toptions: SatisfiableOptions = {},\n): Satisfiability =>\n\tSearch.satisfiable(\n\t\tnodeOf(condition),\n\t\tSearch.kindsIn(\n\t\t\toptions.schema === undefined\n\t\t\t\t? undefined\n\t\t\t\t: Catalog.catalogOf(options.schema.ast),\n\t\t),\n\t\toptions.budget,\n\t)\n\n/**\n * The JSON form of an operand.\n *\n * @stability stable\n * @category models\n * @since 2.0.0\n */\nexport type EncodedOperand =\n\t| { readonly _tag: \"Literal\"; readonly value: Scalar }\n\t| { readonly _tag: \"Principal\"; readonly path: string }\n\n/**\n * The JSON form of a condition with no predicate.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Encoded =\n\t| { readonly _tag: \"True\" }\n\t| { readonly _tag: \"False\" }\n\t| {\n\t\t\treadonly _tag: \"Compare\"\n\t\t\treadonly op: CompareOperator\n\t\t\treadonly field: string\n\t\t\treadonly value: EncodedOperand\n\t  }\n\t| {\n\t\t\treadonly _tag: \"In\"\n\t\t\treadonly field: string\n\t\t\treadonly values: ReadonlyArray<EncodedOperand>\n\t  }\n\t| { readonly _tag: \"Exists\"; readonly field: string }\n\t| { readonly _tag: \"Under\"; readonly prefix: ReadonlyArray<EncodedOperand> }\n\t| {\n\t\t\treadonly _tag: \"And\" | \"Or\"\n\t\t\treadonly conditions: ReadonlyArray<Encoded>\n\t  }\n\t| { readonly _tag: \"Not\"; readonly condition: Encoded }\n\n/**\n * A condition with no predicate, that may read any values. It is the type of\n * {@link schema}: a decoded condition reads nothing, so it fits any rule, and\n * any plain condition, such as one from a builder or a residual, may be\n * encoded.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\n// `any` for what it reads: the field is contravariant, so no other type both\n// takes every condition and fits every rule.\nexport type PlainCondition = Condition<any>\n\n/**\n * The Schema of a condition with no predicate. It checks the shape only. Use\n * `Policy.schema` to check the field names against a domain too.\n *\n * The decoder takes at most 500 levels of conditions, and at most 1000000\n * objects and array items, with a shared object counted for each place. It\n * reads only the own data fields of the input.\n *\n * @stability stable\n * @category schemas\n * @since 0.3.0\n */\nexport const schema: Schema.Codec<PlainCondition, Encoded> =\n\tSchema.Unknown.pipe(\n\t\tSchema.decodeTo(\n\t\t\tSchema.declare(\n\t\t\t\t(input): input is PlainCondition =>\n\t\t\t\t\tNodes.isNode(input) && !input.opaque,\n\t\t\t),\n\t\t\tSchemaTransformation.transformEffect({\n\t\t\t\tdecode: (input: unknown, options) =>\n\t\t\t\t\tResult.match(Json.decode(input), {\n\t\t\t\t\t\tonSuccess: (node) => Effect.succeed(node as never),\n\t\t\t\t\t\tonFailure: (problem) =>\n\t\t\t\t\t\t\tEffect.fail(\n\t\t\t\t\t\t\t\tnew SchemaIssue.Pointer(\n\t\t\t\t\t\t\t\t\tproblem.path,\n\t\t\t\t\t\t\t\t\tnew SchemaIssue.InvalidValue(\n\t\t\t\t\t\t\t\t\t\t{ message: problem.message },\n\t\t\t\t\t\t\t\t\t\tinput,\n\t\t\t\t\t\t\t\t\t\toptions,\n\t\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t}),\n\t\t\t\tencode: (condition: PlainCondition) =>\n\t\t\t\t\tEffect.sync(() => Json.toJson(condition as never)),\n\t\t\t}),\n\t\t),\n\t) as never\n"],"mappings":"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"}
+{"version":3,"file":"Condition.js","names":["Nodes.literal","Nodes.Compare","Nodes.And","Nodes.Or","Nodes.Not","Nodes.In","Nodes.Exists","Nodes.Under","Nodes.principalRef","Nodes.Predicate","Nodes.always","Nodes.never","Nodes.toNode","Algebra.provide","Algebra.evaluate","Algebra.evaluateSync","Algebra.simplify","Algebra.partial","Algebra.fields","Search.satisfiable","Search.kindsIn","Catalog.catalogOf","Nodes.isNode","Json.decode","Json.toJson"],"sources":["../src/Condition.ts"],"sourcesContent":["/**\n * A condition is a test on a resource value. A rule applies only when its\n * condition is true.\n *\n * A condition is plain data: a tree of nodes. So you can:\n * - test it on a value with {@link evaluate};\n * - put the principal into it and make it smaller with {@link partial}, which\n *   gives a \"residual\" condition: the part that still depends on the\n *   resource;\n * - change it into a database query with {@link fold};\n * - keep it as JSON with {@link schema}.\n *\n * Make conditions with a {@link Builder}. A rule gives you a builder for its\n * resource, so the field names and the value types are checked.\n *\n * {@link Builder.predicate} is the one way out of plain data. A predicate runs\n * any `Effect`. Its error type and its service type go into the type of the\n * check. A rule with a predicate can not become JSON, and the type system\n * stops you when you try.\n *\n * @stability stable\n * @since 0.3.0\n */\n// A predicate keeps its error type and service type in the public types. The\n// code below works on the nodes with no types, where they are `unknown`, so\n// the language service check for `unknown` in an Effect is off here.\n// @effect-diagnostics anyUnknownInErrorContext:off\nimport * as Arr from \"effect/Array\"\nimport type * as BigDecimal from \"effect/BigDecimal\"\nimport type * as Cause from \"effect/Cause\"\nimport type * as Chunk from \"effect/Chunk\"\nimport type * as DateTime from \"effect/DateTime\"\nimport type * as Duration from \"effect/Duration\"\nimport type * as Exit from \"effect/Exit\"\nimport type * as HashMap from \"effect/HashMap\"\nimport type * as HashSet from \"effect/HashSet\"\nimport type * as Option from \"effect/Option\"\nimport type * as Redacted from \"effect/Redacted\"\nimport type * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport { dual } from \"effect/Function\"\nimport { hasProperty } from \"effect/Predicate\"\nimport * as Schema from \"effect/Schema\"\nimport * as SchemaIssue from \"effect/SchemaIssue\"\nimport * as SchemaTransformation from \"effect/SchemaTransformation\"\nimport * as Result from \"effect/Result\"\nimport * as Algebra from \"./internal/algebra.ts\"\nimport * as Catalog from \"./internal/catalog.ts\"\nimport * as Json from \"./internal/json.ts\"\nimport * as Nodes from \"./internal/nodes.ts\"\nimport * as Search from \"./internal/search.ts\"\nimport * as Resource from \"./Resource.ts\"\n\n/**\n * A value that a condition can compare.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Scalar = Nodes.Scalar\n\n/**\n * A fixed value in a condition.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Literal = Nodes.Literal\n\n/**\n * A field of the principal. {@link partial} puts the value of the field in its\n * place.\n *\n * A principal field that is `null` or missing has no value. A `Compare`, `In`\n * or `Under` test with it is always false, also with `ne`. So a principal with\n * no id never matches a resource with no owner. `not` still turns false into\n * true.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type PrincipalRef = Nodes.PrincipalRef\n\n/**\n * A field of the principal with a known value type `A`, from a principal of\n * the type `P`. The type fields are only in the types. A test with the\n * reference reads a principal of the type `P`, so it can not go into a rule\n * of a domain with another principal.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Ref<A, P = never> = PrincipalRef & {\n\treadonly \"~Ref\": () => A\n\treadonly \"~Principal\": (principal: P) => void\n}\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Operand = Literal | PrincipalRef\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type CompareOperator = Nodes.CompareOperator\n\n/**\n * Always true.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type True = Nodes.True\n\n/**\n * Always false.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type False = Nodes.False\n\n/**\n * Compares a field with a value. A missing field has the value `null`. `lt`,\n * `lte`, `gt` and `gte` are false when the two sides are not both numbers or\n * both strings.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Compare = Nodes.Compare\n\n/**\n * True when a field is equal to one of the values.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type In = Nodes.In\n\n/**\n * True when a field is not `null` and not missing.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Exists = Nodes.Exists\n\n/**\n * True when the path of the resource starts with the prefix. A resource with\n * no path is never under a prefix.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Under = Nodes.Under\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type And = Nodes.And\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Or = Nodes.Or\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Not = Nodes.Not\n\n/**\n * A test that runs an `Effect`. It can not become JSON or a query.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Predicate = Nodes.Predicate\n\n/**\n * The nodes of a condition, without types. Each node is a class, and only the\n * builder, the functions of this module and the Schema make one. So a plain\n * object, or a spread of a node, is not a node.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Ast = Nodes.Node\n\n/**\n * The mark of a condition with a predicate. `E` and `R` are the error type\n * and the service type of its predicates.\n *\n * @stability stable\n * @category models\n * @since 2.0.0\n */\nexport interface Opaque<out E = never, out R = never> {\n\treadonly \"~Opaque\": { readonly E: E; readonly R: R }\n}\n\n/**\n * The error type of the predicates of a mark `X`. A mark that is not an\n * {@link Opaque}, as `unknown` or `object`, may have any error.\n *\n * @stability stable\n * @category utility types\n * @since 2.0.0\n */\nexport type ErrorOf<X> = X extends Opaque<infer E, infer _R> ? E : unknown\n\n/**\n * The service type of the predicates of a mark `X`. A mark that is not an\n * {@link Opaque}, as `unknown` or `object`, may need any service.\n *\n * @stability stable\n * @category utility types\n * @since 2.0.0\n */\nexport type ServicesOf<X> = X extends Opaque<infer _E, infer R> ? R : unknown\n\n/**\n * The mark `X` with no services.\n *\n * @stability stable\n * @category utility types\n * @since 2.0.0\n */\nexport type Provided<X> =\n\tX extends Opaque<infer E, infer _R> ? Opaque<E> : Opaque<unknown>\n\n/**\n * What the predicates of a condition read: a resource value of the type `V`\n * and a principal of the type `P`. It is only in the types.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport interface Reads<V, P> {\n\treadonly value: V\n\treadonly principal: P\n}\n\n/**\n * A condition. `I` is what its tests read: see {@link Reads}. `X` is\n * {@link Opaque} when the condition has a predicate, and `never` when it is\n * plain data. A plain condition can become JSON or a query.\n *\n * The two type fields are only in the types. `I` goes into a function as an\n * input, so a condition that reads a `Post` does not fit a rule for a\n * `Comment`. `X` comes out of a function, so a plain condition fits where a\n * condition with predicates may go.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Condition<I = unknown, X = never> = Ast & {\n\treadonly \"~Reads\": (reads: I) => void\n\treadonly \"~Opaque\": () => X\n}\n\n/**\n * Any condition.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Any = Condition<any, any>\n\n/**\n * What the tests of a condition read. For a union of conditions, it is what\n * all of them read.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type ReadsOf<C> = [C] extends [\n\t{ readonly \"~Reads\": (reads: infer I) => void },\n]\n\t? I\n\t: unknown\n\n/**\n * The mark of a condition: {@link Opaque} when it has a predicate.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type OpaqueOf<C> = C extends { readonly \"~Opaque\": () => infer X }\n\t? X\n\t: never\n\ntype Leaf = string | number | boolean | bigint | symbol | null | undefined\n/**\n * Values of a class that keeps its data inside. A path does not go into them,\n * as in the field paths of a resource, so a field with such a value is one\n * field. A condition can test only if it exists.\n */\ntype Whole =\n\t| ReadonlyMap<unknown, unknown>\n\t| ReadonlySet<unknown>\n\t| HashMap.HashMap<unknown, unknown>\n\t| HashSet.HashSet<unknown>\n\t| Date\n\t| URL\n\t| Uint8Array\n\t| Option.Option<unknown>\n\t| BigDecimal.BigDecimal\n\t| Duration.Duration\n\t| DateTime.DateTime\n\t| Redacted.Redacted<unknown>\n\t| Chunk.Chunk<unknown>\n\t| Cause.Cause<unknown>\n\t| Result.Result<unknown, unknown>\n\t| Exit.Exit<unknown, unknown>\n\t| File\n\t| FormData\n\t| RegExp\n\t| URLSearchParams\ntype PreviousDepth = [never, 0, 1, 2, 3]\ntype FieldPathInternal<\n\tT,\n\tDepth extends number,\n\tArrays extends boolean,\n\tParents extends boolean = false,\n> = [Depth] extends [never]\n\t? never\n\t: {\n\t\t\t// A record with number keys has number keys, as `counts.1`.\n\t\t\t[K in keyof T & (string | number)]-?: PathsOf<\n\t\t\t\t`${K}`,\n\t\t\t\tNonNullable<T[K]>,\n\t\t\t\tDepth,\n\t\t\t\tArrays,\n\t\t\t\tParents\n\t\t\t>\n\t\t}[keyof T & (string | number)]\n\n/**\n * The paths of one field `K` with the values `V`. Each kind of value in `V`\n * gives its own paths, so a field that holds a string or a struct is a field,\n * and the fields of the struct are fields too. A function is no field.\n */\ntype PathsOf<\n\tK extends string,\n\tV,\n\tDepth extends number,\n\tArrays extends boolean,\n\tParents extends boolean,\n> =\n\t// A field that is only ever `null` or missing is a field too, and so is a\n\t// field that may hold any value, as one of `Schema.Unknown` may.\n\t| ([V] extends [never] ? K : {} extends V ? K : never)\n\t| ([Extract<V, Leaf | Whole>] extends [never] ? never : K)\n\t| ([Extract<V, ReadonlyArray<unknown>>] extends [never]\n\t\t\t? never\n\t\t\t: Arrays extends true\n\t\t\t\t? K\n\t\t\t\t: never)\n\t// A condition reads a field below `K` only when `K` holds plain data: a\n\t// list, a whole value such as a date, or a function may have a getter or a\n\t// method with the name, so the binding does not take such a read. A rule\n\t// or a request names a field and does not read it, so it may.\n\t| (Arrays extends true\n\t\t\t? ObjectPaths<\n\t\t\t\t\tK,\n\t\t\t\t\tExclude<V, Leaf | Whole | Function | ReadonlyArray<unknown>>,\n\t\t\t\t\tDepth,\n\t\t\t\t\tArrays,\n\t\t\t\t\tParents\n\t\t\t\t>\n\t\t\t: [Extract<V, Whole | Function | ReadonlyArray<unknown>>] extends [never]\n\t\t\t\t? ObjectPaths<K, Exclude<V, Leaf>, Depth, Arrays, Parents>\n\t\t\t\t: never)\n\n/** The paths of a field `K` that holds the objects `O`, and of the fields below. */\ntype ObjectPaths<\n\tK extends string,\n\tO,\n\tDepth extends number,\n\tArrays extends boolean,\n\tParents extends boolean,\n> = [O] extends [never]\n\t? never\n\t: // A record is one field to a rule or a request, as `permittedFields`\n\t\t// lists it. So is a struct at the last part that a path may have, since\n\t\t// a path does not go below it.\n\t\t| (Parents extends true\n\t\t\t\t? K\n\t\t\t\t: Arrays extends true\n\t\t\t\t\t? string extends keyof O\n\t\t\t\t\t\t? K\n\t\t\t\t\t\t: number extends keyof O\n\t\t\t\t\t\t\t? K\n\t\t\t\t\t\t\t: [Depth] extends [0]\n\t\t\t\t\t\t\t\t? K\n\t\t\t\t\t\t\t\t: never\n\t\t\t\t\t: never)\n\t\t| `${K}.${FieldPathInternal<O, PreviousDepth[Depth], Arrays, Parents>}`\n\n/**\n * The paths of the fields of `T` that hold one value, with dots for nested\n * fields. Arrays are left out. A map, a set, a date, a URL, a byte array, an\n * `Option` and the other value types of Effect, such as `BigDecimal` and\n * `Duration`, are one field, and a path does not go into them. A path does\n * not go into a field that may hold one of them or a list either. The type\n * goes down four levels, so type checking stays fast. For a union of types,\n * only the common fields are paths.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type FieldPath<T> = [T] extends [object]\n\t? FieldPathInternal<T, 4, false>\n\t: never\n\n/**\n * The paths of the fields of `T` that a rule or a request may name, as in\n * `Rule.Options.fields`. They are the paths of {@link FieldPath}, and the\n * paths of arrays too: a rule may allow or deny a whole array field, and\n * `permittedFields` lists it.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type FieldSelector<T> = [T] extends [object]\n\t? FieldPathInternal<T, 4, true>\n\t: never\n\n/**\n * The names that the `fields` of a rule may have: the paths of\n * {@link FieldSelector}, and the paths of the structs above them. A name of a\n * struct covers the fields below it.\n *\n * @stability stable\n * @category utility types\n * @since 2.0.0\n */\nexport type FieldName<T> = [T] extends [object]\n\t? FieldPathInternal<T, 4, true, true>\n\t: never\n\n/**\n * The value type that fits every field in `F`. For one field, it is the type\n * of the field. For a union of fields, it is the values that each of them can\n * hold, so a value of a union type can not test a field of another type. For\n * a union of data types, as for a rule on two kinds, it is the values that\n * the field can hold in each of them.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type FieldValue<Data, F extends string> = (\n\tData extends unknown\n\t\t? F extends unknown\n\t\t\t? (value: PathValue<Data, F>) => void\n\t\t\t: never\n\t\t: never\n) extends (value: infer V) => void\n\t? V\n\t: never\n\ntype Normalize<A> = Exclude<A, undefined> | (undefined extends A ? null : never)\n\n/**\n * The type of the field of `T` at `Path`. A field that may be missing may also\n * be `null`. Each type of a union gives its own value: a field below a value\n * that is not an object, as below a string, is `null`, as a read of it is.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type PathValue<T, Path extends string> = T extends unknown\n\t? PathValueIn<T, Path>\n\t: never\n\n/** The type of the field at `Path` of `T`, which is not a union. */\ntype PathValueIn<T, Path extends string> = T extends object\n\t? Path extends `${infer Head}.${infer Rest}`\n\t\t? PathValue<ChildOf<T, Head>, Rest>\n\t\t: Normalize<ChildOf<T, Path>>\n\t: null\n\n/**\n * The type of the part `Name` of `T`. A part of a path is text, so the part\n * `\"1\"` names the number key `1` too, as of a record with number keys.\n */\ntype ChildOf<T, Name extends string> = Name extends keyof T\n\t? T[Name]\n\t: Name extends `${infer N extends number}`\n\t\t? N extends keyof T\n\t\t\t? T[N]\n\t\t\t: number extends keyof T\n\t\t\t\t? T[number]\n\t\t\t\t: never\n\t\t: never\n\n/**\n * A value for a field of type `A`: a fixed value, or a field of the principal\n * with the same type.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type OperandOf<A, P = never> = Extract<A, Scalar> | Ref<A, P>\n\ntype ScalarPath<T> = {\n\t[F in FieldPath<T>]: PathValue<T, F> extends Scalar ? F : never\n}[FieldPath<T>]\n\ntype OrderedPath<T> = {\n\t[F in FieldPath<T>]: Exclude<PathValue<T, F>, null> extends number | string\n\t\t? F\n\t\t: never\n}[FieldPath<T>]\n\n/**\n * A test made by a {@link Builder}. It runs no code, but it keeps the value\n * type of its resource, so a test on the fields of one resource can not go\n * into a rule for another resource. A test with a field of the principal\n * keeps the principal type `P` too.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Test<Value, P = unknown> = Condition<Reads<Value, P>>\n\n/**\n * The principal type that a test reads: the principal of each field of the\n * principal in the values `V`, and `unknown` when there is none. A reference\n * from another builder keeps the principal of that builder.\n */\ntype PrincipalOf<V, _P> = [Extract<V, PrincipalRef>] extends [never]\n\t? unknown\n\t: [Extract<V, PrincipalRef>] extends [\n\t\t\t\t{ readonly \"~Principal\": (principal: infer Q) => void },\n\t\t  ]\n\t\t? Q\n\t\t: unknown\n\n/**\n * Makes conditions for a resource with the data type `Data` and the value type\n * `Value`, and a principal with the type `P`.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Builder<Data, Value, P> {\n\t/** The field is equal to the value. */\n\treadonly eq: <\n\t\tconst F extends FieldPath<Data>,\n\t\tconst V extends OperandOf<FieldValue<Data, F>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\t/** The field is not equal to the value. */\n\treadonly ne: <\n\t\tconst F extends FieldPath<Data>,\n\t\tconst V extends OperandOf<FieldValue<Data, F>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\treadonly lt: <\n\t\tconst F extends OrderedPath<Data>,\n\t\tconst V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\treadonly lte: <\n\t\tconst F extends OrderedPath<Data>,\n\t\tconst V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\treadonly gt: <\n\t\tconst F extends OrderedPath<Data>,\n\t\tconst V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\treadonly gte: <\n\t\tconst F extends OrderedPath<Data>,\n\t\tconst V extends OperandOf<Exclude<FieldValue<Data, F>, null>, any>,\n\t>(\n\t\tfield: F,\n\t\tvalue: V,\n\t) => Test<Value, PrincipalOf<V, P>>\n\t/** The field is equal to one of the values. */\n\treadonly in: <\n\t\tconst F extends FieldPath<Data>,\n\t\tconst Vs extends ReadonlyArray<OperandOf<FieldValue<Data, F>, any>>,\n\t>(\n\t\tfield: F,\n\t\tvalues: Vs,\n\t) => Test<Value, PrincipalOf<Vs[number], P>>\n\t/** The field has a value that is not `null`. */\n\treadonly exists: <const F extends FieldPath<Data>>(field: F) => Test<Value>\n\t/** The path of the resource starts with these parts. */\n\treadonly under: <\n\t\tconst Ps extends ReadonlyArray<string | null | Ref<string | null, any>>,\n\t>(\n\t\t...prefix: Ps\n\t) => Test<Value, PrincipalOf<Ps[number], P>>\n\t/**\n\t * A field of the principal, to use as a value. The field must have a\n\t * {@link Scalar} type.\n\t */\n\treadonly principal: <const F extends ScalarPath<P>>(\n\t\tfield: F,\n\t) => Ref<PathValue<P, F>, P>\n\treadonly and: <const Cs extends ReadonlyArray<Any>>(\n\t\t...conditions: Cs\n\t) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>\n\treadonly or: <const Cs extends ReadonlyArray<Any>>(\n\t\t...conditions: Cs\n\t) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>>\n\treadonly not: <C extends Any>(\n\t\tcondition: C,\n\t) => Condition<ReadsOf<C>, OpaqueOf<C>>\n\t/**\n\t * A test that runs any code. It may give a boolean or an `Effect`. A\n\t * condition with a predicate can not become JSON or a query.\n\t */\n\treadonly predicate: <E = never, R = never>(\n\t\tname: string,\n\t\ttest: (\n\t\t\tvalue: Value,\n\t\t\tprincipal: P,\n\t\t) => boolean | Effect.Effect<boolean, E, R>,\n\t) => Condition<Reads<Value, P>, Opaque<E, R>>\n}\n\nconst isOperand = (u: unknown): u is Operand =>\n\thasProperty(u, \"_tag\") && (u._tag === \"Literal\" || u._tag === \"Principal\")\n\nconst toOperand = (value: unknown): Operand =>\n\tisOperand(value) ? value : Nodes.literal(value as Scalar)\n\nconst compare =\n\t(op: CompareOperator) =>\n\t(field: string, value: unknown): Ast =>\n\t\tnew Nodes.Compare({ op, field, value: toOperand(value) })\n\n// A list of conditions goes in as an array, not as arguments: a call may take\n// only so many arguments, and a decoded condition may have more children.\n// The constructor copies the list, so a later change to the array of a caller\n// does not change the condition.\nconst andOf = (conditions: ReadonlyArray<Ast>): Ast =>\n\tnew Nodes.And(conditions as ReadonlyArray<Nodes.Node>)\n\nconst orOf = (conditions: ReadonlyArray<Ast>): Ast =>\n\tnew Nodes.Or(conditions as ReadonlyArray<Nodes.Node>)\n\nconst makeNot = (condition: Ast): Ast => new Nodes.Not(condition as Nodes.Node)\n\nconst sharedBuilder: Builder<any, any, any> = {\n\teq: compare(\"eq\"),\n\tne: compare(\"ne\"),\n\tlt: compare(\"lt\"),\n\tlte: compare(\"lte\"),\n\tgt: compare(\"gt\"),\n\tgte: compare(\"gte\"),\n\tin: (field: string, values: ReadonlyArray<unknown>) =>\n\t\tnew Nodes.In({ field, values: Arr.map(Array.from(values), toOperand) }),\n\texists: (field: string) => new Nodes.Exists({ field }),\n\tunder: (...prefix: ReadonlyArray<unknown>) =>\n\t\tnew Nodes.Under({ prefix: Arr.map(prefix, toOperand) }),\n\tprincipal: (path: string) => Nodes.principalRef(path),\n\tand: (...conditions: ReadonlyArray<Ast>) => andOf(conditions),\n\tor: (...conditions: ReadonlyArray<Ast>) => orOf(conditions),\n\tnot: makeNot,\n\tpredicate: (\n\t\tname: string,\n\t\ttest: (\n\t\t\tvalue: unknown,\n\t\t\tprincipal: unknown,\n\t\t) => boolean | Effect.Effect<boolean, unknown, unknown>,\n\t) =>\n\t\tnew Nodes.Predicate({\n\t\t\tname,\n\t\t\trun: (value, principal) =>\n\t\t\t\tEffect.suspend(() => {\n\t\t\t\t\tconst result = test(value, principal)\n\t\t\t\t\treturn Effect.isEffect(result) ? result : Effect.succeed(result)\n\t\t\t\t}),\n\t\t}),\n} as never\n\n/**\n * Makes a builder. Rules give you a builder with the right types, so you do not\n * often need this.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const builder = <Data, Value, P>(): Builder<Data, Value, P> =>\n\tsharedBuilder\n\n/**\n * Always true.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const always: Condition = Nodes.always as never\n\n/**\n * Always false.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const never: Condition = Nodes.never as never\n\n/**\n * True when all the conditions are true. With no conditions, it is true.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const and: <const Cs extends ReadonlyArray<Any>>(\n\t...conditions: Cs\n) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>> = ((\n\t...conditions: ReadonlyArray<Ast>\n) => andOf(conditions)) as never\n\n/**\n * The same as {@link and}, for a list of conditions of one type. Use it for a\n * long list: a function call may take only so many arguments.\n *\n * @stability stable\n * @category combinators\n * @since 1.0.0\n */\nexport const andAll: <C extends Any>(\n\tconditions: ReadonlyArray<C>,\n) => Condition<ReadsOf<C>, OpaqueOf<C>> = andOf as never\n\n/**\n * The same as {@link or}, for a list of conditions of one type. Use it for a\n * long list: a function call may take only so many arguments.\n *\n * @stability stable\n * @category combinators\n * @since 1.0.0\n */\nexport const orAll: <C extends Any>(\n\tconditions: ReadonlyArray<C>,\n) => Condition<ReadsOf<C>, OpaqueOf<C>> = orOf as never\n\n/**\n * True when one of the conditions is true. With no conditions, it is false.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const or: <const Cs extends ReadonlyArray<Any>>(\n\t...conditions: Cs\n) => Condition<ReadsOf<Cs[number]>, OpaqueOf<Cs[number]>> = ((\n\t...conditions: ReadonlyArray<Ast>\n) => orOf(conditions)) as never\n\n/**\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const not: <C extends Any>(\n\tcondition: C,\n) => Condition<ReadsOf<C>, OpaqueOf<C>> = makeNot as never\n\n/**\n * The data that a condition needs for a test.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Input {\n\t/** The resource value. */\n\treadonly value: object\n\t/**\n\t * The principal. Without it, a principal field has no value. See\n\t * {@link PrincipalRef}.\n\t */\n\treadonly principal?: object | undefined\n\t/** The path of the resource. Without it, `Under` is false. */\n\treadonly path?: ReadonlyArray<Resource.PathSegment> | undefined\n}\n\n/** Gives a condition as a node. A value that no constructor made is a defect. */\nconst nodeOf = (condition: Ast): Nodes.Node => Nodes.toNode(condition)\n\n/**\n * Gives the services in `context` to every predicate of a condition, so the\n * condition needs no services when it runs.\n *\n * @stability stable\n * @category services\n * @since 1.0.0\n */\nexport const provideContext: {\n\t<R>(\n\t\tcontext: Context.Context<R>,\n\t): <I, X>(\n\t\tcondition: Condition<I, X> &\n\t\t\t([ServicesOf<X>] extends [R] ? unknown : never),\n\t) => Condition<I, Provided<X>>\n\t<I, X>(\n\t\tcondition: Condition<I, X>,\n\t\tcontext: Context.Context<ServicesOf<X>>,\n\t): Condition<I, Provided<X>>\n} = dual(2, (condition: Ast, context: Context.Context<never>): Ast =>\n\tAlgebra.provide(nodeOf(condition), context),\n) as never\n\n/**\n * The input of {@link evaluate} that the predicates of a condition need: a\n * value and a principal of the types in `I`. See {@link Reads}.\n */\ntype ReadsInput<I> =\n\tI extends Reads<infer V, infer P>\n\t\t? { readonly value: V } & (unknown extends P\n\t\t\t\t? unknown\n\t\t\t\t: { readonly principal: P })\n\t\t: unknown\n\n/**\n * Tests a condition on a value. A predicate may fail with its error. When the\n * condition has a predicate, the input must have the value and the principal\n * that the predicate reads. The test runs on the simple form of the condition\n * with the principal in it, so it reads only the fields that a residual reads.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const evaluate: <I, X, In extends Input>(\n\tcondition: Condition<I, X>,\n\tinput: In & ReadsInput<I>,\n) => Effect.Effect<boolean, ErrorOf<X>, ServicesOf<X>> = ((\n\tcondition: Ast,\n\tinput: Input,\n): Effect.Effect<boolean, unknown, unknown> =>\n\tEffect.suspend(() => Algebra.evaluate(nodeOf(condition), input))) as never\n\n/**\n * Tests a condition with no predicate on a value, at once.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const evaluateSync: <I, In extends Input>(\n\tcondition: Condition<I>,\n\tinput: In & ReadsInput<I>,\n) => boolean = (condition: Ast, input: Input): boolean =>\n\tAlgebra.evaluateSync(nodeOf(condition), input)\n\n/**\n * Makes a condition smaller without a change to its meaning. It removes `True`\n * and `False` from `And` and `Or`, joins nested `And` and `Or` nodes, and\n * removes double `Not` nodes and copies of a child.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const simplify: <I, X>(condition: Condition<I, X>) => Condition<I, X> =\n\t((condition: Ast) => condition.pipe(nodeOf, Algebra.simplify)) as never\n\ninterface PartialInput {\n\treadonly principal?: object | undefined\n\treadonly path?: ReadonlyArray<Resource.PathSegment> | undefined\n}\n\n/**\n * The principal that {@link partial} must get for the predicates of a\n * condition. A predicate keeps the principal that it gets, so the principal\n * must have the type that the predicate reads.\n */\ntype PrincipalInput<I> =\n\tI extends Reads<infer _V, infer P>\n\t\t? unknown extends P\n\t\t\t? unknown\n\t\t\t: { readonly principal: P }\n\t\t: unknown\n\n/** What a condition reads after {@link partial}: the value, and no principal. */\ntype Bound<I> = I extends Reads<infer V, infer _P> ? Reads<V, unknown> : I\n\n/**\n * Puts the principal into a condition and expands `Under` with the path of the\n * resource. The result is simplified. It has no principal fields and no\n * `Under` nodes. It is `True` or `False` when the answer does not depend on the\n * resource value.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const partial: <I, X>(\n\tcondition: Condition<I, X>,\n\tinput: PartialInput & PrincipalInput<I>,\n) => Condition<Bound<I>, X> = ((condition: Ast, input: PartialInput): Ast =>\n\tAlgebra.partial(nodeOf(condition), input)) as never\n\n/**\n * The functions that change each node of a condition into another form, such\n * as a database query.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Interpreter<A> {\n\treadonly true: () => A\n\treadonly false: () => A\n\treadonly compare: (op: CompareOperator, field: string, value: Scalar) => A\n\treadonly in: (field: string, values: ReadonlyArray<Scalar>) => A\n\treadonly exists: (field: string) => A\n\treadonly and: (conditions: ReadonlyArray<A>) => A\n\treadonly or: (conditions: ReadonlyArray<A>) => A\n\treadonly not: (condition: A) => A\n\t/** Optional. Without it, a predicate makes `fold` fail. */\n\treadonly predicate?: (name: string) => A\n}\n\n/**\n * The error when `fold` can not change a node.\n *\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport class Untranslatable extends Schema.TaggedError<Untranslatable>(\n\t\"@nmnmcc/ability/Condition/Untranslatable\",\n)(\"Untranslatable\", { reason: Schema.String }) {}\n\nconst literalValue = (operand: Operand, field: string): Scalar => {\n\tif (operand._tag !== \"Literal\") {\n\t\tthrow Untranslatable.make({\n\t\t\treason: `The field \"${field}\" uses a principal field. Call Condition.partial first.`,\n\t\t})\n\t}\n\treturn operand.value\n}\n\n/** Folds a condition. A shared child is folded again for each place. */\nconst foldNode = <A>(node: Nodes.Node, interpreter: Interpreter<A>): A => {\n\tswitch (node._tag) {\n\t\tcase \"True\":\n\t\t\treturn interpreter.true()\n\t\tcase \"False\":\n\t\t\treturn interpreter.false()\n\t\tcase \"Compare\":\n\t\t\treturn interpreter.compare(\n\t\t\t\tnode.op,\n\t\t\t\tnode.field,\n\t\t\t\tliteralValue(node.value, node.field),\n\t\t\t)\n\t\tcase \"In\":\n\t\t\treturn interpreter.in(\n\t\t\t\tnode.field,\n\t\t\t\tArr.map(node.values, (operand) => literalValue(operand, node.field)),\n\t\t\t)\n\t\tcase \"Exists\":\n\t\t\treturn interpreter.exists(node.field)\n\t\tcase \"Under\":\n\t\t\tthrow Untranslatable.make({\n\t\t\t\treason:\n\t\t\t\t\t\"An Under node needs the resource path. Call Condition.partial first.\",\n\t\t\t})\n\t\tcase \"And\":\n\t\t\treturn interpreter.and(\n\t\t\t\tArr.map(node.conditions, (child) => foldNode(child, interpreter)),\n\t\t\t)\n\t\tcase \"Or\":\n\t\t\treturn interpreter.or(\n\t\t\t\tArr.map(node.conditions, (child) => foldNode(child, interpreter)),\n\t\t\t)\n\t\tcase \"Not\":\n\t\t\treturn interpreter.not(foldNode(node.condition, interpreter))\n\t\tcase \"Predicate\":\n\t\t\tif (interpreter.predicate === undefined) {\n\t\t\t\tthrow Untranslatable.make({\n\t\t\t\t\treason: `The predicate \"${node.name}\" can not become a query`,\n\t\t\t\t})\n\t\t\t}\n\t\t\treturn interpreter.predicate(node.name)\n\t}\n}\n\n/**\n * Changes a condition into another form with an interpreter. Call\n * {@link partial} first: `fold` fails on principal fields and on `Under`\n * nodes, and on predicates when the interpreter has no `predicate` function.\n *\n * @stability stable\n * @category converting\n * @since 0.3.0\n */\nexport const fold: {\n\t<A>(\n\t\tinterpreter: Interpreter<A>,\n\t): (condition: Any) => Effect.Effect<A, Untranslatable>\n\t<A>(\n\t\tcondition: Any,\n\t\tinterpreter: Interpreter<A>,\n\t): Effect.Effect<A, Untranslatable>\n} = dual(\n\t2,\n\t<A>(\n\t\tcondition: Ast,\n\t\tinterpreter: Interpreter<A>,\n\t): Effect.Effect<A, Untranslatable> =>\n\t\tEffect.try({\n\t\t\ttry: () => foldNode(nodeOf(condition), interpreter),\n\t\t\tcatch: (cause) => {\n\t\t\t\tif (cause instanceof Untranslatable) {\n\t\t\t\t\treturn cause\n\t\t\t\t}\n\t\t\t\tthrow cause\n\t\t\t},\n\t\t}),\n)\n\n/**\n * The fields that a condition uses, in the order that they first come.\n *\n * @stability stable\n * @category getters\n * @since 0.3.0\n */\nexport const fields = (condition: Ast): ReadonlyArray<string> =>\n\tcondition.pipe(nodeOf, Algebra.fields)\n\n// Satisfiability\n\n/**\n * Values of fields, as a nested object. A field that is not in it may have any\n * value. A value with parts that the search does not look into, such as a\n * date, is an empty object.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Example = Search.Example\n\n/**\n * The answer of {@link satisfiable}:\n * - `Satisfiable`: some value makes the condition true. `example` is one.\n * - `Unsatisfiable`: no value makes the condition true.\n * - `Unknown`: the search can not say. The condition has a predicate, or\n *   the search went past its budget.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Satisfiability = Search.Satisfiability\n\n/**\n * The options of {@link satisfiable}.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport interface SatisfiableOptions {\n\t/**\n\t * The Schema of the values. Its shape gives the kinds of values of each\n\t * field. Without it, a field may have any value.\n\t */\n\treadonly schema?: Schema.Top | undefined\n\t/** The most steps that the search may take. The default is 1000000. */\n\treadonly budget?: number | undefined\n}\n\n/**\n * Tests if some value makes a condition true, and gives such a value.\n *\n * Call {@link partial} first: the condition must have no principal fields and\n * no `Under` nodes. A condition with a predicate gives `Unknown`.\n *\n * Each test of a condition compares one field with constants, so the\n * constants cut the values of each field into a few cells. The search tries\n * one value from each cell, one field at a time. The values of a field come\n * from the shape of the Schema in `options.schema`: its literals, `null` for\n * a nullable or optional field, and finite or integer numbers.\n *\n * The search reads the shape of the Schema, not its other checks, such as a\n * minimum length. So `Unsatisfiable` holds for every value of the Schema. A\n * `Satisfiable` example fits the shape, but a check may still stop it.\n *\n * The problem is as hard as boolean satisfiability, so the search has a\n * budget. Past it, the answer is `Unknown`. A condition with more than 256\n * fields gives `Unknown` too.\n *\n * @stability stable\n * @category evaluation\n * @since 1.0.0\n */\nexport const satisfiable = (\n\tcondition: Any,\n\toptions: SatisfiableOptions = {},\n): Satisfiability =>\n\tSearch.satisfiable(\n\t\tnodeOf(condition),\n\t\tSearch.kindsIn(\n\t\t\toptions.schema === undefined\n\t\t\t\t? undefined\n\t\t\t\t: Catalog.catalogOf(options.schema.ast),\n\t\t),\n\t\toptions.budget,\n\t)\n\n/**\n * The JSON form of an operand.\n *\n * @stability stable\n * @category models\n * @since 2.0.0\n */\nexport type EncodedOperand =\n\t| { readonly _tag: \"Literal\"; readonly value: Scalar }\n\t| { readonly _tag: \"Principal\"; readonly path: string }\n\n/**\n * The JSON form of a condition with no predicate.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Encoded =\n\t| { readonly _tag: \"True\" }\n\t| { readonly _tag: \"False\" }\n\t| {\n\t\t\treadonly _tag: \"Compare\"\n\t\t\treadonly op: CompareOperator\n\t\t\treadonly field: string\n\t\t\treadonly value: EncodedOperand\n\t  }\n\t| {\n\t\t\treadonly _tag: \"In\"\n\t\t\treadonly field: string\n\t\t\treadonly values: ReadonlyArray<EncodedOperand>\n\t  }\n\t| { readonly _tag: \"Exists\"; readonly field: string }\n\t| { readonly _tag: \"Under\"; readonly prefix: ReadonlyArray<EncodedOperand> }\n\t| {\n\t\t\treadonly _tag: \"And\" | \"Or\"\n\t\t\treadonly conditions: ReadonlyArray<Encoded>\n\t  }\n\t| { readonly _tag: \"Not\"; readonly condition: Encoded }\n\n/**\n * A condition with no predicate, that may read any values. It is the type of\n * {@link schema}: a decoded condition reads nothing, so it fits any rule, and\n * any plain condition, such as one from a builder or a residual, may be\n * encoded.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\n// `any` for what it reads: the field is contravariant, so no other type both\n// takes every condition and fits every rule.\nexport type PlainCondition = Condition<any>\n\n/**\n * The Schema of a condition with no predicate. It checks the shape only. Use\n * `Policy.schema` to check the field names against a domain too.\n *\n * The decoder takes at most 500 levels of conditions, and at most 1000000\n * objects and array items, with a shared object counted for each place. It\n * reads only the own data fields of the input.\n *\n * @stability stable\n * @category schemas\n * @since 0.3.0\n */\nexport const schema: Schema.Codec<PlainCondition, Encoded> =\n\tSchema.Unknown.pipe(\n\t\tSchema.decodeTo(\n\t\t\tSchema.declare(\n\t\t\t\t(input): input is PlainCondition =>\n\t\t\t\t\tNodes.isNode(input) && !input.opaque,\n\t\t\t),\n\t\t\tSchemaTransformation.transformEffect({\n\t\t\t\tdecode: (input: unknown, options) =>\n\t\t\t\t\tResult.match(Json.decode(input), {\n\t\t\t\t\t\tonSuccess: (node) => Effect.succeed(node as never),\n\t\t\t\t\t\tonFailure: (problem) =>\n\t\t\t\t\t\t\tEffect.fail(\n\t\t\t\t\t\t\t\tnew SchemaIssue.Pointer(\n\t\t\t\t\t\t\t\t\tproblem.path,\n\t\t\t\t\t\t\t\t\tnew SchemaIssue.InvalidValue(\n\t\t\t\t\t\t\t\t\t\t{ message: problem.message },\n\t\t\t\t\t\t\t\t\t\tinput,\n\t\t\t\t\t\t\t\t\t\toptions,\n\t\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t}),\n\t\t\t\tencode: (condition: PlainCondition) =>\n\t\t\t\t\tEffect.sync(() => Json.toJson(condition as never)),\n\t\t\t}),\n\t\t),\n\t) as never\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiqBA,MAAM,aAAa,MAClB,YAAY,GAAG,MAAM,MAAM,EAAE,SAAS,aAAa,EAAE,SAAS;AAE/D,MAAM,aAAa,UAClB,UAAU,KAAK,IAAI,QAAQA,QAAc,KAAe;AAEzD,MAAM,WACJ,QACA,OAAe,UACf,IAAIC,QAAc;CAAE;CAAI;CAAO,OAAO,UAAU,KAAK;AAAE,CAAC;AAM1D,MAAM,SAAS,eACd,IAAIC,IAAU,UAAuC;AAEtD,MAAM,QAAQ,eACb,IAAIC,GAAS,UAAuC;AAErD,MAAM,WAAW,cAAwB,IAAIC,IAAU,SAAuB;AAE9E,MAAM,gBAAwC;CAC7C,IAAI,QAAQ,IAAI;CAChB,IAAI,QAAQ,IAAI;CAChB,IAAI,QAAQ,IAAI;CAChB,KAAK,QAAQ,KAAK;CAClB,IAAI,QAAQ,IAAI;CAChB,KAAK,QAAQ,KAAK;CAClB,KAAK,OAAe,WACnB,IAAIC,GAAS;EAAE;EAAO,QAAQ,IAAI,IAAI,MAAM,KAAK,MAAM,GAAG,SAAS;CAAE,CAAC;CACvE,SAAS,UAAkB,IAAIC,OAAa,EAAE,MAAM,CAAC;CACrD,QAAQ,GAAG,WACV,IAAIC,MAAY,EAAE,QAAQ,IAAI,IAAI,QAAQ,SAAS,EAAE,CAAC;CACvD,YAAY,SAAiBC,aAAmB,IAAI;CACpD,MAAM,GAAG,eAAmC,MAAM,UAAU;CAC5D,KAAK,GAAG,eAAmC,KAAK,UAAU;CAC1D,KAAK;CACL,YACC,MACA,SAKA,IAAIC,UAAgB;EACnB;EACA,MAAM,OAAO,cACZ,OAAO,cAAc;GACpB,MAAM,SAAS,KAAK,OAAO,SAAS;GACpC,OAAO,OAAO,SAAS,MAAM,IAAI,SAAS,OAAO,QAAQ,MAAM;EAChE,CAAC;CACH,CAAC;AACH;;;;;;;;;AAUA,MAAa,gBACZ;;;;;;;;AASD,MAAa,SAAoBC;;;;;;;;AASjC,MAAa,QAAmBC;;;;;;;;AAShC,MAAa,QAGZ,GAAG,eACC,MAAM,UAAU;;;;;;;;;AAUrB,MAAa,SAE6B;;;;;;;;;AAU1C,MAAa,QAE6B;;;;;;;;AAS1C,MAAa,OAGZ,GAAG,eACC,KAAK,UAAU;;;;;;AAOpB,MAAa,MAE6B;;AAsB1C,MAAM,UAAU,cAA+BC,OAAa,SAAS;;;;;;;;;AAUrE,MAAa,iBAWT,KAAK,IAAI,WAAgB,YAC5BC,QAAgB,OAAO,SAAS,GAAG,OAAO,CAC3C;;;;;;;;;;;AAuBA,MAAa,aAIZ,WACA,UAEA,OAAO,cAAcC,WAAiB,OAAO,SAAS,GAAG,KAAK,CAAC;;;;;;;;AAShE,MAAa,gBAGG,WAAgB,UAC/BC,eAAqB,OAAO,SAAS,GAAG,KAAK;;;;;;;;;;AAW9C,MAAa,aACV,cAAmB,UAAU,KAAK,QAAQC,UAAgB;;;;;;;;;;;AAgC7D,MAAa,YAGmB,WAAgB,UAC/CC,UAAgB,OAAO,SAAS,GAAG,KAAK;;;;;;;;AA8BzC,IAAa,iBAAb,cAAoC,OAAO,YAC1C,0CACD,CAAC,CAAC,kBAAkB,EAAE,QAAQ,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhD,MAAM,gBAAgB,SAAkB,UAA0B;CACjE,IAAI,QAAQ,SAAS,WACpB,MAAM,eAAe,KAAK,EACzB,QAAQ,cAAc,MAAM,yDAC7B,CAAC;CAEF,OAAO,QAAQ;AAChB;;AAGA,MAAM,YAAe,MAAkB,gBAAmC;CACzE,QAAQ,KAAK,MAAb;EACC,KAAK,QACJ,OAAO,YAAY,KAAK;EACzB,KAAK,SACJ,OAAO,YAAY,MAAM;EAC1B,KAAK,WACJ,OAAO,YAAY,QAClB,KAAK,IACL,KAAK,OACL,aAAa,KAAK,OAAO,KAAK,KAAK,CACpC;EACD,KAAK,MACJ,OAAO,YAAY,GAClB,KAAK,OACL,IAAI,IAAI,KAAK,SAAS,YAAY,aAAa,SAAS,KAAK,KAAK,CAAC,CACpE;EACD,KAAK,UACJ,OAAO,YAAY,OAAO,KAAK,KAAK;EACrC,KAAK,SACJ,MAAM,eAAe,KAAK,EACzB,QACC,uEACF,CAAC;EACF,KAAK,OACJ,OAAO,YAAY,IAClB,IAAI,IAAI,KAAK,aAAa,UAAU,SAAS,OAAO,WAAW,CAAC,CACjE;EACD,KAAK,MACJ,OAAO,YAAY,GAClB,IAAI,IAAI,KAAK,aAAa,UAAU,SAAS,OAAO,WAAW,CAAC,CACjE;EACD,KAAK,OACJ,OAAO,YAAY,IAAI,SAAS,KAAK,WAAW,WAAW,CAAC;EAC7D,KAAK;GACJ,IAAI,YAAY,cAAc,KAAA,GAC7B,MAAM,eAAe,KAAK,EACzB,QAAQ,kBAAkB,KAAK,KAAK,0BACrC,CAAC;GAEF,OAAO,YAAY,UAAU,KAAK,IAAI;CACxC;AACD;;;;;;;;;;AAWA,MAAa,OAQT,KACH,IAEC,WACA,gBAEA,OAAO,IAAI;CACV,WAAW,SAAS,OAAO,SAAS,GAAG,WAAW;CAClD,QAAQ,UAAU;EACjB,IAAI,iBAAiB,gBACpB,OAAO;EAER,MAAM;CACP;AACD,CAAC,CACH;;;;;;;;AASA,MAAa,UAAU,cACtB,UAAU,KAAK,QAAQC,QAAc;;;;;;;;;;;;;;;;;;;;;;;;;AAqEtC,MAAa,eACZ,WACA,UAA8B,CAAC,MAE/BC,cACC,OAAO,SAAS,GAChBC,QACC,QAAQ,WAAW,KAAA,IAChB,KAAA,IACAC,UAAkB,QAAQ,OAAO,GAAG,CACxC,GACA,QAAQ,MACT;;;;;;;;;;;;;AAoED,MAAa,SACZ,OAAO,QAAQ,KACd,OAAO,SACN,OAAO,SACL,UACAC,OAAa,KAAK,KAAK,CAAC,MAAM,MAChC,GACA,qBAAqB,gBAAgB;CACpC,SAAS,OAAgB,YACxB,OAAO,MAAMC,OAAY,KAAK,GAAG;EAChC,YAAY,SAAS,OAAO,QAAQ,IAAa;EACjD,YAAY,YACX,OAAO,KACN,IAAI,YAAY,QACf,QAAQ,MACR,IAAI,YAAY,aACf,EAAE,SAAS,QAAQ,QAAQ,GAC3B,OACA,OACD,CACD,CACD;CACF,CAAC;CACF,SAAS,cACR,OAAO,WAAWC,OAAY,SAAkB,CAAC;AACnD,CAAC,CACF,CACD"}

package/dist/Domain.d.ts

@@ -1,7 +1,7 @@
 import { Catalog } from "./internal/catalog.js";
 import { Action, Any as Any$1, Data, Descriptor, Kind as Kind$1, Resource, Value } from "./Resource.js";
-import * as Schema from "effect/Schema";
 import * as HashMap from "effect/HashMap";
+import * as Schema from "effect/Schema";
 declare namespace Domain_d_exports {
   export { ActionOf, Any, AnyAction, AnyValue, CommonAction, DataOf, Domain, Kind, Meta, Principal, ResourceOf, Resources, ValueOf, make };
 }

package/dist/Policy.d.ts

@@ -2,7 +2,7 @@ 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 { Rule as Rule$1 } from "./internal/rule.js";
-import { All, Any as Any$3, Ceiling, FirstOf, Node as Node$1, Rules } from "./internal/policy-nodes.js";
+import { Algorithm as Algorithm$1, 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";
@@ -17,7 +17,7 @@ declare namespace Policy_d_exports {
  * @category models
  * @since 0.3.0
  */
-export type Algorithm = "denyOverrides" | "permitOverrides" | "firstApplicable" | "lastApplicable";
+export type Algorithm = Algorithm$1;
 /**
  * A list of rules with a combining algorithm.
  *

package/dist/Policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Policy.d.ts","names":["PolicyNodes.Rules","PolicyNodes.All","PolicyNodes.Any","PolicyNodes.FirstOf","PolicyNodes.Ceiling","PolicyNodes.Node","Domain.Any","Internal.PolicyData","Domain.Kind","Domain.ActionOf","Domain.ValueOf","Domain.DataOf","Condition.FieldSelector","Domain.Principal","Condition.Builder","Condition.Reads","Condition.Condition","Decision.Decision","RuleData.Rule","Domain.Resources","Resource.Kind","Domain.AnyAction","Domain.CommonAction","Domain.AnyValue","Condition.FieldName","Condition.Any","Domain.Meta","Condition.ReadsOf","Condition.OpaqueOf","Internal.PolicyError","Condition.ServicesOf","Condition.Provided","Condition.ErrorOf","Condition.Example","Condition.Encoded"],"sources":["../src/Policy.ts"],"mappings":"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"}
+{"version":3,"file":"Policy.d.ts","names":["PolicyNodes.Algorithm","PolicyNodes.Rules","PolicyNodes.All","PolicyNodes.Any","PolicyNodes.FirstOf","PolicyNodes.Ceiling","PolicyNodes.Node","Domain.Any","Internal.PolicyData","Domain.Kind","Domain.ActionOf","Domain.ValueOf","Domain.DataOf","Condition.FieldSelector","Domain.Principal","Condition.Builder","Condition.Reads","Condition.Condition","Decision.Decision","RuleData.Rule","Domain.Resources","Resource.Kind","Domain.AnyAction","Domain.CommonAction","Domain.AnyValue","Condition.FieldName","Condition.Any","Domain.Meta","Condition.ReadsOf","Condition.OpaqueOf","Internal.PolicyError","Condition.ServicesOf","Condition.Provided","Condition.ErrorOf","Condition.Example","Condition.Encoded"],"sources":["../src/Policy.ts"],"mappings":"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"}

package/dist/Policy.js.map

@@ -1 +1 @@
-{"version":3,"file":"Policy.js","names":["RuleData.builder","RuleData.makePlain","Internal.PolicyError","Internal.define","Internal.combine","Internal.ceiling","Internal.provideContext","Decide.decideAny","Decide.decideSync","Decide.explain","Decide.permittedFields","Analysis.residual","Analysis.coverageAny","Internal.schema"],"sources":["../src/Policy.ts"],"sourcesContent":["/**\n * A policy is a tree that gives a {@link Decision.Decision} for a request.\n *\n * The leaves of the tree are lists of rules. A combining algorithm decides\n * which rule gives the answer when more than one rule applies:\n * - `denyOverrides` (the default): a deny rule wins over every allow rule.\n * - `permitOverrides`: an allow rule wins over every deny rule.\n * - `firstApplicable`: the first rule that applies wins.\n * - `lastApplicable`: the last rule that applies wins.\n *\n * The branches put policies together:\n * - {@link all}: every policy must allow, and one deny is enough to deny. Use\n *   it when a user token may never do more than its user.\n * - {@link any}: one allow is enough.\n * - {@link firstOf}: the first policy that gives an answer wins. Use it for\n *   grants first, then rules.\n * - {@link ceiling}: the deny rules of a second policy are a limit for\n *   everyone. Its allow rules do nothing.\n *\n * A policy gives three kinds of answers:\n * - {@link decide}: the decision for one resource value.\n * - {@link residual}: a condition on resource values. A value passes when the\n *   policy allows the request for that value. Use it to make a database\n *   query, or to ask \"may this principal do this act on some resource of\n *   this kind?\"\n * - {@link permittedFields}: the fields that the policy lets a request use.\n *\n * Each of them takes the policy first and the request second, as in\n * `Policy.decide(policy, request)`. The policy gives the domain, so\n * TypeScript checks the request against it.\n *\n * A policy without predicates can become JSON with {@link schema}.\n *\n * @stability stable\n * @since 0.3.0\n */\nimport type * as Context from \"effect/Context\"\nimport type * as Data from \"effect/Data\"\nimport type * as Effect from \"effect/Effect\"\nimport type * as Schema from \"effect/Schema\"\nimport type * as Condition from \"./Condition.ts\"\nimport * as Analysis from \"./internal/analysis.ts\"\nimport * as Decide from \"./internal/decide.ts\"\nimport * as Internal from \"./internal/policy.ts\"\nimport type * as PolicyNodes from \"./internal/policy-nodes.ts\"\nimport * as RuleData from \"./internal/rule.ts\"\nimport type * as Decision from \"./Decision.ts\"\nimport type * as Domain from \"./Domain.ts\"\nimport type * as Resource from \"./Resource.ts\"\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Algorithm =\n\t\"denyOverrides\" | \"permitOverrides\" | \"firstApplicable\" | \"lastApplicable\"\n\n/**\n * A list of rules with a combining algorithm.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type RulesNode = PolicyNodes.Rules\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type AllNode = PolicyNodes.All\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type AnyNode = PolicyNodes.Any\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type FirstOfNode = PolicyNodes.FirstOf\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type CeilingNode = PolicyNodes.Ceiling\n\n/**\n * The nodes of a policy tree, without types. Each node is a class, and only\n * the functions of this module and the Schema make one.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Node = PolicyNodes.Node\n\n/**\n * A policy for the domain `D`. `X` is `Condition.Opaque` when a rule of the\n * policy has a predicate, and `never` when the policy is plain data. A plain\n * policy can become JSON, and `decideSync` takes it.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Policy<D extends Domain.Any, X = never> = Internal.PolicyData<D, X>\n\n/**\n * Any policy.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Any = Policy<any, any>\n\n/**\n * The domain of a policy.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type DomainOf<P> = P extends Policy<infer D, any> ? D : never\n\n/**\n * The mark of a policy or a rule: `Condition.Opaque` when it has a predicate.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type OpaqueOf<P> = P extends { readonly \"~Opaque\": () => infer X }\n\t? X\n\t: never\n\n/**\n * One act on one resource value, for each kind of the domain. The action must\n * be an action of the kind, and the field must be a field of the kind.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Target<D> = {\n\t[K in Domain.Kind<D>]: {\n\t\treadonly action: Domain.ActionOf<D, K>\n\t\treadonly resource: Domain.ValueOf<D, K>\n\t\treadonly field?: Condition.FieldSelector<Domain.DataOf<D, K>>\n\t\t/** A target has a resource value or a kind, never both. */\n\t\treadonly kind?: never\n\t}\n}[Domain.Kind<D>]\n\n/**\n * A {@link Target} with no field. Each kind keeps its own actions.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type FieldlessTarget<D> = {\n\t[K in Domain.Kind<D>]: {\n\t\treadonly action: Domain.ActionOf<D, K>\n\t\treadonly resource: Domain.ValueOf<D, K>\n\t\treadonly kind?: never\n\t}\n}[Domain.Kind<D>]\n\n/**\n * A scope: a part of a kind, as a condition on its values. It gets a builder\n * with the types of the kind and of the principal, like the condition of a\n * rule. A scope is plain data, so it can not have a predicate.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Scope<D, K extends string> = (\n\tbuilder: Condition.Builder<\n\t\tDomain.DataOf<D, K>,\n\t\tDomain.ValueOf<D, K>,\n\t\tDomain.Principal<D>\n\t>,\n) => Condition.Condition<\n\tCondition.Reads<Domain.ValueOf<D, K>, Domain.Principal<D>>\n>\n\n/**\n * One act on one kind of resource, with no value. With `within`, the target is\n * only the values of the kind in the scope. Without it, the target is every\n * value of the kind.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type KindTarget<D> = {\n\t[K in Domain.Kind<D>]: {\n\t\treadonly action: Domain.ActionOf<D, K>\n\t\treadonly kind: K\n\t\treadonly field?: Condition.FieldSelector<Domain.DataOf<D, K>>\n\t\t/** The part of the kind. See {@link Scope}. */\n\t\treadonly within?: Scope<D, K>\n\t\t/** A target has a resource value or a kind, never both. */\n\t\treadonly resource?: never\n\t}\n}[Domain.Kind<D>]\n\n/**\n * A request: a principal, an action, and a resource value.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Request<D> = Target<D> & { readonly principal: Domain.Principal<D> }\n\n/**\n * A {@link Request} with no field.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type FieldlessRequest<D> = FieldlessTarget<D> & {\n\treadonly principal: Domain.Principal<D>\n}\n\n/**\n * A request about a kind of resource, with no value.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type KindRequest<D> = KindTarget<D> & {\n\treadonly principal: Domain.Principal<D>\n}\n\n/**\n * A request with no types.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface AnyRequest {\n\treadonly principal: object\n\treadonly action: string\n\treadonly resource: object\n\treadonly field?: string | undefined\n}\n\n/**\n * One rule that a decision tested. `path` gives the place of the rule in the\n * policy tree: the index of each child, then the index of the rule.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Step {\n\treadonly path: ReadonlyArray<number>\n\treadonly rule: AnyRule\n\treadonly applies: boolean\n}\n\n/**\n * A decision, and the rules that were tested to make it, in order. Keep it in\n * an audit log.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Explanation {\n\treadonly decision: Decision.Decision\n\treadonly steps: ReadonlyArray<Step>\n}\n\n// Rules\n\n/**\n * A rule for the domain `D`. `I` is what the tests of its condition read, and\n * `X` is its mark: see `Condition.Condition`. A predicate reads the values and\n * the principal of its domain, so a rule may go only into a policy of its own\n * domain. A rule from {@link rule} has the domain `any`.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Rule<D = any, I = unknown, X = never> = RuleData.Rule<D, I, X>\n\n/**\n * The data of a rule.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport interface RuleShape<I = unknown, X = never> {\n\treadonly _tag: \"Allow\" | \"Deny\"\n\treadonly actions: ReadonlyArray<string>\n\treadonly resources: ReadonlyArray<string>\n\treadonly when?: Condition.Condition<I, X>\n\treadonly fields?: ReadonlyArray<string>\n\treadonly reason?: string\n\treadonly id?: string\n\treadonly meta?: unknown\n\t/**\n\t * The domain of the builder that made the rule. Two domains may have the\n\t * same types but other paths, so the types can not tell them apart. It is\n\t * not in the JSON form of a rule.\n\t */\n\treadonly domain?: Domain.Any\n}\n\n/**\n * Any rule.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\n// Every rule fits `never` as what it reads, and a condition taken from such a\n// rule fits no rule that reads a value or a principal.\nexport type AnyRule = Rule<any, never, any>\n\n/**\n * A resource in a rule: a kind name, a resource of the domain, or `\"*\"`.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type RuleTarget<D> = Domain.Kind<D> | Domain.Resources<D> | \"*\"\n\n/**\n * The kind name of a target.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type KindOf<T> = T extends string ? T : Resource.Kind<T>\n\n/**\n * The actions that a rule may use for the kinds `K`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type ActionFor<D, K> =\n\t| \"*\"\n\t| (\"*\" extends K\n\t\t\t? Domain.AnyAction<D>\n\t\t\t: Domain.ActionOf<D, Extract<K, string>>)\n\n/**\n * The targets in the resource argument of a rule: the one target, or the\n * targets of a list.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type TargetOf<Res> = Res extends ReadonlyArray<infer X> ? X : Res\n\n/**\n * The actions that a rule may use for its resource argument. A list of\n * resources may use an action of any of them. One target with a union type\n * may use only an action of every kind in the union, because its value may be\n * any one of them. When the argument may be a list or one target, the rule\n * may use only an action that each of these shapes allows.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type ActionForTargets<D, Res> = (\n\tRes extends ReadonlyArray<infer X>\n\t\t? (action: ActionFor<D, KindOf<X>>) => void\n\t\t: (action: ActionForTarget<D, Res>) => void\n) extends (action: infer A) => void\n\t? A\n\t: never\n\n/** The actions for one target that is not a list. */\ntype ActionForTarget<D, Res> =\n\t| \"*\"\n\t| (\"*\" extends KindOf<Res>\n\t\t\t? Domain.AnyAction<D>\n\t\t\t: Domain.CommonAction<D, Extract<KindOf<Res>, string>>)\n\n/**\n * The data type of the kinds `K`. For `\"*\"` it has no fields.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type DataFor<D, K> = \"*\" extends K\n\t? {}\n\t: Domain.DataOf<D, Extract<K, string>>\n\n/**\n * The value type of the kinds `K`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type ValueFor<D, K> = \"*\" extends K\n\t? Domain.AnyValue<D>\n\t: Domain.ValueOf<D, Extract<K, string>>\n\n/**\n * A field name or a field pattern of the kinds `K`.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type FieldFor<D, K> =\n\tCondition.FieldName<DataFor<D, K>> | `${string}*${string}`\n\n/**\n * A condition that a rule for the kinds `K` may have. Its predicates may read\n * only the values of these kinds and the principal of the domain.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type ConditionFor<D, K> = Condition.Condition<\n\tCondition.Reads<ValueFor<D, K>, Domain.Principal<D>>,\n\tany\n>\n\n/**\n * The options of a rule.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface RuleOptions<D, K, C extends Condition.Any> {\n\t/** The condition. It gets a builder with the types of the resource. */\n\treadonly when?: (\n\t\tbuilder: Condition.Builder<\n\t\t\tDataFor<D, K>,\n\t\t\tValueFor<D, K>,\n\t\t\tDomain.Principal<D>\n\t\t>,\n\t) => C\n\treadonly fields?: ReadonlyArray<FieldFor<D, K>>\n\treadonly reason?: string\n\treadonly id?: string\n\treadonly meta?: Domain.Meta<D>\n}\n\ntype SingleOrArray<A> = A | ReadonlyArray<A>\n\n/**\n * Makes rules with the types of a domain.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Builder<D> {\n\treadonly allow: <\n\t\tconst Res extends SingleOrArray<RuleTarget<D>>,\n\t\tconst A extends ActionForTargets<D, Res>,\n\t\tconst C extends ConditionFor<D, KindOf<TargetOf<Res>>> =\n\t\t\tCondition.Condition,\n\t>(\n\t\taction: SingleOrArray<A>,\n\t\tresource: Res,\n\t\toptions?: RuleOptions<D, KindOf<TargetOf<Res>>, C>,\n\t) => Rule<D, Condition.ReadsOf<C>, Condition.OpaqueOf<C>>\n\treadonly deny: <\n\t\tconst Res extends SingleOrArray<RuleTarget<D>>,\n\t\tconst A extends ActionForTargets<D, Res>,\n\t\tconst C extends ConditionFor<D, KindOf<TargetOf<Res>>> =\n\t\t\tCondition.Condition,\n\t>(\n\t\taction: SingleOrArray<A>,\n\t\tresource: Res,\n\t\toptions?: RuleOptions<D, KindOf<TargetOf<Res>>, C>,\n\t) => Rule<D, Condition.ReadsOf<C>, Condition.OpaqueOf<C>>\n}\n\n/**\n * Makes rules with the types of a domain. `Policy.define` gives one to its\n * generator. Use this one to make rules outside of a generator.\n *\n * @example\n * ```ts\n * const _ = Policy.builder(App)\n * const rule = _.allow(\"read\", Document, {\n *   when: ($) => $.eq(\"ownerId\", $.principal(\"id\")),\n * })\n * ```\n *\n * @stability stable\n * @category constructors\n * @since 2.0.0\n */\nexport const builder = <D extends Domain.Any>(domain: D): Builder<D> =>\n\tRuleData.builder(domain) as never\n\n/**\n * Makes a rule from its data, with no types. It does not check the data\n * against a domain: a policy does that when the rule goes into it. Use\n * {@link builder} for rules with types, or {@link schema} for rules from JSON.\n *\n * The condition may not have a predicate. A policy checks the fields of a\n * condition against the resources of its rule, but it can not check what\n * the code of a predicate reads. A rule from the builder keeps that in its\n * types; this one could give a predicate of one kind to another kind.\n *\n * @stability stable\n * @category constructors\n * @since 2.0.0\n */\nexport const rule: <I = unknown>(\n\tdata: RuleShape<I, never>,\n\t// The types come from the data only, not from where the rule goes.\n) => Rule<any, NoInfer<I>> = RuleData.makePlain as never\n\n/**\n * The options of a list of rules.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Options {\n\t/** The default is `denyOverrides`. */\n\treadonly algorithm?: Algorithm\n}\n\n/**\n * The error when a rule does not fit its domain: it names a kind, an action,\n * a field or a field of the principal that the domain does not have, or it\n * tests a field with a value that the field can not hold. It has one issue\n * for each problem, with its path, and a suggestion when a name has a mistake.\n *\n * @stability stable\n * @category errors\n * @since 2.0.0\n */\nexport const PolicyError: typeof Internal.PolicyError = Internal.PolicyError\n\n/**\n * @stability stable\n * @category errors\n * @since 2.0.0\n */\nexport type PolicyError = Internal.PolicyError\n\n/** The mark of a union of rules: `Condition.Opaque` when one has a predicate. */\ntype RulesOpaque<Rules> = Rules extends { readonly \"~Opaque\": () => infer X }\n\t? X\n\t: never\n\n/**\n * Makes a policy from a generator function that gives rules. It is pure and it\n * gives its result at once.\n *\n * @example\n * ```ts\n * const policy = Policy.define(App)(function* (_) {\n *   yield* _.allow(\"read\", Document)\n *   yield* _.allow([\"update\", \"delete\"], Document, {\n *     when: ($) => $.eq(\"ownerId\", $.principal(\"id\")),\n *   })\n * })\n * ```\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const define: <D extends Domain.Any>(\n\tdomain: D,\n\toptions?: Options,\n) => <Rules extends Rule<D, never, any>, A>(\n\tbody: (builder: Builder<D>) => Generator<Rules, A, unknown>,\n) => Policy<D, RulesOpaque<Rules>> = Internal.define as never\n\ntype Combined<D extends Domain.Any, Ps extends ReadonlyArray<Any>> = Policy<\n\tD,\n\tOpaqueOf<Ps[number]>\n>\n\n/**\n * Every policy must allow, and one deny is enough to deny. With some policies\n * not applicable and none that deny, the result is not applicable.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const all: <const Ps extends readonly [Any, ...Array<Any>]>(\n\tpolicies: Ps,\n) => Combined<DomainOf<Ps[0]>, Ps> = Internal.combine(\"All\")\n\n/**\n * One allow is enough. Without an allow, one deny gives a deny.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const any: <const Ps extends readonly [Any, ...Array<Any>]>(\n\tpolicies: Ps,\n) => Combined<DomainOf<Ps[0]>, Ps> = Internal.combine(\"Any\")\n\n/**\n * The first policy that allows or denies gives the answer.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const firstOf: <const Ps extends readonly [Any, ...Array<Any>]>(\n\tpolicies: Ps,\n) => Combined<DomainOf<Ps[0]>, Ps> = Internal.combine(\"FirstOf\")\n\n/**\n * Puts a limit on a policy. A deny from `cap` always wins. An allow from `cap`\n * does nothing.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const ceiling: {\n\t<D extends Domain.Any, X2>(\n\t\tcap: Policy<D, X2>,\n\t): <X>(policy: Policy<D, X>) => Policy<D, X | X2>\n\t<D extends Domain.Any, X, X2>(\n\t\tpolicy: Policy<D, X>,\n\t\tcap: Policy<D, X2>,\n\t): Policy<D, X | X2>\n} = Internal.ceiling as never\n\n/**\n * Gives the services in `context` to every predicate of a policy, so the\n * policy needs no services when it runs.\n *\n * @stability stable\n * @category services\n * @since 1.0.0\n */\nexport const provideContext: {\n\t<R>(\n\t\tcontext: Context.Context<R>,\n\t): <D extends Domain.Any, X>(\n\t\tpolicy: Policy<D, X> &\n\t\t\t([Condition.ServicesOf<X>] extends [R] ? unknown : never),\n\t) => Policy<D, Condition.Provided<X>>\n\t<D extends Domain.Any, X>(\n\t\tpolicy: Policy<D, X>,\n\t\tcontext: Context.Context<Condition.ServicesOf<X>>,\n\t): Policy<D, Condition.Provided<X>>\n} = Internal.provideContext as never\n\n// Decisions\n\n/**\n * Gives the decision of a policy for a request.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const decide: <D extends Domain.Any, X>(\n\tpolicy: Policy<D, X>,\n\trequest: Request<NoInfer<D>>,\n) => Effect.Effect<\n\tDecision.Decision,\n\tCondition.ErrorOf<X>,\n\tCondition.ServicesOf<X>\n> = Decide.decideAny as never\n\n/**\n * Gives the decision of a policy with no predicates, at once.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const decideSync: <D extends Domain.Any>(\n\tpolicy: Policy<D>,\n\trequest: Request<NoInfer<D>>,\n) => Decision.Decision = Decide.decideSync\n\n/**\n * Gives the decision of a policy and the rules that were tested to make it.\n *\n * One node may be a child of many nodes. Its rules are tested, and are in the\n * steps, each time that the decision comes to it.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const explain: <D extends Domain.Any, X>(\n\tpolicy: Policy<D, X>,\n\trequest: Request<NoInfer<D>>,\n) => Effect.Effect<Explanation, Condition.ErrorOf<X>, Condition.ServicesOf<X>> =\n\tDecide.explain as never\n\n/**\n * Gives the fields of a resource value that the policy lets a request use. It\n * tests each field that a list of fields shows: each scalar, record or array\n * of the resource Schema, with dots for nested fields.\n *\n * A field that holds more than one value, such as a record, is left out when a\n * deny rule names a part of it. The list can not name that part, and the whole\n * field would show it.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const permittedFields: <D extends Domain.Any, X>(\n\tpolicy: Policy<D, X>,\n\trequest: FieldlessRequest<NoInfer<D>>,\n) => Effect.Effect<\n\tReadonlyArray<string>,\n\tCondition.ErrorOf<X>,\n\tCondition.ServicesOf<X>\n> = Decide.permittedFields as never\n\n// Residual conditions\n\n/**\n * What a residual condition reads: a value of the kind `K`. The principal is\n * already in it. A residual is for one kind, so when `K` is a union of kinds,\n * the value must be a value of each of them. No value is, so such a residual\n * can not be evaluated on a value of the wrong kind.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type ResidualReads<D, K> = Condition.Reads<\n\t(\n\t\tK extends unknown ? (value: Domain.ValueOf<D, K & string>) => void : never\n\t) extends (value: infer V) => void\n\t\t? V\n\t\t: never,\n\tunknown\n>\n\n/**\n * Gives the condition on resource values for which the policy allows a\n * request. It has no principal fields and no `Under` nodes, so you can give it\n * to `Condition.fold`. It is made smaller, so it is often `True` or `False`\n * when the answer does not depend on the value, but it does no search: a\n * condition that is true for every value may stay a test. To know if the\n * policy allows every value, or some value, use {@link coverage}.\n *\n * With a scope (`within`), the condition is the scope and the residual\n * together, so it is false for every value outside the scope. Give the policy\n * first to use a scope. The condition comes from its parts, with no search. To\n * know if it allows all of the scope or none of it, use {@link coverage}.\n *\n * When a rule that the request may use has a predicate, the condition is one\n * predicate with the name `\"policy\"`. It runs the whole policy for each value,\n * so its answers and its failures are the same as those of {@link decide}. It\n * takes the principal with it. Give it resource values with their `_tag`. It\n * is false for a value of another kind.\n *\n * A policy tree may use the condition of a child two times, so a small policy\n * may give a very large condition. When the condition would have more than\n * 10000 nodes, this function throws an error. In an `Authorizer`, the error\n * is a defect, so the check fails.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const residual: <\n\tD extends Domain.Any,\n\tX,\n\tconst Req extends KindRequest<NoInfer<D>>,\n>(\n\tpolicy: Policy<D, X>,\n\trequest: Req,\n) => Condition.Condition<ResidualReads<D, Req[\"kind\"]>, X> =\n\tAnalysis.residual as never\n\n/**\n * How much of a scope a policy allows. In each case, `condition` is the exact\n * condition on the values in the scope that the policy allows: give it to\n * `Condition.fold` for a list query.\n * - `All`: the policy allows every value in the scope. `condition` is the\n *   scope (`True` with no scope).\n * - `None`: the policy allows no value in the scope. `condition` is `False`.\n *   An empty scope is `None` too, so a check on a scope that has a mistake,\n *   such as a principal field with no value, never passes.\n * - `Some`: the policy allows some values in the scope and not others.\n *   `allowed` is an example of a value that it allows, and `refused` of a\n *   value in the scope that it does not allow.\n * - `Unknown`: the answer needs a predicate, or the search went past its\n *   budget.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Coverage<I = unknown, X = never> = Data.TaggedEnum<{\n\tAll: { readonly condition: Condition.Condition<I, X> }\n\tNone: { readonly condition: Condition.Condition<I, X> }\n\tSome: {\n\t\treadonly condition: Condition.Condition<I, X>\n\t\treadonly allowed: Condition.Example\n\t\treadonly refused: Condition.Example\n\t}\n\tUnknown: {\n\t\treadonly condition: Condition.Condition<I, X>\n\t\treadonly reason: \"predicate\" | \"budget\"\n\t}\n}>\n\n/**\n * Tells how much of a scope the policy allows: all of it, none of it, or some\n * of it. See {@link Coverage}. With no scope (`within`), the scope is every\n * value of the kind.\n *\n * The answer comes from {@link Condition.satisfiable} with the shape of the\n * Schema of the resource. `All` and `None` hold for every value of the\n * Schema. `Some` means that, by the shape of the Schema, a value may get\n * either answer: a check such as a minimum length may still stop one of the\n * examples. `Unknown` comes only from a predicate or from the budget of the\n * search.\n *\n * `Some` does not mean that such a value is in your database. To know that,\n * run `condition` as a query.\n *\n * @stability stable\n * @category evaluation\n * @since 1.0.0\n */\nexport const coverage: <\n\tD extends Domain.Any,\n\tX,\n\tconst Req extends KindRequest<NoInfer<D>>,\n>(\n\tpolicy: Policy<D, X>,\n\trequest: Req,\n) => Coverage<ResidualReads<D, Req[\"kind\"]>, X> = Analysis.coverageAny as never\n\n// Schema\n\n/**\n * The JSON form of a rule.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface EncodedRule {\n\treadonly _tag: \"Allow\" | \"Deny\"\n\treadonly actions: ReadonlyArray<string>\n\treadonly resources: ReadonlyArray<string>\n\treadonly when?: Condition.Encoded\n\treadonly fields?: ReadonlyArray<string>\n\treadonly reason?: string\n\treadonly id?: string\n\treadonly meta?: unknown\n}\n\n/**\n * The JSON form of a policy.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type EncodedNode =\n\t| {\n\t\t\treadonly _tag: \"Rules\"\n\t\t\treadonly algorithm: Algorithm\n\t\t\treadonly rules: ReadonlyArray<EncodedRule>\n\t  }\n\t| {\n\t\t\treadonly _tag: \"All\" | \"Any\" | \"FirstOf\"\n\t\t\treadonly policies: ReadonlyArray<EncodedNode>\n\t  }\n\t| {\n\t\t\treadonly _tag: \"Ceiling\"\n\t\t\treadonly cap: EncodedNode\n\t\t\treadonly policy: EncodedNode\n\t  }\n\n/**\n * The Schema of the policies of a domain with no predicates. Decoding checks\n * every kind, action, field and principal field against the domain, and the\n * `meta` of each rule against the `meta` Schema of the domain.\n *\n * The decoder takes at most 256 levels of policies and 500 levels of\n * conditions, and at most 1000000 objects and array items, with a shared\n * object counted for each place. It reads only the own data fields of the\n * input.\n *\n * @stability stable\n * @category schemas\n * @since 0.3.0\n */\nexport const schema: <D extends Domain.Any>(\n\tdomain: D,\n) => Schema.Codec<Policy<D>, EncodedNode> = Internal.schema as never\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAygBA,MAAa,WAAiC,WAC7CA,UAAiB,MAAM;;;;;;;;;;;;;;;AAgBxB,MAAa,OAGgBC;;;;;;;;;;;AAwB7B,MAAa,cAA2CC;;;;;;;;;;;;;;;;;;;AAgCxD,MAAa,SAKwBC;;;;;;;;;AAerC,MAAa,MAEwBC,QAAiB,KAAK;;;;;;;;AAS3D,MAAa,MAEwBA,QAAiB,KAAK;;;;;;;;AAS3D,MAAa,UAEwBA,QAAiB,SAAS;;;;;;;;;AAU/D,MAAa,UAQTC;;;;;;;;;AAUJ,MAAa,iBAWTC;;;;;;;;AAWJ,MAAa,SAOTC;;;;;;;;AASJ,MAAa,aAGYC;;;;;;;;;;;AAYzB,MAAa,UAIZC;;;;;;;;;;;;;;AAeD,MAAa,kBAOTC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDJ,MAAa,WAQZC;;;;;;;;;;;;;;;;;;;;AAsDD,MAAa,WAOqCC;;;;;;;;;;;;;;;AA2DlD,MAAa,SAE+BC"}
+{"version":3,"file":"Policy.js","names":["RuleData.builder","RuleData.makePlain","Internal.PolicyError","Internal.define","Internal.combine","Internal.ceiling","Internal.provideContext","Decide.decideAny","Decide.decideSync","Decide.explain","Decide.permittedFields","Analysis.residual","Analysis.coverageAny","Internal.schema"],"sources":["../src/Policy.ts"],"sourcesContent":["/**\n * A policy is a tree that gives a {@link Decision.Decision} for a request.\n *\n * The leaves of the tree are lists of rules. A combining algorithm decides\n * which rule gives the answer when more than one rule applies:\n * - `denyOverrides` (the default): a deny rule wins over every allow rule.\n * - `permitOverrides`: an allow rule wins over every deny rule.\n * - `firstApplicable`: the first rule that applies wins.\n * - `lastApplicable`: the last rule that applies wins.\n *\n * The branches put policies together:\n * - {@link all}: every policy must allow, and one deny is enough to deny. Use\n *   it when a user token may never do more than its user.\n * - {@link any}: one allow is enough.\n * - {@link firstOf}: the first policy that gives an answer wins. Use it for\n *   grants first, then rules.\n * - {@link ceiling}: the deny rules of a second policy are a limit for\n *   everyone. Its allow rules do nothing.\n *\n * A policy gives three kinds of answers:\n * - {@link decide}: the decision for one resource value.\n * - {@link residual}: a condition on resource values. A value passes when the\n *   policy allows the request for that value. Use it to make a database\n *   query, or to ask \"may this principal do this act on some resource of\n *   this kind?\"\n * - {@link permittedFields}: the fields that the policy lets a request use.\n *\n * Each of them takes the policy first and the request second, as in\n * `Policy.decide(policy, request)`. The policy gives the domain, so\n * TypeScript checks the request against it.\n *\n * A policy without predicates can become JSON with {@link schema}.\n *\n * @stability stable\n * @since 0.3.0\n */\nimport type * as Context from \"effect/Context\"\nimport type * as Data from \"effect/Data\"\nimport type * as Effect from \"effect/Effect\"\nimport type * as Schema from \"effect/Schema\"\nimport type * as Condition from \"./Condition.ts\"\nimport * as Analysis from \"./internal/analysis.ts\"\nimport * as Decide from \"./internal/decide.ts\"\nimport * as Internal from \"./internal/policy.ts\"\nimport type * as PolicyNodes from \"./internal/policy-nodes.ts\"\nimport * as RuleData from \"./internal/rule.ts\"\nimport type * as Decision from \"./Decision.ts\"\nimport type * as Domain from \"./Domain.ts\"\nimport type * as Resource from \"./Resource.ts\"\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Algorithm = PolicyNodes.Algorithm\n\n/**\n * A list of rules with a combining algorithm.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type RulesNode = PolicyNodes.Rules\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type AllNode = PolicyNodes.All\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type AnyNode = PolicyNodes.Any\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type FirstOfNode = PolicyNodes.FirstOf\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type CeilingNode = PolicyNodes.Ceiling\n\n/**\n * The nodes of a policy tree, without types. Each node is a class, and only\n * the functions of this module and the Schema make one.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Node = PolicyNodes.Node\n\n/**\n * A policy for the domain `D`. `X` is `Condition.Opaque` when a rule of the\n * policy has a predicate, and `never` when the policy is plain data. A plain\n * policy can become JSON, and `decideSync` takes it.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Policy<D extends Domain.Any, X = never> = Internal.PolicyData<D, X>\n\n/**\n * Any policy.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Any = Policy<any, any>\n\n/**\n * The domain of a policy.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type DomainOf<P> = P extends Policy<infer D, any> ? D : never\n\n/**\n * The mark of a policy or a rule: `Condition.Opaque` when it has a predicate.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type OpaqueOf<P> = P extends { readonly \"~Opaque\": () => infer X }\n\t? X\n\t: never\n\n/**\n * One act on one resource value, for each kind of the domain. The action must\n * be an action of the kind, and the field must be a field of the kind.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Target<D> = {\n\t[K in Domain.Kind<D>]: {\n\t\treadonly action: Domain.ActionOf<D, K>\n\t\treadonly resource: Domain.ValueOf<D, K>\n\t\treadonly field?: Condition.FieldSelector<Domain.DataOf<D, K>>\n\t\t/** A target has a resource value or a kind, never both. */\n\t\treadonly kind?: never\n\t}\n}[Domain.Kind<D>]\n\n/**\n * A {@link Target} with no field. Each kind keeps its own actions.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type FieldlessTarget<D> = {\n\t[K in Domain.Kind<D>]: {\n\t\treadonly action: Domain.ActionOf<D, K>\n\t\treadonly resource: Domain.ValueOf<D, K>\n\t\treadonly kind?: never\n\t}\n}[Domain.Kind<D>]\n\n/**\n * A scope: a part of a kind, as a condition on its values. It gets a builder\n * with the types of the kind and of the principal, like the condition of a\n * rule. A scope is plain data, so it can not have a predicate.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Scope<D, K extends string> = (\n\tbuilder: Condition.Builder<\n\t\tDomain.DataOf<D, K>,\n\t\tDomain.ValueOf<D, K>,\n\t\tDomain.Principal<D>\n\t>,\n) => Condition.Condition<\n\tCondition.Reads<Domain.ValueOf<D, K>, Domain.Principal<D>>\n>\n\n/**\n * One act on one kind of resource, with no value. With `within`, the target is\n * only the values of the kind in the scope. Without it, the target is every\n * value of the kind.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type KindTarget<D> = {\n\t[K in Domain.Kind<D>]: {\n\t\treadonly action: Domain.ActionOf<D, K>\n\t\treadonly kind: K\n\t\treadonly field?: Condition.FieldSelector<Domain.DataOf<D, K>>\n\t\t/** The part of the kind. See {@link Scope}. */\n\t\treadonly within?: Scope<D, K>\n\t\t/** A target has a resource value or a kind, never both. */\n\t\treadonly resource?: never\n\t}\n}[Domain.Kind<D>]\n\n/**\n * A request: a principal, an action, and a resource value.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Request<D> = Target<D> & { readonly principal: Domain.Principal<D> }\n\n/**\n * A {@link Request} with no field.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type FieldlessRequest<D> = FieldlessTarget<D> & {\n\treadonly principal: Domain.Principal<D>\n}\n\n/**\n * A request about a kind of resource, with no value.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type KindRequest<D> = KindTarget<D> & {\n\treadonly principal: Domain.Principal<D>\n}\n\n/**\n * A request with no types.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface AnyRequest {\n\treadonly principal: object\n\treadonly action: string\n\treadonly resource: object\n\treadonly field?: string | undefined\n}\n\n/**\n * One rule that a decision tested. `path` gives the place of the rule in the\n * policy tree: the index of each child, then the index of the rule.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Step {\n\treadonly path: ReadonlyArray<number>\n\treadonly rule: AnyRule\n\treadonly applies: boolean\n}\n\n/**\n * A decision, and the rules that were tested to make it, in order. Keep it in\n * an audit log.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Explanation {\n\treadonly decision: Decision.Decision\n\treadonly steps: ReadonlyArray<Step>\n}\n\n// Rules\n\n/**\n * A rule for the domain `D`. `I` is what the tests of its condition read, and\n * `X` is its mark: see `Condition.Condition`. A predicate reads the values and\n * the principal of its domain, so a rule may go only into a policy of its own\n * domain. A rule from {@link rule} has the domain `any`.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Rule<D = any, I = unknown, X = never> = RuleData.Rule<D, I, X>\n\n/**\n * The data of a rule.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport interface RuleShape<I = unknown, X = never> {\n\treadonly _tag: \"Allow\" | \"Deny\"\n\treadonly actions: ReadonlyArray<string>\n\treadonly resources: ReadonlyArray<string>\n\treadonly when?: Condition.Condition<I, X>\n\treadonly fields?: ReadonlyArray<string>\n\treadonly reason?: string\n\treadonly id?: string\n\treadonly meta?: unknown\n\t/**\n\t * The domain of the builder that made the rule. Two domains may have the\n\t * same types but other paths, so the types can not tell them apart. It is\n\t * not in the JSON form of a rule.\n\t */\n\treadonly domain?: Domain.Any\n}\n\n/**\n * Any rule.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\n// Every rule fits `never` as what it reads, and a condition taken from such a\n// rule fits no rule that reads a value or a principal.\nexport type AnyRule = Rule<any, never, any>\n\n/**\n * A resource in a rule: a kind name, a resource of the domain, or `\"*\"`.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type RuleTarget<D> = Domain.Kind<D> | Domain.Resources<D> | \"*\"\n\n/**\n * The kind name of a target.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type KindOf<T> = T extends string ? T : Resource.Kind<T>\n\n/**\n * The actions that a rule may use for the kinds `K`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type ActionFor<D, K> =\n\t| \"*\"\n\t| (\"*\" extends K\n\t\t\t? Domain.AnyAction<D>\n\t\t\t: Domain.ActionOf<D, Extract<K, string>>)\n\n/**\n * The targets in the resource argument of a rule: the one target, or the\n * targets of a list.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type TargetOf<Res> = Res extends ReadonlyArray<infer X> ? X : Res\n\n/**\n * The actions that a rule may use for its resource argument. A list of\n * resources may use an action of any of them. One target with a union type\n * may use only an action of every kind in the union, because its value may be\n * any one of them. When the argument may be a list or one target, the rule\n * may use only an action that each of these shapes allows.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type ActionForTargets<D, Res> = (\n\tRes extends ReadonlyArray<infer X>\n\t\t? (action: ActionFor<D, KindOf<X>>) => void\n\t\t: (action: ActionForTarget<D, Res>) => void\n) extends (action: infer A) => void\n\t? A\n\t: never\n\n/** The actions for one target that is not a list. */\ntype ActionForTarget<D, Res> =\n\t| \"*\"\n\t| (\"*\" extends KindOf<Res>\n\t\t\t? Domain.AnyAction<D>\n\t\t\t: Domain.CommonAction<D, Extract<KindOf<Res>, string>>)\n\n/**\n * The data type of the kinds `K`. For `\"*\"` it has no fields.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type DataFor<D, K> = \"*\" extends K\n\t? {}\n\t: Domain.DataOf<D, Extract<K, string>>\n\n/**\n * The value type of the kinds `K`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type ValueFor<D, K> = \"*\" extends K\n\t? Domain.AnyValue<D>\n\t: Domain.ValueOf<D, Extract<K, string>>\n\n/**\n * A field name or a field pattern of the kinds `K`.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type FieldFor<D, K> =\n\tCondition.FieldName<DataFor<D, K>> | `${string}*${string}`\n\n/**\n * A condition that a rule for the kinds `K` may have. Its predicates may read\n * only the values of these kinds and the principal of the domain.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type ConditionFor<D, K> = Condition.Condition<\n\tCondition.Reads<ValueFor<D, K>, Domain.Principal<D>>,\n\tany\n>\n\n/**\n * The options of a rule.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface RuleOptions<D, K, C extends Condition.Any> {\n\t/** The condition. It gets a builder with the types of the resource. */\n\treadonly when?: (\n\t\tbuilder: Condition.Builder<\n\t\t\tDataFor<D, K>,\n\t\t\tValueFor<D, K>,\n\t\t\tDomain.Principal<D>\n\t\t>,\n\t) => C\n\treadonly fields?: ReadonlyArray<FieldFor<D, K>>\n\treadonly reason?: string\n\treadonly id?: string\n\treadonly meta?: Domain.Meta<D>\n}\n\ntype SingleOrArray<A> = A | ReadonlyArray<A>\n\n/**\n * Makes rules with the types of a domain.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Builder<D> {\n\treadonly allow: <\n\t\tconst Res extends SingleOrArray<RuleTarget<D>>,\n\t\tconst A extends ActionForTargets<D, Res>,\n\t\tconst C extends ConditionFor<D, KindOf<TargetOf<Res>>> =\n\t\t\tCondition.Condition,\n\t>(\n\t\taction: SingleOrArray<A>,\n\t\tresource: Res,\n\t\toptions?: RuleOptions<D, KindOf<TargetOf<Res>>, C>,\n\t) => Rule<D, Condition.ReadsOf<C>, Condition.OpaqueOf<C>>\n\treadonly deny: <\n\t\tconst Res extends SingleOrArray<RuleTarget<D>>,\n\t\tconst A extends ActionForTargets<D, Res>,\n\t\tconst C extends ConditionFor<D, KindOf<TargetOf<Res>>> =\n\t\t\tCondition.Condition,\n\t>(\n\t\taction: SingleOrArray<A>,\n\t\tresource: Res,\n\t\toptions?: RuleOptions<D, KindOf<TargetOf<Res>>, C>,\n\t) => Rule<D, Condition.ReadsOf<C>, Condition.OpaqueOf<C>>\n}\n\n/**\n * Makes rules with the types of a domain. `Policy.define` gives one to its\n * generator. Use this one to make rules outside of a generator.\n *\n * @example\n * ```ts\n * const _ = Policy.builder(App)\n * const rule = _.allow(\"read\", Document, {\n *   when: ($) => $.eq(\"ownerId\", $.principal(\"id\")),\n * })\n * ```\n *\n * @stability stable\n * @category constructors\n * @since 2.0.0\n */\nexport const builder = <D extends Domain.Any>(domain: D): Builder<D> =>\n\tRuleData.builder(domain) as never\n\n/**\n * Makes a rule from its data, with no types. It does not check the data\n * against a domain: a policy does that when the rule goes into it. Use\n * {@link builder} for rules with types, or {@link schema} for rules from JSON.\n *\n * The condition may not have a predicate. A policy checks the fields of a\n * condition against the resources of its rule, but it can not check what\n * the code of a predicate reads. A rule from the builder keeps that in its\n * types; this one could give a predicate of one kind to another kind.\n *\n * @stability stable\n * @category constructors\n * @since 2.0.0\n */\nexport const rule: <I = unknown>(\n\tdata: RuleShape<I, never>,\n\t// The types come from the data only, not from where the rule goes.\n) => Rule<any, NoInfer<I>> = RuleData.makePlain as never\n\n/**\n * The options of a list of rules.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Options {\n\t/** The default is `denyOverrides`. */\n\treadonly algorithm?: Algorithm\n}\n\n/**\n * The error when a rule does not fit its domain: it names a kind, an action,\n * a field or a field of the principal that the domain does not have, or it\n * tests a field with a value that the field can not hold. It has one issue\n * for each problem, with its path, and a suggestion when a name has a mistake.\n *\n * @stability stable\n * @category errors\n * @since 2.0.0\n */\nexport const PolicyError: typeof Internal.PolicyError = Internal.PolicyError\n\n/**\n * @stability stable\n * @category errors\n * @since 2.0.0\n */\nexport type PolicyError = Internal.PolicyError\n\n/** The mark of a union of rules: `Condition.Opaque` when one has a predicate. */\ntype RulesOpaque<Rules> = Rules extends { readonly \"~Opaque\": () => infer X }\n\t? X\n\t: never\n\n/**\n * Makes a policy from a generator function that gives rules. It is pure and it\n * gives its result at once.\n *\n * @example\n * ```ts\n * const policy = Policy.define(App)(function* (_) {\n *   yield* _.allow(\"read\", Document)\n *   yield* _.allow([\"update\", \"delete\"], Document, {\n *     when: ($) => $.eq(\"ownerId\", $.principal(\"id\")),\n *   })\n * })\n * ```\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const define: <D extends Domain.Any>(\n\tdomain: D,\n\toptions?: Options,\n) => <Rules extends Rule<D, never, any>, A>(\n\tbody: (builder: Builder<D>) => Generator<Rules, A, unknown>,\n) => Policy<D, RulesOpaque<Rules>> = Internal.define as never\n\ntype Combined<D extends Domain.Any, Ps extends ReadonlyArray<Any>> = Policy<\n\tD,\n\tOpaqueOf<Ps[number]>\n>\n\n/**\n * Every policy must allow, and one deny is enough to deny. With some policies\n * not applicable and none that deny, the result is not applicable.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const all: <const Ps extends readonly [Any, ...Array<Any>]>(\n\tpolicies: Ps,\n) => Combined<DomainOf<Ps[0]>, Ps> = Internal.combine(\"All\")\n\n/**\n * One allow is enough. Without an allow, one deny gives a deny.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const any: <const Ps extends readonly [Any, ...Array<Any>]>(\n\tpolicies: Ps,\n) => Combined<DomainOf<Ps[0]>, Ps> = Internal.combine(\"Any\")\n\n/**\n * The first policy that allows or denies gives the answer.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const firstOf: <const Ps extends readonly [Any, ...Array<Any>]>(\n\tpolicies: Ps,\n) => Combined<DomainOf<Ps[0]>, Ps> = Internal.combine(\"FirstOf\")\n\n/**\n * Puts a limit on a policy. A deny from `cap` always wins. An allow from `cap`\n * does nothing.\n *\n * @stability stable\n * @category combinators\n * @since 0.3.0\n */\nexport const ceiling: {\n\t<D extends Domain.Any, X2>(\n\t\tcap: Policy<D, X2>,\n\t): <X>(policy: Policy<D, X>) => Policy<D, X | X2>\n\t<D extends Domain.Any, X, X2>(\n\t\tpolicy: Policy<D, X>,\n\t\tcap: Policy<D, X2>,\n\t): Policy<D, X | X2>\n} = Internal.ceiling as never\n\n/**\n * Gives the services in `context` to every predicate of a policy, so the\n * policy needs no services when it runs.\n *\n * @stability stable\n * @category services\n * @since 1.0.0\n */\nexport const provideContext: {\n\t<R>(\n\t\tcontext: Context.Context<R>,\n\t): <D extends Domain.Any, X>(\n\t\tpolicy: Policy<D, X> &\n\t\t\t([Condition.ServicesOf<X>] extends [R] ? unknown : never),\n\t) => Policy<D, Condition.Provided<X>>\n\t<D extends Domain.Any, X>(\n\t\tpolicy: Policy<D, X>,\n\t\tcontext: Context.Context<Condition.ServicesOf<X>>,\n\t): Policy<D, Condition.Provided<X>>\n} = Internal.provideContext as never\n\n// Decisions\n\n/**\n * Gives the decision of a policy for a request.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const decide: <D extends Domain.Any, X>(\n\tpolicy: Policy<D, X>,\n\trequest: Request<NoInfer<D>>,\n) => Effect.Effect<\n\tDecision.Decision,\n\tCondition.ErrorOf<X>,\n\tCondition.ServicesOf<X>\n> = Decide.decideAny as never\n\n/**\n * Gives the decision of a policy with no predicates, at once.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const decideSync: <D extends Domain.Any>(\n\tpolicy: Policy<D>,\n\trequest: Request<NoInfer<D>>,\n) => Decision.Decision = Decide.decideSync\n\n/**\n * Gives the decision of a policy and the rules that were tested to make it.\n *\n * One node may be a child of many nodes. Its rules are tested, and are in the\n * steps, each time that the decision comes to it.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const explain: <D extends Domain.Any, X>(\n\tpolicy: Policy<D, X>,\n\trequest: Request<NoInfer<D>>,\n) => Effect.Effect<Explanation, Condition.ErrorOf<X>, Condition.ServicesOf<X>> =\n\tDecide.explain as never\n\n/**\n * Gives the fields of a resource value that the policy lets a request use. It\n * tests each field that a list of fields shows: each scalar, record or array\n * of the resource Schema, with dots for nested fields.\n *\n * A field that holds more than one value, such as a record, is left out when a\n * deny rule names a part of it. The list can not name that part, and the whole\n * field would show it.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const permittedFields: <D extends Domain.Any, X>(\n\tpolicy: Policy<D, X>,\n\trequest: FieldlessRequest<NoInfer<D>>,\n) => Effect.Effect<\n\tReadonlyArray<string>,\n\tCondition.ErrorOf<X>,\n\tCondition.ServicesOf<X>\n> = Decide.permittedFields as never\n\n// Residual conditions\n\n/**\n * What a residual condition reads: a value of the kind `K`. The principal is\n * already in it. A residual is for one kind, so when `K` is a union of kinds,\n * the value must be a value of each of them. No value is, so such a residual\n * can not be evaluated on a value of the wrong kind.\n *\n * @stability stable\n * @category utility types\n * @since 1.0.0\n */\nexport type ResidualReads<D, K> = Condition.Reads<\n\t(\n\t\tK extends unknown ? (value: Domain.ValueOf<D, K & string>) => void : never\n\t) extends (value: infer V) => void\n\t\t? V\n\t\t: never,\n\tunknown\n>\n\n/**\n * Gives the condition on resource values for which the policy allows a\n * request. It has no principal fields and no `Under` nodes, so you can give it\n * to `Condition.fold`. It is made smaller, so it is often `True` or `False`\n * when the answer does not depend on the value, but it does no search: a\n * condition that is true for every value may stay a test. To know if the\n * policy allows every value, or some value, use {@link coverage}.\n *\n * With a scope (`within`), the condition is the scope and the residual\n * together, so it is false for every value outside the scope. Give the policy\n * first to use a scope. The condition comes from its parts, with no search. To\n * know if it allows all of the scope or none of it, use {@link coverage}.\n *\n * When a rule that the request may use has a predicate, the condition is one\n * predicate with the name `\"policy\"`. It runs the whole policy for each value,\n * so its answers and its failures are the same as those of {@link decide}. It\n * takes the principal with it. Give it resource values with their `_tag`. It\n * is false for a value of another kind.\n *\n * A policy tree may use the condition of a child two times, so a small policy\n * may give a very large condition. When the condition would have more than\n * 10000 nodes, this function throws an error. In an `Authorizer`, the error\n * is a defect, so the check fails.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const residual: <\n\tD extends Domain.Any,\n\tX,\n\tconst Req extends KindRequest<NoInfer<D>>,\n>(\n\tpolicy: Policy<D, X>,\n\trequest: Req,\n) => Condition.Condition<ResidualReads<D, Req[\"kind\"]>, X> =\n\tAnalysis.residual as never\n\n/**\n * How much of a scope a policy allows. In each case, `condition` is the exact\n * condition on the values in the scope that the policy allows: give it to\n * `Condition.fold` for a list query.\n * - `All`: the policy allows every value in the scope. `condition` is the\n *   scope (`True` with no scope).\n * - `None`: the policy allows no value in the scope. `condition` is `False`.\n *   An empty scope is `None` too, so a check on a scope that has a mistake,\n *   such as a principal field with no value, never passes.\n * - `Some`: the policy allows some values in the scope and not others.\n *   `allowed` is an example of a value that it allows, and `refused` of a\n *   value in the scope that it does not allow.\n * - `Unknown`: the answer needs a predicate, or the search went past its\n *   budget.\n *\n * @stability stable\n * @category models\n * @since 1.0.0\n */\nexport type Coverage<I = unknown, X = never> = Data.TaggedEnum<{\n\tAll: { readonly condition: Condition.Condition<I, X> }\n\tNone: { readonly condition: Condition.Condition<I, X> }\n\tSome: {\n\t\treadonly condition: Condition.Condition<I, X>\n\t\treadonly allowed: Condition.Example\n\t\treadonly refused: Condition.Example\n\t}\n\tUnknown: {\n\t\treadonly condition: Condition.Condition<I, X>\n\t\treadonly reason: \"predicate\" | \"budget\"\n\t}\n}>\n\n/**\n * Tells how much of a scope the policy allows: all of it, none of it, or some\n * of it. See {@link Coverage}. With no scope (`within`), the scope is every\n * value of the kind.\n *\n * The answer comes from {@link Condition.satisfiable} with the shape of the\n * Schema of the resource. `All` and `None` hold for every value of the\n * Schema. `Some` means that, by the shape of the Schema, a value may get\n * either answer: a check such as a minimum length may still stop one of the\n * examples. `Unknown` comes only from a predicate or from the budget of the\n * search.\n *\n * `Some` does not mean that such a value is in your database. To know that,\n * run `condition` as a query.\n *\n * @stability stable\n * @category evaluation\n * @since 1.0.0\n */\nexport const coverage: <\n\tD extends Domain.Any,\n\tX,\n\tconst Req extends KindRequest<NoInfer<D>>,\n>(\n\tpolicy: Policy<D, X>,\n\trequest: Req,\n) => Coverage<ResidualReads<D, Req[\"kind\"]>, X> = Analysis.coverageAny as never\n\n// Schema\n\n/**\n * The JSON form of a rule.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface EncodedRule {\n\treadonly _tag: \"Allow\" | \"Deny\"\n\treadonly actions: ReadonlyArray<string>\n\treadonly resources: ReadonlyArray<string>\n\treadonly when?: Condition.Encoded\n\treadonly fields?: ReadonlyArray<string>\n\treadonly reason?: string\n\treadonly id?: string\n\treadonly meta?: unknown\n}\n\n/**\n * The JSON form of a policy.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type EncodedNode =\n\t| {\n\t\t\treadonly _tag: \"Rules\"\n\t\t\treadonly algorithm: Algorithm\n\t\t\treadonly rules: ReadonlyArray<EncodedRule>\n\t  }\n\t| {\n\t\t\treadonly _tag: \"All\" | \"Any\" | \"FirstOf\"\n\t\t\treadonly policies: ReadonlyArray<EncodedNode>\n\t  }\n\t| {\n\t\t\treadonly _tag: \"Ceiling\"\n\t\t\treadonly cap: EncodedNode\n\t\t\treadonly policy: EncodedNode\n\t  }\n\n/**\n * The Schema of the policies of a domain with no predicates. Decoding checks\n * every kind, action, field and principal field against the domain, and the\n * `meta` of each rule against the `meta` Schema of the domain.\n *\n * The decoder takes at most 256 levels of policies and 500 levels of\n * conditions, and at most 1000000 objects and array items, with a shared\n * object counted for each place. It reads only the own data fields of the\n * input.\n *\n * @stability stable\n * @category schemas\n * @since 0.3.0\n */\nexport const schema: <D extends Domain.Any>(\n\tdomain: D,\n) => Schema.Codec<Policy<D>, EncodedNode> = Internal.schema as never\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwgBA,MAAa,WAAiC,WAC7CA,UAAiB,MAAM;;;;;;;;;;;;;;;AAgBxB,MAAa,OAGgBC;;;;;;;;;;;AAwB7B,MAAa,cAA2CC;;;;;;;;;;;;;;;;;;;AAgCxD,MAAa,SAKwBC;;;;;;;;;AAerC,MAAa,MAEwBC,QAAiB,KAAK;;;;;;;;AAS3D,MAAa,MAEwBA,QAAiB,KAAK;;;;;;;;AAS3D,MAAa,UAEwBA,QAAiB,SAAS;;;;;;;;;AAU/D,MAAa,UAQTC;;;;;;;;;AAUJ,MAAa,iBAWTC;;;;;;;;AAWJ,MAAa,SAOTC;;;;;;;;AASJ,MAAa,aAGYC;;;;;;;;;;;AAYzB,MAAa,UAIZC;;;;;;;;;;;;;;AAeD,MAAa,kBAOTC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDJ,MAAa,WAQZC;;;;;;;;;;;;;;;;;;;;AAsDD,MAAa,WAOqCC;;;;;;;;;;;;;;;AA2DlD,MAAa,SAE+BC"}