@nest-omni/core 3.1.2-8 → 4.1.2-9

package/audit/enums/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audit.enums"), exports);

package/audit/index.d.ts

@@ -0,0 +1,10 @@
+export * from './entities';
+export * from './enums';
+export * from './interfaces';
+export * from './dto';
+export * from './decorators';
+export * from './services';
+export * from './subscribers';
+export * from './interceptors';
+export * from './controllers';
+export * from './audit.module';

package/audit/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entities"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./dto"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./subscribers"), exports);
+__exportStar(require("./interceptors"), exports);
+__exportStar(require("./controllers"), exports);
+__exportStar(require("./audit.module"), exports);

package/audit/interceptors/audit.interceptor.d.ts

@@ -0,0 +1,12 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { AuditContextService } from '../services/audit-context.service';
+export declare class AuditInterceptor implements NestInterceptor {
+    private readonly contextService;
+    constructor(contextService: AuditContextService);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    private setRequestContext;
+    private handleError;
+    private isAuditEnabled;
+    private generateRequestId;
+}

package/audit/interceptors/audit.interceptor.js

@@ -0,0 +1,95 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const operators_1 = require("rxjs/operators");
+const crypto_1 = require("crypto");
+const audit_context_service_1 = require("../services/audit-context.service");
+const decorators_1 = require("../decorators");
+let AuditInterceptor = class AuditInterceptor {
+    constructor(contextService) {
+        this.contextService = contextService;
+    }
+    intercept(context, next) {
+        const request = context.switchToHttp().getRequest();
+        const handler = context.getHandler();
+        const controller = context.getClass();
+        if (!this.isAuditEnabled(controller, handler)) {
+            return next.handle();
+        }
+        this.setRequestContext(request);
+        return next.handle().pipe((0, operators_1.tap)(() => {
+        }), (0, operators_1.catchError)((error) => __awaiter(this, void 0, void 0, function* () {
+            yield this.handleError(error, request);
+            throw error;
+        })));
+    }
+    setRequestContext(request) {
+        var _a, _b, _c;
+        const user = request.user || {};
+        const auditContext = {
+            userId: user.uid || 'anonymous',
+            username: user.username || 'anonymous',
+            requestId: request.id || ((_a = request.headers) === null || _a === void 0 ? void 0 : _a['x-request-id']) || this.generateRequestId(),
+            requestIp: request.ip || ((_b = request.connection) === null || _b === void 0 ? void 0 : _b.remoteAddress),
+            userAgent: (_c = request.headers) === null || _c === void 0 ? void 0 : _c['user-agent'],
+            timestamp: new Date(),
+        };
+        this.contextService.setContext(auditContext);
+    }
+    handleError(error, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.contextService.setContext({
+                metadata: {
+                    error: {
+                        message: error.message,
+                        stack: error.stack,
+                        status: error.status,
+                    },
+                },
+            });
+        });
+    }
+    isAuditEnabled(controller, handler) {
+        try {
+            const controllerMetadata = Reflect.getMetadata(decorators_1.CONTROLLER_AUDIT_OPTIONS, controller);
+            if (controllerMetadata && controllerMetadata.enabled === false) {
+                return false;
+            }
+            const handlerMetadata = Reflect.getMetadata(decorators_1.METHOD_AUDIT_OPTIONS, handler);
+            if (handlerMetadata && handlerMetadata.enabled === false) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return true;
+        }
+    }
+    generateRequestId() {
+        return (0, crypto_1.randomBytes)(16).toString('hex');
+    }
+};
+exports.AuditInterceptor = AuditInterceptor;
+exports.AuditInterceptor = AuditInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [audit_context_service_1.AuditContextService])
+], AuditInterceptor);

package/audit/interceptors/index.d.ts

@@ -0,0 +1 @@
+export * from './audit.interceptor';

package/audit/interceptors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audit.interceptor"), exports);

package/audit/interfaces/audit.interfaces.d.ts

@@ -0,0 +1,119 @@
+import { AuditOperation, MaskingStrategy, RecordStrategy } from '../enums/audit.enums';
+export interface AuditContext {
+    userId?: string;
+    username?: string;
+    requestId?: string;
+    requestIp?: string;
+    userAgent?: string;
+    timestamp?: Date;
+    transactionId?: string;
+    metadata?: Record<string, any>;
+}
+export interface IAuditStrategy {
+    shouldRecord(entityType: string, operation: AuditOperation): boolean;
+    getRecordStrategy(entityType: string, operation: AuditOperation): RecordStrategy;
+    getFieldFilter(entityType: string): IFieldFilter;
+}
+export interface IFieldFilter {
+    shouldIncludeField(fieldName: string, path: string[]): boolean;
+    shouldMaskField(fieldName: string, path: string[]): boolean;
+    getMaskingStrategy(fieldName: string, path: string[]): MaskingStrategy;
+}
+export interface EntityDifference {
+    changes: Array<{
+        path: string[];
+        type: 'ADD' | 'REMOVE' | 'CHANGE';
+        oldValue: any;
+        newValue: any;
+    }>;
+    summary: {
+        added: number;
+        removed: number;
+        changed: number;
+    };
+}
+export interface RestoreOptions {
+    force?: boolean;
+    dryRun?: boolean;
+    excludeFields?: string[];
+    includeFields?: string[];
+    skipDependencies?: boolean;
+    connectionName?: string;
+}
+export interface RestoreResult {
+    success: boolean;
+    message?: string;
+    conflicts?: Array<{
+        field: string;
+        reason: string;
+        currentValue: any;
+        targetValue: any;
+    }>;
+    restoredEntities?: Array<{
+        entityType: string;
+        entityId: string;
+    }>;
+}
+export interface PreCheckResult {
+    canRestore: boolean;
+    conflicts: Array<{
+        field: string;
+        reason: string;
+        currentValue: any;
+        targetValue: any;
+    }>;
+    warnings: string[];
+}
+export interface BatchOperationResult {
+    total: number;
+    success: number;
+    failed: number;
+    errors: Array<{
+        index: number;
+        error: string;
+    }>;
+    results: any[];
+}
+export interface AuditConfig {
+    enabled?: boolean;
+    defaultStrategy?: RecordStrategy;
+    maxDiffDepth?: number;
+    maxDiffFields?: number;
+    connections?: {
+        audit?: string;
+        monitored?: string[];
+    };
+    entities?: Record<string, EntityAuditConfig>;
+    operations?: Record<string, OperationAuditConfig>;
+    security?: {
+        hashChainEnabled?: boolean;
+        hashAlgorithm?: string;
+        masking?: {
+            defaultStrategy?: MaskingStrategy;
+            strategies?: Record<string, MaskingStrategy>;
+        };
+    };
+}
+export interface EntityAuditConfig {
+    enabled?: boolean;
+    strategy?: RecordStrategy;
+    includeFields?: string[];
+    excludeFields?: string[];
+    maskFields?: string[];
+}
+export interface OperationAuditConfig {
+    enabled?: boolean;
+    strategy?: RecordStrategy;
+}
+export interface FieldDisplayOptions {
+    displayName?: string;
+    sensitive?: boolean;
+    formatter?: (value: any) => string;
+}
+export interface ControllerAuditOptions {
+    enabled?: boolean;
+    operations?: AuditOperation[];
+}
+export interface MethodAuditOptions {
+    enabled?: boolean;
+}

package/audit/interfaces/audit.interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/audit/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './audit.interfaces';

package/audit/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audit.interfaces"), exports);

package/audit/services/audit-context.service.d.ts

@@ -0,0 +1,10 @@
+import { ClsService } from 'nestjs-cls';
+import { AuditContext } from '../interfaces';
+export declare class AuditContextService {
+    private readonly cls;
+    constructor(cls: ClsService);
+    getCurrentContext(): Promise<AuditContext>;
+    setContext(context: Partial<AuditContext>): void;
+    clearContext(): void;
+    private getDefaultContext;
+}

package/audit/services/audit-context.service.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditContextService = void 0;
+const common_1 = require("@nestjs/common");
+const nestjs_cls_1 = require("nestjs-cls");
+let AuditContextService = class AuditContextService {
+    constructor(cls) {
+        this.cls = cls;
+    }
+    getCurrentContext() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cls.get('auditContext') || this.getDefaultContext();
+        });
+    }
+    setContext(context) {
+        const currentContext = this.cls.get('auditContext') || this.getDefaultContext();
+        this.cls.set('auditContext', Object.assign(Object.assign({}, currentContext), context));
+    }
+    clearContext() {
+        this.cls.set('auditContext', undefined);
+    }
+    getDefaultContext() {
+        return {
+            userId: 'system',
+            username: 'system',
+            requestId: '',
+            requestIp: '',
+            userAgent: '',
+            timestamp: new Date(),
+        };
+    }
+};
+exports.AuditContextService = AuditContextService;
+exports.AuditContextService = AuditContextService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [nestjs_cls_1.ClsService])
+], AuditContextService);

package/audit/services/audit-strategy.service.d.ts

@@ -0,0 +1,19 @@
+import { IAuditStrategy, IFieldFilter, AuditConfig } from '../interfaces';
+import { AuditOperation, RecordStrategy, MaskingStrategy } from '../enums';
+export declare class DefaultFieldFilter implements IFieldFilter {
+    private readonly includeFields?;
+    private readonly excludeFields?;
+    private readonly maskFields?;
+    constructor(includeFields?: string[], excludeFields?: string[], maskFields?: string[]);
+    shouldIncludeField(fieldName: string, path: string[]): boolean;
+    shouldMaskField(fieldName: string, path: string[]): boolean;
+    getMaskingStrategy(fieldName: string, path: string[]): MaskingStrategy;
+    private matchPattern;
+}
+export declare class DefaultAuditStrategy implements IAuditStrategy {
+    private readonly config?;
+    constructor(config?: AuditConfig);
+    shouldRecord(entityType: string, operation: AuditOperation): boolean;
+    getRecordStrategy(entityType: string, operation: AuditOperation): RecordStrategy;
+    getFieldFilter(entityType: string): IFieldFilter;
+}

package/audit/services/audit-strategy.service.js

@@ -0,0 +1,89 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultAuditStrategy = exports.DefaultFieldFilter = void 0;
+const common_1 = require("@nestjs/common");
+const enums_1 = require("../enums");
+class DefaultFieldFilter {
+    constructor(includeFields, excludeFields, maskFields) {
+        this.includeFields = includeFields;
+        this.excludeFields = excludeFields;
+        this.maskFields = maskFields;
+    }
+    shouldIncludeField(fieldName, path) {
+        const fullPath = [...path, fieldName].join('.');
+        if (this.includeFields && this.includeFields.length > 0) {
+            return this.includeFields.some((pattern) => this.matchPattern(fullPath, pattern));
+        }
+        if (this.excludeFields && this.excludeFields.length > 0) {
+            return !this.excludeFields.some((pattern) => this.matchPattern(fullPath, pattern));
+        }
+        return true;
+    }
+    shouldMaskField(fieldName, path) {
+        var _a;
+        const fullPath = [...path, fieldName].join('.');
+        return ((_a = this.maskFields) === null || _a === void 0 ? void 0 : _a.some((pattern) => this.matchPattern(fullPath, pattern))) || false;
+    }
+    getMaskingStrategy(fieldName, path) {
+        return enums_1.MaskingStrategy.MASK;
+    }
+    matchPattern(path, pattern) {
+        if (pattern.endsWith('*')) {
+            return path.startsWith(pattern.slice(0, -1));
+        }
+        return path === pattern;
+    }
+}
+exports.DefaultFieldFilter = DefaultFieldFilter;
+let DefaultAuditStrategy = class DefaultAuditStrategy {
+    constructor(config) {
+        this.config = config;
+    }
+    shouldRecord(entityType, operation) {
+        var _a, _b, _c, _d, _e;
+        const globalEnabled = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.enabled) !== false;
+        if (!globalEnabled)
+            return false;
+        const entityConfig = (_c = (_b = this.config) === null || _b === void 0 ? void 0 : _b.entities) === null || _c === void 0 ? void 0 : _c[entityType];
+        if (entityConfig && entityConfig.enabled === false)
+            return false;
+        const operationConfig = (_e = (_d = this.config) === null || _d === void 0 ? void 0 : _d.operations) === null || _e === void 0 ? void 0 : _e[operation];
+        if (operationConfig && operationConfig.enabled === false)
+            return false;
+        return true;
+    }
+    getRecordStrategy(entityType, operation) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const entityStrategy = (_c = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.entities) === null || _b === void 0 ? void 0 : _b[entityType]) === null || _c === void 0 ? void 0 : _c.strategy;
+        if (entityStrategy)
+            return entityStrategy;
+        const operationStrategy = (_f = (_e = (_d = this.config) === null || _d === void 0 ? void 0 : _d.operations) === null || _e === void 0 ? void 0 : _e[operation]) === null || _f === void 0 ? void 0 : _f.strategy;
+        if (operationStrategy)
+            return operationStrategy;
+        return ((_g = this.config) === null || _g === void 0 ? void 0 : _g.defaultStrategy) || enums_1.RecordStrategy.FULL;
+    }
+    getFieldFilter(entityType) {
+        var _a, _b;
+        const entityConfig = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.entities) === null || _b === void 0 ? void 0 : _b[entityType];
+        return new DefaultFieldFilter(entityConfig === null || entityConfig === void 0 ? void 0 : entityConfig.includeFields, entityConfig === null || entityConfig === void 0 ? void 0 : entityConfig.excludeFields, entityConfig === null || entityConfig === void 0 ? void 0 : entityConfig.maskFields);
+    }
+};
+exports.DefaultAuditStrategy = DefaultAuditStrategy;
+exports.DefaultAuditStrategy = DefaultAuditStrategy = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)('AUDIT_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], DefaultAuditStrategy);

package/audit/services/entity-audit.service.d.ts

@@ -0,0 +1,37 @@
+import { Repository, EntityManager } from 'typeorm';
+import { EntityAuditLogEntity, EntityTransactionEntity } from '../entities';
+import { AuditOperation } from '../enums';
+import { AuditConfig, IAuditStrategy, EntityDifference, RestoreOptions, RestoreResult, PreCheckResult } from '../interfaces';
+import { AuditContextService } from './audit-context.service';
+import { MultiDatabaseService } from './multi-database.service';
+import { PageDto } from '../../common/dto';
+import { AuditLogQueryDto } from '../dto';
+export declare class EntityAuditService {
+    private readonly auditLogRepository;
+    private readonly transactionRepository;
+    private readonly entityManager;
+    private readonly contextService;
+    private readonly multiDbService;
+    private readonly auditStrategy;
+    private readonly config?;
+    private readonly auditConnectionName;
+    constructor(auditLogRepository: Repository<EntityAuditLogEntity>, transactionRepository: Repository<EntityTransactionEntity>, entityManager: EntityManager, contextService: AuditContextService, multiDbService: MultiDatabaseService, auditStrategy?: IAuditStrategy, config?: AuditConfig, auditConnectionName?: string);
+    logEntityChange(entityType: string, entityId: string, operation: AuditOperation, oldValue: Record<string, any>, newValue: Record<string, any>, metadata?: Record<string, any>): Promise<EntityAuditLogEntity | null>;
+    getAuditLogs(query: AuditLogQueryDto): Promise<PageDto<EntityAuditLogEntity>>;
+    compareEntities(entityType: string, entityId: string, fromLogId?: string, toLogId?: string): Promise<EntityDifference>;
+    preCheckRestore(entityType: string, entityId: string, auditLogId: string): Promise<PreCheckResult>;
+    restoreEntity(entityType: string, entityId: string, auditLogId: string, options?: RestoreOptions): Promise<RestoreResult>;
+    private calculateChangedFields;
+    private calculateChangedFieldPaths;
+    private deepEqual;
+    private deepDiff;
+    private compareSnapshotData;
+    private filterAndMaskFields;
+    private applyMasking;
+    private hashValue;
+    private maskValue;
+    private partialMaskValue;
+    private generateHashChain;
+    private generateDescription;
+    private detectConflicts;
+}