@koalarx/nest 3.0.3 → 3.0.5

package/core/utils/interfaces/icomparable.d.ts

@@ -0,0 +1,5 @@
+export type IComparableId = string | number;
+export declare abstract class IComparable<T = any> {
+    abstract _id: IComparableId;
+    abstract equals(obj: IComparable<T>): boolean;
+}

package/core/utils/interfaces/icomparable.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IComparable = void 0;
+class IComparable {
+}
+exports.IComparable = IComparable;

package/core/utils/list.d.ts

@@ -0,0 +1,39 @@
+import { Type } from '@nestjs/common';
+import 'reflect-metadata';
+import { IComparableId } from './interfaces/icomparable';
+export type OrderDirection = 'asc' | 'desc';
+export type ListActionType = 'added' | 'updated' | 'removed';
+export interface ListProps<T> {
+    list?: T[];
+    entityType?: Type<T>;
+}
+export declare class List<T> {
+    readonly entityType?: Type<T> | undefined;
+    private _list;
+    private _addedItemsList;
+    private _updatedItemsList;
+    private _removedItemsList;
+    constructor(entityType?: Type<T> | undefined);
+    private indexOf;
+    private contains;
+    private mapInternalIdIfIsEmpty;
+    get length(): number;
+    orderBy(by: keyof T, direction?: OrderDirection): this;
+    first(): NonNullable<T> | null;
+    last(): NonNullable<T> | null;
+    findById(id: IComparableId): T | null;
+    findByValue(value: any): T | null;
+    setList(list: T[]): this;
+    add(item: T): this | undefined;
+    remove(item: T): this;
+    update(items: T[]): this;
+    clear(): this;
+    forEach(callback: (item: T, index: number) => void): this;
+    forEachAsync(callback: (item: T, index: number) => Promise<void>): Promise<this>;
+    map<U>(callback: (item: T, index: number) => U): List<U>;
+    mapAsync<U>(callback: (item: T, index: number) => Promise<U>): Promise<List<U>>;
+    filter(callback: (item: T, index: number) => boolean): List<T>;
+    filterAsync(callback: (item: T, index: number) => Promise<boolean>): Promise<List<T>>;
+    find(callback: (item: T, index: number) => boolean): T | null;
+    toArray(type?: ListActionType): T[];
+}

package/core/utils/list.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.List = void 0;
+require("reflect-metadata");
+const entity_base_1 = require("../database/entity.base");
+class List {
+    entityType;
+    _list = [];
+    _addedItemsList = [];
+    _updatedItemsList = [];
+    _removedItemsList = [];
+    constructor(entityType) {
+        this.entityType = entityType;
+    }
+    indexOf(item, list = this._list) {
+        if (item instanceof entity_base_1.EntityBase) {
+            return list
+                .filter((i) => i instanceof entity_base_1.EntityBase)
+                .filter((i) => !!i._id)
+                .findIndex((i) => item._id === i._id ||
+                item.id === i.id);
+        }
+        return list
+            .filter((i) => !(i instanceof entity_base_1.EntityBase))
+            .findIndex((i) => item === i);
+    }
+    contains(item, list = this._list) {
+        return this.indexOf(item, list) > -1;
+    }
+    mapInternalIdIfIsEmpty(list) {
+        return list.map((item) => {
+            if (item instanceof entity_base_1.EntityBase && !item._id) {
+                item._id = item.id;
+            }
+            return item;
+        });
+    }
+    get length() {
+        return this._list.length;
+    }
+    orderBy(by, direction = 'asc') {
+        const inverse = direction === 'desc';
+        this._list.sort((a, b) => {
+            if (typeof a !== 'string' && typeof b !== 'string') {
+                if ((!inverse && a[by] > b[by]) || (inverse && a[by] < b[by])) {
+                    return 1;
+                }
+                else if ((!inverse && a[by] < b[by]) || (inverse && a[by] > b[by])) {
+                    return -1;
+                }
+                else {
+                    return 0;
+                }
+            }
+            else {
+                return 0;
+            }
+        });
+        return this;
+    }
+    first() {
+        return this._list[0] ?? null;
+    }
+    last() {
+        return this._list[this._list.length - 1] ?? null;
+    }
+    findById(id) {
+        return (this._list
+            .filter((item) => item instanceof entity_base_1.EntityBase)
+            .find((item) => item._id === id || item.id === id) ??
+            null);
+    }
+    findByValue(value) {
+        return this._list.find((item) => item === value) ?? null;
+    }
+    setList(list) {
+        this._list = this.mapInternalIdIfIsEmpty(list);
+        return this;
+    }
+    add(item) {
+        if (this.contains(item)) {
+            this._list[this.indexOf(item)] = item;
+            if (!this.contains(item, this._updatedItemsList)) {
+                this._updatedItemsList.push(item);
+            }
+            return;
+        }
+        this._list.push(item);
+        this._addedItemsList.push(item);
+        return this;
+    }
+    remove(item) {
+        const index = this.indexOf(item);
+        if (index > -1) {
+            this._list.splice(index, 1);
+            if (!this.contains(item, this._removedItemsList)) {
+                this._removedItemsList.push(item);
+            }
+        }
+        return this;
+    }
+    update(items) {
+        items = this.mapInternalIdIfIsEmpty(items);
+        items.forEach((item) => this.add(item));
+        this._list
+            .filter((item) => !this.contains(item, items))
+            .forEach((item) => this.remove(item));
+        return this;
+    }
+    clear() {
+        this._addedItemsList = [];
+        this._updatedItemsList = [];
+        this._removedItemsList = this._list;
+        this._list = [];
+        return this;
+    }
+    forEach(callback) {
+        this._list.forEach(callback);
+        return this;
+    }
+    async forEachAsync(callback) {
+        return Promise.all(this._list.map(callback)).then(() => this);
+    }
+    map(callback) {
+        const mappedItems = this._list.map(callback);
+        const list = new List();
+        list.setList(mappedItems);
+        return list;
+    }
+    async mapAsync(callback) {
+        return Promise.all(this._list.map(callback)).then((mappedItems) => {
+            const mappedList = new List();
+            mappedList.setList(mappedItems);
+            return mappedList;
+        });
+    }
+    filter(callback) {
+        const filteredItems = this._list.filter(callback);
+        const list = new List();
+        list.setList(filteredItems);
+        return list;
+    }
+    async filterAsync(callback) {
+        return Promise.all(this._list.filter(callback))
+            .then((list) => list.filter((item) => item))
+            .then((filteredItems) => {
+            const list = new List();
+            list.setList(filteredItems);
+            return list;
+        });
+    }
+    find(callback) {
+        return this._list.find(callback) ?? null;
+    }
+    toArray(type) {
+        switch (type) {
+            case 'added':
+                return this._addedItemsList;
+            case 'updated':
+                return this._updatedItemsList;
+            case 'removed':
+                return this._removedItemsList;
+            default:
+                return this._list;
+        }
+    }
+}
+exports.List = List;

package/core/utils/promise-all.d.ts

@@ -0,0 +1,7 @@
+type PromisesResponseType<T> = {
+    [K in keyof T]: Awaited<T[K]>;
+};
+export declare class Promises {
+    static result<T>(requests: T): Promise<PromisesResponseType<T>>;
+}
+export {};

package/core/utils/promise-all.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Promises = void 0;
+class Promises {
+    static async result(requests) {
+        const promises = [];
+        Object.values(requests).forEach((promise) => promises.push(promise));
+        return Promise.all(promises).then((result) => {
+            let currentIndex = 0;
+            const response = {};
+            Object.keys(requests).forEach((propName) => {
+                response[propName] = result[currentIndex];
+                currentIndex++;
+            });
+            return response;
+        });
+    }
+}
+exports.Promises = Promises;

package/core/utils/set-mask-document-number.d.ts

@@ -0,0 +1 @@
+export declare function setMaskDocumentNumber(document?: string): string;

package/core/utils/set-mask-document-number.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMaskDocumentNumber = setMaskDocumentNumber;
+const KlString_1 = require("@koalarx/utils/KlString");
+function setMaskDocumentNumber(document) {
+    if (!document) {
+        return '';
+    }
+    const documentWithoutMask = document.replace(/[^0-9]/g, '');
+    return documentWithoutMask.length === 11
+        ? (0, KlString_1.maskCpf)(documentWithoutMask)
+        : (0, KlString_1.maskCnpj)(documentWithoutMask);
+}

package/core/validators/file-validator.d.ts

@@ -0,0 +1,27 @@
+import { FileValidator } from '@nestjs/common';
+import { FileType } from '..';
+type FileTypeInternal = FileType | FileType[] | Record<string, FileType[]>;
+export declare class FileSizeValidator extends FileValidator {
+    private maxSizeBytes;
+    private multiple;
+    private errorFileName;
+    constructor(args: {
+        maxSizeBytes: number;
+        multiple: boolean;
+    });
+    isValid(file?: FileTypeInternal): Promise<boolean>;
+    buildErrorMessage(file: any): string;
+}
+export declare class FileTypeValidator extends FileValidator {
+    private multiple;
+    private errorFileName;
+    private filetype;
+    constructor(args: {
+        multiple: boolean;
+        filetype: RegExp | string;
+    });
+    isMimeTypeValid(file: FileType): boolean;
+    isValid(file?: FileTypeInternal): Promise<boolean>;
+    buildErrorMessage(file: any): string;
+}
+export {};

package/core/validators/file-validator.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTypeValidator = exports.FileSizeValidator = void 0;
+const common_1 = require("@nestjs/common");
+const runFileValidation = async (args) => {
+    if (args.multiple) {
+        const fileFields = Object.keys(args.file);
+        for (const field of fileFields) {
+            const fieldFile = args.file[field];
+            if (Array.isArray(fieldFile)) {
+                for (const f of fieldFile) {
+                    if (!args.validator(f)) {
+                        return { errorFileName: f.originalname, isValid: false };
+                    }
+                }
+            }
+            else {
+                if (!args.validator(fieldFile)) {
+                    return { errorFileName: fieldFile.originalname, isValid: false };
+                }
+            }
+        }
+        return { isValid: true };
+    }
+    if (Array.isArray(args.file)) {
+        for (const f of args.file) {
+            if (!args.validator(f)) {
+                return { errorFileName: f.originalname, isValid: false };
+            }
+        }
+        return { isValid: true };
+    }
+    if (args.validator(args.file)) {
+        return { errorFileName: args.file.originalname, isValid: false };
+    }
+    return { isValid: true };
+};
+class FileSizeValidator extends common_1.FileValidator {
+    maxSizeBytes;
+    multiple;
+    errorFileName;
+    constructor(args) {
+        super({});
+        this.maxSizeBytes = args.maxSizeBytes;
+        this.multiple = args.multiple;
+    }
+    async isValid(file) {
+        if (!file) {
+            return true;
+        }
+        const result = await runFileValidation({
+            file,
+            multiple: this.multiple,
+            validator: (f) => f.size < this.maxSizeBytes,
+        });
+        this.errorFileName = result.errorFileName ?? '';
+        return result.isValid;
+    }
+    buildErrorMessage(file) {
+        return (`file ${this.errorFileName || ''} exceeded the size limit ` +
+            parseFloat((this.maxSizeBytes / 1024 / 1024).toFixed(2)) +
+            'MB');
+    }
+}
+exports.FileSizeValidator = FileSizeValidator;
+class FileTypeValidator extends common_1.FileValidator {
+    multiple;
+    errorFileName;
+    filetype;
+    constructor(args) {
+        super({});
+        this.multiple = args.multiple;
+        this.filetype = args.filetype;
+    }
+    isMimeTypeValid(file) {
+        return file.mimetype.search(this.filetype) === 0;
+    }
+    async isValid(file) {
+        if (!file) {
+            return true;
+        }
+        const result = await runFileValidation({
+            multiple: this.multiple,
+            file,
+            validator: (f) => this.isMimeTypeValid(f),
+        });
+        this.errorFileName = result.errorFileName ?? '';
+        return result.isValid;
+    }
+    buildErrorMessage(file) {
+        return `file ${this.errorFileName || ''} must be of type ${this.filetype}`;
+    }
+}
+exports.FileTypeValidator = FileTypeValidator;

package/decorators/api-exclude-endpoint-diff-develop.decorator.d.ts

@@ -0,0 +1 @@
+export declare const ApiExcludeEndpointDiffDevelop: () => MethodDecorator;

package/decorators/api-exclude-endpoint-diff-develop.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExcludeEndpointDiffDevelop = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const env_config_1 = require("../core/utils/env.config");
+const ApiExcludeEndpointDiffDevelop = () => {
+    return (0, swagger_1.ApiExcludeEndpoint)(!env_config_1.EnvConfig.isEnvDevelop);
+};
+exports.ApiExcludeEndpointDiffDevelop = ApiExcludeEndpointDiffDevelop;

package/decorators/api-property-enum.decorator.d.ts

@@ -0,0 +1,8 @@
+import { EnumAllowedTypes } from '@nestjs/swagger/dist/interfaces/schema-object-metadata.interface';
+interface ApiPropertyEnumOptions {
+    enum: EnumAllowedTypes;
+    isArray?: boolean;
+    required?: boolean;
+}
+export declare function ApiPropertyEnum(options: ApiPropertyEnumOptions): (target: any, propertyKey: string) => void;
+export {};

package/decorators/api-property-enum.decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPropertyEnum = ApiPropertyEnum;
+const swagger_1 = require("@nestjs/swagger");
+function ApiPropertyEnum(options) {
+    return function (target, propertyKey) {
+        const enumValues = Object.values(options.enum)
+            .filter((value) => typeof value === 'number')
+            .map((value) => ({
+            value,
+            description: options.enum[value],
+        }));
+        const description = enumValues
+            .map((enumValue) => `${enumValue.description}: ${enumValue.value}`)
+            .join('\n');
+        (0, swagger_1.ApiProperty)({
+            ...options,
+            description: ['```', description, '```'].join('\n'),
+        })(target, propertyKey);
+    };
+}

package/decorators/api-property-only-develop.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ApiPropertyOptions } from '@nestjs/swagger';
+export declare const ApiPropertyOnlyDevelop: (propertyOptions: ApiPropertyOptions) => PropertyDecorator;

package/decorators/api-property-only-develop.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPropertyOnlyDevelop = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const env_config_1 = require("../core/utils/env.config");
+const ApiPropertyOnlyDevelop = (propertyOptions) => {
+    return env_config_1.EnvConfig.isEnvDevelop ? (0, swagger_1.ApiProperty)(propertyOptions) : () => { };
+};
+exports.ApiPropertyOnlyDevelop = ApiPropertyOnlyDevelop;

package/decorators/cookies.decorator.d.ts

@@ -0,0 +1 @@
+export declare const Cookies: (...dataOrPipes: (string | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;

package/decorators/cookies.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cookies = void 0;
+const common_1 = require("@nestjs/common");
+exports.Cookies = (0, common_1.createParamDecorator)((data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    return data ? request.cookies?.[data] : request.cookies;
+});

package/decorators/is-public.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_PUBLIC_KEY = "isPublic";
+export declare const IsPublic: () => import("@nestjs/common").CustomDecorator<string>;

package/decorators/is-public.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsPublic = exports.IS_PUBLIC_KEY = void 0;
+const common_1 = require("@nestjs/common");
+exports.IS_PUBLIC_KEY = 'isPublic';
+const IsPublic = () => (0, common_1.SetMetadata)(exports.IS_PUBLIC_KEY, true);
+exports.IsPublic = IsPublic;

package/decorators/upload.decorator.d.ts

@@ -0,0 +1 @@
+export declare function UploadDecorator(maxSizeInKb: number, filetype: RegExp): ParameterDecorator;

package/decorators/upload.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadDecorator = UploadDecorator;
+const common_1 = require("@nestjs/common");
+const file_validator_1 = require("../core/validators/file-validator");
+function UploadDecorator(maxSizeInKb, filetype) {
+    const maxSizeBytes = maxSizeInKb * 1024;
+    return (0, common_1.UploadedFiles)(new common_1.ParseFilePipe({
+        validators: [
+            new file_validator_1.FileSizeValidator({ maxSizeBytes, multiple: true }),
+            new file_validator_1.FileTypeValidator({
+                filetype,
+                multiple: true,
+            }),
+        ],
+        fileIsRequired: false,
+    }));
+}

package/env/env.d.ts

@@ -0,0 +1,25 @@
+import 'dotenv/config';
+import { z } from 'zod';
+export declare const envSchema: z.ZodObject<{
+    PORT: z.ZodDefault<z.ZodNumber>;
+    NODE_ENV: z.ZodEnum<["test", "develop", "staging", "production"]>;
+    PRISMA_QUERY_LOG: z.ZodOptional<z.ZodEffects<z.ZodString, boolean | undefined, string>>;
+    SWAGGER_USERNAME: z.ZodOptional<z.ZodString>;
+    SWAGGER_PASSWORD: z.ZodOptional<z.ZodString>;
+    REDIS_CONNECTION_STRING: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    PORT: number;
+    NODE_ENV: "test" | "develop" | "staging" | "production";
+    PRISMA_QUERY_LOG?: boolean | undefined;
+    SWAGGER_USERNAME?: string | undefined;
+    SWAGGER_PASSWORD?: string | undefined;
+    REDIS_CONNECTION_STRING?: string | undefined;
+}, {
+    NODE_ENV: "test" | "develop" | "staging" | "production";
+    PORT?: number | undefined;
+    PRISMA_QUERY_LOG?: string | undefined;
+    SWAGGER_USERNAME?: string | undefined;
+    SWAGGER_PASSWORD?: string | undefined;
+    REDIS_CONNECTION_STRING?: string | undefined;
+}>;
+export type Env = z.infer<typeof envSchema>;

package/env/env.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envSchema = void 0;
+require("dotenv/config");
+const zod_1 = require("zod");
+const boolean_schema_1 = require("../core/controllers/schemas/boolean.schema");
+exports.envSchema = zod_1.z.object({
+    PORT: zod_1.z.coerce.number().default(3000),
+    NODE_ENV: zod_1.z.enum(['test', 'develop', 'staging', 'production']),
+    PRISMA_QUERY_LOG: (0, boolean_schema_1.booleanSchema)().optional(),
+    SWAGGER_USERNAME: zod_1.z.string().optional(),
+    SWAGGER_PASSWORD: zod_1.z.string().optional(),
+    REDIS_CONNECTION_STRING: zod_1.z.string().optional(),
+});

package/env/env.module.d.ts

@@ -0,0 +1,2 @@
+export declare class EnvModule {
+}

package/env/env.module.js

@@ -0,0 +1,20 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvModule = void 0;
+const common_1 = require("@nestjs/common");
+const env_service_1 = require("./env.service");
+let EnvModule = class EnvModule {
+};
+exports.EnvModule = EnvModule;
+exports.EnvModule = EnvModule = __decorate([
+    (0, common_1.Module)({
+        providers: [env_service_1.EnvService],
+        exports: [env_service_1.EnvService],
+    })
+], EnvModule);

package/env/env.service.d.ts

@@ -0,0 +1,7 @@
+import { ConfigService } from '@nestjs/config';
+import { Env } from './env';
+export declare class EnvService<TEnv extends Env = Env> {
+    private readonly configService;
+    constructor(configService: ConfigService<TEnv, true>);
+    get<T extends keyof TEnv>(key: T): (string extends infer T_1 ? T_1 extends string ? T_1 extends keyof TEnv ? string extends infer T_2 ? T_2 extends string ? T_2 extends import("@nestjs/config").Path<TEnv[T_1]> ? import("@nestjs/config").PathValue<TEnv[T_1], T_2> : never : never : never : never : never : never) | (any extends infer T_3 ? T_3 extends any ? T_3 extends keyof TEnv ? TEnv[T_3] : never : never : never);
+}

package/env/env.service.js

@@ -0,0 +1,28 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+let EnvService = class EnvService {
+    configService;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    get(key) {
+        return this.configService.get(key, { infer: true });
+    }
+};
+exports.EnvService = EnvService;
+exports.EnvService = EnvService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], EnvService);

package/filters/domain-errors.filter.d.ts

@@ -0,0 +1,18 @@
+import { ArgumentsHost } from '@nestjs/common';
+import { BaseExceptionFilter } from '@nestjs/core';
+import { BadRequestError } from '../core/errors/bad-request.error';
+import { ConflictError } from '../core/errors/conflict.error';
+import { NoContentError } from '../core/errors/no-content.error';
+import { NotAllowedError } from '../core/errors/not-allowed.error';
+import { ResourceNotFoundError } from '../core/errors/resource-not-found.error';
+import { UserAlreadyExist } from '../core/errors/user-already-exist.error';
+import { WrongCredentialsError } from '../core/errors/wrong-credentials.error';
+import { ILoggingService } from '../services/logging/ilogging.service';
+type DomainErrors = NotAllowedError | ResourceNotFoundError | UserAlreadyExist | WrongCredentialsError | ConflictError | BadRequestError | NoContentError;
+export declare class DomainErrorsFilter extends BaseExceptionFilter {
+    private readonly loggingService;
+    constructor(loggingService: ILoggingService);
+    catch(exception: DomainErrors, host: ArgumentsHost): import("express").Response<any, Record<string, any>>;
+    private map;
+}
+export {};