@elsikora/nestjs-crud-automator 2.0.2-dev.1 → 2.0.3-dev.1

package/dist/cjs/decorator/api/route-custom.decorator.d.ts

@@ -1,5 +1,5 @@
-import type { IApiBaseEntity } from '../../src/interface/api-base-entity.interface';
-import type { IApiRouteCustomProperties } from '../../src/interface/decorator/api/index';
+import { IApiBaseEntity } from '../../interface/api-base-entity.interface';
+import { IApiRouteCustomProperties } from '../../interface/decorator/api';
 /**
  * Creates a custom API route with metadata, runtime properties, and route runtime interception.
  * @template E - Entity type represented by the custom route metadata.

package/dist/cjs/decorator/api/service/decorator.d.ts

@@ -1,5 +1,5 @@
-import type { IApiBaseEntity } from '../../../src/interface/api-base-entity.interface';
-import type { TApiServiceProperties } from '../../../src/type/decorator/api/service/index';
+import { IApiBaseEntity } from '../../../interface/api-base-entity.interface';
+import { TApiServiceProperties } from '../../../type/decorator/api/service';
 /**
  * Creates a class decorator that adds CRUD operations to a service class for a specific entity
  * @param {TApiServiceProperties<E>} properties - Configuration properties for the service

package/dist/cjs/decorator/api/service/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./decorator";
-export * from "./observable.decorator";
+export * from './decorator';
+export * from './observable.decorator';

package/dist/cjs/decorator/api/subscriber/function.decorator.d.ts

@@ -1,5 +1,5 @@
-import type { IApiBaseEntity } from '../../../src/interface/api-base-entity.interface';
-import type { IApiFunctionSubscriberProperties } from '../../../src/interface/decorator/api/subscriber/index';
+import { IApiBaseEntity } from '../../../interface/api-base-entity.interface';
+import { IApiFunctionSubscriberProperties } from '../../../interface/decorator/api/subscriber';
 /**
  * Decorator for creating a new subscriber that listens to and intercepts events from a service.
  * It allows you to create a subscriber and link it to a specific entity.

package/dist/cjs/decorator/api/subscriber/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./function.decorator";
-export * from "./route.decorator";
+export * from './function.decorator';
+export * from './route.decorator';

package/dist/cjs/decorator/api/subscriber/route.decorator.d.ts

@@ -1,5 +1,5 @@
-import type { IApiBaseEntity } from '../../../src/interface/api-base-entity.interface';
-import type { IApiRouteSubscriberProperties } from '../../../src/interface/decorator/api/subscriber/index';
+import { IApiBaseEntity } from '../../../interface/api-base-entity.interface';
+import { IApiRouteSubscriberProperties } from '../../../interface/decorator/api/subscriber';
 /**
  * Decorator for creating a new subscriber that listens to and intercepts events from a controller.
  * It allows you to create a subscriber and link it to a specific entity.

package/dist/cjs/decorator/index.d.ts

@@ -1 +1 @@
-export * from "./api";
+export * from './api';

package/dist/cjs/enum/class/authorization/index.d.ts

@@ -1,6 +1,6 @@
-export { EApiAuthorizationDecisionType } from "./decision-type.enum";
-export { EApiPolicyEffect } from "./effect.enum";
-export { EApiAuthorizationMode } from "./mode.enum";
-export { EApiAuthorizationPermissionMatch } from "./permission-match.enum";
-export * from "./policy";
-export { EApiAuthorizationPrincipalType } from "./principal-type.enum";
+export { EApiAuthorizationDecisionType } from './decision-type.enum';
+export { EApiPolicyEffect } from './effect.enum';
+export { EApiAuthorizationMode } from './mode.enum';
+export { EApiAuthorizationPermissionMatch } from './permission-match.enum';
+export * from './policy';
+export { EApiAuthorizationPrincipalType } from './principal-type.enum';

package/dist/cjs/enum/class/authorization/policy/index.d.ts

@@ -1,4 +1,4 @@
-export { EApiPolicyAttachmentType } from "./attachment-type.enum";
-export { EApiPolicyOnType } from "./on-type.enum";
-export { EApiPolicySourceType } from "./source-type.enum";
-export { EApiPolicyStatus } from "./status.enum";
+export { EApiPolicyAttachmentType } from './attachment-type.enum';
+export { EApiPolicyOnType } from './on-type.enum';
+export { EApiPolicySourceType } from './source-type.enum';
+export { EApiPolicyStatus } from './status.enum';

package/dist/cjs/enum/class/index.d.ts

@@ -1 +1 @@
-export * from "./authorization";
+export * from './authorization';

package/dist/cjs/enum/decorator/api/controller/index.d.ts

@@ -1,4 +1,4 @@
-export { EApiControllerLoadRelationsStrategy } from "./load-relations-strategy.enum";
-export { EApiControllerRelationReferenceShape } from "./relation-reference-shape.enum";
-export * from "./request";
-export { EApiControllerResponseTarget } from "./response-target.enum";
+export { EApiControllerLoadRelationsStrategy } from './load-relations-strategy.enum';
+export { EApiControllerRelationReferenceShape } from './relation-reference-shape.enum';
+export * from './request';
+export { EApiControllerResponseTarget } from './response-target.enum';

package/dist/cjs/enum/decorator/api/controller/request/index.d.ts

@@ -1,2 +1,2 @@
-export { EApiControllerRequestTarget } from "./target.enum";
-export { EApiControllerRequestTransformerType } from "./transformer-type.enum";
+export { EApiControllerRequestTarget } from './target.enum';
+export { EApiControllerRequestTransformerType } from './transformer-type.enum';

package/dist/cjs/enum/decorator/api/index.d.ts

@@ -1,9 +1,9 @@
-export * from "./action.enum";
-export * from "./authentication-type.enum";
-export * from "./controller";
-export * from "./dto-type.enum";
-export { EApiFunctionTransactionMode } from "./function-transaction-mode.enum";
-export { EApiFunctionType } from "./function-type.enum";
-export * from "./on-type.enum";
-export * from "./property";
-export * from "./route-type.enum";
+export * from './action.enum';
+export * from './authentication-type.enum';
+export * from './controller';
+export * from './dto-type.enum';
+export { EApiFunctionTransactionMode } from './function-transaction-mode.enum';
+export { EApiFunctionType } from './function-type.enum';
+export * from './on-type.enum';
+export * from './property';
+export * from './route-type.enum';

package/dist/cjs/enum/decorator/api/property/date/index.d.ts

@@ -1,2 +1,2 @@
-export { EApiPropertyDateIdentifier } from "./identifier.enum";
-export { EApiPropertyDateType } from "./type.enum";
+export { EApiPropertyDateIdentifier } from './identifier.enum';
+export { EApiPropertyDateType } from './type.enum';

package/dist/cjs/enum/decorator/api/property/index.d.ts

@@ -1,5 +1,5 @@
-export { EApiPropertyDataType } from "./data-type.enum";
-export * from "./date";
-export { EApiPropertyDescribeType } from "./desribe-type.enum";
-export { EApiPropertyNumberType } from "./number-type.enum";
-export { EApiPropertyStringType } from "./string-type.enum";
+export { EApiPropertyDataType } from './data-type.enum';
+export * from './date';
+export { EApiPropertyDescribeType } from './desribe-type.enum';
+export { EApiPropertyNumberType } from './number-type.enum';
+export { EApiPropertyStringType } from './string-type.enum';

package/dist/cjs/enum/decorator/index.d.ts

@@ -1 +1 @@
-export * from "./api";
+export * from './api';

package/dist/cjs/enum/filter/index.d.ts

@@ -1,2 +1,2 @@
-export { EFilterOperation, EFilterOperationArray, EFilterOperationBoolean, EFilterOperationDate, EFilterOperationEnum, EFilterOperationNumber, EFilterOperationObject, EFilterOperationRelation, EFilterOperationString, EFilterOperationUuid } from "./operation.enum";
-export { EFilterOrderDirection } from "./order-direction.enum";
+export { EFilterOperation, EFilterOperationArray, EFilterOperationBoolean, EFilterOperationDate, EFilterOperationEnum, EFilterOperationNumber, EFilterOperationObject, EFilterOperationRelation, EFilterOperationString, EFilterOperationUuid } from './operation.enum';
+export { EFilterOrderDirection } from './order-direction.enum';

package/dist/cjs/enum/index.d.ts

@@ -1,6 +1,6 @@
-export * from "./class/authorization";
-export * from "./decorator/api";
-export { EException } from "./exception.enum";
-export * from "./filter";
-export * from "./utility";
-export * from "./validator";
+export * from './class/authorization';
+export * from './decorator/api';
+export { EException } from './exception.enum';
+export * from './filter';
+export * from './utility';
+export * from './validator';

package/dist/cjs/enum/utility/error-string/index.d.ts

@@ -1,2 +1,2 @@
-export { EErrorStringAction } from "./action.enum";
-export { EErrorStringCompositeAction } from "./composite-action.enum";
+export { EErrorStringAction } from './action.enum';
+export { EErrorStringCompositeAction } from './composite-action.enum';

package/dist/cjs/enum/utility/index.d.ts

@@ -1,3 +1,3 @@
-export { EManualDtoPropertyMetadataDecorator } from "./dto/manual/property-metadata/decorator.enum";
-export * from "./error-string";
-export { EApiExceptionDetailsType } from "./exception-details-type.enum";
+export { EManualDtoPropertyMetadataDecorator } from './dto/manual/property-metadata/decorator.enum';
+export * from './error-string';
+export { EApiExceptionDetailsType } from './exception-details-type.enum';

package/dist/cjs/enum/validator/index.d.ts

@@ -1,2 +1,2 @@
-export { EHasPairedCustomSuffixesFieldsArgumentType } from "./has-paired-custom-suffixes-fields-argument-type.enum";
-export { EMastMatchOneOfSchemasValidationErrorType } from "./must-match-one-of-schemas-error-type.enum";
+export { EHasPairedCustomSuffixesFieldsArgumentType } from './has-paired-custom-suffixes-fields-argument-type.enum';
+export { EMastMatchOneOfSchemasValidationErrorType } from './must-match-one-of-schemas-error-type.enum';

package/dist/cjs/factory/api-controller.factory.d.ts

@@ -1,8 +1,8 @@
-import type { IApiBaseEntity } from '../src/interface/api-base-entity.interface';
-import type { IApiControllerProperties } from '../src/interface/decorator/api/index';
-import type { IApiEntity } from '../src/interface/entity/index';
-import type { TApiControllerMethodName, TApiControllerTargetMethod } from '../src/type/factory/api/controller/index';
-import { EApiRouteType } from '../src/enum/decorator/api/index';
+import { IApiBaseEntity } from '../interface/api-base-entity.interface';
+import { IApiControllerProperties } from '../interface/decorator/api';
+import { IApiEntity } from '../interface/entity';
+import { TApiControllerMethodName, TApiControllerTargetMethod } from '../type/factory/api/controller';
+import { EApiRouteType } from '../enum/decorator/api';
 export declare class ApiControllerFactory<E extends IApiBaseEntity> {
     protected target: TApiControllerTargetMethod<E>;
     private readonly properties;

package/dist/cjs/factory/index.d.ts

@@ -1 +1 @@
-export { ApiControllerFactory } from "./api-controller.factory";
+export { ApiControllerFactory } from './api-controller.factory';

package/dist/cjs/index.d.ts

@@ -1,11 +1,11 @@
-export * from "./class";
-export * from "./constant";
-export * from "./decorator/api";
-export * from "./enum";
-export * from "./factory";
-export * from "./interceptor";
-export type * from "./interface";
-export * from "./module";
-export type * from "./type";
-export * from "./utility";
-export * from "./validator";
+export * from './class';
+export * from './constant';
+export * from './decorator/api';
+export * from './enum';
+export * from './factory';
+export * from './interceptor';
+export type * from './interface';
+export * from './module';
+export type * from './type';
+export * from './utility';
+export * from './validator';

package/dist/cjs/index.js

@@ -14,10 +14,13 @@ var bootstrapValidation_service_class = require('./class/api/authorization/boots
 var cacheInvalidation_service_class = require('./class/api/authorization/cache-invalidation.service.class.js');
 var engine_class = require('./class/api/authorization/engine.class.js');
 var guard_class = require('./class/api/authorization/guard.class.js');
-var hookPermissionResolver_class = require('./class/api/authorization/hook-permission-resolver.class.js');
-var attachmentResolver_class = require('./class/api/authorization/iam/attachment-resolver.class.js');
-var documentResolver_class = require('./class/api/authorization/iam/document-resolver.class.js');
-var documentValidator_class = require('./class/api/authorization/iam/document-validator.class.js');
+var cache_class = require('./class/api/authorization/hook/permission/cache.class.js');
+var resolver_class = require('./class/api/authorization/hook/permission/resolver.class.js');
+var cache_class$1 = require('./class/api/authorization/iam/attachment/cache.class.js');
+var resolver_class$1 = require('./class/api/authorization/iam/attachment/resolver.class.js');
+var cache_class$2 = require('./class/api/authorization/iam/document/cache.class.js');
+var resolver_class$2 = require('./class/api/authorization/iam/document/resolver.class.js');
+var validator_class = require('./class/api/authorization/iam/document/validator.class.js');
 var engine_class$1 = require('./class/api/authorization/iam/engine.class.js');
 var queryPlanner_class = require('./class/api/authorization/iam/query-planner.class.js');
 var base_class = require('./class/api/authorization/policy/base.class.js');
@@ -244,21 +247,33 @@ Object.defineProperty(exports, "ApiAuthorizationGuard", {
 	enumerable: true,
 	get: function () { return guard_class.ApiAuthorizationGuard; }
 });
+Object.defineProperty(exports, "ApiAuthorizationHookPermissionCache", {
+	enumerable: true,
+	get: function () { return cache_class.ApiAuthorizationHookPermissionCache; }
+});
 Object.defineProperty(exports, "ApiAuthorizationHookPermissionResolver", {
 	enumerable: true,
-	get: function () { return hookPermissionResolver_class.ApiAuthorizationHookPermissionResolver; }
+	get: function () { return resolver_class.ApiAuthorizationHookPermissionResolver; }
+});
+Object.defineProperty(exports, "ApiAuthorizationIamAttachmentCache", {
+	enumerable: true,
+	get: function () { return cache_class$1.ApiAuthorizationIamAttachmentCache; }
 });
 Object.defineProperty(exports, "ApiAuthorizationIamAttachmentResolver", {
 	enumerable: true,
-	get: function () { return attachmentResolver_class.ApiAuthorizationIamAttachmentResolver; }
+	get: function () { return resolver_class$1.ApiAuthorizationIamAttachmentResolver; }
+});
+Object.defineProperty(exports, "ApiAuthorizationIamDocumentCache", {
+	enumerable: true,
+	get: function () { return cache_class$2.ApiAuthorizationIamDocumentCache; }
 });
 Object.defineProperty(exports, "ApiAuthorizationIamDocumentResolver", {
 	enumerable: true,
-	get: function () { return documentResolver_class.ApiAuthorizationIamDocumentResolver; }
+	get: function () { return resolver_class$2.ApiAuthorizationIamDocumentResolver; }
 });
 Object.defineProperty(exports, "ApiAuthorizationIamDocumentValidator", {
 	enumerable: true,
-	get: function () { return documentValidator_class.ApiAuthorizationIamDocumentValidator; }
+	get: function () { return validator_class.ApiAuthorizationIamDocumentValidator; }
 });
 Object.defineProperty(exports, "ApiAuthorizationIamEngine", {
 	enumerable: true,

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/interceptor/api-route-runtime.interceptor.d.ts

@@ -1,5 +1,5 @@
-import type { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
-import type { Observable } from "rxjs";
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
 export declare class ApiRouteRuntimeInterceptor implements NestInterceptor {
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
 }

package/dist/cjs/interceptor/correlation-id-response-body.interceptor.d.ts

@@ -1,5 +1,5 @@
-import type { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
-import type { Observable } from "rxjs";
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
 /**
  * Global interceptor that adds correlation IDs and timestamps to all error responses.
  * @see {@link https://elsikora.com/docs/nestjs-crud-automator/api-reference/interceptors | API Reference - Interceptors}

package/dist/cjs/interceptor/index.d.ts

@@ -1 +1 @@
-export { CorrelationIDResponseBodyInterceptor } from "./correlation-id-response-body.interceptor";
+export { CorrelationIDResponseBodyInterceptor } from './correlation-id-response-body.interceptor';

package/dist/cjs/interface/api/authentication-request.interface.d.ts

@@ -1,6 +1,6 @@
-import type { IApiBaseEntity } from '../../src/interface/api-base-entity.interface';
-import type { IApiAuthorizationDecision } from '../../src/interface/class/api/authorization/index';
-import type { TApiAuthorizationRuleTransformPayload } from '../../src/type/class/api/authorization/rule/transform-payload.type';
+import { IApiBaseEntity } from '../api-base-entity.interface';
+import { IApiAuthorizationDecision } from '../class/api/authorization';
+import { TApiAuthorizationRuleTransformPayload } from '../../type/class/api/authorization/rule/transform-payload.type';
 export interface IApiAuthenticationRequest {
     authorizationDecision?: IApiAuthorizationDecision<IApiBaseEntity, TApiAuthorizationRuleTransformPayload<IApiBaseEntity>>;
     user: unknown;

package/dist/cjs/interface/api/index.d.ts

@@ -1,3 +1,3 @@
-export { type IApiAuthenticationRequest } from "./authentication-request.interface";
-export { type IApiDtoValidator } from "./dto-validator.interface";
-export { type IApiRequestValidator } from "./request-validator.interface";
+export { type IApiAuthenticationRequest } from './authentication-request.interface';
+export { type IApiDtoValidator } from './dto-validator.interface';
+export { type IApiRequestValidator } from './request-validator.interface';

package/dist/cjs/interface/api/request-validator.interface.d.ts

@@ -1,6 +1,6 @@
-import type { EErrorStringAction } from '../../src/enum/utility/index';
-import type { TApiException } from '../../src/type/class/index';
-import type { TApiControllerGetListQuery } from '../../src/type/decorator/api/controller/index';
+import { EErrorStringAction } from '../../enum/utility';
+import { TApiException } from '../../type/class';
+import { TApiControllerGetListQuery } from '../../type/decorator/api/controller';
 export interface IApiRequestValidator<E> {
     errorType: EErrorStringAction;
     exception: TApiException;

package/dist/cjs/interface/api-base-entity.interface.d.ts

@@ -1,4 +1,4 @@
-import type { ObjectLiteral } from "typeorm";
+import { ObjectLiteral } from 'typeorm';
 export interface IApiBaseEntity extends ObjectLiteral {
     name?: string;
 }

package/dist/cjs/interface/class/api/authorization/audit-sink.interface.d.ts

@@ -1,5 +1,5 @@
-import type { IApiBaseEntity } from '../../../../src/interface/api-base-entity.interface';
-import type { IApiAuthorizationDecision } from "./decision";
+import { IApiBaseEntity } from '../../../api-base-entity.interface';
+import { IApiAuthorizationDecision } from './decision';
 export interface IApiAuthorizationAuditSink {
     record<E extends IApiBaseEntity, R>(decision: IApiAuthorizationDecision<E, R>): Promise<void> | void;
 }

package/dist/cjs/interface/class/api/authorization/decision/index.d.ts

@@ -1,4 +1,4 @@
-export { type IApiAuthorizationDecision } from "./interface";
-export { type IApiAuthorizationDecisionRuleTrace } from "./rule-trace.interface";
-export { type IApiAuthorizationDecisionStatementTrace } from "./statement-trace.interface";
-export { type IApiAuthorizationDecisionTrace } from "./trace.interface";
+export { type IApiAuthorizationDecision } from './interface';
+export { type IApiAuthorizationDecisionRuleTrace } from './rule-trace.interface';
+export { type IApiAuthorizationDecisionStatementTrace } from './statement-trace.interface';
+export { type IApiAuthorizationDecisionTrace } from './trace.interface';

package/dist/cjs/interface/class/api/authorization/decision/interface.d.ts

@@ -1,10 +1,10 @@
-import type { EApiAuthorizationMode, EApiPolicyEffect } from '../../../../../src/enum/class/authorization/index';
-import type { IApiBaseEntity } from '../../../../../src/interface/api-base-entity.interface';
-import type { IApiAuthorizationRule } from '../../../../../src/interface/class/api/authorization/rule/interface';
-import type { IApiAuthorizationScope } from '../../../../../src/interface/class/api/authorization/scope.interface';
-import type { TApiAuthorizationRuleResultTransform } from '../../../../../src/type/class/api/authorization/rule/result-transform.type';
-import type { IApiAuthorizationPrincipal } from "../principal/interface";
-import type { IApiAuthorizationDecisionTrace } from "./trace.interface";
+import { EApiAuthorizationMode, EApiPolicyEffect } from '../../../../../enum/class/authorization';
+import { IApiBaseEntity } from '../../../../api-base-entity.interface';
+import { IApiAuthorizationRule } from '../rule/interface';
+import { IApiAuthorizationScope } from '../scope.interface';
+import { TApiAuthorizationRuleResultTransform } from '../../../../../type/class/api/authorization/rule/result-transform.type';
+import { IApiAuthorizationPrincipal } from '../principal/interface';
+import { IApiAuthorizationDecisionTrace } from './trace.interface';
 export interface IApiAuthorizationDecision<E extends IApiBaseEntity, R> {
     action: string;
     appliedRules: Array<IApiAuthorizationRule<E, R>>;

package/dist/cjs/interface/class/api/authorization/decision/rule-trace.interface.d.ts

@@ -1,4 +1,4 @@
-import type { EApiPolicyEffect } from '../../../../../src/enum/class/authorization/index';
+import { EApiPolicyEffect } from '../../../../../enum/class/authorization';
 export interface IApiAuthorizationDecisionRuleTrace {
     description?: string;
     effect: EApiPolicyEffect;

package/dist/cjs/interface/class/api/authorization/decision/statement-trace.interface.d.ts

@@ -1,4 +1,4 @@
-import type { EApiPolicyEffect, EApiPolicySourceType } from '../../../../../src/enum/class/authorization/index';
+import { EApiPolicyEffect, EApiPolicySourceType } from '../../../../../enum/class/authorization';
 export interface IApiAuthorizationDecisionStatementTrace {
     effect: EApiPolicyEffect;
     isMatched: boolean;

package/dist/cjs/interface/class/api/authorization/decision/trace.interface.d.ts

@@ -1,8 +1,8 @@
-import type { EApiAuthorizationDecisionType, EApiAuthorizationMode } from '../../../../../src/enum/class/authorization/index';
-import type { IApiPolicyAttachment } from "../policy/attachment/interface";
-import type { IApiPolicyDocumentRecord } from "../policy/document/record.interface";
-import type { IApiAuthorizationDecisionRuleTrace } from "./rule-trace.interface";
-import type { IApiAuthorizationDecisionStatementTrace } from "./statement-trace.interface";
+import { EApiAuthorizationDecisionType, EApiAuthorizationMode } from '../../../../../enum/class/authorization';
+import { IApiPolicyAttachment } from '../policy/attachment/interface';
+import { IApiPolicyDocumentRecord } from '../policy/document/record.interface';
+import { IApiAuthorizationDecisionRuleTrace } from './rule-trace.interface';
+import { IApiAuthorizationDecisionStatementTrace } from './statement-trace.interface';
 export interface IApiAuthorizationDecisionTrace {
     attachments?: ReadonlyArray<IApiPolicyAttachment>;
     boundaries?: ReadonlyArray<IApiPolicyAttachment>;

package/dist/cjs/interface/class/api/authorization/engine.interface.d.ts

@@ -1,6 +1,6 @@
-import type { IApiBaseEntity } from '../../../../src/interface/api-base-entity.interface';
-import type { IApiAuthorizationDecision } from '../../../../src/interface/class/api/authorization/decision/index';
-import type { IApiAuthorizationEngineEvaluateOptions } from "./evaluate-options.interface";
+import { IApiBaseEntity } from '../../../api-base-entity.interface';
+import { IApiAuthorizationDecision } from './decision';
+import { IApiAuthorizationEngineEvaluateOptions } from './evaluate-options.interface';
 export interface IApiAuthorizationEngine<E extends IApiBaseEntity> {
     evaluate<R>(options: IApiAuthorizationEngineEvaluateOptions<E, R>): Promise<IApiAuthorizationDecision<E, R>>;
 }

package/dist/cjs/interface/class/api/authorization/evaluate-options.interface.d.ts

@@ -1,7 +1,7 @@
-import type { EApiAuthorizationMode } from '../../../../src/enum/class/authorization/index';
-import type { IApiBaseEntity } from '../../../../src/interface/api-base-entity.interface';
-import type { IApiAuthorizationPolicy } from '../../../../src/interface/class/api/authorization/policy/interface';
-import type { IApiAuthorizationPrincipal } from '../../../../src/interface/class/api/authorization/principal/index';
+import { EApiAuthorizationMode } from '../../../../enum/class/authorization';
+import { IApiBaseEntity } from '../../../api-base-entity.interface';
+import { IApiAuthorizationPolicy } from './policy/interface';
+import { IApiAuthorizationPrincipal } from './principal';
 export interface IApiAuthorizationEngineEvaluateOptions<E extends IApiBaseEntity, R> {
     action: string;
     mode: EApiAuthorizationMode;

package/dist/cjs/interface/class/api/authorization/hook-permission-source.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IApiAuthorizationPrincipal } from "./principal";
+import { IApiAuthorizationPrincipal } from './principal';
 export interface IApiHookPermissionSource {
     getPermissions(principal: IApiAuthorizationPrincipal): Promise<ReadonlyArray<string>>;
 }

package/dist/cjs/interface/class/api/authorization/iam-module-options.interface.d.ts

@@ -1,5 +1,5 @@
-import type { IApiPolicyAttachmentSource } from "./policy/attachment";
-import type { IApiPolicyDocumentSource } from "./policy/document";
+import { IApiPolicyAttachmentSource } from './policy/attachment';
+import { IApiPolicyDocumentSource } from './policy/document';
 export interface IApiAuthorizationIamModuleOptions {
     attachmentSources?: ReadonlyArray<IApiPolicyAttachmentSource>;
     documentSources?: ReadonlyArray<IApiPolicyDocumentSource>;

package/dist/cjs/interface/class/api/authorization/index.d.ts

@@ -1,13 +1,13 @@
-export { type IApiAuthorizationAuditSink } from "./audit-sink.interface";
-export type * from "./decision";
-export { type IApiAuthorizationEngine } from "./engine.interface";
-export { type IApiAuthorizationEngineEvaluateOptions } from "./evaluate-options.interface";
-export { type IApiHookPermissionSource } from "./hook-permission-source.interface";
-export { type IApiAuthorizationIamModuleOptions } from "./iam-module-options.interface";
-export type * from "./module-options";
-export type * from "./policy";
-export type * from "./principal";
-export { type IApiAuthorizationRequestMetadata } from "./request-metadata.interface";
-export type * from "./resource";
-export type * from "./rule";
-export { type IApiAuthorizationScope } from "./scope.interface";
+export { type IApiAuthorizationAuditSink } from './audit-sink.interface';
+export type * from './decision';
+export { type IApiAuthorizationEngine } from './engine.interface';
+export { type IApiAuthorizationEngineEvaluateOptions } from './evaluate-options.interface';
+export { type IApiHookPermissionSource } from './hook-permission-source.interface';
+export { type IApiAuthorizationIamModuleOptions } from './iam-module-options.interface';
+export type * from './module-options';
+export type * from './policy';
+export type * from './principal';
+export { type IApiAuthorizationRequestMetadata } from './request-metadata.interface';
+export type * from './resource';
+export type * from './rule';
+export { type IApiAuthorizationScope } from './scope.interface';

package/dist/cjs/interface/class/api/authorization/module-options/async.interface.d.ts

@@ -1,6 +1,6 @@
-import type { FactoryProvider, ModuleMetadata, Type } from "@nestjs/common";
-import type { IApiAuthorizationModuleOptionsFactory } from "./factory.interface";
-import type { IApiAuthorizationModuleOptions } from "./interface";
+import { FactoryProvider, ModuleMetadata, Type } from '@nestjs/common';
+import { IApiAuthorizationModuleOptionsFactory } from './factory.interface';
+import { IApiAuthorizationModuleOptions } from './interface';
 export interface IApiAuthorizationModuleAsyncOptions extends Pick<ModuleMetadata, "imports"> {
     inject?: FactoryProvider["inject"];
     useClass?: Type<IApiAuthorizationModuleOptionsFactory>;

package/dist/cjs/interface/class/api/authorization/module-options/factory.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IApiAuthorizationModuleOptions } from "./interface";
+import { IApiAuthorizationModuleOptions } from './interface';
 export interface IApiAuthorizationModuleOptionsFactory {
     createApiAuthorizationModuleOptions(): IApiAuthorizationModuleOptions | Promise<IApiAuthorizationModuleOptions>;
 }

package/dist/cjs/interface/class/api/authorization/module-options/index.d.ts

@@ -1,3 +1,3 @@
-export { type IApiAuthorizationModuleAsyncOptions } from "./async.interface";
-export { type IApiAuthorizationModuleOptionsFactory } from "./factory.interface";
-export { type IApiAuthorizationModuleOptions } from "./interface";
+export { type IApiAuthorizationModuleAsyncOptions } from './async.interface';
+export { type IApiAuthorizationModuleOptionsFactory } from './factory.interface';
+export { type IApiAuthorizationModuleOptions } from './interface';

package/dist/cjs/interface/class/api/authorization/module-options/interface.d.ts

@@ -1,6 +1,6 @@
-import type { IApiHookPermissionSource } from "../hook-permission-source.interface";
-import type { IApiAuthorizationIamModuleOptions } from "../iam-module-options.interface";
-import type { IApiAuthorizationPrincipalResolver } from "../principal";
+import { IApiHookPermissionSource } from '../hook-permission-source.interface';
+import { IApiAuthorizationIamModuleOptions } from '../iam-module-options.interface';
+import { IApiAuthorizationPrincipalResolver } from '../principal';
 export interface IApiAuthorizationModuleOptions {
     hookPermissionSources?: ReadonlyArray<IApiHookPermissionSource>;
     iam?: IApiAuthorizationIamModuleOptions;

package/dist/cjs/interface/class/api/authorization/policy/attachment/index.d.ts

@@ -1,3 +1,3 @@
-export { type IApiPolicyAttachment } from "./interface";
-export { type IApiResolvedPolicyAttachments } from "./resolved.interface";
-export { type IApiPolicyAttachmentSource } from "./source.interface";
+export { type IApiPolicyAttachment } from './interface';
+export { type IApiResolvedPolicyAttachments } from './resolved.interface';
+export { type IApiPolicyAttachmentSource } from './source.interface';

package/dist/cjs/interface/class/api/authorization/policy/attachment/interface.d.ts

@@ -1,4 +1,4 @@
-import type { EApiAuthorizationPrincipalType } from '../../../../../../src/enum/class/authorization/index';
+import { EApiAuthorizationPrincipalType } from '../../../../../../enum/class/authorization';
 export interface IApiPolicyAttachment {
     metadata?: Record<string, unknown>;
     policyId: string;

package/dist/cjs/interface/class/api/authorization/policy/attachment/resolved.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IApiPolicyAttachment } from "./interface";
+import { IApiPolicyAttachment } from './interface';
 export interface IApiResolvedPolicyAttachments {
     attachments: ReadonlyArray<IApiPolicyAttachment>;
     boundaries: ReadonlyArray<IApiPolicyAttachment>;

package/dist/cjs/interface/class/api/authorization/policy/attachment/source.interface.d.ts

@@ -1,5 +1,5 @@
-import type { IApiAuthorizationPrincipal } from "../../principal/interface";
-import type { IApiResolvedPolicyAttachments } from "./resolved.interface";
+import { IApiAuthorizationPrincipal } from '../../principal/interface';
+import { IApiResolvedPolicyAttachments } from './resolved.interface';
 export interface IApiPolicyAttachmentSource {
     getAttachments(principal: IApiAuthorizationPrincipal): Promise<IApiResolvedPolicyAttachments>;
 }