@roomstay/core 0.1.85-2 → 0.1.85-4

package/dist/types/Rule/EDayOfWeek.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum EDayOfWeek {
+    MON = "MON",
+    TUE = "TUE",
+    WED = "WED",
+    THU = "THU",
+    FRI = "FRI",
+    SAT = "SAT",
+    SUN = "SUN"
+}

package/dist/types/Rule/EDisplayPolicyEffectType.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum EDisplayPolicyEffectType {
+    Visibility = "visibility",
+    Exclusivity = "exclusivity"
+}
+export declare enum EDisplayPolicyExclusivityMode {
+    Cheapest = "cheapest",
+    MostExpensive = "most_expensive"
+}
+export interface IDisplayPolicyExclusivityConfiguration {
+    mode: EDisplayPolicyExclusivityMode;
+}

package/dist/types/Rule/ERuleType.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum ERuleType {
+    Schedule = "Schedule",
+    GeoLock = "GeoLock",
+    DeviceTarget = "DeviceTarget",
+    DayOfWeek = "DayOfWeek",
+    HotelRestriction = "HotelRestriction",
+    RoomRestriction = "RoomRestriction",
+    RateRestriction = "RateRestriction",
+    NightCount = "NightCount",
+    AnyOf = "AnyOf"
+}

package/dist/types/Rule/IRule.type.d.ts

@@ -0,0 +1 @@
+export type { IRuleSpec } from './IRuleConfigurations.type';

package/dist/types/Rule/IRuleConfigurations.type.d.ts

@@ -0,0 +1,68 @@
+import { EDayOfWeek } from './EDayOfWeek.enum';
+import { ERuleType } from './ERuleType.enum';
+export interface IScheduleConfig {
+    type: 'clock' | 'stay';
+    rules: Array<{
+        type: 'include' | 'exclude';
+        startDate: string;
+        endDate: string;
+        rrule?: string;
+    }>;
+}
+export interface IGeoLockConfig {
+    applicableCountryCodes: string[];
+    mode: 'allow' | 'deny';
+}
+export type TDeviceTarget = 'mobile' | 'desktop';
+export interface IDeviceTargetConfig {
+    allowedDevices: TDeviceTarget[];
+}
+export type TDayOfWeekSource = 'arrival' | 'night' | 'booking';
+export interface IDayOfWeekConfig {
+    source: TDayOfWeekSource;
+    allowedDays: EDayOfWeek[];
+}
+export interface IHotelRestrictionConfig {
+    hotelIds: string[];
+}
+export interface IRoomRestrictionConfig {
+    roomCodes: string[];
+}
+export interface IRateRestrictionConfig {
+    rateCodes: string[];
+}
+export interface INightCountConfig {
+    min?: number;
+    max?: number;
+}
+export interface IAnyOfConfig {
+    branches: IRuleSpec[][];
+}
+export type IRuleSpec = {
+    ruleType: ERuleType.Schedule;
+    configuration: IScheduleConfig;
+} | {
+    ruleType: ERuleType.GeoLock;
+    configuration: IGeoLockConfig;
+} | {
+    ruleType: ERuleType.DeviceTarget;
+    configuration: IDeviceTargetConfig;
+} | {
+    ruleType: ERuleType.DayOfWeek;
+    configuration: IDayOfWeekConfig;
+} | {
+    ruleType: ERuleType.HotelRestriction;
+    configuration: IHotelRestrictionConfig;
+} | {
+    ruleType: ERuleType.RoomRestriction;
+    configuration: IRoomRestrictionConfig;
+} | {
+    ruleType: ERuleType.RateRestriction;
+    configuration: IRateRestrictionConfig;
+} | {
+    ruleType: ERuleType.NightCount;
+    configuration: INightCountConfig;
+} | {
+    ruleType: ERuleType.AnyOf;
+    configuration: IAnyOfConfig;
+};

package/dist/types/Rule/IRuleContext.type.d.ts

@@ -0,0 +1,13 @@
+export interface IRuleContextDescriptor {
+    hasHotel: true;
+    hasNow: true;
+    optional: {
+        checkInDate?: true;
+        checkOutDate?: true;
+        nightDate?: true;
+        event?: true;
+        geolocation?: true;
+        rateCode?: true;
+        roomCode?: true;
+    };
+}

package/dist/types/Rule/index.d.ts

@@ -0,0 +1,4 @@
+export * from './EDayOfWeek.enum';
+export * from './EDisplayPolicyEffectType.enum';
+export * from './ERuleType.enum';
+export * from './IRuleConfigurations.type';

package/dist/types/Rules/DisplayPolicyEffect.schema.d.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import { EDisplayPolicyExclusiveMode } from '../DisplayPolicy/IDisplayPolicy.type';
+/**
+ * Every DisplayPolicy has *rules* (predicates that gate when it applies) and an *effect*
+ * (what it does to its bound rates):
+ *
+ * - `visibility`  — show the bound rates only when the rules pass (no config needed).
+ * - `exclusivity` — show only the cheapest / most expensive of the bound rates.
+ */
+export type EDisplayPolicyEffectType = 'visibility' | 'exclusivity';
+export declare const DISPLAY_POLICY_EFFECT_TYPES: EDisplayPolicyEffectType[];
+export declare const EDisplayPolicyEffectTypeSchema: z.ZodEnum<{
+    visibility: "visibility";
+    exclusivity: "exclusivity";
+}>;
+export declare const ExclusivityEffectConfigSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        Cheapest: EDisplayPolicyExclusiveMode.Cheapest;
+        MostExpensive: EDisplayPolicyExclusiveMode.MostExpensive;
+    }>;
+}, z.core.$strip>;
+export type IExclusivityEffectConfig = z.infer<typeof ExclusivityEffectConfigSchema>;

package/dist/types/Rules/ERuleType.enum.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The shared library of reusable Rules — predicates over a context, written once
+ * and used by every subject (DisplayPolicy rate visibility, RMS discount applicability,
+ * PromoCode eligibility).
+ *
+ * `AnyOf` = OR (`.some`), `AllOf` = AND (`.every`); both are shaped `{ rules: IRule[] }`.
+ * The top-level rule list of any subject is an implicit root AND.
+ */
+export declare enum ERuleType {
+    Schedule = "Schedule",
+    GeoLock = "GeoLock",
+    DeviceTarget = "DeviceTarget",
+    HotelRestriction = "HotelRestriction",
+    RoomRestriction = "RoomRestriction",
+    RateRestriction = "RateRestriction",
+    StayLength = "StayLength",
+    AnyOf = "AnyOf",
+    AllOf = "AllOf"
+}

package/dist/types/Rules/Rule.schema.d.ts

@@ -0,0 +1,124 @@
+import * as z from 'zod';
+import { EDisplayPolicyDeviceTarget } from '../DisplayPolicy/IDisplayPolicy.type';
+import { ERuleType } from './ERuleType.enum';
+/**
+ * Which date a Schedule rule's windows test.
+ *
+ * - `bookingTime` → `hotel.now()` (the moment the booking is being made)
+ * - `arrivalDate` → the stay's check-in date
+ * - `stayDates`   → a single night under test (per-night pass only)
+ *
+ * `mode` replaces the legacy `type: 'clock' | 'stay'` field, which collided with the
+ * per-window `type: 'include' | 'exclude'` and misleadingly called the arrival date "stay".
+ */
+export declare enum EScheduleMode {
+    BookingTime = "bookingTime",
+    ArrivalDate = "arrivalDate",
+    StayDates = "stayDates"
+}
+export declare const ScheduleWindowSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        include: "include";
+        exclude: "exclude";
+    }>;
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+    rrule: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ScheduleConfigSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        bookingTime: EScheduleMode.BookingTime;
+        arrivalDate: EScheduleMode.ArrivalDate;
+        stayDates: EScheduleMode.StayDates;
+    }>;
+    rules: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            include: "include";
+            exclude: "exclude";
+        }>;
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        rrule: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GeoLockConfigSchema: z.ZodObject<{
+    applicableCountryCodes: z.ZodArray<z.ZodString>;
+    mode: z.ZodEnum<{
+        block: "block";
+        allow: "allow";
+    }>;
+}, z.core.$strip>;
+export declare const DeviceTargetConfigSchema: z.ZodObject<{
+    allowedDevices: z.ZodArray<z.ZodEnum<{
+        desktop: EDisplayPolicyDeviceTarget.Desktop;
+        mobile: EDisplayPolicyDeviceTarget.Mobile;
+    }>>;
+}, z.core.$strip>;
+export declare const HotelRestrictionConfigSchema: z.ZodObject<{
+    providerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const RoomRestrictionConfigSchema: z.ZodObject<{
+    roomCodes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const RateRestrictionConfigSchema: z.ZodObject<{
+    rateCodes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const StayLengthConfigSchema: z.ZodObject<{
+    minNights: z.ZodOptional<z.ZodNumber>;
+    maxNights: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type IScheduleConfig = z.infer<typeof ScheduleConfigSchema>;
+export type IScheduleWindow = z.infer<typeof ScheduleWindowSchema>;
+export type IGeoLockConfig = z.infer<typeof GeoLockConfigSchema>;
+export type IDeviceTargetConfig = z.infer<typeof DeviceTargetConfigSchema>;
+export type IHotelRestrictionConfig = z.infer<typeof HotelRestrictionConfigSchema>;
+export type IRoomRestrictionConfig = z.infer<typeof RoomRestrictionConfigSchema>;
+export type IRateRestrictionConfig = z.infer<typeof RateRestrictionConfigSchema>;
+export type IStayLengthConfig = z.infer<typeof StayLengthConfigSchema>;
+/** `AnyOf`/`AllOf` config: a nested rule list. `AnyOf` = OR, `AllOf` = AND. */
+export interface ICompositeConfig {
+    rules: IRule[];
+}
+/**
+ * The canonical rule — a discriminated union that ties each `ruleType` to its config shape,
+ * so constructing a rule with the wrong configuration is a compile error. Use this everywhere
+ * rules are *built* (the RMS sync mapper, the write path).
+ */
+export type IRule = {
+    ruleType: ERuleType.Schedule;
+    configuration: IScheduleConfig;
+} | {
+    ruleType: ERuleType.GeoLock;
+    configuration: IGeoLockConfig;
+} | {
+    ruleType: ERuleType.DeviceTarget;
+    configuration: IDeviceTargetConfig;
+} | {
+    ruleType: ERuleType.HotelRestriction;
+    configuration: IHotelRestrictionConfig;
+} | {
+    ruleType: ERuleType.RoomRestriction;
+    configuration: IRoomRestrictionConfig;
+} | {
+    ruleType: ERuleType.RateRestriction;
+    configuration: IRateRestrictionConfig;
+} | {
+    ruleType: ERuleType.StayLength;
+    configuration: IStayLengthConfig;
+} | {
+    ruleType: ERuleType.AnyOf;
+    configuration: ICompositeConfig;
+} | {
+    ruleType: ERuleType.AllOf;
+    configuration: ICompositeConfig;
+};
+/**
+ * A persisted / dynamically-edited rule row whose `configuration` hasn't been validated yet
+ * (a JSON DB column, an HTTP body, an admin field-array row). Narrow it to {@link IRule} with
+ * {@link RuleSchema}.parse — parse returns the typed value, so narrowing never needs a cast.
+ */
+export type IStoredRule = {
+    ruleType: ERuleType;
+    configuration: unknown;
+};
+export declare const RuleSchema: z.ZodType<IRule>;

package/dist/types/index.d.ts

@@ -172,7 +172,12 @@ export * from './GiftCards/GiftCardLogs.enum';
  * Display Policies
  */
 export * from './DisplayPolicy/IDisplayPolicy.type';
-export * from './DisplayPolicy/EDisplayPolicyRuleType.enum';
+/**
+ * Shared Rules library + DisplayPolicy effect model
+ */
+export * from './Rules/ERuleType.enum';
+export * from './Rules/Rule.schema';
+export * from './Rules/DisplayPolicyEffect.schema';
 /**
  * Metasearch
  */