@nmnmcc/ability 0.1.0

package/dist/Ability.d.ts

@@ -0,0 +1,516 @@
+import { AliasError as AliasError$1, AuthorizationError as AuthorizationError$1, ConditionError as ConditionError$1, PredicateEvaluationError as PredicateEvaluationError$1, QueryGenerationError as QueryGenerationError$1, RawRuleError as RawRuleError$1, RuleTypeId as RuleTypeId$1, SerializationError as SerializationError$1, SubjectDetectionError as SubjectDetectionError$1, SubjectTypeId as SubjectTypeId$1, TypeId as TypeId$1 } from "./internal/ability.js";
+import { MongoQuery } from "@ucast/mongo2js";
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as Inspectable from "effect/Inspectable";
+import * as Pipeable from "effect/Pipeable";
+
+//#region src/Ability.d.ts
+declare namespace Ability_d_exports {
+  export { Ability, AbilityOptions, ActionAliases, ActionResolver, AliasError, AnyAction, AnyRule, AnySubject, AuthorizationError, Builder, CheckRequest, ConditionError, DetectSubjectType, ExpandedAction, FieldOf, FieldPath, FieldPattern, MongoCondition, PermittedFieldsOptions, Predicate, PredicateEvaluationError, QueryGenerationError, RawRule, RawRuleError, Rule, RuleKind, RuleOptions, RuleQueryRequest, RuleSubject, RuleTypeId, SerializationError, SingleOrReadonlyArray, SubjectDetectionError, SubjectMap, SubjectName, SubjectQueryRequest, SubjectTypeId, SubjectUnion, ToRawRulesOptions, TypeId, TypedSubject, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject };
+}
+/**
+ * @since 0.1.0
+ * @category Type Ids
+ */
+declare const TypeId: typeof TypeId$1;
+/**
+ * @since 0.1.0
+ * @category Type Ids
+ */
+type TypeId = typeof TypeId;
+/**
+ * @since 0.1.0
+ * @category Type Ids
+ */
+declare const SubjectTypeId: typeof SubjectTypeId$1;
+/**
+ * @since 0.1.0
+ * @category Type Ids
+ */
+type SubjectTypeId = typeof SubjectTypeId;
+/**
+ * Unique identifier for `Rule` values.
+ *
+ * @since 0.1.0
+ * @category Type Ids
+ */
+declare const RuleTypeId: typeof RuleTypeId$1;
+/**
+ * @since 0.1.0
+ * @category Type Ids
+ */
+type RuleTypeId = typeof RuleTypeId;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type SingleOrReadonlyArray<A> = A | ReadonlyArray<A>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type ActionAliases = Readonly<Record<string, SingleOrReadonlyArray<string>>>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type ActionResolver = (action: SingleOrReadonlyArray<string>) => ReadonlyArray<string>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type AnyAction = "manage";
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type AnySubject = "all";
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type SubjectMap = Readonly<Record<string, object>>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type SubjectName<Subjects extends SubjectMap> = string & keyof Subjects;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type RuleSubject<Subjects extends SubjectMap> = SubjectName<Subjects> | AnySubject;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type SubjectUnion<Subjects extends SubjectMap> = Subjects[SubjectName<Subjects>];
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Function | ReadonlyArray<unknown>;
+type PreviousDepth = [never, 0, 1, 2, 3, 4, 5];
+type FieldPathInternal<Subject, Depth extends number> = [Depth] extends [never] ? never : Subject extends Primitive ? never : Subject extends object ? { [Key in keyof Subject & string]: Subject[Key] extends Primitive ? Key : Key | `${Key}.${FieldPathInternal<Subject[Key], PreviousDepth[Depth]>}` }[keyof Subject & string] : never;
+/**
+ * Dot-path field names for a subject. The recursion depth is intentionally
+ * bounded to keep public type-checking predictable.
+ *
+ * @since 0.1.0
+ * @category Models
+ */
+type FieldPath<Subject> = FieldPathInternal<Subject, 5>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type FieldPattern = `${string}*${string}`;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type FieldOf<Subject> = string & (FieldPath<Subject> | FieldPattern);
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type MongoCondition<Subject extends object> = MongoQuery<Subject> & Readonly<Record<string, unknown>>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type RuleKind = "Allow" | "Deny";
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type Predicate<Subject, E = never, R = never> = (subject: Subject) => boolean | Effect.Effect<boolean, E, R>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface RuleOptions<Subject extends object, Fields extends string, E = never, R = never> {
+  readonly fields?: SingleOrReadonlyArray<Fields>;
+  readonly conditions?: MongoCondition<Subject>;
+  readonly when?: Predicate<Subject, E, R>;
+  readonly reason?: string;
+}
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface Rule<Kind extends RuleKind, Action extends string, Name extends string, Subject extends object, Fields extends string, E, R> extends Equal.Equal, Inspectable.Inspectable, Pipeable.Pipeable, Effect.Yieldable<Rule<Kind, Action, Name, Subject, Fields, E, R>, Rule<Kind, Action, Name, Subject, Fields, E, R>> {
+  readonly [RuleTypeId]: RuleTypeId;
+  readonly _tag: Kind;
+  readonly action: SingleOrReadonlyArray<Action>;
+  readonly subject: SingleOrReadonlyArray<Name>;
+  readonly fields?: ReadonlyArray<Fields>;
+  readonly conditions?: MongoCondition<Subject>;
+  readonly when?: Predicate<Subject, E, R>;
+  readonly reason?: string;
+}
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type AnyRule = Rule<RuleKind, string, string, any, string, any, any>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface TypedSubject<Name extends string, Value extends object> extends Equal.Equal, Inspectable.Inspectable, Pipeable.Pipeable {
+  readonly [SubjectTypeId]: SubjectTypeId;
+  readonly _tag: "Subject";
+  readonly subject: Name;
+  readonly value: Value;
+}
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type DetectSubjectType<Subjects extends SubjectMap> = (value: object) => SubjectName<Subjects>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface AbilityOptions<Subjects extends SubjectMap, Aliases extends ActionAliases = {}> {
+  readonly detectSubjectType?: DetectSubjectType<Subjects>;
+  readonly actionAliases?: Aliases;
+}
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface Ability<Subjects extends SubjectMap, Rules extends AnyRule = never, Aliases extends ActionAliases = {}> extends Equal.Equal, Inspectable.Inspectable, Pipeable.Pipeable {
+  readonly [TypeId]: TypeId;
+  readonly rules: ReadonlyArray<Rules>;
+  readonly options: AbilityOptions<Subjects, Aliases>;
+  readonly _Subjects?: (_: never) => Subjects;
+  readonly _Rules?: (_: never) => Rules;
+  readonly _Aliases?: (_: never) => Aliases;
+}
+type ElementOf<A> = A extends ReadonlyArray<infer B> ? B : A;
+type SubjectFor<Subjects extends SubjectMap, Name> = Name extends AnySubject ? SubjectUnion<Subjects> : Name extends SubjectName<Subjects> ? Subjects[Name] : never;
+type PreviousAliasDepth = [never, 0, 1, 2, 3, 4, 5];
+/**
+ * Expands an action through configured aliases. The recursion depth is bounded
+ * to keep public type-checking predictable.
+ *
+ * @since 0.1.0
+ * @category Models
+ */
+type ExpandedAction<Action extends string, Aliases extends ActionAliases, Depth extends number = 5> = Action | ([Depth] extends [0] ? never : Action extends keyof Aliases & string ? ExpandedAction<ElementOf<Aliases[Action]> & string, Aliases, PreviousAliasDepth[Depth]> : never);
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface Builder<Subjects extends SubjectMap> {
+  readonly allow: <const Action extends SingleOrReadonlyArray<string>, const Name extends SingleOrReadonlyArray<RuleSubject<Subjects>>, const Fields extends FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object> = FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object>, E = never, R = never>(action: Action, subject: Name, options?: RuleOptions<SubjectFor<Subjects, ElementOf<Name>> & object, Fields, E, R>) => Rule<"Allow", ElementOf<Action> & string, ElementOf<Name> & string, SubjectFor<Subjects, ElementOf<Name>> & object, Fields, E, R>;
+  readonly deny: <const Action extends SingleOrReadonlyArray<string>, const Name extends SingleOrReadonlyArray<RuleSubject<Subjects>>, const Fields extends FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object> = FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object>, E = never, R = never>(action: Action, subject: Name, options?: RuleOptions<SubjectFor<Subjects, ElementOf<Name>> & object, Fields, E, R>) => Rule<"Deny", ElementOf<Action> & string, ElementOf<Name> & string, SubjectFor<Subjects, ElementOf<Name>> & object, Fields, E, R>;
+}
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface RawRule<Action extends string = string, Name extends string = string, Fields extends string = string, Conditions = unknown> {
+  readonly action: SingleOrReadonlyArray<Action>;
+  readonly subject: SingleOrReadonlyArray<Name>;
+  readonly fields?: SingleOrReadonlyArray<Fields>;
+  readonly conditions?: Conditions;
+  readonly inverted?: boolean;
+  readonly reason?: string;
+}
+type RuleAction<Rules> = Rules extends Rule<infer _Kind, infer Action, infer _Name, infer _Subject, infer _Fields, infer _E, infer _R> ? Action : never;
+type RuleSubjectName<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer Name, infer _Subject, infer _Fields, infer _E, infer _R> ? Name : never;
+type RuleFields<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer _Name, infer _Subject, infer Fields, infer _E, infer _R> ? Fields : never;
+type RuleError<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer _Name, infer _Subject, infer _Fields, infer E, infer _R> ? E : never;
+type RuleServices<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer _Name, infer _Subject, infer _Fields, infer _E, infer R> ? R : never;
+type ActionMatches<Rule, Action extends string, Aliases extends ActionAliases> = Rule extends AnyRule ? Action extends ExpandedAction<RuleAction<Rule> & string, Aliases> ? Rule : AnyAction extends RuleAction<Rule> ? Rule : never : never;
+type SubjectMatches<Rule, Name extends string> = Rule extends AnyRule ? Name extends RuleSubjectName<Rule> ? Rule : AnySubject extends RuleSubjectName<Rule> ? Rule : never : never;
+type RulesMatching<Rules, Action extends string, Name extends string, Aliases extends ActionAliases> = SubjectMatches<ActionMatches<Rules, Action, Aliases>, Name>;
+type AllowedActions<Rules, Aliases extends ActionAliases> = AnyAction extends RuleAction<Rules> ? string : ExpandedAction<RuleAction<Rules> & string, Aliases>;
+type AllowedSubjects<Subjects extends SubjectMap, Rules> = AnySubject extends RuleSubjectName<Rules> ? SubjectName<Subjects> : Extract<RuleSubjectName<Rules>, SubjectName<Subjects>>;
+type FieldFor<Subjects extends SubjectMap, Rules, Aliases extends ActionAliases, Action extends string, Name extends SubjectName<Subjects>> = RuleFields<RulesMatching<Rules, Action, Name, Aliases>> extends infer Fields ? [Fields] extends [never] ? FieldOf<Subjects[Name]> : Extract<Fields, FieldPattern> extends never ? Fields & string : FieldOf<Subjects[Name]> : never;
+type ExplicitCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = AllowedSubjects<Subjects, Rules> extends infer Name ? Name extends SubjectName<Subjects> ? AllowedActions<Rules, Aliases> extends infer Action ? Action extends string ? {
+  readonly action: Action;
+  readonly subject: Name;
+  readonly value?: Subjects[Name] | TypedSubject<Name, Subjects[Name]>;
+  readonly field?: FieldFor<Subjects, Rules, Aliases, Action, Name>;
+} : never : never : never : never;
+type TypedSubjectCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = AllowedSubjects<Subjects, Rules> extends infer Name ? Name extends SubjectName<Subjects> ? AllowedActions<Rules, Aliases> extends infer Action ? Action extends string ? {
+  readonly action: Action;
+  readonly subject?: never;
+  readonly value: TypedSubject<Name, Subjects[Name]>;
+  readonly field?: FieldFor<Subjects, Rules, Aliases, Action, Name>;
+} : never : never : never : never;
+type DetectedSubjectCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = {
+  readonly action: AllowedActions<Rules, Aliases>;
+  readonly subject?: never;
+  readonly value: SubjectUnion<Subjects>;
+  readonly field?: string;
+};
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type CheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases = {}> = ExplicitCheckRequest<Subjects, Rules, Aliases> | TypedSubjectCheckRequest<Subjects, Rules, Aliases> | DetectedSubjectCheckRequest<Subjects, Rules, Aliases>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type RuleQueryRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases = {}> = CheckRequest<Subjects, Rules, Aliases>;
+type ExplicitSubjectQueryRequest<Subjects extends SubjectMap, Rules extends AnyRule> = AllowedSubjects<Subjects, Rules> extends infer Name ? Name extends SubjectName<Subjects> ? {
+  readonly subject: Name;
+  readonly value?: Subjects[Name] | TypedSubject<Name, Subjects[Name]>;
+} : never : never;
+type TypedSubjectQueryRequest<Subjects extends SubjectMap, Rules extends AnyRule> = AllowedSubjects<Subjects, Rules> extends infer Name ? Name extends SubjectName<Subjects> ? {
+  readonly subject?: never;
+  readonly value: TypedSubject<Name, Subjects[Name]>;
+} : never : never;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+type SubjectQueryRequest<Subjects extends SubjectMap, Rules extends AnyRule> = ExplicitSubjectQueryRequest<Subjects, Rules> | TypedSubjectQueryRequest<Subjects, Rules> | {
+  readonly subject?: never;
+  readonly value: SubjectUnion<Subjects>;
+};
+type RequestAction<Request> = Request extends {
+  readonly action: infer Action;
+} ? Action & string : string;
+type RequestSubject<Request> = Request extends {
+  readonly subject: infer Name;
+} ? Name & string : Request extends {
+  readonly value: TypedSubject<infer Name, object>;
+} ? Name & string : string;
+type MatchingRules<Rules, Request, Aliases extends ActionAliases> = RulesMatching<Rules, RequestAction<Request>, RequestSubject<Request>, Aliases>;
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface ToRawRulesOptions {
+  readonly strict?: boolean;
+}
+/**
+ * @since 0.1.0
+ * @category Models
+ */
+interface PermittedFieldsOptions<Rules extends AnyRule> {
+  readonly fieldsFrom: (rule: Rules) => ReadonlyArray<string>;
+}
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+declare const AuthorizationError: typeof AuthorizationError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+type AuthorizationError = AuthorizationError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+declare const ConditionError: typeof ConditionError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+type ConditionError = ConditionError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+declare const PredicateEvaluationError: typeof PredicateEvaluationError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+type PredicateEvaluationError = PredicateEvaluationError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+declare const SerializationError: typeof SerializationError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+type SerializationError = SerializationError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+declare const RawRuleError: typeof RawRuleError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+type RawRuleError = RawRuleError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+declare const SubjectDetectionError: typeof SubjectDetectionError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+type SubjectDetectionError = SubjectDetectionError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+declare const AliasError: typeof AliasError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+type AliasError = AliasError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+declare const QueryGenerationError: typeof QueryGenerationError$1;
+/**
+ * @since 0.1.0
+ * @category Errors
+ */
+type QueryGenerationError = QueryGenerationError$1;
+/**
+ * Creates an action resolver for an alias map.
+ *
+ * @since 0.1.0
+ * @category Constructors
+ */
+declare const createAliasResolver: <const Aliases extends ActionAliases>(aliases: Aliases) => ActionResolver;
+/**
+ * Defines an immutable Ability from a generator-based rule program.
+ *
+ * @since 0.1.0
+ * @category Constructors
+ */
+declare const define: <Subjects extends SubjectMap>() => <Eff extends AnyRule, A, const Aliases extends ActionAliases = {}>(body: (builder: Builder<Subjects>) => Generator<Eff, A, unknown>, options?: AbilityOptions<Subjects, Aliases>) => Ability<Subjects, Eff, Aliases>;
+/**
+ * Constructs an Ability directly from rules.
+ *
+ * @since 0.1.0
+ * @category Constructors
+ */
+declare const make: <Subjects extends SubjectMap, Rules extends AnyRule, const Aliases extends ActionAliases = {}>(rules: Iterable<Rules>, options?: AbilityOptions<Subjects, Aliases>) => Ability<Subjects, Rules, Aliases>;
+/**
+ * Constructs an Ability from JSON-safe rules.
+ *
+ * @since 0.1.0
+ * @category Constructors
+ */
+declare const fromRawRules: <Subjects extends SubjectMap, const Aliases extends ActionAliases = {}>(rules: Iterable<RawRule<string, RuleSubject<Subjects>, string, MongoCondition<SubjectUnion<Subjects>>>>, options?: AbilityOptions<Subjects, Aliases>) => Effect.Effect<Ability<Subjects, AnyRule, Aliases>, AliasError | RawRuleError>;
+/**
+ * Creates a pure typed subject wrapper without mutating the wrapped value.
+ *
+ * @since 0.1.0
+ * @category Constructors
+ */
+declare const subject: <const Name extends string, Value extends object>(name: Name, value: Value) => TypedSubject<Name, Value>;
+/**
+ * Returns whether a value is an Ability.
+ *
+ * @since 0.1.0
+ * @category Guards
+ */
+declare const isAbility: (value: unknown) => value is Ability<SubjectMap, AnyRule, ActionAliases>;
+/**
+ * Returns whether a value is a rule.
+ *
+ * @since 0.1.0
+ * @category Guards
+ */
+declare const isRule: (value: unknown) => value is AnyRule;
+/**
+ * Returns whether a value is a typed subject wrapper.
+ *
+ * @since 0.1.0
+ * @category Guards
+ */
+declare const isSubject: (value: unknown) => value is TypedSubject<string, object>;
+/**
+ * Unwraps a typed subject wrapper.
+ *
+ * @since 0.1.0
+ * @category Accessors
+ */
+declare const unwrapSubject: <Value>(value: Value) => Value extends TypedSubject<infer _Name, infer Subject> ? Subject : Value;
+/**
+ * Detects a subject name for a value using an Ability's detection strategy.
+ *
+ * @since 0.1.0
+ * @category Accessors
+ */
+declare const detectSubjectType: <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(self: Ability<Subjects, Rules, Aliases>, value: object | TypedSubject<SubjectName<Subjects>, SubjectUnion<Subjects>>) => Effect.Effect<SubjectName<Subjects>, SubjectDetectionError>;
+/**
+ * Converts an Ability to JSON-safe raw rules.
+ *
+ * @since 0.1.0
+ * @category Conversions
+ */
+declare const toRawRules: <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(self: Ability<Subjects, Rules, Aliases>, options?: ToRawRulesOptions) => Effect.Effect<ReadonlyArray<RawRule>, SerializationError>;
+/**
+ * Returns rules that may apply for a request before field, condition and predicate checks.
+ *
+ * @since 0.1.0
+ * @category Accessors
+ */
+declare const possibleRulesFor: {
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<ReadonlyArray<MatchingRules<Rules, Request, Aliases>>, SubjectDetectionError>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<ReadonlyArray<MatchingRules<Rules, Request, Aliases>>, SubjectDetectionError>;
+};
+/**
+ * Returns rules that may apply for a request after field checks.
+ *
+ * @since 0.1.0
+ * @category Accessors
+ */
+declare const rulesFor: {
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<ReadonlyArray<MatchingRules<Rules, Request, Aliases>>, SubjectDetectionError>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<ReadonlyArray<MatchingRules<Rules, Request, Aliases>>, SubjectDetectionError>;
+};
+/**
+ * Returns the first matching rule for a request, if any.
+ *
+ * @since 0.1.0
+ * @category Accessors
+ */
+declare const relevantRuleFor: {
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<MatchingRules<Rules, Request, Aliases> | undefined, ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<MatchingRules<Rules, Request, Aliases> | undefined, ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+};
+/**
+ * Returns actions that have rules for a subject.
+ *
+ * @since 0.1.0
+ * @category Accessors
+ */
+declare const actionsFor: {
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends SubjectQueryRequest<Subjects, Rules>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<ReadonlyArray<AllowedActions<Rules, Aliases>>, SubjectDetectionError>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends SubjectQueryRequest<Subjects, Rules>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<ReadonlyArray<AllowedActions<Rules, Aliases>>, SubjectDetectionError>;
+};
+/**
+ * Checks a request and fails with `AuthorizationError` when the request is not authorized.
+ *
+ * @since 0.1.0
+ * @category Combinators
+ */
+declare const check: {
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<void, AuthorizationError | ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<void, AuthorizationError | ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+};
+/**
+ * Computes fields permitted for a request.
+ *
+ * @since 0.1.0
+ * @category Combinators
+ */
+declare const permittedFields: {
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(request: Request, options: PermittedFieldsOptions<Rules>): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<ReadonlyArray<string>, ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request, options: PermittedFieldsOptions<Rules>): Effect.Effect<ReadonlyArray<string>, ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+};
+//#endregion
+export { Ability, AbilityOptions, Ability_d_exports, ActionAliases, ActionResolver, AliasError, AnyAction, AnyRule, AnySubject, AuthorizationError, Builder, CheckRequest, ConditionError, DetectSubjectType, ExpandedAction, FieldOf, FieldPath, FieldPattern, MongoCondition, PermittedFieldsOptions, Predicate, PredicateEvaluationError, QueryGenerationError, RawRule, RawRuleError, Rule, RuleKind, RuleOptions, RuleQueryRequest, RuleSubject, RuleTypeId, SerializationError, SingleOrReadonlyArray, SubjectDetectionError, SubjectMap, SubjectName, SubjectQueryRequest, SubjectTypeId, SubjectUnion, ToRawRulesOptions, TypeId, TypedSubject, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject };