hh-contracts 0.0.109 → 0.0.111

package/build/users/user.models.d.ts

@@ -0,0 +1,246 @@
+import * as z from 'zod';
+import { AppStatuses } from '../common';
+export declare const USER_STATUSES: {
+    readonly invited: "invited";
+    readonly blocked: "blocked";
+    readonly active: "active";
+    readonly disabled: "disabled";
+};
+export declare const USER_STATUS_VALUES: [AppStatuses.TUser, ...AppStatuses.TUser[]];
+export declare const UserStatusSchema: z.ZodEnum<{
+    active: "active";
+    disabled: "disabled";
+    invited: "invited";
+    blocked: "blocked";
+}>;
+export type TUserStatus = z.infer<typeof UserStatusSchema>;
+export declare const UserSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    phone: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    preferredLang: z.ZodEnum<{
+        en: "en";
+        ru: "ru";
+    }>;
+    timezone: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+        invited: "invited";
+        blocked: "blocked";
+    }>>;
+    avatarUrl: z.ZodOptional<z.ZodURL>;
+    isEmailVerified: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type TUser = z.infer<typeof UserSchema>;
+export declare const UserPersistedSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    phone: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    preferredLang: z.ZodEnum<{
+        en: "en";
+        ru: "ru";
+    }>;
+    timezone: z.ZodString;
+    status: z.ZodNonOptional<z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+        invited: "invited";
+        blocked: "blocked";
+    }>>>;
+    avatarUrl: z.ZodOptional<z.ZodURL>;
+    isEmailVerified: z.ZodNonOptional<z.ZodOptional<z.ZodBoolean>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    id: z.ZodUUID;
+}, z.core.$strip>;
+export type TUserPersisted = z.infer<typeof UserPersistedSchema>;
+export declare const UserListItemSchema: z.ZodObject<{
+    createdAt: z.ZodDate;
+    id: z.ZodUUID;
+    email: z.ZodEmail;
+    status: z.ZodNonOptional<z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+        invited: "invited";
+        blocked: "blocked";
+    }>>>;
+    avatarUrl: z.ZodOptional<z.ZodURL>;
+    fullName: z.ZodString;
+    roleAssignments: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scope: z.ZodLiteral<"global">;
+        id: z.ZodUUID;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        scope: z.ZodLiteral<"hotel">;
+        hotelId: z.ZodUUID;
+        id: z.ZodUUID;
+        name: z.ZodString;
+        hotelName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>], "scope">>;
+}, z.core.$strip>;
+export type TUserListItem = z.infer<typeof UserListItemSchema>;
+export declare const UserDetailSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    phone: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    preferredLang: z.ZodEnum<{
+        en: "en";
+        ru: "ru";
+    }>;
+    timezone: z.ZodString;
+    status: z.ZodNonOptional<z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+        invited: "invited";
+        blocked: "blocked";
+    }>>>;
+    avatarUrl: z.ZodOptional<z.ZodURL>;
+    isEmailVerified: z.ZodNonOptional<z.ZodOptional<z.ZodBoolean>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    id: z.ZodUUID;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    fullName: z.ZodOptional<z.ZodString>;
+    roleAssignments: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scope: z.ZodLiteral<"global">;
+        role: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                hotel: "hotel";
+                superAdmin: "superAdmin";
+                system: "system";
+                guest: "guest";
+            }>;
+            isActive: z.ZodNonOptional<z.ZodOptional<z.ZodBoolean>>;
+            isDefault: z.ZodNonOptional<z.ZodOptional<z.ZodBoolean>>;
+            createdAt: z.ZodDate;
+            updatedAt: z.ZodDate;
+            id: z.ZodUUID;
+            name: z.ZodNullable<z.ZodString>;
+            description: z.ZodNullable<z.ZodString>;
+            permissions: z.ZodArray<z.ZodObject<{
+                name: z.ZodNullable<z.ZodString>;
+                id: z.ZodUUID;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        id: z.ZodUUID;
+        grantedBy: z.ZodOptional<z.ZodUUID>;
+        roleId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        scope: z.ZodLiteral<"hotel">;
+        hotelId: z.ZodUUID;
+        role: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                hotel: "hotel";
+                superAdmin: "superAdmin";
+                system: "system";
+                guest: "guest";
+            }>;
+            isActive: z.ZodNonOptional<z.ZodOptional<z.ZodBoolean>>;
+            isDefault: z.ZodNonOptional<z.ZodOptional<z.ZodBoolean>>;
+            createdAt: z.ZodDate;
+            updatedAt: z.ZodDate;
+            id: z.ZodUUID;
+            name: z.ZodNullable<z.ZodString>;
+            description: z.ZodNullable<z.ZodString>;
+            permissions: z.ZodArray<z.ZodObject<{
+                name: z.ZodNullable<z.ZodString>;
+                id: z.ZodUUID;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        hotel: z.ZodOptional<z.ZodObject<{
+            createdAt: z.ZodDate;
+            updatedAt: z.ZodDate;
+            id: z.ZodUUID;
+            slug: z.ZodString;
+            status: z.ZodNonOptional<z.ZodOptional<z.ZodEnum<{
+                active: "active";
+                disabled: "disabled";
+                pending: "pending";
+                maintenance: "maintenance";
+                archived: "archived";
+            }>>>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        id: z.ZodUUID;
+        grantedBy: z.ZodOptional<z.ZodUUID>;
+        roleId: z.ZodUUID;
+    }, z.core.$strip>], "scope">>;
+}, z.core.$strip>;
+export type TUserDetail = z.infer<typeof UserDetailSchema>;
+export declare const UserWriteSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    phone: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    preferredLang: z.ZodEnum<{
+        en: "en";
+        ru: "ru";
+    }>;
+    timezone: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+        invited: "invited";
+        blocked: "blocked";
+    }>>;
+    avatarUrl: z.ZodOptional<z.ZodURL>;
+    isEmailVerified: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type TUserWrite = z.infer<typeof UserWriteSchema>;
+export declare const UserUpdateSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodEmail>;
+    phone: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    preferredLang: z.ZodOptional<z.ZodEnum<{
+        en: "en";
+        ru: "ru";
+    }>>;
+    timezone: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+        invited: "invited";
+        blocked: "blocked";
+    }>>>;
+    avatarUrl: z.ZodOptional<z.ZodOptional<z.ZodURL>>;
+    isEmailVerified: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type TUserUpdate = z.infer<typeof UserUpdateSchema>;
+export declare const UserCreateWithAssignmentsSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    phone: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    preferredLang: z.ZodEnum<{
+        en: "en";
+        ru: "ru";
+    }>;
+    timezone: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+        invited: "invited";
+        blocked: "blocked";
+    }>>;
+    avatarUrl: z.ZodOptional<z.ZodURL>;
+    isEmailVerified: z.ZodOptional<z.ZodBoolean>;
+    roleAssignments: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scope: z.ZodLiteral<"global">;
+        roleId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        scope: z.ZodLiteral<"hotel">;
+        hotelId: z.ZodUUID;
+        roleId: z.ZodUUID;
+    }, z.core.$strip>], "scope">>;
+}, z.core.$strip>;
+export type TUserCreateWithAssignments = z.infer<typeof UserCreateWithAssignmentsSchema>;
+//# sourceMappingURL=user.models.d.ts.map

package/build/users/user.models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.models.d.ts","sourceRoot":"","sources":["../../users/user.models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAE,WAAW,EAA8D,MAAM,WAAW,CAAC;AAOpG,eAAO,MAAM,aAAa;;;;;CAAmB,CAAC;AAC9C,eAAO,MAAM,kBAAkB,6CAA0B,CAAC;AAE1D,eAAO,MAAM,gBAAgB;;;;;EAA6B,CAAC;AAC3D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;iBAUrB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEjE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;iBAS7B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI3B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;iBAAa,CAAC;AAC1C,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;iBAAuB,CAAC;AACrD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE1C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/build/users/user.models.js

@@ -0,0 +1,80 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserCreateWithAssignmentsSchema = exports.UserUpdateSchema = exports.UserWriteSchema = exports.UserDetailSchema = exports.UserListItemSchema = exports.UserPersistedSchema = exports.UserSchema = exports.UserStatusSchema = exports.USER_STATUS_VALUES = exports.USER_STATUSES = void 0;
+const z = __importStar(require("zod"));
+const common_1 = require("../common");
+const user_role_assignments_models_1 = require("./user-role-assignments.models");
+exports.USER_STATUSES = common_1.AppStatuses.USER;
+exports.USER_STATUS_VALUES = common_1.AppStatuses.USER_VALUES;
+exports.UserStatusSchema = z.enum(exports.USER_STATUS_VALUES);
+exports.UserSchema = z.object({
+    email: z.email().toLowerCase(),
+    phone: z.string().trim().min(6).max(20).optional(),
+    firstName: z.string().min(1),
+    lastName: z.string().min(1),
+    preferredLang: z.enum(common_1.LANGUAGE_KEYS),
+    timezone: common_1.TimezoneSchema,
+    status: exports.UserStatusSchema.optional(),
+    avatarUrl: z.url().optional(),
+    isEmailVerified: z.boolean().optional(),
+});
+exports.UserPersistedSchema = exports.UserSchema.required({
+    status: true,
+    isEmailVerified: true,
+}).extend({
+    id: common_1.UuidSchema,
+    ...common_1.TimestampSchema.shape,
+});
+exports.UserListItemSchema = exports.UserPersistedSchema.pick({
+    id: true,
+    email: true,
+    status: true,
+    createdAt: true,
+    avatarUrl: true,
+}).extend({
+    fullName: z.string(),
+    roleAssignments: z.array(user_role_assignments_models_1.UserRoleAssignmentListItemSchema),
+});
+exports.UserDetailSchema = exports.UserPersistedSchema.extend({
+    isActive: z.boolean().optional(),
+    fullName: z.string().optional(),
+    roleAssignments: z.array(user_role_assignments_models_1.UserRoleAssignmentWithEntitiesSchema),
+});
+exports.UserWriteSchema = exports.UserSchema;
+exports.UserUpdateSchema = exports.UserSchema.partial();
+exports.UserCreateWithAssignmentsSchema = exports.UserSchema.extend({
+    roleAssignments: z.array(user_role_assignments_models_1.UserRoleAssignmentSchema),
+});

package/build/users/users.api.d.ts

@@ -0,0 +1,25 @@
+export declare const USERS_CONTROLLER: {
+    readonly prefix: "users";
+    readonly endpoints: {
+        readonly findMany: "";
+        readonly find: ":id";
+        readonly create: "";
+        readonly update: ":id";
+        readonly delete: ":id";
+        readonly assignRole: ":id/role-assignments";
+        readonly replaceRoleAssignments: ":id/role-assignments";
+    };
+};
+export declare const USERS_API: import("../common/utils").TApi<{
+    readonly prefix: "users";
+    readonly endpoints: {
+        readonly findMany: "";
+        readonly find: ":id";
+        readonly create: "";
+        readonly update: ":id";
+        readonly delete: ":id";
+        readonly assignRole: ":id/role-assignments";
+        readonly replaceRoleAssignments: ":id/role-assignments";
+    };
+}>;
+//# sourceMappingURL=users.api.d.ts.map

package/build/users/users.api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.api.d.ts","sourceRoot":"","sources":["../../users/users.api.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAWG,CAAC;AAEjC,eAAO,MAAM,SAAS;;;;;;;;;;;EAA8B,CAAC"}

package/build/users/users.api.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USERS_API = exports.USERS_CONTROLLER = void 0;
+const utils_1 = require("../common/utils");
+exports.USERS_CONTROLLER = {
+    prefix: 'users',
+    endpoints: {
+        findMany: '',
+        find: ':id',
+        create: '',
+        update: ':id',
+        delete: ':id',
+        assignRole: ':id/role-assignments',
+        replaceRoleAssignments: ':id/role-assignments',
+    },
+};
+exports.USERS_API = (0, utils_1.createApi)(exports.USERS_CONTROLLER);

package/package.json

@@ -1,15 +1,27 @@
 {
   "name": "hh-contracts",
-  "version": "0.0.109",
+  "version": "0.0.111",
   "description": "",
   "main": "./build/index.js",
+  "types": "./build/index.d.ts",
   "scripts": {
     "prepublish": "rm -rf build && tsc",
-    "build": "tsc"
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "clean": "rm -rf build node_modules"
   },
-  "author": "",
+  "author": "atom",
   "license": "ISC",
   "dependencies": {
     "zod": "^4.1.9"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "build"
+  ],
+  "publishConfig": {
+    "access": "public"
   }
 }

package/app-menu/get.query.ts

@@ -1,17 +0,0 @@
-import * as z from 'zod';
-import { NavigationItemEntitySchema, UuidSchema } from '../common';
-
-const GetAppMenuQueryRequestSchema = z.object({
-  userUuid: UuidSchema,
-});
-const GetAppMenuQueryResponseSchema = z.object({
-  appMenu: z.array(NavigationItemEntitySchema),
-});
-
-export namespace GetAppMenuQuery {
-  export const RequestSchema = GetAppMenuQueryRequestSchema;
-  export type TRequest = z.infer<typeof RequestSchema>;
-
-  export const ResponseSchema = GetAppMenuQueryResponseSchema;
-  export type TResponse = z.infer<typeof ResponseSchema>;
-}

package/app-menu/index.ts

@@ -1 +0,0 @@
-export * from './get.query';

package/common/constants/app-ability.constant.ts

@@ -1,22 +0,0 @@
-import { ENTITIES } from './entity.constant';
-
-export namespace AppAbility {
-  export const ACTIONS = {
-    manage: 'manage',
-    create: 'create',
-    read: 'read',
-    update: 'update',
-    delete: 'delete',
-    hotelClientMessaging: 'hotelClientMessaging',
-  } as const;
-  export type TAction = (typeof ACTIONS)[keyof typeof ACTIONS];
-  export const ACTION_VALUES = Object.values(ACTIONS) as [TAction];
-
-  export const SUBJECTS = {
-    ...ENTITIES,
-    hotelsWebsocketClient: 'hotelsWebsocketClient',
-    all: 'all',
-  } as const;
-  export type TSubject = (typeof SUBJECTS)[keyof typeof SUBJECTS];
-  export const SUBJECT_VALUES = Object.values(SUBJECTS) as [TSubject];
-}

package/common/constants/app-errors.constant.ts

@@ -1,235 +0,0 @@
-export const APP_ERRORS = {
-  common: {
-    validation: {
-      statusCode: 400, // HttpStatus.BAD_REQUEST,
-      code: 'COMMON-01',
-      messageKey: 'errors.common.validation',
-    },
-    unauthorized: {
-      statusCode: 401, // HttpStatus.UNAUTHORIZED,
-      code: 'COMMON-02',
-      messageKey: 'errors.common.unauthorized',
-    },
-    forbidden: {
-      statusCode: 403, // HttpStatus.FORBIDDEN,
-      code: 'COMMON-03',
-      messageKey: 'errors.common.forbidden',
-    },
-    requestTimeout: {
-      statusCode: 408, // HttpStatus.REQUEST_TIMEOUT,
-      code: 'COMMON-04',
-      messageKey: 'errors.common.requestTimeout',
-    },
-    unprocessableEntity: {
-      statusCode: 422, // HttpStatus.UNPROCESSABLE_ENTITY,
-      code: 'COMMON-05',
-      messageKey: 'errors.common.unprocessableEntity',
-    },
-    internalServer: {
-      statusCode: 500, // HttpStatus.INTERNAL_SERVER_ERROR,
-      code: 'COMMON-06',
-      messageKey: 'errors.common.internalServer',
-    },
-    // Перенести в отдельную сущность
-    // hotelClientNotConnected: {
-    //   statusCode: 503, // HttpStatus.SERVICE_UNAVAILABLE,
-    //   code: 'COMMON-05',
-    //   message: 'Hotel client is not connected.',
-    // },
-    // hotelClientInternalError: {
-    //   statusCode: 500, // HttpStatus.INTERNAL_SERVER_ERROR,
-    //   code: 'COMMON-06',
-    //   message: 'Hotel client internal error.',
-    // },
-  },
-  auth: {
-    wrongCredentials: {
-      statusCode: 401, // HttpStatus.UNAUTHORIZED,
-      code: 'AUTH-01',
-      messageKey: 'errors.auth.wrongCredentials',
-    },
-  },
-  translation: {
-    alreadyExists: {
-      statusCode: 409, // HttpStatus.CONFLICT,
-      code: 'TRANSLATION-02',
-      messageKey: 'errors.translation.alreadyExists',
-    },
-    entityFieldExists: {
-      statusCode: 409, // HttpStatus.CONFLICT,
-      code: 'TRANSLATION-03',
-      messageKey: 'errors.translation.entityFieldExists',
-    },
-    createFailed: {
-      statusCode: 500, // HttpStatus.INTERNAL_SERVER_ERROR,
-      code: 'TRANSLATION-04',
-      messageKey: 'errors.translation.createFailed',
-    },
-    updateFailed: {
-      statusCode: 500, // HttpStatus.INTERNAL_SERVER_ERROR,
-      code: 'TRANSLATION-05',
-      messageKey: 'errors.translation.updateFailed',
-    },
-    deleteFailed: {
-      statusCode: 500, // HttpStatus.INTERNAL_SERVER_ERROR,
-      code: 'TRANSLATION-06',
-      messageKey: 'errors.translation.deleteFailed',
-    },
-    findFailed: {
-      statusCode: 500, // HttpStatus.INTERNAL_SERVER_ERROR,
-      code: 'TRANSLATION-07',
-      messageKey: 'errors.translation.findFailed',
-    },
-    required: {
-      statusCode: 500, // HttpStatus.INTERNAL_SERVER_ERROR,
-      code: 'TRANSLATION-08',
-      messageKey: 'errors.translation.required',
-    },
-  },
-  translate: {
-    failed: {
-      statusCode: 500, // HttpStatus.INTERNAL_SERVER_ERROR,
-      code: 'TRANSLATE-01',
-      messageKey: 'errors.translate.failed',
-    },
-  },
-  user: {
-    notFound: {
-      statusCode: 404, // HttpStatus.NOT_FOUND,
-      code: 'USER-01',
-      messageKey: 'errors.user.notFound',
-    },
-    alreadyExists: {
-      statusCode: 409, // HttpStatus.CONFLICT,
-      code: 'USER-02',
-      messageKey: 'errors.user.alreadyExists',
-    },
-  },
-  role: {
-    notFound: {
-      statusCode: 404, // HttpStatus.NOT_FOUND,
-      code: 'ROLE-01',
-      messageKey: 'errors.role.notFound',
-    },
-    cannotDeleteDefault: {
-      statusCode: 400, // HttpStatus.BAD_REQUEST,
-      code: 'ROLE-02',
-      messageKey: 'errors.role.cannotDeleteDefault',
-    },
-  },
-  permission: {
-    notFound: {
-      statusCode: 404, // HttpStatus.NOT_FOUND,
-      code: 'PERMISSION-01',
-      messageKey: 'errors.permission.notFound',
-    },
-  },
-  hotel: {
-    notFound: {
-      statusCode: 404, // HttpStatus.NOT_FOUND,
-      code: 'HOTEL-01',
-      messageKey: 'errors.hotel.notFound',
-    },
-    alreadyExists: {
-      statusCode: 409, // HttpStatus.CONFLICT,
-      code: 'HOTEL-02',
-      messageKey: 'errors.hotel.alreadyExists',
-    },
-  },
-  roomCategory: {
-    notFound: {
-      statusCode: 404, // HttpStatus.NOT_FOUND,
-      code: 'ROOM-CATEGORY-01',
-      messageKey: 'errors.roomCategory.notFound',
-    },
-    alreadyExists: {
-      statusCode: 409, // HttpStatus.CONFLICT,
-      code: 'ROOM-CATEGORY-02',
-      messageKey: 'errors.roomCategory.alreadyExists',
-    },
-  },
-  room: {
-    notFound: {
-      statusCode: 404, // HttpStatus.NOT_FOUND,
-      code: 'ROOM-01',
-      messageKey: 'errors.room.notFound',
-    },
-  },
-
-  page: {
-    notFound: {
-      statusCode: 404,
-      code: 'PAGE-01',
-      messageKey: 'errors.page.notFound',
-    },
-    draft: {
-      statusCode: 404,
-      code: 'PAGE-02',
-      messageKey: 'errors.page.draft',
-    },
-    inactive: {
-      statusCode: 404,
-      code: 'PAGE-03',
-      messageKey: 'errors.page.inactive',
-    },
-    alreadyExists: {
-      statusCode: 409,
-      code: 'PAGE-04',
-      messageKey: 'errors.page.alreadyExists',
-    },
-    createFailed: {
-      statusCode: 500,
-      code: 'PAGE-05',
-      messageKey: 'errors.page.createFailed',
-    },
-    updateFailed: {
-      statusCode: 500,
-      code: 'PAGE-06',
-      messageKey: 'errors.page.updateFailed',
-    },
-    deleteFailed: {
-      statusCode: 500,
-      code: 'PAGE-07',
-      messageKey: 'errors.page.deleteFailed',
-    },
-    findFailed: {
-      statusCode: 500,
-      code: 'PAGE-08',
-      messageKey: 'errors.page.findFailed',
-    },
-  },
-} as const;
-
-interface IError {
-  statusCode: number;
-  code: string;
-  messageKey: string;
-}
-
-export type TMappedErrors<T extends Record<string, unknown>> = {
-  [k in keyof T]: T[k] extends Record<string, unknown>
-    ? T[k] extends IError
-      ? T[k]
-      : TMappedErrors<T[k]>
-    : never;
-}[keyof T];
-export type TAppError = TMappedErrors<typeof APP_ERRORS>;
-export type TAppErrorCode = TAppError['code'];
-export type TAppErrorMessageKey = TAppError['messageKey'];
-
-export interface IBaseErrorDetails {
-  type?: string;
-  message?: string;
-  messageKey?: string;
-  params?: Record<string, unknown>;
-}
-
-export interface IErrorDetails extends IBaseErrorDetails {
-  [key: string]: string | IErrorDetails | IErrorDetails[] | Record<string, unknown> | undefined;
-}
-export type TAppErrorDetails = Record<string, IErrorDetails | IErrorDetails[]>;
-
-export type TAppErrorWithDetails = TAppError & {
-  message?: string;
-  details?: TAppErrorDetails;
-};