@nmnmcc/ability 0.2.0 → 0.3.0

package/dist/Condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Condition.js","names":["internal.builder","internal.always","internal.never","internal.and","internal.or","internal.not","internal.evaluate","internal.evaluateSync","internal.partial","internal.simplify","internal.Untranslatable","internal.fold","internal.fields","internal.schema"],"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 */\nimport type * as Effect from \"effect/Effect\"\nimport type * as Schema from \"effect/Schema\"\nimport * as internal from \"./internal/condition.ts\"\nimport type * 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 = string | number | boolean | null\n\n/**\n * A fixed value in a condition.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Literal {\n\treadonly _tag: \"Literal\"\n\treadonly value: Scalar\n}\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 interface PrincipalRef {\n\treadonly _tag: \"Principal\"\n\treadonly path: string\n}\n\n/**\n * A field of the principal with a known value type.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Ref<A> = PrincipalRef & { readonly \"~Ref\"?: () => A }\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 = \"eq\" | \"ne\" | \"lt\" | \"lte\" | \"gt\" | \"gte\"\n\n/**\n * Always true.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface True {\n\treadonly _tag: \"True\"\n}\n\n/**\n * Always false.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface False {\n\treadonly _tag: \"False\"\n}\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 interface Compare {\n\treadonly _tag: \"Compare\"\n\treadonly op: CompareOperator\n\treadonly field: string\n\treadonly value: Operand\n}\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 interface In {\n\treadonly _tag: \"In\"\n\treadonly field: string\n\treadonly values: ReadonlyArray<Operand>\n}\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 interface Exists {\n\treadonly _tag: \"Exists\"\n\treadonly field: string\n}\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 interface Under {\n\treadonly _tag: \"Under\"\n\treadonly prefix: ReadonlyArray<Operand>\n}\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface And {\n\treadonly _tag: \"And\"\n\treadonly conditions: ReadonlyArray<Ast>\n}\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Or {\n\treadonly _tag: \"Or\"\n\treadonly conditions: ReadonlyArray<Ast>\n}\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Not {\n\treadonly _tag: \"Not\"\n\treadonly condition: Ast\n}\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 interface Predicate {\n\treadonly _tag: \"Predicate\"\n\treadonly name: string\n\treadonly run: (\n\t\tvalue: any,\n\t\tprincipal: any,\n\t) => Effect.Effect<boolean, unknown, unknown>\n}\n\n/**\n * The nodes of a condition, without types.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Ast =\n\tTrue | False | Compare | In | Exists | Under | And | Or | Not | Predicate\n\n/**\n * The type marker for a condition with a {@link Predicate}.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Opaque = \"Opaque\"\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Variance<E, R, O> {\n\treadonly E: () => E\n\treadonly R: () => R\n\treadonly O: () => O\n}\n\n/**\n * A condition. `E` and `R` are the error type and the service type of its\n * predicates. `O` is {@link Opaque} when the condition has a predicate, and\n * `never` when it is plain data.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Condition<E = never, R = never, O = never> = Ast & {\n\treadonly \"~Condition\"?: Variance<E, R, O>\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, any>\n\n/**\n * The error type of a condition.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type Error<C> = C extends {\n\treadonly \"~Condition\"?: Variance<infer E, infer _R, infer _O>\n}\n\t? E\n\t: never\n\n/**\n * The service type of a condition.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type Services<C> = C extends {\n\treadonly \"~Condition\"?: Variance<infer _E, infer R, infer _O>\n}\n\t? R\n\t: never\n\n/**\n * {@link Opaque} when a condition has a predicate.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type OpaqueOf<C> = C extends {\n\treadonly \"~Condition\"?: Variance<infer _E, infer _R, infer O>\n}\n\t? O\n\t: never\n\ntype Leaf = string | number | boolean | bigint | symbol | null | undefined\ntype PreviousDepth = [never, 0, 1, 2, 3]\ntype FieldPathInternal<T, Depth extends number> = [Depth] extends [never]\n\t? never\n\t: {\n\t\t\t[K in keyof T & string]-?: NonNullable<T[K]> extends Leaf\n\t\t\t\t? K\n\t\t\t\t: NonNullable<T[K]> extends ReadonlyArray<unknown> | Function\n\t\t\t\t\t? never\n\t\t\t\t\t: NonNullable<T[K]> extends object\n\t\t\t\t\t\t? `${K}.${FieldPathInternal<NonNullable<T[K]>, PreviousDepth[Depth]>}`\n\t\t\t\t\t\t: never\n\t\t}[keyof T & string]\n\n/**\n * The paths of the fields of `T` that hold one value, with dots for nested\n * fields. Arrays are left out. The type goes down four levels, so type\n * checking stays fast. For a union of types, only the common fields are\n * 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>\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`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type PathValue<\n\tT,\n\tPath extends string,\n> = Path extends `${infer Head}.${infer Rest}`\n\t? Head extends keyof T\n\t\t? undefined extends T[Head]\n\t\t\t? PathValue<NonNullable<T[Head]>, Rest> | null\n\t\t\t: null extends T[Head]\n\t\t\t\t? PathValue<NonNullable<T[Head]>, Rest> | null\n\t\t\t\t: PathValue<T[Head], Rest>\n\t\t: never\n\t: Path extends keyof T\n\t\t? Normalize<T[Path]>\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> = Extract<A, Scalar> | Ref<A>\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 * 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: <const F extends FieldPath<Data>>(\n\t\tfield: F,\n\t\tvalue: OperandOf<PathValue<Data, F>>,\n\t) => Condition\n\t/** The field is not equal to the value. */\n\treadonly ne: <const F extends FieldPath<Data>>(\n\t\tfield: F,\n\t\tvalue: OperandOf<PathValue<Data, F>>,\n\t) => Condition\n\treadonly lt: <const F extends OrderedPath<Data>>(\n\t\tfield: F,\n\t\tvalue: OperandOf<Exclude<PathValue<Data, F>, null>>,\n\t) => Condition\n\treadonly lte: <const F extends OrderedPath<Data>>(\n\t\tfield: F,\n\t\tvalue: OperandOf<Exclude<PathValue<Data, F>, null>>,\n\t) => Condition\n\treadonly gt: <const F extends OrderedPath<Data>>(\n\t\tfield: F,\n\t\tvalue: OperandOf<Exclude<PathValue<Data, F>, null>>,\n\t) => Condition\n\treadonly gte: <const F extends OrderedPath<Data>>(\n\t\tfield: F,\n\t\tvalue: OperandOf<Exclude<PathValue<Data, F>, null>>,\n\t) => Condition\n\t/** The field is equal to one of the values. */\n\treadonly in: <const F extends FieldPath<Data>>(\n\t\tfield: F,\n\t\tvalues: ReadonlyArray<OperandOf<PathValue<Data, F>>>,\n\t) => Condition\n\t/** The field has a value that is not `null`. */\n\treadonly exists: <const F extends FieldPath<Data>>(field: F) => Condition\n\t/** The path of the resource starts with these parts. */\n\treadonly under: (\n\t\t...prefix: ReadonlyArray<string | null | Ref<string | null>>\n\t) => Condition\n\t/** A field of the principal, to use as a value. */\n\treadonly principal: <const F extends FieldPath<P>>(\n\t\tfield: F,\n\t) => Ref<PathValue<P, F>>\n\treadonly and: <const Cs extends ReadonlyArray<Any>>(\n\t\t...conditions: Cs\n\t) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>\n\treadonly or: <const Cs extends ReadonlyArray<Any>>(\n\t\t...conditions: Cs\n\t) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>\n\treadonly not: <C extends Any>(\n\t\tcondition: C,\n\t) => Condition<Error<C>, Services<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<E, R, Opaque>\n}\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\tinternal.builder\n\n/**\n * Always true.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const always: Condition = internal.always\n\n/**\n * Always false.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const never: Condition = internal.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<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>> =\n\tinternal.and 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<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>> =\n\tinternal.or 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<Error<C>, Services<C>, OpaqueOf<C>> = internal.not 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/**\n * Tests a condition on a value. A predicate may fail with its error.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const evaluate: {\n\t(\n\t\tinput: Input,\n\t): <E, R, O>(condition: Condition<E, R, O>) => Effect.Effect<boolean, E, R>\n\t<E, R, O>(\n\t\tcondition: Condition<E, R, O>,\n\t\tinput: Input,\n\t): Effect.Effect<boolean, E, R>\n} = internal.evaluate 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: {\n\t(input: Input): (condition: Condition) => boolean\n\t(condition: Condition, input: Input): boolean\n} = internal.evaluateSync\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: {\n\t(input: {\n\t\treadonly principal?: object | undefined\n\t\treadonly path?: ReadonlyArray<Resource.PathSegment> | undefined\n\t}): <E, R, O>(condition: Condition<E, R, O>) => Condition<E, R, O>\n\t<E, R, O>(\n\t\tcondition: Condition<E, R, O>,\n\t\tinput: {\n\t\t\treadonly principal?: object | undefined\n\t\t\treadonly path?: ReadonlyArray<Resource.PathSegment> | undefined\n\t\t},\n\t): Condition<E, R, O>\n} = internal.partial as never\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.\n *\n * @stability stable\n * @category evaluation\n * @since 0.3.0\n */\nexport const simplify: <E, R, O>(\n\tcondition: Condition<E, R, O>,\n) => Condition<E, R, O> = internal.simplify 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 const Untranslatable: typeof internal.Untranslatable =\n\tinternal.Untranslatable\n\n/**\n * @stability stable\n * @category errors\n * @since 0.3.0\n */\nexport type Untranslatable = internal.Untranslatable\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} = internal.fold\n\n/**\n * The fields that a condition uses.\n *\n * @stability stable\n * @category getters\n * @since 0.3.0\n */\nexport const fields: (condition: Any) => ReadonlyArray<string> = internal.fields\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\tExclude<Ast, Predicate | And | Or | Not> | EncodedAnd | EncodedOr | EncodedNot\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface EncodedAnd {\n\treadonly _tag: \"And\"\n\treadonly conditions: ReadonlyArray<Encoded>\n}\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface EncodedOr {\n\treadonly _tag: \"Or\"\n\treadonly conditions: ReadonlyArray<Encoded>\n}\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface EncodedNot {\n\treadonly _tag: \"Not\"\n\treadonly condition: Encoded\n}\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 * @stability stable\n * @category schemas\n * @since 0.3.0\n */\nexport const schema: Schema.Codec<Condition, Encoded> = internal.schema\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAocA,MAAa,UACZA;;;;;;;;AASD,MAAa,SAAoBC;;;;;;;;AASjC,MAAa,QAAmBC;;;;;;;;AAShC,MAAa,MAGZC;;;;;;;;AASD,MAAa,KAGZC;;;;;;AAOD,MAAa,MAEwCC;;;;;;;;AA4BrD,MAAa,WAQTC;;;;;;;;AASJ,MAAa,eAGTC;;;;;;;;;;;AAYJ,MAAa,UAYTC;;;;;;;;;;AAWJ,MAAa,WAEaC;;;;;;;;AA8B1B,MAAa,iBACZC;;;;;;;;;;AAkBD,MAAa,OAQTC;;;;;;;;AASJ,MAAa,SAAoDC;;;;;;;;;AAkDjE,MAAa,SAA2CC"}

package/dist/Decision.d.ts

@@ -0,0 +1,131 @@
+import { Any } from "./Rule.js";
+import * as Data from "effect/Data";
+declare namespace Decision_d_exports {
+  export { Allow, Decision, Deny, NotApplicable, isAllow, isDeny, isNotApplicable, match, reason };
+}
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Decision = Data.TaggedEnum<{
+  Allow: {
+    /** The rule that gave the answer, when a rule gave it. */
+    readonly rule?: Any;
+  };
+  Deny: {
+    /** The rule that gave the answer, when a rule gave it. */
+    readonly rule?: Any;
+    readonly reason?: string;
+  };
+  NotApplicable: {};
+}>;
+/**
+ * @stability stable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const Allow: (args: {
+  readonly rule?: Any;
+}) => Decision;
+/**
+ * @stability stable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const Deny: (args: {
+  readonly rule?: Any;
+  readonly reason?: string;
+}) => Decision;
+/**
+ * @stability stable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const NotApplicable: Decision;
+/**
+ * @stability stable
+ * @category guards
+ * @since 0.3.0
+ */
+export declare const isAllow: (decision: Decision) => decision is Extract<Decision, {
+  readonly _tag: "Allow";
+}>;
+/**
+ * @stability stable
+ * @category guards
+ * @since 0.3.0
+ */
+export declare const isDeny: (decision: Decision) => decision is Extract<Decision, {
+  readonly _tag: "Deny";
+}>;
+/**
+ * @stability stable
+ * @category guards
+ * @since 0.3.0
+ */
+export declare const isNotApplicable: (decision: Decision) => decision is Extract<Decision, {
+  readonly _tag: "NotApplicable";
+}>;
+/**
+ * Matches each kind of decision.
+ *
+ * @stability stable
+ * @category pattern matching
+ * @since 0.3.0
+ */
+export declare const match: {
+  <Cases extends { readonly [Tag in "Allow" | "Deny" | "NotApplicable"]: (args: Extract<{
+    readonly _tag: "Allow";
+    readonly rule?: Any;
+  } | {
+    readonly _tag: "Deny";
+    readonly rule?: Any;
+    readonly reason?: string;
+  } | {
+    readonly _tag: "NotApplicable";
+  }, {
+    readonly _tag: Tag;
+  }>) => any; }>(cases: Cases): (value: {
+    readonly _tag: "Allow";
+    readonly rule?: Any;
+  } | {
+    readonly _tag: "Deny";
+    readonly rule?: Any;
+    readonly reason?: string;
+  } | {
+    readonly _tag: "NotApplicable";
+  }) => import("effect/Unify").Unify<ReturnType<Cases["Allow" | "Deny" | "NotApplicable"]>>;
+  <Cases extends { readonly [Tag in "Allow" | "Deny" | "NotApplicable"]: (args: Extract<{
+    readonly _tag: "Allow";
+    readonly rule?: Any;
+  } | {
+    readonly _tag: "Deny";
+    readonly rule?: Any;
+    readonly reason?: string;
+  } | {
+    readonly _tag: "NotApplicable";
+  }, {
+    readonly _tag: Tag;
+  }>) => any; }>(value: {
+    readonly _tag: "Allow";
+    readonly rule?: Any;
+  } | {
+    readonly _tag: "Deny";
+    readonly rule?: Any;
+    readonly reason?: string;
+  } | {
+    readonly _tag: "NotApplicable";
+  }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Allow" | "Deny" | "NotApplicable"]>>;
+};
+/**
+ * The reason of a decision: the reason of a `Deny`, or the reason of the rule
+ * that gave the answer.
+ *
+ * @stability stable
+ * @category getters
+ * @since 0.3.0
+ */
+export declare const reason: (decision: Decision) => string | undefined;
+export { Decision_d_exports };
+//# sourceMappingURL=Decision.d.ts.map

package/dist/Decision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decision.d.ts","names":["Rule.Any"],"sources":["../src/Decision.ts"],"mappings":";;;;;;;;;;YAqBY,WAAW,KAAK;EAC3B;;aAEU,OAAOA;;EAEjB;;aAEU,OAAOA;aACP;;EAEV;;;;;;;qBAgBY,QAAQ;WAAiB,OAAOA;MAAe;;;;;;qBAO/C,OAAO;WACV,OAAOA;WACP;MACJ;;;;;;qBAOO,eAAe;;;;;;qBAOf,UACZ,UAAU,aACN,YAAY,QAAQ;WAAqB;;;;;;;qBAOjC,SACZ,UAAU,aACN,YAAY,QAAQ;WAAqB;;;;;;;qBAOjC,kBACZ,UAAU,aACN,YAAY,QAAQ;WAAqB;;;;;;;;;qBAUjC;;;aA7EK,OAAAA;;;aAIA,OAAAA;aACE;;;;;;;;;;;;;;;;;aALF,OAAAA;;;aAIA,OAAAA;aACE;;;;;;;;;;;;;;;;;;;;;;;;qBAkFP,SAAM,UAAc"}

package/dist/Decision.js

@@ -0,0 +1,83 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Data from "effect/Data";
+// src/Decision.ts
+/**
+* A decision is the answer of a policy to a request:
+* - `Allow`: a rule lets the principal do the act.
+* - `Deny`: a rule stops the principal.
+* - `NotApplicable`: no rule gives an answer.
+*
+* `NotApplicable` is not the same as `Deny`. A check treats it as a "no", but
+* an `Authorizer` with a decider asks the decider first. See
+* `Authorizer.Options.decider`.
+*
+* @stability stable
+* @since 0.3.0
+*/
+var Decision_exports = /* @__PURE__ */ __exportAll({
+	Allow: () => Allow,
+	Deny: () => Deny,
+	NotApplicable: () => NotApplicable,
+	isAllow: () => isAllow,
+	isDeny: () => isDeny,
+	isNotApplicable: () => isNotApplicable,
+	match: () => match,
+	reason: () => reason
+});
+const { $is, $match, Allow: allow, Deny: deny, NotApplicable: notApplicable } = Data.taggedEnum();
+/**
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const Allow = allow;
+/**
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const Deny = deny;
+/**
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const NotApplicable = notApplicable();
+/**
+* @stability stable
+* @category guards
+* @since 0.3.0
+*/
+const isAllow = $is("Allow");
+/**
+* @stability stable
+* @category guards
+* @since 0.3.0
+*/
+const isDeny = $is("Deny");
+/**
+* @stability stable
+* @category guards
+* @since 0.3.0
+*/
+const isNotApplicable = $is("NotApplicable");
+/**
+* Matches each kind of decision.
+*
+* @stability stable
+* @category pattern matching
+* @since 0.3.0
+*/
+const match = $match;
+/**
+* The reason of a decision: the reason of a `Deny`, or the reason of the rule
+* that gave the answer.
+*
+* @stability stable
+* @category getters
+* @since 0.3.0
+*/
+const reason = (decision) => decision._tag === "Deny" ? decision.reason ?? decision.rule?.reason : decision._tag === "Allow" ? decision.rule?.reason : void 0;
+export { Allow, Decision_exports, Deny, NotApplicable, isAllow, isDeny, isNotApplicable, match, reason };
+
+//# sourceMappingURL=Decision.js.map

package/dist/Decision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decision.js","names":[],"sources":["../src/Decision.ts"],"sourcesContent":["/**\n * A decision is the answer of a policy to a request:\n * - `Allow`: a rule lets the principal do the act.\n * - `Deny`: a rule stops the principal.\n * - `NotApplicable`: no rule gives an answer.\n *\n * `NotApplicable` is not the same as `Deny`. A check treats it as a \"no\", but\n * an `Authorizer` with a decider asks the decider first. See\n * `Authorizer.Options.decider`.\n *\n * @stability stable\n * @since 0.3.0\n */\nimport * as Data from \"effect/Data\"\nimport type * as Rule from \"./Rule.ts\"\n\n/**\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Decision = Data.TaggedEnum<{\n\tAllow: {\n\t\t/** The rule that gave the answer, when a rule gave it. */\n\t\treadonly rule?: Rule.Any\n\t}\n\tDeny: {\n\t\t/** The rule that gave the answer, when a rule gave it. */\n\t\treadonly rule?: Rule.Any\n\t\treadonly reason?: string\n\t}\n\tNotApplicable: {}\n}>\n\nconst {\n\t$is,\n\t$match,\n\tAllow: allow,\n\tDeny: deny,\n\tNotApplicable: notApplicable,\n} = Data.taggedEnum<Decision>()\n\n/**\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const Allow: (args: { readonly rule?: Rule.Any }) => Decision = allow\n\n/**\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const Deny: (args: {\n\treadonly rule?: Rule.Any\n\treadonly reason?: string\n}) => Decision = deny\n\n/**\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const NotApplicable: Decision = notApplicable()\n\n/**\n * @stability stable\n * @category guards\n * @since 0.3.0\n */\nexport const isAllow: (\n\tdecision: Decision,\n) => decision is Extract<Decision, { readonly _tag: \"Allow\" }> = $is(\"Allow\")\n\n/**\n * @stability stable\n * @category guards\n * @since 0.3.0\n */\nexport const isDeny: (\n\tdecision: Decision,\n) => decision is Extract<Decision, { readonly _tag: \"Deny\" }> = $is(\"Deny\")\n\n/**\n * @stability stable\n * @category guards\n * @since 0.3.0\n */\nexport const isNotApplicable: (\n\tdecision: Decision,\n) => decision is Extract<Decision, { readonly _tag: \"NotApplicable\" }> =\n\t$is(\"NotApplicable\")\n\n/**\n * Matches each kind of decision.\n *\n * @stability stable\n * @category pattern matching\n * @since 0.3.0\n */\nexport const match = $match\n\n/**\n * The reason of a decision: the reason of a `Deny`, or the reason of the rule\n * that gave the answer.\n *\n * @stability stable\n * @category getters\n * @since 0.3.0\n */\nexport const reason = (decision: Decision): string | undefined =>\n\tdecision._tag === \"Deny\"\n\t\t? (decision.reason ?? decision.rule?.reason)\n\t\t: decision._tag === \"Allow\"\n\t\t\t? decision.rule?.reason\n\t\t\t: undefined\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAM,EACL,KACA,QACA,OAAO,OACP,MAAM,MACN,eAAe,kBACZ,KAAK,WAAqB;;;;;;AAO9B,MAAa,QAA0D;;;;;;AAOvE,MAAa,OAGI;;;;;;AAOjB,MAAa,gBAA0B,cAAc;;;;;;AAOrD,MAAa,UAEoD,IAAI,OAAO;;;;;;AAO5E,MAAa,SAEmD,IAAI,MAAM;;;;;;AAO1E,MAAa,kBAGZ,IAAI,eAAe;;;;;;;;AASpB,MAAa,QAAQ;;;;;;;;;AAUrB,MAAa,UAAU,aACtB,SAAS,SAAS,SACd,SAAS,UAAU,SAAS,MAAM,SACnC,SAAS,SAAS,UACjB,SAAS,MAAM,SACf,KAAA"}

package/dist/Domain.d.ts

@@ -0,0 +1,148 @@
+import { Action, Any as Any$1, Data, Descriptor, Kind as Kind$1, Resource, Value } from "./Resource.js";
+import { Any as Any$2 } from "./Principal.js";
+import * as Schema from "effect/Schema";
+declare namespace Domain_d_exports {
+  export { ActionOf, Any, AnyAction, AnyValue, DataOf, Domain, Kind, Meta, Principal, ResourceOf, Resources, TypeId, ValueOf, isDomain, make };
+}
+/**
+ * @stability stable
+ * @category type IDs
+ * @since 0.3.0
+ */
+export declare const TypeId: "~@nmnmcc/ability/Domain";
+/**
+ * @stability stable
+ * @category type IDs
+ * @since 0.3.0
+ */
+export type TypeId = typeof TypeId;
+/**
+ * A domain. `P` is the type of the principal, `Resources` is the union of the
+ * resources, and `Meta` is the type of the extra data that a rule may keep.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Domain<P extends object, Resources extends Any$1, Meta> {
+  readonly [TypeId]: TypeId;
+  readonly principal: Any$2;
+  readonly resources: ReadonlyMap<string, Descriptor>;
+  readonly meta: Schema.Top | undefined;
+  readonly "~Domain"?: {
+    readonly Principal: P;
+    readonly Resources: Resources;
+    readonly Meta: Meta;
+  };
+}
+/**
+ * Any domain.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Any = Domain<any, any, any>;
+/**
+ * The type of the principal of a domain.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type Principal<D> = D extends Domain<infer P, any, any> ? P : never;
+/**
+ * The union of the resources of a domain.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type Resources<D> = D extends Domain<any, infer R, any> ? R : never;
+/**
+ * The type of the extra data that a rule of the domain may keep.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type Meta<D> = D extends Domain<any, any, infer M> ? M : never;
+/**
+ * The kind names of a domain.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type Kind<D> = Kind$1<Resources<D>>;
+/**
+ * The resource of a domain with the kind `K`.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type ResourceOf<D, K extends string> = Resources<D> extends (infer R) ? R extends Resource<K, any, any, any> ? R : never : never;
+/**
+ * The actions of the resource with the kind `K`.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type ActionOf<D, K extends string> = Action<ResourceOf<D, K>>;
+/**
+ * All the actions of all the resources of a domain.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type AnyAction<D> = Action<Resources<D>>;
+/**
+ * The data type of the resource with the kind `K`.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type DataOf<D, K extends string> = Data<ResourceOf<D, K>>;
+/**
+ * The value type of the resource with the kind `K`.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type ValueOf<D, K extends string> = Value<ResourceOf<D, K>>;
+/**
+ * The union of the value types of all the resources of a domain.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type AnyValue<D> = Value<Resources<D>>;
+/**
+ * Makes a domain. Each resource must have its own kind name. Give `meta` when
+ * rules must keep extra data, such as the scope of a grant.
+ *
+ * @stability stable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const make: <P extends Any$2, const Resources extends ReadonlyArray<Any$1>, M extends Schema.Top = Schema.Never>(options: {
+  readonly principal: P;
+  readonly resources: Resources;
+  readonly meta?: M;
+}) => Domain<P["Type"], Resources[number], M["Type"]>;
+/**
+ * Tests if a value is a domain.
+ *
+ * @stability stable
+ * @category guards
+ * @since 0.3.0
+ */
+export declare const isDomain: (u: unknown) => u is Any;
+export { Domain_d_exports };
+//# sourceMappingURL=Domain.d.ts.map

package/dist/Domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Domain.d.ts","names":["Resource.Any","PrincipalSchema.Any","Resource.Descriptor","Resource.Kind","Resource.Resource","Resource.Action","Resource.Data","Resource.Value"],"sources":["../src/Domain.ts"],"mappings":";;;;;;;;;;;qBA0Ba;;;;;;YAOD,gBAAgB;;;;;;;;;iBAUX,OAChB,kBACA,kBAAkBA,OAClB;YAEU,SAAS;WACV,WAAWC;WACX,WAAW,oBAAoBC;WAC/B,MAAM,OAAO;WACb;aACC,WAAW;aACX,WAAW;aACX,MAAM;;;;;;;;;;YAWL,MAAM;;;;;;;;YASN,UAAU,KAAK,UAAU,aAAa,eAAe;;;;;;;;YASrD,UAAU,KAAK,UAAU,kBAAkB,UAAU;;;;;;;;YASrD,KAAK,KAAK,UAAU,uBAAuB,KAAK;;;;;;;;YAShD,KAAK,KAAKC,OAAc,UAAU;;;;;;;;YASlC,WAAW,GAAG,oBACzB,UAAU,kBAAiB,KACxB,UAAUC,SAAkB,oBAC3B;;;;;;;;YAWO,SAAS,GAAG,oBAAoBC,OAAgB,WAAW,GAAG;;;;;;;;YAS9D,UAAU,KAAKA,OAAgB,UAAU;;;;;;;;YASzC,OAAO,GAAG,oBAAoBC,KAAc,WAAW,GAAG;;;;;;;;YAS1D,QAAQ,GAAG,oBAAoBC,MAAe,WAAW,GAAG;;;;;;;;YAS5D,SAAS,KAAKA,MAAe,UAAU;;;;;;;;;qBAUtC,OACZ,UAAUN,aACJ,kBAAkB,cAAcD,QACtC,UAAU,OAAO,MAAM,OAAO,OAC7B;WACQ,WAAW;WACX,WAAW;WACX,OAAO;MACX,OAAO,WAAW,mBAAmB;;;;;;;;qBAS9B,WAAW,eAAe,KAAK"}

package/dist/Domain.js

@@ -0,0 +1,34 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { TypeId as TypeId$1, isDomain as isDomain$1, make as make$1 } from "./internal/domain.js";
+// src/Domain.ts
+var Domain_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	isDomain: () => isDomain,
+	make: () => make
+});
+/**
+* @stability stable
+* @category type IDs
+* @since 0.3.0
+*/
+const TypeId = TypeId$1;
+/**
+* Makes a domain. Each resource must have its own kind name. Give `meta` when
+* rules must keep extra data, such as the scope of a grant.
+*
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const make = make$1;
+/**
+* Tests if a value is a domain.
+*
+* @stability stable
+* @category guards
+* @since 0.3.0
+*/
+const isDomain = isDomain$1;
+export { Domain_exports, TypeId, isDomain, make };
+
+//# sourceMappingURL=Domain.js.map

package/dist/Domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Domain.js","names":["internal.TypeId","internal.make","internal.isDomain"],"sources":["../src/Domain.ts"],"sourcesContent":["/**\n * A domain puts together the principal and all the resources of an\n * application. All other modules get their types from the domain. A rule may\n * only use the actions of its resource. A condition may only use the fields of\n * its resource and of the principal.\n *\n * @example\n * ```ts\n * import { Domain } from \"@nmnmcc/ability\"\n *\n * const App = Domain.make({ principal: Caller, resources: [Bot, Trigger] })\n * ```\n *\n * @stability stable\n * @since 0.3.0\n */\nimport type * as Schema from \"effect/Schema\"\nimport * as internal from \"./internal/domain.ts\"\nimport type * as PrincipalSchema from \"./Principal.ts\"\nimport type * as Resource from \"./Resource.ts\"\n\n/**\n * @stability stable\n * @category type IDs\n * @since 0.3.0\n */\nexport const TypeId: \"~@nmnmcc/ability/Domain\" = internal.TypeId\n\n/**\n * @stability stable\n * @category type IDs\n * @since 0.3.0\n */\nexport type TypeId = typeof TypeId\n\n/**\n * A domain. `P` is the type of the principal, `Resources` is the union of the\n * resources, and `Meta` is the type of the extra data that a rule may keep.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport interface Domain<\n\tP extends object,\n\tResources extends Resource.Any,\n\tMeta,\n> {\n\treadonly [TypeId]: TypeId\n\treadonly principal: PrincipalSchema.Any\n\treadonly resources: ReadonlyMap<string, Resource.Descriptor>\n\treadonly meta: Schema.Top | undefined\n\treadonly \"~Domain\"?: {\n\t\treadonly Principal: P\n\t\treadonly Resources: Resources\n\t\treadonly Meta: Meta\n\t}\n}\n\n/**\n * Any domain.\n *\n * @stability stable\n * @category models\n * @since 0.3.0\n */\nexport type Any = Domain<any, any, any>\n\n/**\n * The type of the principal of a domain.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type Principal<D> = D extends Domain<infer P, any, any> ? P : never\n\n/**\n * The union of the resources of a domain.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type Resources<D> = D extends Domain<any, infer R, any> ? R : never\n\n/**\n * The type of the extra data that a rule of the domain may keep.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type Meta<D> = D extends Domain<any, any, infer M> ? M : never\n\n/**\n * The kind names of a domain.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type Kind<D> = Resource.Kind<Resources<D>>\n\n/**\n * The resource of a domain with the kind `K`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type ResourceOf<D, K extends string> =\n\tResources<D> extends infer R\n\t\t? R extends Resource.Resource<K, any, any, any>\n\t\t\t? R\n\t\t\t: never\n\t\t: never\n\n/**\n * The actions of the resource with the kind `K`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type ActionOf<D, K extends string> = Resource.Action<ResourceOf<D, K>>\n\n/**\n * All the actions of all the resources of a domain.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type AnyAction<D> = Resource.Action<Resources<D>>\n\n/**\n * The data type of the resource with the kind `K`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type DataOf<D, K extends string> = Resource.Data<ResourceOf<D, K>>\n\n/**\n * The value type of the resource with the kind `K`.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type ValueOf<D, K extends string> = Resource.Value<ResourceOf<D, K>>\n\n/**\n * The union of the value types of all the resources of a domain.\n *\n * @stability stable\n * @category utility types\n * @since 0.3.0\n */\nexport type AnyValue<D> = Resource.Value<Resources<D>>\n\n/**\n * Makes a domain. Each resource must have its own kind name. Give `meta` when\n * rules must keep extra data, such as the scope of a grant.\n *\n * @stability stable\n * @category constructors\n * @since 0.3.0\n */\nexport const make: <\n\tP extends PrincipalSchema.Any,\n\tconst Resources extends ReadonlyArray<Resource.Any>,\n\tM extends Schema.Top = Schema.Never,\n>(options: {\n\treadonly principal: P\n\treadonly resources: Resources\n\treadonly meta?: M\n}) => Domain<P[\"Type\"], Resources[number], M[\"Type\"]> = internal.make\n\n/**\n * Tests if a value is a domain.\n *\n * @stability stable\n * @category guards\n * @since 0.3.0\n */\nexport const isDomain: (u: unknown) => u is Any = internal.isDomain\n"],"mappings":";;;;;;;;;;;;;AA0BA,MAAa,SAAoCA;;;;;;;;;AAiJjD,MAAa,OAQ2CC;;;;;;;;AASxD,MAAa,WAAqCC"}

package/dist/HttpApi.d.ts

@@ -0,0 +1,129 @@
+import { ActionOf, Any, Kind, ValueOf } from "./Domain.js";
+import { Forbidden, Pending, PolicyUnavailable } from "./internal/authorizer.js";
+import { AnyServiceClass } from "./Authorizer.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * One check that an endpoint needs: an action on a kind of resource. With
+ * `load`, the middleware loads the resource value from the path parameters
+ * and checks the action on that value. Without `load`, it checks the action
+ * on the kind.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Requirement {
+  readonly action: string;
+  readonly kind: string;
+  readonly load?: (params: Readonly<Record<string, string | undefined>>) => Effect.Effect<object, unknown, unknown>;
+}
+declare const Required_base: Context.ServiceClass<Required, "@nmnmcc/ability/HttpApi/Required", readonly Requirement[]>;
+/**
+ * The checks that an endpoint needs.
+ *
+ * @stability unstable
+ * @category annotations
+ * @since 0.3.0
+ */
+export declare class Required extends Required_base {}
+declare const GroupRequired_base: Context.ServiceClass<GroupRequired, "@nmnmcc/ability/HttpApi/GroupRequired", {
+  readonly read: ReadonlyArray<Requirement>;
+  readonly write: ReadonlyArray<Requirement>;
+}>;
+/**
+ * The checks for every endpoint of a group with no {@link Required}
+ * annotation. `read` is for GET requests. `write` is for all other methods.
+ *
+ * @stability unstable
+ * @category annotations
+ * @since 0.3.0
+ */
+export declare class GroupRequired extends GroupRequired_base {}
+/**
+ * Makes a {@link Requirement} with the types of an authorizer. The action must
+ * be an action of the kind, and `load` must give a value of the kind.
+ *
+ * `load` may fail. Its errors must be errors of the middleware, and the
+ * services that it needs must be given to {@link layer}.
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const requires: <A extends {
+  readonly domain: Any;
+}, const K extends Kind<A["domain"]>>(authorizer: A, action: ActionOf<A["domain"], K>, kind: K, load?: (params: Readonly<Record<string, string | undefined>>) => Effect.Effect<ValueOf<A["domain"], K>, unknown, unknown>) => Requirement;
+/**
+ * The errors of the middleware, with HTTP status codes: 403 for
+ * `Forbidden`, 503 for `PolicyUnavailable`, and 409 for `Pending`.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 0.3.0
+ */
+export declare const errors: readonly [import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<Forbidden, {
+  readonly _tag: "Forbidden";
+  readonly action: string;
+  readonly kind: string;
+  readonly field?: string;
+  readonly reason?: string;
+}, readonly [import("effect/Schema").TaggedStruct<"Forbidden", {
+  readonly action: import("effect/Schema").String;
+  readonly kind: import("effect/Schema").String;
+  readonly field: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+  readonly reason: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+}>], {
+  readonly _tag: "Forbidden";
+  readonly action: string;
+  readonly kind: string;
+  readonly field?: string;
+  readonly reason?: string;
+}>, import("effect/Schema").TaggedStruct<"Forbidden", {
+  readonly action: import("effect/Schema").String;
+  readonly kind: import("effect/Schema").String;
+  readonly field: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+  readonly reason: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+}>, never, never>, import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<PolicyUnavailable, {
+  readonly _tag: "PolicyUnavailable";
+  readonly cause: import("effect/Schema").Json;
+}, readonly [import("effect/Schema").TaggedStruct<"PolicyUnavailable", {
+  readonly cause: import("effect/Schema").Defect;
+}>], {
+  readonly _tag: "PolicyUnavailable";
+  readonly cause: unknown;
+}>, import("effect/Schema").TaggedStruct<"PolicyUnavailable", {
+  readonly cause: import("effect/Schema").Defect;
+}>, never, never>, import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<Pending, {
+  readonly _tag: "Pending";
+  readonly ticket: string;
+  readonly reason?: string;
+}, readonly [import("effect/Schema").TaggedStruct<"Pending", {
+  readonly ticket: import("effect/Schema").String;
+  readonly reason: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+}>], {
+  readonly _tag: "Pending";
+  readonly ticket: string;
+  readonly reason?: string;
+}>, import("effect/Schema").TaggedStruct<"Pending", {
+  readonly ticket: import("effect/Schema").String;
+  readonly reason: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+}>, never, never>];
+/**
+ * Makes the layer of an authorization middleware. The middleware reads the
+ * {@link Required} and {@link GroupRequired} annotations and checks each
+ * requirement with the authorizer.
+ *
+ * The layer takes the authorizer when it is built. The middleware must
+ * require the services of the authorizer, such as the identity of the
+ * caller. `R` is the type of the services that the `load` functions need. The
+ * layer takes them when it is built too.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 0.3.0
+ */
+export declare const layer: <Self, Id extends string, A extends AnyServiceClass, R = never>(middleware: Context.ServiceClass<Self, Id, any>, authorizer: A) => Layer.Layer<Self, never, (A extends Context.Key<infer I, any> ? I : never) | R>;
+export {};
+//# sourceMappingURL=HttpApi.d.ts.map

package/dist/HttpApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpApi.d.ts","names":["Domain.Any","Domain.Kind","Domain.ActionOf","Domain.ValueOf","_$__internal_authorizer_ts0.Forbidden","_$__internal_authorizer_ts0.PolicyUnavailable","_$__internal_authorizer_ts0.Pending","Authorizer.AnyServiceClass"],"sources":["../src/HttpApi.ts"],"mappings":";;;;;;;;;;;;;;;;iBAgDiB;WACP;WACA;WACA,QACR,QAAQ,SAAS,wCACb,OAAO;;;;;;;;;;qBAUA,iBAAiB;;WAgBb,MAAA,cAAc;WACb,OAAA,cAAc;;;;;;;;;;qBAJnB,sBAAsB;;;;;;;;;;;;qBAmBtB,WACZ;WAAqB,QAAQA;SACvB,UAAUC,KAAY,cAE5B,YAAY,GACZ,QAAQC,SAAgB,aAAa,IACrC,MAAM,GACN,QACC,QAAQ,SAAS,wCACb,OAAO,OAAOC,QAAe,aAAa,0BAC3C;;;;;;;;;qBAUQ,0CAAM,iCAAA,mBAANC;;;;;;;;;;;;;;;;;;;;;;2C,oDAAMC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoBN,QACZ,MACA,mBACA,UAAUE,iBACV,WAEA,YAAY,QAAQ,aAAa,MAAM,UACvC,YAAY,MACR,MAAM,MACV,cAEC,UAAU,QAAQ,UAAU,UAAU,aAAa"}