@pisell/pisellos 2.3.144 → 2.3.145

package/lib/modules/ResourcePlanner/planner.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createAvailabilityProjection = createAvailabilityProjection;
+exports.getDurationBusinessDate = getDurationBusinessDate;
 exports.getProductTimeRanges = getProductTimeRanges;
 exports.queryAvailabilityProjection = queryAvailabilityProjection;
 exports.validateAvailabilitySelection = validateAvailabilitySelection;
@@ -250,6 +251,18 @@ function evaluateCandidateTimeGate(params) {
     };
   }
   const policy = product.cutOffPolicy;
+  // Current duration items can be shown outside business hours. Their real
+  // interval must remain unavailable, including products with no resource groups.
+  if (evaluationContext.useDurationTimeGrid && product.kind === 'duration' && !projection.meta.defaults.operatingHours.windows.some(window => {
+    const range = normalizeAbsoluteRange(window);
+    return range && contains(range, candidateRange);
+  })) {
+    return {
+      status: 'unavailable',
+      reasonCodes: ['outside_operating_hours'],
+      conflictCode: 'booking_cutoff'
+    };
+  }
   if (!policy) return null;
   if (resolveCutOffPolicyIssue(policy)) {
     return {
@@ -286,8 +299,8 @@ function evaluateCandidateTimeGate(params) {
     // otherwise a minute refresh turns it into 0 capacity and incorrectly
     // advances a create flow to the next slot. The earlier `past` gate still
     // rejects the anchor once its booking range has ended.
-    const isActivePosDurationAnchor = evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration' && !product.isFlexibleDuration && evaluationContext.durationCandidateAnchorAtMs === candidateRange.start;
-    const usesMinutePrecision = product.isFlexibleDuration || evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration';
+    const isActivePosDurationAnchor = evaluationContext.useExactDurationCandidateMinute && !evaluationContext.enforceSaleCutoff && product.kind === 'duration' && !product.isFlexibleDuration && evaluationContext.durationCandidateAnchorAtMs === candidateRange.start;
+    const usesMinutePrecision = product.isFlexibleDuration || evaluationContext.useDurationTimeGrid || evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration';
     const hasNotReachedStart = isActivePosDurationAnchor || (usesMinutePrecision ? floorToMinute(now) <= candidateRange.start : now < candidateRange.start);
     if (hasNotReachedStart) return null;
     return {
@@ -489,11 +502,34 @@ function normalizeOperatingHours(params) {
   }));
   const windows = normalizeWindows(sourceWindows);
   const excludedWindows = normalizeWindows(params.input?.excludedWindows || []);
+  // Keep original dates and opening anchors separately: the availability
+  // windows below may be clipped at midnight or merged without segment identity.
+  const periodMap = new Map();
+  const originalPeriods = params.input?.businessPeriods || [...sourceWindows, ...(params.input?.excludedWindows || [])].map(window => ({
+    businessDate: window.businessDate || window.startAt.slice(0, 10),
+    startAt: window.openingAnchorAt || window.startAt,
+    endAt: window.endAt
+  }));
+  originalPeriods.forEach(period => {
+    const range = normalizeAbsoluteRange(period);
+    if (!range) return;
+    const previous = periodMap.get(period.businessDate);
+    periodMap.set(period.businessDate, {
+      start: previous ? Math.min(previous.start, range.start) : range.start,
+      end: previous ? Math.max(previous.end, range.end) : range.end
+    });
+  });
+  const businessPeriods = Array.from(periodMap, ([businessDate, range]) => ({
+    businessDate,
+    startAt: formatDateTime(range.start, params.timezoneName, params.fixedOffsetMinutes),
+    endAt: formatDateTime(range.end, params.timezoneName, params.fixedOffsetMinutes)
+  })).sort((left, right) => left.startAt.localeCompare(right.startAt));
   return {
     source: params.input?.source || params.fallbackSource,
     scheduleIds: uniqById(params.input?.scheduleIds || []),
     missingScheduleIds: uniqById(params.input?.missingScheduleIds || []),
     windows,
+    businessPeriods,
     ...(excludedWindows.length > 0 ? {
       excludedWindows
     } : {})
@@ -992,6 +1028,162 @@ function createDurationTimeRangeWithEnd(product, start, bookingEnd, projection,
     scheduleRefs: []
   };
 }
+
+/** Resolve the label without changing the real calendar timestamp. */
+function getDurationBusinessDate(projection, startAt) {
+  const start = toDateTime(startAt);
+  const periods = projection.meta.defaults.operatingHours.businessPeriods || [];
+  const period = [...periods].reverse().find(item => {
+    const range = normalizeAbsoluteRange(item);
+    return range && range.start <= start && start < range.end;
+  });
+  return period?.businessDate || startAt.slice(0, 10);
+}
+function getAlignedDurationRanges(params) {
+  const {
+    projection,
+    product,
+    request,
+    runtimeOptions,
+    dateRange,
+    operatingRanges,
+    baseRanges,
+    resourceWindowIndex,
+    fixedOffsetMinutes
+  } = params;
+  const step = projection.meta.defaults.slotStepMinutes;
+  const now = floorToMinute(toDateTime(runtimeOptions.evaluatedAt || projection.meta.durationCandidateAnchorAt));
+  if (!Number.isFinite(now)) throw availabilityError('INVALID_TARGET_FILTER', 'evaluatedAt 必须是有效时间');
+  const nowAt = formatDateTime(now, projection.meta.timezone, fixedOffsetMinutes);
+  const currentBusinessDate = getDurationBusinessDate(projection, nowAt);
+  const inRequestedDays = date => date >= dateRange.startDate && date <= dateRange.endDate;
+  const periods = (projection.meta.defaults.operatingHours.businessPeriods || []).filter(period => inRequestedDays(period.businessDate));
+  // A prepared month includes tomorrow's windows too; the single-day UI must
+  // receive the selected business cycle's end, not tomorrow's closing time.
+  const operatingEndAt = dateRange.startDate === dateRange.endDate && periods.length ? periods.reduce((latest, period) => period.endAt > latest ? period.endAt : latest, periods[0].endAt) : undefined;
+  const ranges = [];
+  const duration = resolveRequestedDurationMinutes(product, request);
+  const addRange = (start, end, businessDate) => {
+    if (end <= start) return;
+    const candidate = createDurationTimeRangeWithEnd(product, start, end, projection, fixedOffsetMinutes);
+    candidate.businessDate = businessDate || getDurationBusinessDate(projection, candidate.startAt);
+    if (inRequestedDays(candidate.businessDate)) ranges.push(candidate);
+  };
+  // A flexible end comes from resources that actually cover this exact start,
+  // never from the next future window. Keep alternative real ends separate.
+  const flexibleEnds = start => {
+    const operating = operatingRanges.find(range => range.start <= start && start < range.end);
+    if (!operating) return [];
+    const businessDate = getDurationBusinessDate(projection, formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes));
+    const period = projection.meta.defaults.operatingHours.businessPeriods?.find(item => item.businessDate === businessDate);
+    const operatingEnd = Math.min(operating.end, period ? toDateTime(period.endAt) : operating.end);
+    const requiredGroups = (product.requirementGroups || []).filter(group => group.required !== false);
+    const groups = requiredGroups.map(group => projection.resources.filter(resource => matchesRequirementGroup(group, resource, product, request.partySize)).filter(resource => !request.resourceIds?.length || request.resourceIds.some(id => sameId(id, resource.id))).flatMap(resource => (resourceWindowIndex.get(String(resource.id)) || []).filter(range => range.start <= start && start < range.end).map(range => Math.min(range.end, operatingEnd))));
+    if (groups.some(ends => ends.length === 0)) return [];
+    if (!groups.length) return [operatingEnd];
+    return Array.from(new Set(groups.flat())).filter(end => groups.every(ends => ends.some(availableEnd => availableEnd >= end))).sort((left, right) => left - right);
+  };
+  if (product.isFlexibleDuration) {
+    // Preserve the existing continuous-window UI, with the business-day label.
+    periods.forEach(period => {
+      const periodRange = normalizeAbsoluteRange(period);
+      baseRanges.forEach(range => {
+        const start = Math.max(range.start, periodRange.start, now);
+        const end = Math.min(range.end, periodRange.end);
+        if (start < end) addRange(start, end, period.businessDate);
+      });
+    });
+  } else {
+    periods.forEach(period => {
+      const periodRange = normalizeAbsoluteRange(period);
+      const anchor = 60 % step === 0 ? toDateStart(period.businessDate) : periodRange.start;
+      baseRanges.forEach(range => {
+        const lower = Math.max(range.start, periodRange.start, now);
+        const upper = Math.min(range.end, periodRange.end);
+        let cursor = anchor + Math.ceil((lower - anchor) / (step * 60000)) * step * 60000;
+        for (; cursor + duration * 60000 <= upper; cursor += step * 60000) {
+          addRange(cursor, cursor + duration * 60000, period.businessDate);
+        }
+      });
+    });
+  }
+  let unavailableCurrentTime;
+  if (inRequestedDays(currentBusinessDate)) {
+    if (product.isFlexibleDuration) {
+      const ends = flexibleEnds(now);
+      ends.forEach(end => addRange(now, end, currentBusinessDate));
+      if (!ends.length) {
+        unavailableCurrentTime = {
+          productId: product.id,
+          startAt: nowAt,
+          date: formatDate(now),
+          businessDate: currentBusinessDate,
+          startTime: formatTime(now),
+          status: 'unavailable',
+          reasonCodes: [operatingRanges.some(range => range.start <= now && now < range.end) ? 'outside_resource_window' : 'outside_operating_hours']
+        };
+      }
+    } else {
+      // Even outside a working window the fixed product has a real end. Query
+      // reports unavailable; POS manual capabilities remain a separate policy.
+      addRange(now, now + duration * 60000, currentBusinessDate);
+    }
+  }
+  const rememberedAt = request.rememberedStartAtByProductId?.[String(product.id)];
+  if (rememberedAt !== undefined) {
+    const start = toDateTime(rememberedAt);
+    if (!Number.isFinite(start)) throw availabilityError('INVALID_TARGET_FILTER', '记忆开始时间必须是完整日期时间');
+    if (product.isFlexibleDuration) {
+      flexibleEnds(start).forEach(end => addRange(start, end));
+    } else {
+      addRange(start, start + duration * 60000);
+    }
+  }
+  const editingAt = request.editingStartAtByProductId?.[String(product.id)];
+  if (editingAt !== undefined) {
+    const start = toDateTime(editingAt);
+    const editingDuration = Number(request.durationMinutesByProductId?.[String(product.id)]);
+    if (!Number.isFinite(start) || !Number.isInteger(editingDuration) || editingDuration <= 0) {
+      throw availabilityError('INVALID_TARGET_FILTER', '编辑时间必须包含完整开始日期时间和明确的正整数时长');
+    }
+    // Editing restores the original interval, including its actual overnight
+    // date. It neither adopts the current grid nor recomputes a flexible end.
+    if (request.allowOutsideOperatingHoursForRequestedStartTimes || operatingRanges.some(range => range.start <= start && start < range.end)) {
+      addRange(start, addMinutesZoned(start, editingDuration, projection.meta.timezone));
+    }
+  }
+
+  // Explicit custom input keeps its existing start + requested duration
+  // semantics. Remembered input above must never use this default-30 path.
+  if (dateRange.startDate === dateRange.endDate) {
+    resolveRequestedDurationStartTimes(product, request).forEach(startTime => {
+      const sameDayStart = toDateTimeInDate(dateRange.startDate, startTime);
+      const period = periods.find(item => item.businessDate === dateRange.startDate);
+      const periodRange = period ? normalizeAbsoluteRange(period) : null;
+      const nextDayStart = (0, _localClock.addLocalCalendarDays)(sameDayStart, 1);
+      // HH:mm is entered within a selected business day, whose early hours
+      // may belong to the next calendar day. Do not move other out-of-hours
+      // manual input to tomorrow merely because the business closes overnight.
+      const start = periodRange && !(periodRange.start <= sameDayStart && sameDayStart < periodRange.end) && periodRange.start <= nextDayStart && nextDayStart < periodRange.end ? nextDayStart : sameDayStart;
+      if (request.allowOutsideOperatingHoursForRequestedStartTimes || operatingRanges.some(range => range.start <= start && start < range.end)) {
+        addRange(start, start + duration * 60000);
+      }
+    });
+  }
+  return {
+    productId: product.id,
+    title: product.title,
+    kind: product.kind,
+    slotStepMinutes: step,
+    ...(operatingEndAt ? {
+      operatingEndAt
+    } : {}),
+    ranges: dedupeProductRanges(ranges),
+    ...(unavailableCurrentTime ? {
+      unavailableCurrentTime
+    } : {})
+  };
+}
 function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
   const normalizedPartySize = normalizePartySize(request.partySize);
   const dateRange = resolveProjectionDateRange(projection, request.dateRange);
@@ -1044,6 +1236,19 @@ function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
       includeExcludedWindows: allowExcludedScheduleDateOverride
     })).reduce((current, ranges) => current === null ? ranges : intersectRangeLists(current, ranges), null) || [] : null;
     const baseRanges = resourceRanges === null ? operatingRanges : intersectRangeLists(resourceRanges, operatingRanges);
+    if (runtimeOptions.useDurationTimeGrid) {
+      return getAlignedDurationRanges({
+        projection,
+        product,
+        request,
+        runtimeOptions,
+        dateRange,
+        operatingRanges,
+        baseRanges,
+        resourceWindowIndex,
+        fixedOffsetMinutes
+      });
+    }
     const durationMinutes = resolveRequestedDurationMinutes(product, request);
     const flexibleStartAt = (() => {
       if (!product.isFlexibleDuration) return undefined;
@@ -1265,7 +1470,9 @@ function buildEvaluationContext(params) {
     selectionsByGroupKey,
     useExactDurationCandidateMinute: params.useExactDurationCandidateMinute === true,
     durationCandidateAnchorAtMs: Number.isFinite(durationCandidateAnchorAt) ? floorToMinute(durationCandidateAnchorAt) : null,
-    allowExcludedScheduleDateOverride: params.allowExcludedScheduleDateOverride === true
+    allowExcludedScheduleDateOverride: params.allowExcludedScheduleDateOverride === true,
+    useDurationTimeGrid: params.useDurationTimeGrid === true,
+    enforceSaleCutoff: params.enforceSaleCutoff === true
   };
 }
 function summarizeStatuses(statuses) {
@@ -1672,6 +1879,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
     projection,
     evaluatedAt,
     resourceIds: request.resourceIds,
+    useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+    enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
     useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
     allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
   });
@@ -1748,6 +1957,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
     partySize: normalizedPartySize
   }, {
     evaluatedAt,
+    useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+    enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
     useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
     allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
   });
@@ -1772,7 +1983,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
           candidateRangeCache,
           evaluationContext
         });
-        const aggregate = byDate.get(candidate.date) || {
+        const candidateDate = runtimeOptions.useDurationTimeGrid ? candidate.businessDate || candidate.date : candidate.date;
+        const aggregate = byDate.get(candidateDate) || {
           availableCount: 0,
           totalCount: 0,
           maxPartySize: 0,
@@ -1790,8 +2002,24 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
         aggregate.maxCapacity += evaluated.maxCapacity;
         pushStatusAggregate(aggregate.statusAggregate, evaluated.status);
         evaluated.reasonCodes.forEach(reasonCode => aggregate.reasonCodeSet.add(reasonCode));
-        byDate.set(candidate.date, aggregate);
+        byDate.set(candidateDate, aggregate);
       });
+      if (group.unavailableCurrentTime) {
+        const current = group.unavailableCurrentTime;
+        const aggregate = byDate.get(current.businessDate) || {
+          availableCount: 0,
+          totalCount: 0,
+          maxPartySize: 0,
+          remainingCapacity: 0,
+          maxCapacity: 0,
+          reasonCodeSet: new Set(),
+          statusAggregate: createStatusAggregate()
+        };
+        aggregate.totalCount += 1;
+        pushStatusAggregate(aggregate.statusAggregate, 'unavailable');
+        current.reasonCodes.forEach(reason => aggregate.reasonCodeSet.add(reason));
+        byDate.set(current.businessDate, aggregate);
+      }
       const dates = enumerateDates(dateRange.startDate, dateRange.endDate).map(date => {
         const aggregate = byDate.get(date);
         return {
@@ -1849,10 +2077,20 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
       maxPartySize = Math.max(maxPartySize, evaluated.maxPartySize);
       pushStatusAggregate(productStatusAggregate, evaluated.status);
       evaluated.reasonCodes.forEach(reasonCode => productReasonCodeSet.add(reasonCode));
-      const dateAggregate = dateStatusMap.get(candidate.date) || createStatusAggregate();
+      const candidateDate = runtimeOptions.useDurationTimeGrid ? candidate.businessDate || candidate.date : candidate.date;
+      const dateAggregate = dateStatusMap.get(candidateDate) || createStatusAggregate();
       pushStatusAggregate(dateAggregate, evaluated.status);
-      dateStatusMap.set(candidate.date, dateAggregate);
+      dateStatusMap.set(candidateDate, dateAggregate);
     });
+    if (group.unavailableCurrentTime) {
+      const current = group.unavailableCurrentTime;
+      totalTimeCount += 1;
+      pushStatusAggregate(productStatusAggregate, 'unavailable');
+      current.reasonCodes.forEach(reason => productReasonCodeSet.add(reason));
+      const dateAggregate = dateStatusMap.get(current.businessDate) || createStatusAggregate();
+      pushStatusAggregate(dateAggregate, 'unavailable');
+      dateStatusMap.set(current.businessDate, dateAggregate);
+    }
     const availableDateCount = Array.from(dateStatusMap.values()).filter(aggregate => {
       const status = summarizeStatusAggregate(aggregate);
       return status === 'available' || status === 'limited';
@@ -1921,6 +2159,8 @@ function validateAvailabilitySelection(projection, params, runtimeOptions = {})
       projection,
       evaluatedAt,
       requirementSelections: params.requirementSelections,
+      useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+      enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
       useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
       allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
     })

package/lib/modules/ResourcePlanner/types.d.ts

@@ -92,6 +92,9 @@ export interface AvailabilityProduct {
     raw?: Record<string, any>;
 }
 export interface AvailabilityResourceWindow extends AvailabilityAbsoluteRange {
+    /** Original business day and opening anchor, before coverage clipping. */
+    businessDate?: string;
+    openingAnchorAt?: string;
     source?: string;
     raw?: Record<string, any>;
 }
@@ -101,10 +104,15 @@ export interface AvailabilityOperatingHoursSnapshot {
     scheduleIds: AvailabilityId[];
     missingScheduleIds: AvailabilityId[];
     windows: AvailabilityResourceWindow[];
+    /** Complete business cycles; lunch gaps remain in windows, not in this envelope. */
+    businessPeriods?: AvailabilityBusinessPeriod[];
     /** Schedule windows omitted only because their date is excluded. POS may use
      * these to surface an unavailable, manually selectable candidate. */
     excludedWindows?: AvailabilityResourceWindow[];
 }
+export interface AvailabilityBusinessPeriod extends AvailabilityAbsoluteRange {
+    businessDate: string;
+}
 export interface AvailabilityResource {
     id: AvailabilityId;
     formId?: AvailabilityId;
@@ -212,6 +220,17 @@ export interface ProductTimeRange extends AvailabilityDisplayRange {
     bookingEndAt: string;
     scheduleRefs: AvailabilityScheduleRef[];
     primaryScheduleRef?: AvailabilityScheduleRef;
+    /** Business-day label. date/startAt keep the actual calendar date. */
+    businessDate?: string;
+}
+export interface UnavailableCurrentTime {
+    productId: AvailabilityId;
+    startAt: string;
+    date: string;
+    businessDate: string;
+    startTime: string;
+    status: 'unavailable';
+    reasonCodes: string[];
 }
 export interface ProductTimeRangeGroup {
     productId: AvailabilityId;
@@ -221,6 +240,8 @@ export interface ProductTimeRangeGroup {
     /** 单日查询对应营业窗口的最终结束时刻，不受资源排班是否为空影响。 */
     operatingEndAt?: string;
     ranges: ProductTimeRange[];
+    /** A display-only current item when flexible duration has no valid end. Never submit it. */
+    unavailableCurrentTime?: UnavailableCurrentTime;
 }
 export interface AvailabilityAssignment extends AvailabilityAbsoluteRange {
     productId: AvailabilityId;
@@ -242,6 +263,10 @@ export interface GetProductTimeRangesRequest {
     partySize?: number;
     durationMinutesByProductId?: Record<string, number>;
     durationStartTimesByProductId?: Record<string, string[]>;
+    /** Restore only the exact remembered start; recompute the end from current product/windows. */
+    rememberedStartAtByProductId?: Record<string, string>;
+    /** Edit only: preserve the full actual start plus an explicit durationMinutesByProductId. */
+    editingStartAtByProductId?: Record<string, string>;
     /**
      * POS 手工输入时间的兼容开关：只为明确请求的 start time 补候选，
      * 不改变常规候选列表仍按营业时间生成的规则。
@@ -250,6 +275,10 @@ export interface GetProductTimeRangesRequest {
 }
 export interface GetProductTimeRangesRuntimeOptions {
     evaluatedAt?: string;
+    /** Enabled by the POS/Kiosk facade only; other consumers retain their existing grid. */
+    useDurationTimeGrid?: boolean;
+    /** Automatic remembered selection must not use POS opening-minute cutoff exceptions. */
+    enforceSaleCutoff?: boolean;
     /**
      * Internal POS capability: fixed-duration candidates start from the stable
      * context anchor's current minute instead of rounding up to ten minutes, and

package/lib/solution/BookingByStep/index.d.ts

@@ -328,7 +328,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         date: string;
         status: string;
         week: string;
-        weekNum: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+        weekNum: 0 | 2 | 1 | 6 | 4 | 5 | 3;
     }[]>;
     submitTimeSlot(timeSlots: TimeSliceItem): void;
     private getScheduleDataByIds;

package/lib/solution/BookingTicket/utils/addProductDecision.d.ts

@@ -65,7 +65,6 @@ export interface AddProductDecideContext extends BookingCalcContext {
     type?: 'select' | 'detail';
     quantity?: number;
     customerId?: number | string;
-    channel?: string;
 }
 /**
  * 统一补齐预约商品的运行态字段。

package/lib/solution/BookingTicket/utils/addProductDecision.js

@@ -146,7 +146,7 @@ function isMultiDayLike(cacheItem) {
  * `_extend.resource / capacity / startDate / endDate` 等后续 booking mapper 需要的字段。
  */
 function prepareBookingCacheItem(cacheItem, ctx) {
-  if (isNormalBookingProduct(cacheItem) || hasPreparedBookingExtend(cacheItem)) {
+  if (ctx?.rememberedTime === undefined && (isNormalBookingProduct(cacheItem) || hasPreparedBookingExtend(cacheItem))) {
     return cacheItem;
   }
   return (0, _BookingContext.getProductExtend)({

package/lib/solution/UnifiedBookingSales/index.d.ts

@@ -99,6 +99,9 @@ export declare class UnifiedBookingSalesImpl extends BookingTicket {
     protected getSubModuleHooks(moduleName: string): any;
     private createAvailabilityFacadeError;
     private getAvailabilityScopeDescriptor;
+    private usesDurationTimeGrid;
+    private getCurrentAvailabilityBusinessDate;
+    private getAvailabilityBusinessDateRange;
     private normalizeAvailabilityIdList;
     private normalizeAvailabilityStringList;
     private normalizeAvailabilityPrepareDescriptor;