@via-profit/ability 3.6.5 → 3.7.1

package/dist/index.cjs

@@ -32,6 +32,8 @@ function brand$3(code) {
 }
 const AbilityCondition = {
     equals: brand$3('='),
+    defined: brand$3('defined'),
+    not_defined: brand$3('not_defined'),
     not_equals: brand$3('<>'),
     greater_than: brand$3('>'),
     less_than: brand$3('<'),
@@ -64,6 +66,8 @@ function fromLiteral(literal) {
         length_equals: AbilityCondition.length_equals,
         always: AbilityCondition.always,
         never: AbilityCondition.never,
+        defined: AbilityCondition.defined,
+        not_defined: AbilityCondition.not_defined,
     };
     const value = map[literal];
     if (!value) {
@@ -104,6 +108,10 @@ function toLiteral(cond) {
             return 'always';
         case AbilityCondition.never:
             return 'never';
+        case AbilityCondition.defined:
+            return 'defined';
+        case AbilityCondition.not_defined:
+            return 'not_defined';
         default:
             return 'never';
     }
@@ -126,15 +134,6 @@ const AbilityMatch = {
     disabled: brand$2('disabled'),
 };
 
-const colors = {
-    reset: '\x1b[0m',
-    green: '\x1b[32m',
-    red: '\x1b[31m',
-    blue: '\x1b[34m',
-    yellow: '\x1b[33m',
-    white: '\x1b[37m',
-    gray: '\x1b[90m',
-};
 class AbilityExplain {
     type;
     children;
@@ -150,27 +149,36 @@ class AbilityExplain {
     }
     toString(indentPrefix = '', isLast = true) {
         const isMatch = this.match === AbilityMatch.match;
-        const mark = isMatch ? `${colors.green}✓${colors.reset}` : `${colors.red}✗${colors.reset}`;
+        const isMismatch = this.match === AbilityMatch.mismatch;
+        const isPending = this.match === AbilityMatch.pending;
+        // const isDisabled = this.match === AbilityMatch.disabled;
+        const mark = isMatch
+            ? `<match ✓>`
+            : isMismatch
+                ? `<mismatch ✗>`
+                : isPending
+                    ? `<pending …>`
+                    : `<disabled ⊘>`;
         let label;
         switch (this.type) {
             case 'policy':
-                label = `${colors.blue}POLICY${colors.reset}`;
+                label = `POLICY`;
                 break;
             case 'ruleSet':
-                label = `${colors.yellow}RULESET${colors.reset}`;
+                label = `RULESET`;
                 break;
             default:
-                label = `${colors.white}RULE${colors.reset}`;
+                label = `RULE`;
         }
         const branch = indentPrefix.length === 0
             ? ''
             : isLast
-                ? `${colors.gray}└─${colors.reset} `
-                : `${colors.gray}├─${colors.reset} `;
+                ? `└─ `
+                : `├─ `;
         let out = `${indentPrefix}${branch}${label} ${this.name} — ${mark}`;
         if (this.debugInfo)
-            out += ` ${colors.gray}(${this.debugInfo})${colors.reset}`;
-        const nextIndent = indentPrefix + (isLast ? '   ' : `${colors.gray}│  ${colors.reset}`);
+            out += ` (${this.debugInfo})`;
+        const nextIndent = indentPrefix + (isLast ? '   ' : `│  `);
         this.children.forEach((child, idx) => {
             out += '\n' + child.toString(nextIndent, idx === this.children.length - 1);
         });
@@ -183,6 +191,7 @@ class AbilityExplainRule extends AbilityExplain {
             type: 'rule',
             match: rule.state,
             name: rule.name,
+            debugInfo: `${rule.subject} ${rule.condition} ${JSON.stringify(rule.resource)}`,
         });
     }
 }
@@ -221,11 +230,13 @@ class AbilityResult {
      * Useful for debugging, logging, or building UI tools that visualize permission logic.
      */
     explain() {
-        return this.strategy.policies
+        const resMarker = this.strategy.isDenied() ? '== DENIED==' : '== ALLOWED ==';
+        const policiesExplain = this.strategy.policies
             .map(policy => {
             return new AbilityExplainPolicy(policy).toString();
         })
             .join('\n');
+        return `${resMarker}\n${policiesExplain}\n`;
     }
     decisive() {
         return this.strategy.decisivePolicy();
@@ -245,7 +256,17 @@ class AbilityResult {
     };
 }
 
+function brand$1(code) {
+    return code;
+}
+const AbilityPolicyEffect = {
+    deny: brand$1('deny'),
+    permit: brand$1('permit'),
+};
+
 class AbilityResolver {
+    onDeny;
+    onAllow;
     StrategyClass;
     policyEntries;
     constructor(
@@ -254,6 +275,8 @@ class AbilityResolver {
      */
     policyOrListOfPolicies, strategy, options = {}) {
         const policies = this.toArray(policyOrListOfPolicies);
+        this.onDeny = options.onDeny;
+        this.onAllow = options.onAllow;
         const filtered = options.tags
             ? policies.filter(p => p.tags.some(tag => options.tags.includes(tag)))
             : policies;
@@ -291,11 +314,19 @@ class AbilityResolver {
         // 3. Use strategy
         const strategy = new this.StrategyClass(filteredPolicies);
         const effect = strategy.evaluate();
-        return new AbilityResult(effect, strategy);
+        const result = new AbilityResult(effect, strategy);
+        if (effect === AbilityPolicyEffect.deny && this.onDeny) {
+            this.onDeny(result);
+        }
+        if (effect === AbilityPolicyEffect.permit && this.onAllow) {
+            this.onAllow(result);
+        }
+        return result;
     }
-    enforce(permission, resource, environment) {
+    enforce(permission, resource, environment, options) {
         const result = this.resolve(permission, resource, environment);
         if (result.isDenied()) {
+            options?.onDeny && options?.onDeny(result);
             throw new AbilityError(`Permission denied`);
         }
     }
@@ -416,7 +447,7 @@ class AbilityTypeGenerator {
                                 environmentStructure[action] = {};
                             }
                             const existingEnvType = environmentStructure[action][envPath];
-                            const targetType = ruleType; // или 'unknown', если хочешь жёстко
+                            const targetType = ruleType;
                             if (existingEnvType && existingEnvType !== targetType) {
                                 environmentStructure[action][envPath] = `${existingEnvType} | ${targetType}`;
                             }
@@ -1004,14 +1035,6 @@ class AbilityPolicy {
     }
 }
 
-function brand$1(code) {
-    return code;
-}
-const AbilityPolicyEffect = {
-    deny: brand$1('deny'),
-    permit: brand$1('permit'),
-};
-
 /**
  * Represents a rule that defines a condition to be checked against a subject and resource.
  */
@@ -1063,6 +1086,8 @@ class AbilityRule {
     static valueLen = (v) => this.isString(v) || Array.isArray(v) ? v.length : null;
     static operatorHandlers = {
         [toLiteral(AbilityCondition.always)]: () => true,
+        [toLiteral(AbilityCondition.defined)]: (a) => typeof a !== 'undefined',
+        [toLiteral(AbilityCondition.not_defined)]: (a) => typeof a === 'undefined',
         [toLiteral(AbilityCondition.never)]: () => false,
         [toLiteral(AbilityCondition.equals)]: (a, b) => a === b,
         [toLiteral(AbilityCondition.not_equals)]: (a, b) => a !== b,
@@ -1602,6 +1627,7 @@ const TokenTypes = {
     NULL: brand('NULL'),
     EQ_NULL: brand('EQ_NULL'),
     NOT_EQ_NULL: brand('NOT_EQ_NULL'),
+    DEFINED: brand('DEFINED'),
     NOT_EQ: brand('NOT_EQ'),
     LEN_GT: brand('LEN_GT'),
     LEN_LT: brand('LEN_LT'),
@@ -1652,9 +1678,11 @@ class AbilityDSLLexer {
         'true',
         'false',
         'null',
+        'defined',
         'contains',
         'includes',
         'length',
+        'len',
         'has',
         'in',
         'gt',
@@ -1868,11 +1896,11 @@ class AbilityDSLLexer {
         const startLine = this.line;
         const startColumn = this.column;
         const start = this.pos;
-        // Первый сегмент
+        // First segment
         while (!this.isAtEnd() && /[a-zA-Z0-9_*]/.test(this.peek())) {
             this.advance();
         }
-        // Сегменты через точку
+        // dots segments
         while (!this.isAtEnd() && this.peek() === '.') {
             this.advance(); // dot
             if (!/[a-zA-Z_*]/.test(this.peek())) {
@@ -1889,7 +1917,7 @@ class AbilityDSLLexer {
         if (word === 'never') {
             return new AbilityDSLToken(TokenTypes.NEVER, word, startLine, startColumn);
         }
-        // Если есть точка — это путь (identifier или permission)
+        // (identifier or permission)
         if (word.includes('.')) {
             const last = this.tokens[this.tokens.length - 1];
             if (last?.type === TokenTypes.EFFECT) {
@@ -1899,16 +1927,13 @@ class AbilityDSLLexer {
             }
             return new AbilityDSLToken(TokenTypes.IDENTIFIER, word, startLine, startColumn);
         }
-        // Ключевые слова
         if (this.keywords.has(word)) {
-            // Эффекты
             if (word === 'permit' || word === 'allow') {
                 return new AbilityDSLToken(TokenTypes.EFFECT, 'permit', startLine, startColumn);
             }
             if (word === 'deny' || word === 'forbidden') {
                 return new AbilityDSLToken(TokenTypes.EFFECT, 'deny', startLine, startColumn);
             }
-            // Групповые ключевые слова
             if (word === 'all') {
                 return new AbilityDSLToken(TokenTypes.ALL, word, startLine, startColumn);
             }
@@ -1921,13 +1946,15 @@ class AbilityDSLLexer {
             if (word === 'if') {
                 return new AbilityDSLToken(TokenTypes.IF, word, startLine, startColumn);
             }
-            // Булевы и null
             if (word === 'true' || word === 'false') {
                 return new AbilityDSLToken(TokenTypes.BOOLEAN, word, startLine, startColumn);
             }
             if (word === 'null') {
                 return new AbilityDSLToken(TokenTypes.NULL, word, startLine, startColumn);
             }
+            if (word === 'defined') {
+                return new AbilityDSLToken(TokenTypes.DEFINED, word, startLine, startColumn);
+            }
             if (word === 'except') {
                 return new AbilityDSLToken(TokenTypes.EXCEPT, word, startLine, startColumn);
             }
@@ -2079,7 +2106,8 @@ class AbilityDSLTokenStream {
         if (this.eof()) {
             return false;
         }
-        return this.peek().type === type;
+        const p = this.peek().type;
+        return p === type;
     }
     match(type) {
         if (this.check(type)) {
@@ -2515,6 +2543,7 @@ class AbilityDSLParser {
         const operatorConsumesValue = operator !== TokenTypes.EQ_NULL &&
             operator !== TokenTypes.NOT_EQ_NULL &&
             operator !== TokenTypes.NULL &&
+            operator !== TokenTypes.DEFINED &&
             operator !== TokenTypes.ALWAYS &&
             operator !== TokenTypes.NEVER;
         if (operatorConsumesValue) {
@@ -2567,42 +2596,46 @@ class AbilityDSLParser {
         this.stream.reset();
         // "length equals"
         this.stream.mark();
-        if (this.matchWord('length') && this.matchWord('equals')) {
+        if ((this.matchWord('length') || this.matchWord('len')) && this.matchWord('equals')) {
             this.stream.commit();
             return { condition: AbilityCondition.length_equals, operator: TokenTypes.LEN_EQ };
         }
         this.stream.reset();
         // "length ="
         this.stream.mark();
-        if (this.matchWord('length') && this.matchSymbol('=')) {
+        if ((this.matchWord('length') || this.matchWord('len')) && this.matchSymbol('=')) {
             this.stream.commit();
             return { condition: AbilityCondition.length_equals, operator: TokenTypes.LEN_EQ };
         }
         this.stream.reset();
         // "length greater than"
         this.stream.mark();
-        if (this.matchWord('length') && this.matchWord('greater') && this.matchWord('than')) {
+        if ((this.matchWord('length') || this.matchWord('len')) &&
+            this.matchWord('greater') &&
+            this.matchWord('than')) {
             this.stream.commit();
             return { condition: AbilityCondition.length_greater_than, operator: TokenTypes.LEN_GT };
         }
         this.stream.reset();
         // "length >"
         this.stream.mark();
-        if (this.matchWord('length') && this.matchSymbol('>')) {
+        if ((this.matchWord('length') || this.matchWord('len')) && this.matchSymbol('>')) {
             this.stream.commit();
             return { condition: AbilityCondition.length_greater_than, operator: TokenTypes.LEN_GT };
         }
         this.stream.reset();
         // "length less than"
         this.stream.mark();
-        if (this.matchWord('length') && this.matchWord('less') && this.matchWord('than')) {
+        if ((this.matchWord('length') || this.matchWord('len')) &&
+            this.matchWord('less') &&
+            this.matchWord('than')) {
             this.stream.commit();
             return { condition: AbilityCondition.length_less_than, operator: TokenTypes.LEN_LT };
         }
         this.stream.reset();
         // "length <"
         this.stream.mark();
-        if (this.matchWord('length') && this.matchSymbol('<')) {
+        if ((this.matchWord('length') || this.matchWord('len')) && this.matchSymbol('<')) {
             this.stream.commit();
             return { condition: AbilityCondition.length_less_than, operator: TokenTypes.LEN_LT };
         }
@@ -2730,6 +2763,20 @@ class AbilityDSLParser {
             }
         }
         this.stream.reset();
+        // is defined
+        this.stream.mark();
+        if (this.matchWord('is') && this.matchWord('defined')) {
+            this.stream.commit();
+            return { condition: AbilityCondition.defined, operator: TokenTypes.DEFINED };
+        }
+        this.stream.reset();
+        // is not defined
+        this.stream.mark();
+        if (this.matchWord('is') && this.matchWord('not') && this.matchWord('defined')) {
+            this.stream.commit();
+            return { condition: AbilityCondition.not_defined, operator: TokenTypes.DEFINED };
+        }
+        this.stream.reset();
         // Single token (symbol or keyword)
         const token = this.stream.peek();
         if (token.type !== TokenTypes.SYMBOL &&
@@ -2801,7 +2848,8 @@ class AbilityDSLParser {
         if ((token.type === TokenTypes.KEYWORD ||
             token.type === TokenTypes.IDENTIFIER ||
             token.type === TokenTypes.ALWAYS ||
-            token.type === TokenTypes.NEVER) &&
+            token.type === TokenTypes.NEVER ||
+            token.type === TokenTypes.DEFINED) &&
             token.value === word) {
             this.stream.next();
             return true;
@@ -2839,6 +2887,11 @@ class AbilityDSLParser {
             this.stream.syntaxError(`Unexpected ${token.type} in value position`, token);
         }
         this.stream.next();
+        // if (token.type === TokenTypes.IDENTIFIER) {
+        //   this.stream.next();
+        //
+        //   return this.parseValue();
+        // }
         // CHECK THIS SWITCH COMPARE
         switch (token.type) {
             case TokenTypes.STRING:
@@ -2849,8 +2902,10 @@ class AbilityDSLParser {
                 return token.value === 'true';
             case TokenTypes.NULL:
                 return null;
+            case TokenTypes.DEFINED:
+                return typeof token.value !== 'undefined';
             case TokenTypes.IDENTIFIER:
-                return token.value;
+                return null;
             default: {
                 this.stream.syntaxError(`Unexpected value token "${token.value}"`, token, [
                     TokenTypes.KEYWORD,

package/dist/index.d.ts

@@ -7,13 +7,15 @@ declare const AbilityCompare: {
     readonly and: AbilityCompareType;
 };
 
-type AbilityConditionCode = '=' | '<>' | '>' | '<' | '>=' | '<=' | 'in' | 'not in' | 'contains' | 'not contains' | 'length greater than' | 'length less than' | 'length equals' | 'always' | 'never';
-type AbilityConditionLiteral = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'in' | 'not_in' | 'greater_than' | 'less_than' | 'less_or_equal' | 'greater_or_equal' | 'length_greater_than' | 'length_less_than' | 'length_equals' | 'always' | 'never';
+type AbilityConditionCode = '=' | '<>' | '>' | '<' | '>=' | '<=' | 'in' | 'not in' | 'contains' | 'not contains' | 'length greater than' | 'length less than' | 'length equals' | 'always' | 'never' | 'defined' | 'not_defined';
+type AbilityConditionLiteral = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'in' | 'not_in' | 'greater_than' | 'less_than' | 'less_or_equal' | 'greater_or_equal' | 'length_greater_than' | 'length_less_than' | 'length_equals' | 'always' | 'never' | 'defined' | 'not_defined';
 type AbilityConditionType = AbilityConditionCode & {
     __brand: 'AbilityCondition';
 };
 declare const AbilityCondition: {
     readonly equals: AbilityConditionType;
+    readonly defined: AbilityConditionType;
+    readonly not_defined: AbilityConditionType;
     readonly not_equals: AbilityConditionType;
     readonly greater_than: AbilityConditionType;
     readonly less_than: AbilityConditionType;
@@ -438,7 +440,7 @@ declare abstract class AbilityStrategy<Resource extends ResourceObject = Record<
 
 declare class AbilityResult<R extends ResourceObject = Record<string, unknown>, E extends EnvironmentObject = Record<string, unknown>> {
     protected readonly effect: AbilityPolicyEffectType;
-    protected readonly strategy: AbilityStrategy<R, E>;
+    readonly strategy: AbilityStrategy<R, E>;
     constructor(effect: AbilityPolicyEffectType, strategy: AbilityStrategy<R, E>);
     /**
      * Returns a list of explanations for each policy involved in the ability evaluation.
@@ -455,13 +457,23 @@ declare class AbilityResult<R extends ResourceObject = Record<string, unknown>,
 
 interface AbilityResolverOptions<TTags extends string> {
     tags?: readonly TTags[];
+    readonly onDeny?: EnforceOnDeny;
+    readonly onAllow?: EnforceOnAllow;
 }
 type ExtractResources<P> = P extends AbilityPolicy<infer R, any, any> ? R : never;
 type ExtractEnvironment<P> = P extends AbilityPolicy<any, infer E, any> ? E : never;
 type ExtractPermission<R> = R extends AbilityResolver<infer P, any, any> ? keyof ExtractResources<P> & string : never;
 type ExtractResourceByPermission<P, Perm extends string> = P extends AbilityPolicy<infer R, any, any> ? (Perm extends keyof R ? R[Perm] : never) : never;
 type ExtractEnvironmentByPermission<P, Perm extends string> = P extends AbilityPolicy<any, infer E, any> ? (Perm extends keyof E ? E[Perm] : never) : never;
+type EnforceOptions<R extends ResourceObject = Record<string, unknown>, E extends EnvironmentObject = Record<string, unknown>> = {
+    readonly onDeny?: EnforceOnDeny<R, E>;
+    readonly onAllow?: EnforceOnDeny<R, E>;
+};
+type EnforceOnDeny<R extends ResourceObject = Record<string, unknown>, E extends EnvironmentObject = Record<string, unknown>> = (result: AbilityResult<R, E>) => void;
+type EnforceOnAllow<R extends ResourceObject = Record<string, unknown>, E extends EnvironmentObject = Record<string, unknown>> = (result: AbilityResult<R, E>) => void;
 declare class AbilityResolver<P extends AbilityPolicy<any, any, any>, S extends AbilityStrategy<P extends AbilityPolicy<infer R, infer E, any> ? R : never, P extends AbilityPolicy<any, infer E, any> ? E : never>, TTags extends string = P extends AbilityPolicy<any, any, infer T> ? T : never> {
+    private readonly onDeny?;
+    private readonly onAllow?;
     private readonly StrategyClass;
     private readonly policyEntries;
     constructor(
@@ -477,7 +489,7 @@ declare class AbilityResolver<P extends AbilityPolicy<any, any, any>, S extends
      * @param environment
      */
     resolve<Permission extends keyof ExtractResources<P> & string>(permission: Permission, resource: ExtractResourceByPermission<P, Permission>, environment?: ExtractEnvironmentByPermission<P, Permission>): AbilityResult<ExtractResourceByPermission<P, Permission>, ExtractEnvironment<P>>;
-    enforce<Permission extends keyof ExtractResources<P> & string>(permission: Permission, resource: ExtractResourceByPermission<P, Permission>, environment?: ExtractEnvironmentByPermission<P, Permission>): void | never;
+    enforce<Permission extends keyof ExtractResources<P> & string>(permission: Permission, resource: ExtractResourceByPermission<P, Permission>, environment?: ExtractEnvironmentByPermission<P, Permission>, options?: EnforceOptions): void | never;
     /**
      * @deprecated - will be removed
      *
@@ -590,7 +602,7 @@ declare class AbilityDSLParser<R extends ResourceObject = Record<string, unknown
     private isStartOfAlias;
 }
 
-type TokenTypeCode = 'EFFECT' | 'IF' | 'PERMISSION' | 'IDENTIFIER' | 'COLON' | 'COMMA' | 'DOT' | 'LBRACKET' | 'RBRACKET' | 'ALL' | 'ANY' | 'OF' | 'EOF' | 'COMMENT' | 'EQ' | 'CONTAINS' | 'IN' | 'NOT_IN' | 'NOT_CONTAINS' | 'GT' | 'GTE' | 'LT' | 'LTE' | 'NULL' | 'EQ_NULL' | 'NOT_EQ_NULL' | 'NOT_EQ' | 'LEN_GT' | 'LEN_LT' | 'LEN_EQ' | 'ALWAYS' | 'NEVER' | 'EXCEPT' | 'ANNOTATION' | 'STRING' | 'NUMBER' | 'BOOLEAN' | 'SYMBOL' | 'KEYWORD' | 'ALIAS' | 'UNKNOWN';
+type TokenTypeCode = 'EFFECT' | 'IF' | 'PERMISSION' | 'IDENTIFIER' | 'COLON' | 'COMMA' | 'DOT' | 'LBRACKET' | 'RBRACKET' | 'ALL' | 'ANY' | 'OF' | 'EOF' | 'COMMENT' | 'EQ' | 'CONTAINS' | 'IN' | 'NOT_IN' | 'NOT_CONTAINS' | 'GT' | 'GTE' | 'LT' | 'LTE' | 'NULL' | 'EQ_NULL' | 'NOT_EQ_NULL' | 'DEFINED' | 'NOT_EQ' | 'LEN_GT' | 'LEN_LT' | 'LEN_EQ' | 'ALWAYS' | 'NEVER' | 'EXCEPT' | 'ANNOTATION' | 'STRING' | 'NUMBER' | 'BOOLEAN' | 'SYMBOL' | 'KEYWORD' | 'ALIAS' | 'UNKNOWN';
 type TokenType = TokenTypeCode & {
     __brand: 'TokenType';
 };
@@ -621,6 +633,7 @@ declare const TokenTypes: {
     readonly NULL: TokenType;
     readonly EQ_NULL: TokenType;
     readonly NOT_EQ_NULL: TokenType;
+    readonly DEFINED: TokenType;
     readonly NOT_EQ: TokenType;
     readonly LEN_GT: TokenType;
     readonly LEN_LT: TokenType;
@@ -858,4 +871,4 @@ declare class PriorityStrategy<R extends ResourceObject, E extends EnvironmentOb
 }
 
 export { AbilityCompare, AbilityCondition, AbilityDSLLexer, AbilityDSLParser, AbilityDSLToken, AbilityError, AbilityExplain, AbilityExplainPolicy, AbilityExplainRule, AbilityExplainRuleSet, AbilityJSONParser, AbilityMatch, AbilityParserError, AbilityPolicy, AbilityPolicyEffect, AbilityResolver, AbilityResult, AbilityRule, AbilityRuleSet, AbilityStrategy, AbilityTypeGenerator, AllMustPermitStrategy, AnyPermitStrategy, DenyOverridesStrategy, FirstMatchStrategy, OnlyOneApplicableStrategy, PermitOverridesStrategy, PriorityStrategy, SequentialLastMatchStrategy, TokenTypes, ability, fromLiteral, isConditionEqual, isConditionNotEqual, toLiteral };
-export type { AbilityCompareType, AbilityConditionCode, AbilityConditionLiteral, AbilityConditionType, AbilityExplainConfig, AbilityExplainType, AbilityMatchType, AbilityPolicyConfig, AbilityPolicyConstructorProps, AbilityPolicyEffectType, AbilityResolverOptions, AbilityRuleConfig, AbilityRuleConstructorProps, AbilityRuleSetConfig, AbilityRuleSetConstructorProps, EnvironmentObject, ExtractEnvironment, ExtractEnvironmentByPermission, ExtractPermission, ExtractResourceByPermission, ExtractResources, NestedDict, Primitive, ResourceObject, ResourcesMap, TokenType, TokenTypeCode };
+export type { AbilityCompareType, AbilityConditionCode, AbilityConditionLiteral, AbilityConditionType, AbilityExplainConfig, AbilityExplainType, AbilityMatchType, AbilityPolicyConfig, AbilityPolicyConstructorProps, AbilityPolicyEffectType, AbilityResolverOptions, AbilityRuleConfig, AbilityRuleConstructorProps, AbilityRuleSetConfig, AbilityRuleSetConstructorProps, EnforceOnAllow, EnforceOnDeny, EnforceOptions, EnvironmentObject, ExtractEnvironment, ExtractEnvironmentByPermission, ExtractPermission, ExtractResourceByPermission, ExtractResources, NestedDict, Primitive, ResourceObject, ResourcesMap, TokenType, TokenTypeCode };