hh-contracts 0.0.95 → 0.0.97

package/common/constants/domain-name.constant.ts

@@ -0,0 +1,8 @@
+import { minLength } from 'zod';
+
+export const DOMAIN_NAME_CONFIG = {
+  minLength: 1,
+  maxLength: 253,
+  regex: /^(?!-)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/i,
+  messageKey: 'zod.domainName.invalidFormat',
+} as const;

package/common/constants/index.ts

@@ -12,4 +12,6 @@ export * from './order-direction.constant';
 export * from './role-types.constant';
 export * from './route-component-key.constants';
 export * from './slug.constant';
+export * from './time-zone.constant';
+export * from './domain-name.constant';
 export * from './translatable-field.constant';

package/common/constants/slug.constant.ts

@@ -4,4 +4,5 @@ export const SLUG_CONFIG = {
   maxLength: 63,
   minLength: 3,
   regex: /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
-};
+  messageKey: 'zod.slug.invalidFormat',
+} as const;

package/common/constants/time-zone.constant.ts

@@ -0,0 +1,4 @@
+export const TIME_ZONE_CONFIG = {
+  regex: /^[A-Za-z]+(?:[_-][A-Za-z]+)?\/[A-Za-z]+(?:[_-][A-Za-z]+)?$/,
+  messageKey: 'zod.timezone.invalidFormat',
+} as const;

package/common/models/domain-name.schema.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { DOMAIN_NAME_CONFIG } from '../constants';
+
+export const DomainNameSchema = z
+  .string()
+  .min(DOMAIN_NAME_CONFIG.minLength)
+  .max(DOMAIN_NAME_CONFIG.maxLength)
+  .refine(value => DOMAIN_NAME_CONFIG.regex.test(value), {
+    params: {
+      messageKey: DOMAIN_NAME_CONFIG.messageKey,
+    },
+  });
+
+export type TDomainName = z.infer<typeof DomainNameSchema>;

package/common/models/index.ts

@@ -7,6 +7,8 @@ export * from './pagination.schema';
 export * from './search.schema';
 export * from './slug.schema';
 export * from './timestamp.schemas';
+export * from './timezone.schema';
 export * from './language-keys.schema';
 export * from './translations.schemas';
-export * from './uuid-array.schema';
+export * from './uuid.schemas';
+export * from './domain-name.schema';

package/common/models/slug.schema.ts

@@ -6,5 +6,9 @@ export const SlugSchema = z
   .trim()
   .min(SLUG_CONFIG.minLength)
   .max(SLUG_CONFIG.maxLength)
-  .regex(SLUG_CONFIG.regex)
+  .refine(value => SLUG_CONFIG.regex.test(value), {
+    params: {
+      messageKey: SLUG_CONFIG.messageKey,
+    },
+  })
   .toLowerCase();

package/common/models/timestamp.schemas.ts

@@ -8,3 +8,7 @@ export const TimestampSchema = z.object({
 export const TimestampWithDeletedSchema = TimestampSchema.extend({
   deletedAt: z.date().nullable(),
 });
+
+export const IsoDatetimeSchema = z.iso.datetime();
+export const IsoDateSchema = z.iso.date();
+export const IsoTimeSchema = z.iso.time();

package/common/models/timezone.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+import { TIME_ZONE_CONFIG } from '../constants';
+
+export const TimezoneSchema = z.string().refine(value => TIME_ZONE_CONFIG.regex.test(value), {
+  params: {
+    messageKey: TIME_ZONE_CONFIG.messageKey,
+  },
+});
+
+export type TTimezone = z.infer<typeof TimezoneSchema>;

package/common/models/uuid.schemas.ts

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

package/companies/company.models.ts

@@ -1,9 +1,9 @@
 import * as z from 'zod';
-import { TimestampSchema } from '../common';
+import { TimestampSchema, UuidSchema } from '../common';
 
 export const CompanyPersistedSchema = z
   .object({
-    id: z.uuid(),
+    id: UuidSchema,
     inn: z.string(),
     isActive: z.boolean().default(true),
   })

package/hotels/amenities/hotel-amenity.model.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+import { HOTEL_AMENITY_VALUES } from '../constants';
+import { UuidSchema } from '../../common';
+
+export const HotelAmenitySchema = z.object({
+  hotelId: UuidSchema,
+  amenityCode: z.enum(HOTEL_AMENITY_VALUES),
+  isPrimary: z.boolean().default(false),
+});
+export type THotelAmenity = z.infer<typeof HotelAmenitySchema>;

package/hotels/amenities/index.ts

@@ -0,0 +1 @@
+export * from './hotel-amenity.model';

package/hotels/constants/hotel-amenity.constant.ts

@@ -0,0 +1,18 @@
+export const HOTEL_AMENITIES = {
+  wifi: 'wifi',
+  parking: 'parking',
+  pool: 'pool',
+  spa: 'spa',
+  gym: 'gym',
+  restaurant: 'restaurant',
+  bar: 'bar',
+  conferenceRoom: 'conferenceRoom',
+  businessCenter: 'businessCenter',
+} as const;
+
+export type THotelAmenityCode = (typeof HOTEL_AMENITIES)[keyof typeof HOTEL_AMENITIES];
+
+export const HOTEL_AMENITY_VALUES = Object.values(HOTEL_AMENITIES) as [
+  THotelAmenityCode,
+  ...THotelAmenityCode[],
+];

package/hotels/constants/hotel-contact-type.constant.ts

@@ -0,0 +1,12 @@
+export const HOTEL_CONTACT_TYPES = {
+  mainPhone: 'mainPhone',
+  reservations: 'reservations',
+  sales: 'sales',
+} as const;
+
+export type THotelContactType = (typeof HOTEL_CONTACT_TYPES)[keyof typeof HOTEL_CONTACT_TYPES];
+
+export const HOTEL_CONTACT_TYPE_VALUES = Object.values(HOTEL_CONTACT_TYPES) as [
+  THotelContactType,
+  ...THotelContactType[],
+];

package/hotels/constants/hotel-feature.constant.ts

@@ -0,0 +1,14 @@
+export const HOTEL_FEATURES = {
+  site: 'site',
+  services: 'services',
+  digitalSignage: 'digitalSignage',
+  hskRoomStatus: 'hskRoomStatus',
+  fbBreakfastCheckin: 'fbBreakfastCheckin',
+} as const;
+
+export type THotelFeatureKey = (typeof HOTEL_FEATURES)[keyof typeof HOTEL_FEATURES];
+
+export const HOTEL_FEATURE_VALUES = Object.values(HOTEL_FEATURES) as [
+  THotelFeatureKey,
+  ...THotelFeatureKey[],
+];

package/hotels/constants/hotel-integration-connection-state.constant.ts

@@ -0,0 +1,13 @@
+export const HOTEL_INTEGRATION_CONNECTION_STATES = {
+  offline: 'offline',
+  connecting: 'connecting',
+  online: 'online',
+  degraded: 'degraded',
+} as const;
+
+export type THotelIntegrationConnectionState =
+  (typeof HOTEL_INTEGRATION_CONNECTION_STATES)[keyof typeof HOTEL_INTEGRATION_CONNECTION_STATES];
+
+export const HOTEL_INTEGRATION_CONNECTION_STATE_VALUES = Object.values(
+  HOTEL_INTEGRATION_CONNECTION_STATES,
+) as [THotelIntegrationConnectionState, ...THotelIntegrationConnectionState[]];

package/hotels/constants/hotel-integration-credential-status.constant.ts

@@ -0,0 +1,12 @@
+export const HOTEL_INTEGRATION_CREDENTIAL_STATUSES = {
+  active: 'active',
+  rotating: 'rotating',
+  revoked: 'revoked',
+} as const;
+
+export type THotelIntegrationCredentialStatus =
+  (typeof HOTEL_INTEGRATION_CREDENTIAL_STATUSES)[keyof typeof HOTEL_INTEGRATION_CREDENTIAL_STATUSES];
+
+export const HOTEL_INTEGRATION_CREDENTIAL_STATUS_VALUES = Object.values(
+  HOTEL_INTEGRATION_CREDENTIAL_STATUSES,
+) as [THotelIntegrationCredentialStatus, ...THotelIntegrationCredentialStatus[]];

package/hotels/constants/hotel-integration-provider.constant.ts

@@ -0,0 +1,11 @@
+export const HOTEL_INTEGRATION_PROVIDERS = {
+  opera: 'opera',
+} as const;
+
+export type THotelIntegrationProvider =
+  (typeof HOTEL_INTEGRATION_PROVIDERS)[keyof typeof HOTEL_INTEGRATION_PROVIDERS];
+
+export const HOTEL_INTEGRATION_PROVIDER_VALUES = Object.values(HOTEL_INTEGRATION_PROVIDERS) as [
+  THotelIntegrationProvider,
+  ...THotelIntegrationProvider[],
+];

package/hotels/constants/hotel-integration-sync-status.constant.ts

@@ -0,0 +1,13 @@
+export const HOTEL_INTEGRATION_SYNC_STATUSES = {
+  idle: 'idle',
+  running: 'running',
+  success: 'success',
+  failed: 'failed',
+} as const;
+
+export type THotelIntegrationSyncStatus =
+  (typeof HOTEL_INTEGRATION_SYNC_STATUSES)[keyof typeof HOTEL_INTEGRATION_SYNC_STATUSES];
+
+export const HOTEL_INTEGRATION_SYNC_STATUS_VALUES = Object.values(
+  HOTEL_INTEGRATION_SYNC_STATUSES,
+) as [THotelIntegrationSyncStatus, ...THotelIntegrationSyncStatus[]];

package/hotels/constants/hotel-policy-type.constant.ts

@@ -0,0 +1,15 @@
+export const HOTEL_POLICY_TYPES = {
+  cancellation: 'cancellation',
+  deposit: 'deposit',
+  meal: 'meal',
+  pet: 'pet',
+  smoking: 'smoking',
+} as const;
+
+export type THotelPolicyType =
+  (typeof HOTEL_POLICY_TYPES)[keyof typeof HOTEL_POLICY_TYPES];
+
+export const HOTEL_POLICY_TYPE_VALUES = Object.values(HOTEL_POLICY_TYPES) as [
+  THotelPolicyType,
+  ...THotelPolicyType[],
+];

package/hotels/constants/hotel-rating-source.constant.ts

@@ -0,0 +1,12 @@
+export const HOTEL_RATING_SOURCES = {
+  google: 'google',
+  yandexMaps: 'yandexMaps',
+  ostrovok: 'ostrovok',
+} as const;
+
+export type THotelRatingSource = (typeof HOTEL_RATING_SOURCES)[keyof typeof HOTEL_RATING_SOURCES];
+
+export const HOTEL_RATING_SOURCE_VALUES = Object.values(HOTEL_RATING_SOURCES) as [
+  THotelRatingSource,
+  ...THotelRatingSource[],
+];

package/hotels/constants/index.ts

@@ -0,0 +1,9 @@
+export * from './hotel-amenity.constant';
+export * from './hotel-contact-type.constant';
+export * from './hotel-feature.constant';
+export * from './hotel-integration-connection-state.constant';
+export * from './hotel-integration-credential-status.constant';
+export * from './hotel-integration-provider.constant';
+export * from './hotel-integration-sync-status.constant';
+export * from './hotel-policy-type.constant';
+export * from './hotel-rating-source.constant';

package/hotels/contacts/hotel-contact.model.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import { HOTEL_CONTACT_TYPE_VALUES } from '../constants';
+import { TimestampSchema, UuidSchema } from '../../common';
+
+export const HotelContactSchema = z
+  .object({
+    hotelId: UuidSchema,
+    contactType: z.enum(HOTEL_CONTACT_TYPE_VALUES),
+    value: z.string().min(1),
+    isPublic: z.boolean().default(true),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .extend(TimestampSchema.shape);
+
+export type THotelContact = z.infer<typeof HotelContactSchema>;

package/hotels/contacts/index.ts

@@ -0,0 +1 @@
+export * from './hotel-contact.model';

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

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../common';
+import { HOTELS_API, HOTELS_CONTROLLER } from '../hotels.api';
+import { HotelWriteSchema, HotelDetailSchema } from '../hotel.models';
+
+export namespace CreateHotelContract {
+  export const getUrl = HOTELS_API.create;
+  export const endpoint = HOTELS_CONTROLLER.endpoints.create;
+  export const httpMethod = HTTP_METHODS.post;
+
+  export const RequestSchema = HotelWriteSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = HotelDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../common';
+import { HOTELS_API, HOTELS_CONTROLLER } from '../hotels.api';
+
+export namespace DeleteHotelContract {
+  export const getUrl = HOTELS_API.deleteById;
+  export const endpoint = HOTELS_CONTROLLER.endpoints.deleteById;
+  export const httpMethod = HTTP_METHODS.delete;
+
+  export const ResponseSchema = z.void();
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

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

@@ -1 +1,27 @@
-export namespace FindHotelContract {}
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../common';
+import { HotelDetailSchema } from '../hotel.models';
+import {
+  HOTELS_API,
+  HOTELS_BY_SLUG_API,
+  HOTELS_BY_SLUG_CONTROLLER,
+  HOTELS_CONTROLLER,
+} from '../hotels.api';
+
+export namespace FindHotelByIdContract {
+  export const getUrl = HOTELS_API.findById;
+  export const endpoint = HOTELS_CONTROLLER.endpoints.findById;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const ResponseSchema = HotelDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}
+
+export namespace FindHotelBySlugContract {
+  export const getUrl = HOTELS_BY_SLUG_API.find;
+  export const endpoint = HOTELS_BY_SLUG_CONTROLLER.endpoints.find;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const ResponseSchema = HotelDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/hotels/contracts/find-many-hotels.contract.ts

@@ -0,0 +1,43 @@
+import * as z from 'zod';
+import { HTTP_METHODS, CommonQueryParamsSchema, PaginationResponseSchema } from '../../common';
+import { HotelListItemSchema } from '../hotel.models';
+import { HOTELS_API, HOTELS_CONTROLLER } from '../hotels.api';
+
+const BaseQuerySchema = HotelListItemSchema.pick({
+  status: true,
+  category: true,
+  stars: true,
+}).partial();
+
+const OrderBySchema = HotelListItemSchema.omit({
+  id: true,
+}).keyof();
+
+const FindManyHotelsContractRequestSchema = BaseQuerySchema.extend({
+  ...CommonQueryParamsSchema.shape,
+  orderBy: OrderBySchema.optional(),
+});
+
+const FindManyHotelsContractResponseSchema = z
+  .object({
+    hotels: z.array(HotelListItemSchema),
+  })
+  .extend(PaginationResponseSchema.shape);
+
+export namespace FindManyHotelsContract {
+  export const getUrl = HOTELS_API.findMany;
+  export const endpoint = HOTELS_CONTROLLER.endpoints.findMany;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const BaseFilterSchema = BaseQuerySchema;
+  export type TBaseFilter = z.infer<typeof BaseFilterSchema>;
+
+  export const SORTING_KEYS = OrderBySchema.options;
+  export type TSortingKey = z.infer<typeof OrderBySchema>;
+
+  export const RequestSchema = FindManyHotelsContractRequestSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = FindManyHotelsContractResponseSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/hotels/contracts/index.ts

@@ -1 +1,5 @@
 export * from './find-hotel.contract';
+export * from './find-many-hotels.contract';
+export * from './update-hotel.contract';
+export * from './delete-hotel.contract';
+export * from './create-hotel.contract';

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

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../common';
+import { HOTELS_API, HOTELS_CONTROLLER } from '../hotels.api';
+import { HotelDetailSchema } from '../hotel.models';
+import { CreateHotelContract } from './create-hotel.contract';
+
+export namespace UpdateHotelContract {
+  export const getUrl = HOTELS_API.updateById;
+  export const endpoint = HOTELS_CONTROLLER.endpoints.updateById;
+  export const httpMethod = HTTP_METHODS.put;
+
+  export const RequestSchema = CreateHotelContract.RequestSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = HotelDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/hotels/domains/contracts/find-hotel-domain-settings.contract.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_DOMAINS_API, HOTEL_DOMAINS_CONTROLLER } from '../hotel-domains.api';
+import { HotelDomainListSchema } from '../hotel-domains.schema';
+
+export namespace FindHotelDomainsContract {
+  export const getUrl = HOTEL_DOMAINS_API.find;
+  export const endpoint = HOTEL_DOMAINS_CONTROLLER.endpoints.find;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const ResponseSchema = HotelDomainListSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/hotels/domains/contracts/index.ts

@@ -0,0 +1,2 @@
+export * from './find-hotel-domain-settings.contract';
+export * from './update-hotel-domain-settings.contract';

package/hotels/domains/contracts/update-hotel-domain-settings.contract.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_DOMAINS_API, HOTEL_DOMAINS_CONTROLLER } from '../hotel-domains.api';
+import { HotelDomainPersistedSchema, HotelDomainSchema } from '../hotel-domains.schema';
+
+export namespace UpdateHotelDomainContract {
+  export const getUrl = HOTEL_DOMAINS_API.update;
+  export const endpoint = HOTEL_DOMAINS_CONTROLLER.endpoints.update;
+  export const httpMethod = HTTP_METHODS.put;
+
+  export const RequestSchema = HotelDomainSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = HotelDomainPersistedSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,11 @@
+import { createApi, TController } from '../../common/utils';
+
+export const HOTEL_DOMAINS_CONTROLLER = {
+  prefix: 'hotels/by-id/:hotelId/domains',
+  endpoints: {
+    find: '',
+    update: '',
+  },
+} as const satisfies TController;
+
+export const HOTEL_DOMAINS_API = createApi(HOTEL_DOMAINS_CONTROLLER);

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/features/hotel-feature.model.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { TimestampSchema } from '../../common';
+import { HOTEL_FEATURE_VALUES } from '../constants';
+
+export const HotelFeatureSchema = z
+  .object({
+    hotelId: z.uuid(),
+    feature: z.enum(HOTEL_FEATURE_VALUES),
+    enabled: z.boolean(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .extend(TimestampSchema.shape);
+
+export type THotelFeature = z.infer<typeof HotelFeatureSchema>;

package/hotels/features/index.ts

@@ -0,0 +1 @@
+export * from './hotel-feature.model';

package/hotels/hotel.models.ts

@@ -0,0 +1,70 @@
+import * as z from 'zod';
+import {
+  LANGUAGE_KEYS,
+  TimestampSchema,
+  AppStatuses,
+  SlugSchema,
+  makeTranslations,
+  IsoTimeSchema,
+  TimezoneSchema,
+  UuidSchema,
+} from '../common';
+
+export const HotelSchema = z.object({
+  slug: SlugSchema,
+  chainId: UuidSchema.optional(),
+  status: z.enum(AppStatuses.HOTEL_VALUES).optional(), // сервер может проставить дефолт
+  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(),
+});
+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({
+  name: z.string().min(3),
+  description: z.string().optional(),
+});
+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,
+  timezone: true,
+  currency: true,
+  defaultLang: true,
+  availableLangs: true,
+  checkInFrom: true,
+  checkOutUntil: true,
+  version: true,
+}).extend({
+  name: z.string().nullable(),
+});
+export type THotelListItem = z.infer<typeof HotelListItemSchema>;

package/hotels/hotels.api.ts

@@ -1,12 +1,22 @@
 import { createApi, TController } from '../common/utils';
 
+export const HOTELS_CONTROLLER = {
+  prefix: 'hotels',
+  endpoints: {
+    create: '',
+    findMany: '',
+    findById: 'by-id/:hotelId',
+    updateById: 'by-id/:hotelId',
+    deleteById: 'by-id/:hotelId',
+  },
+} as const satisfies TController;
+
 export const HOTELS_BY_SLUG_CONTROLLER = {
-  prefix: 'hotels/by-slug',
+  prefix: 'hotels/by-slug/:hotelSlug',
   endpoints: {
-    findTheme: ':hotelSlug/theme',
-    findSitePageByLang: ':hotelSlug/sites/pages/:slug',
-    findSitePage: ':hotelSlug/sites/pages/:slug',
+    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

@@ -1,5 +1,14 @@
 export * from './contracts';
+export * from './constants';
+export * from './amenities';
+export * from './contacts';
+export * from './features';
+export * from './integrations';
+export * from './location';
+export * from './policies';
+export * from './ratings';
 export * from './sites';
+export * from './domains';
 export * from './themes';
-export * from './hotel.model';
+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),
+});