hh-contracts 0.0.96 → 0.0.98

package/hotels/domains/hotel-domains.schema.ts

@@ -0,0 +1,25 @@
+import * as z from 'zod';
+import {
+  DomainNameSchema,
+  IsoDatetimeSchema,
+  KIND_OF_APP_VALUES,
+  TimestampSchema,
+  UuidSchema,
+} from '../../common';
+
+export const HotelDomainSchema = z.object({
+  kindOfApp: z.enum(KIND_OF_APP_VALUES),
+  customDomain: DomainNameSchema.optional(),
+  isCustomDomainVerified: z.boolean().default(false),
+  customDomainVerifiedAt: IsoDatetimeSchema.optional(),
+});
+
+export const HotelDomainPersistedSchema = HotelDomainSchema.extend({
+  id: UuidSchema,
+  hotelId: UuidSchema,
+}).extend(TimestampSchema.shape);
+
+export const HotelDomainListSchema = z.array(HotelDomainPersistedSchema);
+
+export type THotelDomain = z.infer<typeof HotelDomainSchema>;
+export type THotelDomainPersisted = z.infer<typeof HotelDomainPersistedSchema>;

package/hotels/domains/index.ts

@@ -0,0 +1,3 @@
+export * from './hotel-domains.schema';
+export * from './hotel-domains.api';
+export * from './contracts';

package/hotels/hotel.models.ts

@@ -7,30 +7,30 @@ import {
   makeTranslations,
   IsoTimeSchema,
   TimezoneSchema,
+  UuidSchema,
 } from '../common';
 
-export const HotelPersistedSchema = z
-  .object({
-    id: z.uuid(),
-    slug: SlugSchema,
-    //принадлежность к сети
-    chainId: z.uuid().optional(),
-    status: z.enum(AppStatuses.HOTEL_VALUES).default(AppStatuses.HOTEL.pending),
-    //категория отеля
-    category: z.string().min(1).max(64).optional(),
-    timezone: TimezoneSchema,
-    currency: z.string().length(3),
-    defaultLang: z.enum(LANGUAGE_KEYS),
-    availableLangs: z.array(z.enum(LANGUAGE_KEYS)),
-    stars: z.number().int().min(1).max(5).optional(),
-    checkInFrom: IsoTimeSchema,
-    checkOutUntil: IsoTimeSchema,
-    // добавить тип настроек
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    version: z.number().int().nonnegative(),
-  })
-  .extend(TimestampSchema.shape);
+export const HotelSchema = z.object({
+  slug: SlugSchema,
+  chainId: UuidSchema.nullable().optional(),
+  status: z.enum(AppStatuses.HOTEL_VALUES).optional(), // сервер может проставить дефолт
+  category: z.string().min(1).max(64).nullable().optional(),
+  timezone: TimezoneSchema,
+  currency: z.string().length(3),
+  defaultLang: z.enum(LANGUAGE_KEYS),
+  availableLangs: z.array(z.enum(LANGUAGE_KEYS)),
+  stars: z.number().int().min(1).max(5).nullable().optional(),
+  checkInFrom: IsoTimeSchema,
+  checkOutUntil: IsoTimeSchema,
+  metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export type THotel = z.infer<typeof HotelSchema>;
 
+export const HotelPersistedSchema = HotelSchema.required({ status: true }).extend({
+  id: UuidSchema,
+  version: z.number().int().nonnegative(),
+  ...TimestampSchema.shape,
+});
 export type THotelPersisted = z.infer<typeof HotelPersistedSchema>;
 
 export const HotelTranslationsSchema = z.object({
@@ -39,11 +39,21 @@ export const HotelTranslationsSchema = z.object({
 });
 export type THotelTranslations = z.infer<typeof HotelTranslationsSchema>;
 
+export const HotelWriteSchema = HotelSchema.extend({
+  translations: makeTranslations(HotelTranslationsSchema),
+});
+export type THotelWrite = z.infer<typeof HotelWriteSchema>;
+
 export const HotelWithTranslationsSchema = HotelPersistedSchema.extend({
   translations: makeTranslations(HotelTranslationsSchema),
 });
 export type THotelWithTranslations = z.infer<typeof HotelWithTranslationsSchema>;
 
+export const HotelDetailSchema = HotelPersistedSchema.extend({
+  translations: makeTranslations(HotelTranslationsSchema),
+});
+export type THotelDetail = z.infer<typeof HotelDetailSchema>;
+
 export const HotelListItemSchema = HotelPersistedSchema.omit({
   chainId: true,
   metadata: true,

package/hotels/hotels.api.ts

@@ -8,8 +8,15 @@ export const HOTELS_CONTROLLER = {
     findById: 'by-id/:hotelId',
     updateById: 'by-id/:hotelId',
     deleteById: 'by-id/:hotelId',
-    findBySlug: 'by-slug/:hotelSlug',
+  },
+} as const satisfies TController;
+
+export const HOTELS_BY_SLUG_CONTROLLER = {
+  prefix: 'hotels/by-slug/:hotelSlug',
+  endpoints: {
+    find: '',
   },
 } as const satisfies TController;
 
 export const HOTELS_API = createApi(HOTELS_CONTROLLER);
+export const HOTELS_BY_SLUG_API = createApi(HOTELS_BY_SLUG_CONTROLLER);

package/hotels/index.ts

@@ -8,7 +8,7 @@ export * from './location';
 export * from './policies';
 export * from './ratings';
 export * from './sites';
-export * from './settings';
+export * from './domains';
 export * from './themes';
 export * from './hotel.models';
 export * from './hotels.api';

package/hotels/integrations/configs/index.ts

@@ -0,0 +1 @@
+export * from './opera-integration-config.model';

package/hotels/integrations/configs/opera-integration-config.model.ts

@@ -0,0 +1,6 @@
+import * as z from 'zod';
+import { HOTEL_INTEGRATION_PROVIDERS } from '../../constants';
+
+export const OperaIntegrationConfigSchema = z.object({
+  provider: z.literal(HOTEL_INTEGRATION_PROVIDERS.opera),
+});

package/hotels/integrations/contracts/create-hotel-integration.contract.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+import {
+  HotelIntegrationDetailSchema,
+  HotelIntegrationWriteSchema,
+} from '../hotel-integration.model';
+
+export namespace CreateHotelIntegrationContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.create;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.create;
+  export const httpMethod = HTTP_METHODS.post;
+
+  export const RequestSchema = HotelIntegrationWriteSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = HotelIntegrationDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string };
+}

package/hotels/integrations/contracts/delete-hotel-integration.contract.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+
+export namespace DeleteHotelIntegrationContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.delete;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.delete;
+  export const httpMethod = HTTP_METHODS.delete;
+
+  export const ResponseSchema = z.void();
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string; integrationId: string };
+}

package/hotels/integrations/contracts/find-all-hotel-integrations.contract.ts

@@ -0,0 +1,18 @@
+import * as z from 'zod';
+import { HTTP_METHODS, SearchSchema } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+import { HotelIntegrationSchema } from '../hotel-integration.model';
+
+export namespace FindAllHotelIntegrationsContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.findAll;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.findAll;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const RequestSchema = SearchSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = z.array(HotelIntegrationSchema);
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string };
+}

package/hotels/integrations/contracts/find-hotel-integration.contract.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+import { HotelIntegrationDetailSchema } from '../hotel-integration.model';
+
+export namespace FindHotelIntegrationContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.findOne;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.findOne;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const ResponseSchema = HotelIntegrationDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string; integrationId: string };
+}

package/hotels/integrations/contracts/index.ts

@@ -0,0 +1,5 @@
+export * from './find-all-hotel-integrations.contract';
+export * from './find-hotel-integration.contract';
+export * from './create-hotel-integration.contract';
+export * from './update-hotel-integration.contract';
+export * from './delete-hotel-integration.contract';

package/hotels/integrations/contracts/update-hotel-integration.contract.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+import {
+  HotelIntegrationDetailSchema,
+  HotelIntegrationWriteSchema,
+} from '../hotel-integration.model';
+
+export namespace UpdateHotelIntegrationContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.update;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.update;
+  export const httpMethod = HTTP_METHODS.put;
+
+  export const RequestSchema = HotelIntegrationWriteSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = HotelIntegrationDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string; integrationId: string };
+}

package/hotels/integrations/hotel-integration.model.ts

@@ -1,29 +1,80 @@
 import * as z from 'zod';
-import { TimestampSchema } from '../../common';
-import { HOTEL_INTEGRATION_PROVIDER_VALUES } from '../constants';
+import { SlugSchema, TimestampSchema } from '../../common';
+import {
+  HOTEL_INTEGRATION_CONNECTION_STATE_VALUES,
+  HOTEL_INTEGRATION_CREDENTIAL_STATUS_VALUES,
+  HOTEL_INTEGRATION_PROVIDER_VALUES,
+  HOTEL_INTEGRATION_SYNC_STATUS_VALUES,
+} from '../constants';
+import { OperaIntegrationConfigSchema } from './configs';
 
-export const HotelIntegrationSchema = z
+export const HotelIntegrationConfigSchema = z.discriminatedUnion('provider', [
+  OperaIntegrationConfigSchema,
+]);
+
+export const HotelIntegrationSchema = z.object({
+  alias: SlugSchema,
+  config: HotelIntegrationConfigSchema,
+  credentialId: z.uuid().nullable().optional(),
+});
+export type THotelIntegration = z.infer<typeof HotelIntegrationSchema>;
+
+export const HotelIntegrationPersistedSchema = HotelIntegrationSchema.required({
+  credentialId: true,
+}).extend({
+  id: z.uuid(),
+  secretHash: z.string().min(1),
+  secretSalt: z.string().min(1),
+  ...TimestampSchema.shape,
+});
+
+export const HotelIntegrationWriteSchema = HotelIntegrationSchema;
+export type THotelIntegrationWrite = z.infer<typeof HotelIntegrationWriteSchema>;
+
+export const HotelIntegrationDetailSchema = HotelIntegrationPersistedSchema.omit({
+  secretHash: true,
+  secretSalt: true,
+});
+export type THotelIntegrationDetail = z.infer<typeof HotelIntegrationDetailSchema>;
+
+export const HotelIntegrationAssignSchema = z
   .object({
+    id: z.uuid(),
+    integrationId: z.uuid(),
     hotelId: z.uuid(),
-    provider: z.enum(HOTEL_INTEGRATION_PROVIDER_VALUES),
-    externalHotelId: z.string().min(1),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    credentialId: z.uuid().optional(),
+    hotelExternalId: z.string(),
+    isActive: z.boolean().default(true),
   })
   .extend(TimestampSchema.shape);
+export type THotelIntegrationAssign = z.infer<typeof HotelIntegrationAssignSchema>;
 
-export type THotelIntegration = z.infer<typeof HotelIntegrationSchema>;
+export const HotelIntegrationConnectionSchema = z
+  .object({
+    id: z.uuid(),
+    integrationId: z.uuid(),
+    connectionState: z.enum(HOTEL_INTEGRATION_CONNECTION_STATE_VALUES),
+    lastHeartbeatAt: z.date(),
+    lastSeenAt: z.date(),
+    lastSyncStatus: z.enum(HOTEL_INTEGRATION_SYNC_STATUS_VALUES),
+    lastSyncAt: z.date().nullable(),
+    failedAt: z.date().nullable(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .extend(TimestampSchema.shape);
+export type THotelIntegrationConnection = z.infer<typeof HotelIntegrationConnectionSchema>;
 
 export const HotelIntegrationCredentialSchema = z
   .object({
     id: z.uuid(),
+    integrationId: z.uuid(),
     provider: z.enum(HOTEL_INTEGRATION_PROVIDER_VALUES),
     login: z.string().min(1),
     encryptedSecret: z.string().min(1),
     encryptionVersion: z.string().min(1),
+    status: z.enum(HOTEL_INTEGRATION_CREDENTIAL_STATUS_VALUES),
+    expiresAt: z.date().nullable(),
     meta: z.record(z.string(), z.unknown()).optional(),
     rotatedAt: z.date().nullable(),
   })
   .extend(TimestampSchema.shape);
-
 export type THotelIntegrationCredential = z.infer<typeof HotelIntegrationCredentialSchema>;

package/hotels/integrations/hotel-integrations.api.ts

@@ -3,7 +3,7 @@ import { createApi, TController } from '../../common/utils';
 export const HOTEL_INTEGRATIONS_CONTROLLER = {
   prefix: 'hotels/by-id/:hotelId/integrations',
   endpoints: {
-    findMany: '',
+    findAll: 'findAll',
     findOne: ':integrationId',
     create: '',
     update: ':integrationId',

package/hotels/integrations/index.ts

@@ -1,2 +1,3 @@
 export * from './hotel-integration.model';
 export * from './hotel-integrations.api';
+export * from './contracts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hh-contracts",
-  "version": "0.0.96",
+  "version": "0.0.98",
   "description": "",
   "main": "./build/index.js",
   "scripts": {

package/permissions/contracts/create-permission.contract.ts

@@ -1,13 +1,9 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
 import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
-import { PermissionWithTranslationsSchema } from '../permission.models';
+import { PermissionWriteSchema, PermissionDetailSchema } from '../permission.models';
 
-const CreatePermissionContractRequestSchema = PermissionWithTranslationsSchema.omit({
-  id: true,
-  createdAt: true,
-  updatedAt: true,
-});
+const CreatePermissionContractRequestSchema = PermissionWriteSchema;
 
 export namespace CreatePermissionContract {
   export const getUrl = PERMISSIONS_API.create;
@@ -17,6 +13,6 @@ export namespace CreatePermissionContract {
   export const RequestSchema = CreatePermissionContractRequestSchema;
   export type TRequest = z.infer<typeof RequestSchema>;
 
-  export const ResponseSchema = PermissionWithTranslationsSchema;
+  export const ResponseSchema = PermissionDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/permissions/contracts/find-permission.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { PermissionWithTranslationsSchema } from '../permission.models';
+import { PermissionDetailSchema } from '../permission.models';
 import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
 
 export namespace FindPermissionContract {
@@ -8,6 +8,6 @@ export namespace FindPermissionContract {
   export const endpoint = PERMISSIONS_CONTROLLER.endpoints.find;
   export const httpMethod = HTTP_METHODS.get;
 
-  export const ResponseSchema = PermissionWithTranslationsSchema;
+  export const ResponseSchema = PermissionDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/permissions/contracts/update-permission.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { PermissionWithTranslationsSchema } from '../permission.models';
+import { PermissionDetailSchema } from '../permission.models';
 import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
 import { CreatePermissionContract } from './create-permission.contract';
 
@@ -12,6 +12,6 @@ export namespace UpdatePermissionContract {
   export const RequestSchema = CreatePermissionContract.RequestSchema;
   export type TRequest = z.infer<typeof RequestSchema>;
 
-  export const ResponseSchema = PermissionWithTranslationsSchema;
+  export const ResponseSchema = PermissionDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/permissions/permission.models.ts

@@ -1,29 +1,35 @@
 import * as z from 'zod';
-import { AppAbility, TimestampSchema, makeTranslations } from '../common';
+import { AppAbility, TimestampSchema, UuidSchema, makeTranslations } from '../common';
+import { PermissionConditionFlagsSchema } from './permisson-conditions.model';
 
-export const PermissionPersistedSchema = z
-  .object({
-    id: z.uuid(),
-
-    action: z.enum(AppAbility.ACTION_VALUES),
-    subject: z.enum(AppAbility.SUBJECT_VALUES),
-    conditions: z.json().optional().nullable(),
-  })
-  .extend(TimestampSchema.shape);
+export const PermissionSchema = z.object({
+  action: z.enum(AppAbility.ACTION_VALUES),
+  subject: z.enum(AppAbility.SUBJECT_VALUES),
+  conditions: PermissionConditionFlagsSchema,
+});
+export type TPermission = z.infer<typeof PermissionSchema>;
 
+export const PermissionPersistedSchema = PermissionSchema.extend({
+  id: UuidSchema,
+  ...TimestampSchema.shape,
+});
 export type TPermissionPersisted = z.infer<typeof PermissionPersistedSchema>;
 
-// V2 translations: all translatable fields are inside per-language translation object
 export const PermissionTranslationsSchema = z.object({
   name: z.string().min(3),
   description: z.string().optional(),
 });
 export type TPermissionTranslations = z.infer<typeof PermissionTranslationsSchema>;
 
-export const PermissionWithTranslationsSchema = PermissionPersistedSchema.extend({
+export const PermissionWriteSchema = PermissionSchema.extend({
+  translations: makeTranslations(PermissionTranslationsSchema),
+});
+export type TPermissionWrite = z.infer<typeof PermissionWriteSchema>;
+
+export const PermissionDetailSchema = PermissionPersistedSchema.extend({
   translations: makeTranslations(PermissionTranslationsSchema),
 });
-export type TPermissionWithTranslations = z.infer<typeof PermissionWithTranslationsSchema>;
+export type TPermissionDetail = z.infer<typeof PermissionDetailSchema>;
 
 export const PermissionListItemSchema = PermissionPersistedSchema.extend({
   name: z.string().nullable(),

package/permissions/permisson-conditions.model.ts

@@ -0,0 +1,7 @@
+import * as z from 'zod';
+
+export const PermissionConditionFlagsSchema = z.object({
+  hotelFilter: z.boolean().default(false),
+  userFilter: z.boolean().default(false),
+});
+export type TPermissionConditionFlags = z.infer<typeof PermissionConditionFlagsSchema>;

package/roles/contracts/create-role.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { RoleWithTranslationsSchema } from '../role.models';
+import { RoleWriteSchema, RoleDetailSchema } from '../role.models';
 import { ROLES_API, ROLES_CONTROLLER } from '../roles.api';
 
 export namespace CreateRoleContract {
@@ -8,13 +8,9 @@ export namespace CreateRoleContract {
   export const endpoint = ROLES_CONTROLLER.endpoints.create;
   export const httpMethod = HTTP_METHODS.post;
 
-  export const RequestSchema = RoleWithTranslationsSchema.omit({
-    id: true,
-    createdAt: true,
-    updatedAt: true,
-  });
+  export const RequestSchema = RoleWriteSchema;
   export type TRequest = z.infer<typeof RequestSchema>;
 
-  export const ResponseSchema = RoleWithTranslationsSchema;
+  export const ResponseSchema = RoleDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/roles/contracts/find-role.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { RoleWithTranslationsSchema } from '../role.models';
+import { RoleDetailSchema } from '../role.models';
 import { ROLES_API, ROLES_CONTROLLER } from '../roles.api';
 
 export namespace FindRoleContract {
@@ -8,6 +8,6 @@ export namespace FindRoleContract {
   export const endpoint = ROLES_CONTROLLER.endpoints.find;
   export const httpMethod = HTTP_METHODS.get;
 
-  export const ResponseSchema = RoleWithTranslationsSchema;
+  export const ResponseSchema = RoleDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/roles/contracts/update-role.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { RoleWithTranslationsSchema } from '../role.models';
+import { RoleDetailSchema } from '../role.models';
 import { ROLES_API, ROLES_CONTROLLER } from '../roles.api';
 import { CreateRoleContract } from './create-role.contract';
 
@@ -12,6 +12,6 @@ export namespace UpdateRoleContract {
   export const RequestSchema = CreateRoleContract.RequestSchema;
   export type TRequest = z.infer<typeof RequestSchema>;
 
-  export const ResponseSchema = RoleWithTranslationsSchema;
+  export const ResponseSchema = RoleDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/roles/role.models.ts

@@ -1,21 +1,25 @@
 import * as z from 'zod';
-import { ROLE_TYPE_VALUES, TimestampSchema, UuidArraySchema, makeTranslations } from '../common';
+import {
+  ROLE_TYPE_VALUES,
+  TimestampSchema,
+  UuidArraySchema,
+  UuidSchema,
+  makeTranslations,
+} from '../common';
 import { PermissionListItemSchema } from '../permissions';
 
-export const RolePersistedSchema = z
-  .object({
-    id: z.uuid(),
-    type: z.enum(ROLE_TYPE_VALUES),
-    isActive: z.boolean().default(true),
-    isDefault: z.boolean().default(false),
-  })
-  .extend(TimestampSchema.shape);
-export type TRolePersisted = z.infer<typeof RolePersistedSchema>;
+export const RoleSchema = z.object({
+  type: z.enum(ROLE_TYPE_VALUES),
+  isActive: z.boolean().optional(),
+  isDefault: z.boolean().optional(),
+});
+export type TRole = z.infer<typeof RoleSchema>;
 
-export const RoleWithPermissionsSchema = RolePersistedSchema.extend({
-  permissionIds: UuidArraySchema.optional(),
+export const RolePersistedSchema = RoleSchema.required({ isActive: true, isDefault: true }).extend({
+  id: UuidSchema,
+  ...TimestampSchema.shape,
 });
-export type TRoleWithPermissions = z.infer<typeof RoleWithPermissionsSchema>;
+export type TRolePersisted = z.infer<typeof RolePersistedSchema>;
 
 export const RoleTranslationsSchema = z.object({
   name: z.string().min(3),
@@ -23,10 +27,17 @@ export const RoleTranslationsSchema = z.object({
 });
 export type TRoleTranslations = z.infer<typeof RoleTranslationsSchema>;
 
-export const RoleWithTranslationsSchema = RoleWithPermissionsSchema.extend({
+export const RoleWriteSchema = RoleSchema.extend({
   translations: makeTranslations(RoleTranslationsSchema),
+  permissionIds: UuidArraySchema.optional(),
+});
+export type TRoleWrite = z.infer<typeof RoleWriteSchema>;
+
+export const RoleDetailSchema = RolePersistedSchema.extend({
+  translations: makeTranslations(RoleTranslationsSchema),
+  permissionIds: UuidArraySchema.optional(),
 });
-export type TRoleWithTranslations = z.infer<typeof RoleWithTranslationsSchema>;
+export type TRoleDetail = z.infer<typeof RoleDetailSchema>;
 
 export const RoleListItemSchema = RolePersistedSchema.extend({
   name: z.string().nullable(),

package/build/hotels/settings/contracts/find-hotel-domain-settings.contract.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FindHotelDomainSettingsContract = void 0;
-const common_1 = require("../../../common");
-const hotel_domain_settings_api_1 = require("../hotel-domain-settings.api");
-const hotel_domain_settings_schema_1 = require("../hotel-domain-settings.schema");
-var FindHotelDomainSettingsContract;
-(function (FindHotelDomainSettingsContract) {
-    FindHotelDomainSettingsContract.getUrl = hotel_domain_settings_api_1.HOTEL_DOMAIN_SETTINGS_API.find;
-    FindHotelDomainSettingsContract.endpoint = hotel_domain_settings_api_1.HOTEL_DOMAIN_SETTINGS_CONTROLLER.endpoints.find;
-    FindHotelDomainSettingsContract.httpMethod = common_1.HTTP_METHODS.get;
-    FindHotelDomainSettingsContract.ResponseSchema = hotel_domain_settings_schema_1.HotelDomainSettingsListSchema;
-})(FindHotelDomainSettingsContract || (exports.FindHotelDomainSettingsContract = FindHotelDomainSettingsContract = {}));

package/build/hotels/settings/contracts/update-hotel-domain-settings.contract.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateHotelDomainSettingsContract = void 0;
-const common_1 = require("../../../common");
-const hotel_domain_settings_api_1 = require("../hotel-domain-settings.api");
-const hotel_domain_settings_schema_1 = require("../hotel-domain-settings.schema");
-var UpdateHotelDomainSettingsContract;
-(function (UpdateHotelDomainSettingsContract) {
-    UpdateHotelDomainSettingsContract.getUrl = hotel_domain_settings_api_1.HOTEL_DOMAIN_SETTINGS_API.update;
-    UpdateHotelDomainSettingsContract.endpoint = hotel_domain_settings_api_1.HOTEL_DOMAIN_SETTINGS_CONTROLLER.endpoints.update;
-    UpdateHotelDomainSettingsContract.httpMethod = common_1.HTTP_METHODS.put;
-    UpdateHotelDomainSettingsContract.RequestSchema = hotel_domain_settings_schema_1.HotelDomainSettingsSchema;
-    UpdateHotelDomainSettingsContract.ResponseSchema = hotel_domain_settings_schema_1.HotelDomainSettingsPersistedSchema;
-})(UpdateHotelDomainSettingsContract || (exports.UpdateHotelDomainSettingsContract = UpdateHotelDomainSettingsContract = {}));

package/build/hotels/settings/hotel-domain-settings.api.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HOTEL_DOMAIN_SETTINGS_API = exports.HOTEL_DOMAIN_SETTINGS_CONTROLLER = void 0;
-const utils_1 = require("../../common/utils");
-exports.HOTEL_DOMAIN_SETTINGS_CONTROLLER = {
-    prefix: 'hotels/by-id/:hotelId/settings/domains',
-    endpoints: {
-        find: '',
-        update: '',
-    },
-};
-exports.HOTEL_DOMAIN_SETTINGS_API = (0, utils_1.createApi)(exports.HOTEL_DOMAIN_SETTINGS_CONTROLLER);

package/common/models/uuid-array.schema.ts

@@ -1,3 +0,0 @@
-import * as z from 'zod';
-
-export const UuidArraySchema = z.array(z.uuid());