@nmnmcc/ability 0.1.0 → 0.2.0

package/dist/internal/ability.js

@@ -1,5 +1,5 @@
 import { cloneSerializable } from "./serializable.js";
-import { guard } from "@ucast/mongo2js";
+import { createMongoAbility, mongoQueryMatcher } from "@casl/ability";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
@@ -27,7 +27,7 @@ const SubjectTypeId = Symbol.for("@nmnmcc/ability/Subject");
 const RuleTypeId = Symbol.for("@nmnmcc/ability/Rule");
 const anyAction = "manage";
 const anySubject = "all";
-const RuleIndexTypeId = Symbol.for("@nmnmcc/ability/Ability/ruleIndex");
+const CaslStateTypeId = Symbol.for("@nmnmcc/ability/Ability/caslState");
 /**
 * @since 0.1.0
 * @category Errors
@@ -42,16 +42,6 @@ var ConditionError = class extends Data.TaggedError("ConditionError") {};
 * @since 0.1.0
 * @category Errors
 */
-var PredicateEvaluationError = class extends Data.TaggedError("PredicateEvaluationError") {};
-/**
-* @since 0.1.0
-* @category Errors
-*/
-var SerializationError = class extends Data.TaggedError("SerializationError") {};
-/**
-* @since 0.1.0
-* @category Errors
-*/
 var RawRuleError = class extends Data.TaggedError("RawRuleError") {};
 /**
 * @since 0.1.0
@@ -141,7 +131,6 @@ const ruleHashInput = (rule) => ({
 	subject: rule.subject,
 	fields: rule.fields,
 	conditions: rule.conditions,
-	when: rule.when,
 	reason: rule.reason
 });
 const RuleProto = {
@@ -230,49 +219,44 @@ const freezeRule = (rule) => {
 	copy.subject = normalizeArray(rule.subject);
 	if (rule.fields !== void 0) copy.fields = copyArray(rule.fields);
 	if (rule.conditions !== void 0) copy.conditions = cloneSerializable(rule.conditions);
-	if (rule.when !== void 0) copy.when = rule.when;
 	if (rule.reason !== void 0) copy.reason = rule.reason;
 	return Object.freeze(copy);
 };
-const addIndexedRule = (index, subjectName, action, indexedRule) => {
-	let subjectIndex = index.get(subjectName);
-	if (subjectIndex === void 0) {
-		subjectIndex = /* @__PURE__ */ new Map();
-		index.set(subjectName, subjectIndex);
-	}
-	let rules = subjectIndex.get(action);
-	if (rules === void 0) {
-		rules = [];
-		subjectIndex.set(action, rules);
-	}
-	rules.push(indexedRule);
-};
-const freezeRuleIndex = (index) => {
-	const subjects = /* @__PURE__ */ new Map();
-	for (const [subjectName, actions] of index) {
-		const actionIndex = /* @__PURE__ */ new Map();
-		for (const [action, rules] of actions) actionIndex.set(action, Object.freeze(rules.slice().sort((a, b) => b.index - a.index)));
-		subjects.set(subjectName, actionIndex);
-	}
-	return Object.freeze({ rulesBySubject: subjects });
+const toCaslRawRule = (rule) => {
+	const raw = {
+		action: cloneSerializable(rule.action),
+		subject: cloneSerializable(rule.subject)
+	};
+	if (rule.fields !== void 0) raw.fields = cloneSerializable(rule.fields);
+	if (rule.conditions !== void 0) raw.conditions = cloneSerializable(rule.conditions);
+	if (rule._tag === "Deny") raw.inverted = true;
+	if (rule.reason !== void 0) raw.reason = rule.reason;
+	return raw;
 };
-const buildRuleIndex = (rules, aliases) => {
+const buildCaslState = (rules, aliases) => {
 	const resolver = createAliasResolver(aliases ?? {});
-	const index = /* @__PURE__ */ new Map();
+	const rulesByRawRule = /* @__PURE__ */ new WeakMap();
+	const indexByRule = /* @__PURE__ */ new Map();
+	const rawRules = [];
 	let ruleIndex = 0;
 	for (const rule of rules) {
-		const indexedRule = {
-			rule,
-			index: ruleIndex
-		};
-		const actions = resolver(rule.action);
-		const subjects = wrapArray(rule.subject);
-		for (const subjectName of subjects) for (const action of actions) addIndexedRule(index, subjectName, action, indexedRule);
+		const rawRule = toCaslRawRule(rule);
+		rawRules.push(rawRule);
+		rulesByRawRule.set(rawRule, rule);
+		indexByRule.set(rule, ruleIndex);
 		ruleIndex = ruleIndex + 1;
 	}
-	return freezeRuleIndex(index);
+	return Object.freeze({
+		ability: createMongoAbility(rawRules, {
+			anyAction,
+			anySubjectType: anySubject,
+			resolveAction: (action) => resolver(action)
+		}),
+		rulesByRawRule,
+		indexByRule: Object.freeze(indexByRule)
+	});
 };
-const getRuleIndex = (self) => self[RuleIndexTypeId];
+const getCaslState = (self) => self[CaslStateTypeId];
 /**
 * @internal
 */
@@ -280,7 +264,7 @@ const make = (rules, options) => {
 	const self = Object.create(AbilityProto);
 	self.rules = Object.freeze(Array.from(rules, freezeRule));
 	self.options = freezeOptions(options);
-	self[RuleIndexTypeId] = buildRuleIndex(self.rules, self.options.actionAliases);
+	self[CaslStateTypeId] = buildCaslState(self.rules, self.options.actionAliases);
 	return Object.freeze(self);
 };
 const makeRule = (kind, action, subjectName, options) => {
@@ -290,7 +274,6 @@ const makeRule = (kind, action, subjectName, options) => {
 	rule.subject = normalizeArray(subjectName);
 	if (options?.fields !== void 0) rule.fields = copyArray(wrapArray(options.fields));
 	if (options?.conditions !== void 0) rule.conditions = cloneSerializable(options.conditions);
-	if (options?.when !== void 0) rule.when = options.when;
 	if (options?.reason !== void 0) rule.reason = options.reason;
 	return Object.freeze(rule);
 };
@@ -380,34 +363,7 @@ const toRuntimeSubjectRequest = Effect.fnUntraced(function* (self, request) {
 	if (hasOwnValue(request)) runtime.value = unwrapSubject(request.value);
 	return runtime;
 });
-const regexpSpecialChars = /[-/\\^$+?.()|[\]{}]/g;
-const regexpAny = /\.?\*+\.?/g;
-const regexpStars = /\*+/;
-const regexpDot = /\./g;
-const detectRegexpPattern = (match, index, source) => {
-	const quantifier = source[0] === "*" || match[0] === "." && match[match.length - 1] === "." ? "+" : "*";
-	const matcher = match.includes("**") ? "." : "[^.]";
-	const pattern = match.replace(regexpDot, "\\$&").replace(regexpStars, matcher + quantifier);
-	return index + match.length === source.length ? `(?:${pattern})?` : pattern;
-};
-const escapeRegexp = (match, index, source) => {
-	if (match === "." && (source[index - 1] === "*" || source[index + 1] === "*")) return match;
-	return `\\${match}`;
-};
-const createFieldPattern = (fields) => {
-	const patterns = fields.map((field) => field.replace(regexpSpecialChars, escapeRegexp).replace(regexpAny, detectRegexpPattern));
-	const pattern = patterns.length > 1 ? `(?:${patterns.join("|")})` : patterns[0] ?? "";
-	return new RegExp(`^${pattern}$`);
-};
-const createFieldMatcher = (fields) => {
-	const pattern = fields.some((field) => field.includes("*")) ? createFieldPattern(fields) : void 0;
-	return pattern === void 0 ? (field) => fields.includes(field) : (field) => pattern.test(field);
-};
-const matchesField = (rule, request) => {
-	if (rule.fields === void 0) return true;
-	if (request.field === void 0) return rule._tag === "Allow";
-	return createFieldMatcher(rule.fields)(request.field);
-};
+const matchesField = (candidate, request) => candidate.caslRule.matchesField(request.field);
 const isEmptyCondition = (conditions) => Object.keys(conditions).length === 0;
 const makeConditionError = (request, cause) => {
 	const error = {
@@ -418,59 +374,42 @@ const makeConditionError = (request, cause) => {
 	if (request.field !== void 0) error.field = request.field;
 	return new ConditionError(error);
 };
-const makePredicateEvaluationError = (request, cause) => {
-	const error = {
-		action: request.action,
-		subject: request.subject,
-		cause
-	};
-	if (request.field !== void 0) error.field = request.field;
-	return new PredicateEvaluationError(error);
-};
-const matchesConditions = Effect.fnUntraced(function* (rule, request) {
+const matchesConditions = Effect.fnUntraced(function* (candidate, request) {
+	const { rule } = candidate;
 	if (rule.conditions === void 0) return true;
 	if (request.value === void 0) return rule._tag === "Allow" || isEmptyCondition(rule.conditions);
 	return yield* Effect.try({
-		try: () => guard(rule.conditions)(request.value),
+		try: () => candidate.caslRule.matchesConditions(request.value),
 		catch: (cause) => makeConditionError(request, cause)
 	});
 });
-const matchesPredicate = Effect.fnUntraced(function* (rule, request) {
-	if (rule.when === void 0) return true;
-	if (request.value === void 0) return false;
-	const result = yield* Effect.try({
-		try: () => rule.when?.(request.value) ?? true,
-		catch: (cause) => makePredicateEvaluationError(request, cause)
-	});
-	return Effect.isEffect(result) ? yield* result : result;
+const matchesCandidateRule = Effect.fnUntraced(function* (candidate, request) {
+	if (!matchesField(candidate, request)) return false;
+	return yield* matchesConditions(candidate, request);
 });
-const matchesCandidateRule = Effect.fnUntraced(function* (rule, request) {
-	if (!matchesField(rule, request)) return false;
-	if (!(yield* matchesConditions(rule, request))) return false;
-	return yield* matchesPredicate(rule, request);
-});
-const collectIndexedRules = (self, request, order) => {
-	const collected = /* @__PURE__ */ new Map();
-	const pairs = [[request.subject, request.action]];
-	if (request.action !== anyAction) pairs.push([request.subject, anyAction]);
-	if (request.subject !== anySubject) pairs.push([anySubject, request.action]);
-	if (request.subject !== anySubject && request.action !== anyAction) pairs.push([anySubject, anyAction]);
-	for (const [subjectName, action] of pairs) {
-		const rules = getRuleIndex(self).rulesBySubject.get(subjectName)?.get(action);
-		if (rules !== void 0) for (const indexedRule of rules) collected.set(indexedRule.rule, indexedRule);
-	}
-	const sorted = Array.from(collected.values()).sort((a, b) => order === "descending" ? b.index - a.index : a.index - b.index);
-	return Object.freeze(sorted.map((indexedRule) => indexedRule.rule));
+const getRuntimeRule = (state, caslRule) => {
+	const rule = state.rulesByRawRule.get(caslRule.origin);
+	if (rule === void 0) throw new Error("CASL rule is not owned by this Ability");
+	return rule;
+};
+const collectRuleCandidates = (self, request, order) => {
+	const state = getCaslState(self);
+	const candidates = state.ability.possibleRulesFor(request.action, request.subject).map((caslRule) => ({
+		rule: getRuntimeRule(state, caslRule),
+		caslRule
+	}));
+	const sorted = order === "descending" ? candidates : candidates.slice().sort((a, b) => (state.indexByRule.get(a.rule) ?? 0) - (state.indexByRule.get(b.rule) ?? 0));
+	return Object.freeze(sorted);
 };
-const possibleRulesForRequest = (self, request) => collectIndexedRules(self, request, "descending");
-const possibleRulesForDefinitionOrder = (self, request) => collectIndexedRules(self, request, "ascending");
+const possibleRulesForRequest = (self, request) => Object.freeze(collectRuleCandidates(self, request, "descending").map((candidate) => candidate.rule));
+const possibleRuleCandidatesForDefinitionOrder = (self, request) => collectRuleCandidates(self, request, "ascending");
 const relevantRuleForEffect = Effect.fnUntraced(function* (self, request) {
-	const rules = possibleRulesForRequest(self, request);
+	const candidates = collectRuleCandidates(self, request, "descending");
 	let index = 0;
-	while (index < rules.length) {
-		const rule = rules[index];
-		if (rule !== void 0) {
-			if (yield* matchesCandidateRule(rule, request)) return rule;
+	while (index < candidates.length) {
+		const candidate = candidates[index];
+		if (candidate !== void 0) {
+			if (yield* matchesCandidateRule(candidate, request)) return candidate.rule;
 		}
 		index = index + 1;
 	}
@@ -504,7 +443,7 @@ const possibleRulesFor = dual(2, Effect.fnUntraced(function* (self, request) {
 */
 const rulesFor = dual(2, Effect.fnUntraced(function* (self, request) {
 	const runtimeRequest = yield* toRuntimeRequest(self, request);
-	return Object.freeze(possibleRulesForRequest(self, runtimeRequest).filter((rule) => matchesField(rule, runtimeRequest)));
+	return Object.freeze(collectRuleCandidates(self, runtimeRequest, "descending").filter((candidate) => matchesField(candidate, runtimeRequest)).map((candidate) => candidate.rule));
 }));
 /**
 * @internal
@@ -517,14 +456,7 @@ const relevantRuleFor = dual(2, Effect.fnUntraced(function* (self, request) {
 */
 const actionsFor = dual(2, Effect.fnUntraced(function* (self, request) {
 	const runtimeRequest = yield* toRuntimeSubjectRequest(self, request);
-	const actions = /* @__PURE__ */ new Set();
-	const collect = (subjectName) => {
-		const subjectIndex = getRuleIndex(self).rulesBySubject.get(subjectName);
-		if (subjectIndex !== void 0) for (const action of subjectIndex.keys()) actions.add(action);
-	};
-	collect(runtimeRequest.subject);
-	if (runtimeRequest.subject !== anySubject) collect(anySubject);
-	return unique(actions);
+	return unique(getCaslState(self).ability.actionsFor(runtimeRequest.subject));
 }));
 const rawRuleError = (reason, ruleIndex, cause) => {
 	const error = {
@@ -541,7 +473,7 @@ const validateArrayValue = (value, name, index) => {
 const validateRawConditions = (conditions, index) => {
 	if (conditions === void 0) return Effect.void;
 	return Effect.asVoid(Effect.try({
-		try: () => guard(conditions),
+		try: () => mongoQueryMatcher(conditions),
 		catch: (cause) => rawRuleError("rawRule.conditions cannot be compiled", index, cause)
 	}));
 };
@@ -568,6 +500,11 @@ const fromRawRules = Effect.fnUntraced(function* (rules, options) {
 		catch: (cause) => cause instanceof AliasError ? cause : rawRuleError("Unable to construct Ability from raw rules", index, cause)
 	});
 });
+const updateEffect = (self, rules) => fromRawRules(rules, self.options);
+/**
+* @internal
+*/
+const update = dual(2, updateEffect);
 const ruleToRaw = (rule) => {
 	const raw = {
 		action: cloneSerializable(rule.action),
@@ -582,18 +519,9 @@ const ruleToRaw = (rule) => {
 /**
 * @internal
 */
-const toRawRules = Effect.fnUntraced(function* (self, options) {
-	const strict = options?.strict !== false;
+const toRawRules = Effect.fnUntraced(function* (self) {
 	const rawRules = [];
-	let index = 0;
-	for (const rule of self.rules) {
-		if (strict && rule.when !== void 0) return yield* Effect.fail(new SerializationError({
-			reason: "Cannot serialize rules with function predicates in strict mode",
-			ruleIndex: index
-		}));
-		rawRules.push(ruleToRaw(rule));
-		index = index + 1;
-	}
+	for (const rule of self.rules) rawRules.push(ruleToRaw(rule));
 	return Object.freeze(rawRules);
 });
 const fieldsForRule = (rule, options) => rule.fields ?? options.fieldsFrom(rule);
@@ -602,18 +530,16 @@ const fieldsForRule = (rule, options) => rule.fields ?? options.fieldsFrom(rule)
 */
 const permittedFields = dual(3, Effect.fnUntraced(function* (self, request, options) {
 	const runtimeRequest = yield* toRuntimeRequest(self, request);
-	const rules = possibleRulesForDefinitionOrder(self, runtimeRequest);
+	const candidates = possibleRuleCandidatesForDefinitionOrder(self, runtimeRequest);
 	const fields = /* @__PURE__ */ new Set();
 	let index = 0;
-	while (index < rules.length) {
-		const rule = rules[index];
-		if (rule !== void 0) {
-			if (yield* matchesConditions(rule, runtimeRequest)) {
-				if (yield* matchesPredicate(rule, runtimeRequest)) {
-					const ruleFields = fieldsForRule(rule, options);
-					for (const field of ruleFields) if (rule._tag === "Allow") fields.add(field);
-					else fields.delete(field);
-				}
+	while (index < candidates.length) {
+		const candidate = candidates[index];
+		if (candidate !== void 0) {
+			if (yield* matchesConditions(candidate, runtimeRequest)) {
+				const ruleFields = fieldsForRule(candidate.rule, options);
+				for (const field of ruleFields) if (candidate.rule._tag === "Allow") fields.add(field);
+				else fields.delete(field);
 			}
 		}
 		index = index + 1;
@@ -621,4 +547,4 @@ const permittedFields = dual(3, Effect.fnUntraced(function* (self, request, opti
 	return Object.freeze(Array.from(fields));
 }));
 //#endregion
-export { AliasError, AuthorizationError, ConditionError, PredicateEvaluationError, QueryGenerationError, RawRuleError, RuleTypeId, SerializationError, SubjectDetectionError, SubjectTypeId, TypeId, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject };
+export { AliasError, AuthorizationError, ConditionError, QueryGenerationError, RawRuleError, RuleTypeId, SubjectDetectionError, SubjectTypeId, TypeId, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject, update };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nmnmcc/ability",
-  "version": "0.1.0",
-  "description": "An Effect-style authorization library inspired by CASL.",
+  "version": "0.2.0",
+  "description": "Authorization primitives for Effect programs, backed by CASL.",
   "license": "Apache-2.0",
   "type": "module",
   "packageManager": "yarn@4.14.1",
@@ -36,20 +36,17 @@
       "import": "./dist/AbilityExtra.js",
       "default": "./dist/AbilityExtra.js"
     },
-    "./AbilityRef": {
-      "types": "./dist/AbilityRef.d.ts",
-      "import": "./dist/AbilityRef.js",
-      "default": "./dist/AbilityRef.js"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
     "build": "tsdown",
     "prepack": "yarn build",
-    "prepublishOnly": "yarn typecheck && yarn test",
-    "release:check": "yarn typecheck && yarn test && yarn pack --dry-run",
+    "prepublishOnly": "yarn typecheck && yarn test-types && yarn test",
+    "release:check": "yarn typecheck && yarn test-types && yarn test && yarn pack --dry-run",
+    "format": "prettier . -w",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
+    "test-types": "tstyche",
     "npm": "YARN_NPM_REGISTRY_SERVER=https://registry.npmjs.org yarn npm"
   },
   "publishConfig": {
@@ -57,19 +54,20 @@
     "registry": "https://registry.npmjs.org"
   },
   "devDependencies": {
+    "@casl/ability": "^6.8.1",
     "@effect/language-service": "^0.85.1",
     "@effect/vitest": "4.0.0-beta.59",
     "@types/node": "^25.6.0",
     "effect": "^4.0.0-beta.59",
+    "prettier": "^3.8.3",
     "tsdown": "^0.21.10",
+    "tstyche": "^7.1.0",
     "tsx": "^4.21.0",
     "typescript": "^6.0.3",
     "vitest": "4.1.4"
   },
   "peerDependencies": {
+    "@casl/ability": "^6.8.1",
     "effect": "^4.0.0-beta.59"
-  },
-  "dependencies": {
-    "@ucast/mongo2js": "^2.0.0"
   }
 }

package/dist/AbilityRef.d.ts

@@ -1,110 +0,0 @@
-import { Ability, AliasError, AnyRule, MongoCondition, RawRule, RawRuleError, RuleSubject, SubjectMap, SubjectUnion } from "./Ability.js";
-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/AbilityRef.d.ts
-declare namespace AbilityRef_d_exports {
-  export { AbilityRef, Event, EventHandler, EventName, TypeId, Unsubscribe, UpdateEvent, UpdatedEvent, get, isAbilityRef, make, on, set, update };
-}
-/**
- * @since 0.1.0
- * @category Type Ids
- */
-declare const TypeId: unique symbol;
-/**
- * @since 0.1.0
- * @category Type Ids
- */
-type TypeId = typeof TypeId;
-/**
- * @since 0.1.0
- * @category Models
- */
-type EventName = "update" | "updated";
-/**
- * @since 0.1.0
- * @category Models
- */
-interface UpdateEvent<Subjects extends SubjectMap> {
-  readonly previous: Ability<Subjects, AnyRule>;
-  readonly next: Ability<Subjects, AnyRule>;
-}
-/**
- * @since 0.1.0
- * @category Models
- */
-interface UpdatedEvent<Subjects extends SubjectMap> {
-  readonly previous: Ability<Subjects, AnyRule>;
-  readonly current: Ability<Subjects, AnyRule>;
-}
-/**
- * @since 0.1.0
- * @category Models
- */
-type Event<Subjects extends SubjectMap, Name extends EventName> = Name extends "update" ? UpdateEvent<Subjects> : UpdatedEvent<Subjects>;
-/**
- * @since 0.1.0
- * @category Models
- */
-type EventHandler<Subjects extends SubjectMap, Name extends EventName> = (event: Event<Subjects, Name>) => void | Effect.Effect<void>;
-/**
- * @since 0.1.0
- * @category Models
- */
-type Unsubscribe = () => void;
-/**
- * @since 0.1.0
- * @category Models
- */
-interface AbilityRef<Subjects extends SubjectMap> extends Equal.Equal, Inspectable.Inspectable, Pipeable.Pipeable {
-  readonly [TypeId]: TypeId;
-  readonly current: Ability<Subjects, AnyRule>;
-  /** @internal */
-  readonly handlers: {
-    readonly update: Array<EventHandler<Subjects, "update">>;
-    readonly updated: Array<EventHandler<Subjects, "updated">>;
-  };
-}
-/**
- * @since 0.1.0
- * @category Constructors
- */
-declare const make: <Subjects extends SubjectMap, Rules extends AnyRule>(ability: Ability<Subjects, Rules>) => AbilityRef<Subjects>;
-/**
- * @since 0.1.0
- * @category Guards
- */
-declare const isAbilityRef: (value: unknown) => value is AbilityRef<SubjectMap>;
-/**
- * @since 0.1.0
- * @category Accessors
- */
-declare const get: <Subjects extends SubjectMap>(self: AbilityRef<Subjects>) => Ability<Subjects, AnyRule>;
-/**
- * @since 0.1.0
- * @category Combinators
- */
-declare const set: {
-  <Subjects extends SubjectMap, Rules extends AnyRule>(ability: Ability<Subjects, Rules>): (self: AbilityRef<Subjects>) => Effect.Effect<void>;
-  <Subjects extends SubjectMap, Rules extends AnyRule>(self: AbilityRef<Subjects>, ability: Ability<Subjects, Rules>): Effect.Effect<void>;
-};
-/**
- * @since 0.1.0
- * @category Combinators
- */
-declare const update: {
-  <Subjects extends SubjectMap, Rules extends AnyRule>(next: Ability<Subjects, Rules> | Iterable<RawRule<string, RuleSubject<Subjects>, string, MongoCondition<SubjectUnion<Subjects>>>>): (self: AbilityRef<Subjects>) => Effect.Effect<void, AliasError | RawRuleError>;
-  <Subjects extends SubjectMap, Rules extends AnyRule>(self: AbilityRef<Subjects>, next: Ability<Subjects, Rules> | Iterable<RawRule<string, RuleSubject<Subjects>, string, MongoCondition<SubjectUnion<Subjects>>>>): Effect.Effect<void, AliasError | RawRuleError>;
-};
-/**
- * @since 0.1.0
- * @category Combinators
- */
-declare const on: {
-  <Subjects extends SubjectMap, Name extends EventName>(name: Name, handler: EventHandler<Subjects, Name>): (self: AbilityRef<Subjects>) => Effect.Effect<Unsubscribe>;
-  <Subjects extends SubjectMap, Name extends EventName>(self: AbilityRef<Subjects>, name: Name, handler: EventHandler<Subjects, Name>): Effect.Effect<Unsubscribe>;
-};
-//#endregion
-export { AbilityRef, AbilityRef_d_exports, Event, EventHandler, EventName, TypeId, Unsubscribe, UpdateEvent, UpdatedEvent, get, isAbilityRef, make, on, set, update };