@pisell/pisellos 2.2.292 → 2.2.293

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

@@ -0,0 +1,49 @@
+import type { AvailabilityDateRange } from '../../modules/ResourcePlanner';
+type AvailabilityId = number | string;
+export declare class AvailabilityRemoteOccupancyCache {
+    private readonly maxCells;
+    private readonly cells;
+    private readonly resourceMeta;
+    private readonly resourceCellCounts;
+    constructor(maxCells?: number);
+    clear(): void;
+    read(params: {
+        scopeKey: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+    }): Record<string, any>[] | null;
+    hasCompleteCoverage(params: {
+        scopeKey: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+    }): boolean;
+    publish(params: {
+        scopeKey: string;
+        timezoneName: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+        rawResources: Record<string, any>[];
+        version: number;
+    }): void;
+    private buildResourceKey;
+    private buildCellKey;
+    private touchCell;
+    /**
+     * A response is one coherent resource snapshot for its requested range. If any overlapping day
+     * already contains a newer response, publishing only the older response's remaining days would
+     * let a cross-midnight event leak back into that newer day when ranges are recomposed.
+     */
+    private canPublishResourceRange;
+    /**
+     * A day cell stores the original event range so it can be reconstructed without losing server
+     * identity. When a newer adjacent-day response replaces that event, evict older neighbour cells
+     * whose event overlaps the refreshed range. The next wider read becomes a cache miss instead of
+     * reintroducing stale occupancy from the neighbour.
+     */
+    private invalidateAdjacentOverlappingCells;
+    private deleteCell;
+    private deleteResourceCells;
+    private writeResourceMeta;
+    private writeCell;
+}
+export {};

package/lib/solution/UnifiedBookingSales/remoteOccupancyCache.js

@@ -0,0 +1,316 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AvailabilityRemoteOccupancyCache = void 0;
+var _lodashEs = require("lodash-es");
+var _localClock = require("../../modules/ResourcePlanner/localClock");
+function uniqueIds(values) {
+  const result = new Map();
+  values.forEach(value => {
+    if (value === undefined || value === null || value === '') return;
+    result.set(String(value), value);
+  });
+  return Array.from(result.values());
+}
+function buildDateList(dateRange) {
+  if (!dateRange?.startDate || !dateRange?.endDate) return [];
+  try {
+    const startOrdinal = (0, _localClock.dateOrdinalFromLocalDate)(dateRange.startDate);
+    const endOrdinal = (0, _localClock.dateOrdinalFromLocalDate)(dateRange.endDate);
+    if (endOrdinal < startOrdinal) return [];
+    const dates = [];
+    let cursor = (0, _localClock.localDateToScalarStart)(dateRange.startDate);
+    for (let ordinal = startOrdinal; ordinal <= endOrdinal; ordinal += 1) {
+      dates.push((0, _localClock.formatLocalDate)(cursor));
+      cursor = (0, _localClock.addLocalCalendarDays)(cursor, 1);
+    }
+    return dates;
+  } catch {
+    return [];
+  }
+}
+function resolveResourceId(raw) {
+  const id = raw.resourceId ?? raw.resource_id ?? raw.id;
+  if (id === undefined || id === null || id === '') return null;
+  return id;
+}
+function getRawEventStartAt(rawEvent) {
+  const startAt = rawEvent.start_at ?? rawEvent.startAt ?? rawEvent.start_time ?? rawEvent.startTime;
+  return startAt ? String(startAt) : null;
+}
+function getRawEventEndAt(rawEvent) {
+  const endAt = rawEvent.end_at ?? rawEvent.endAt ?? rawEvent.end_time ?? rawEvent.endTime;
+  return endAt ? String(endAt) : null;
+}
+function parseEventScalar(value) {
+  return (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(value));
+}
+function buildEventIdentity(resourceId, rawEvent) {
+  const scheduleEventId = rawEvent.schedule_event_id ?? rawEvent.scheduleEventId;
+  if (scheduleEventId !== undefined && scheduleEventId !== null && scheduleEventId !== '') {
+    return `scheduleEvent:${String(resourceId)}:${String(scheduleEventId)}`;
+  }
+  const bookingUid = rawEvent.booking_uid ?? rawEvent.bookingUid ?? rawEvent.metadata?.unique_identification_number;
+  if (bookingUid !== undefined && bookingUid !== null && bookingUid !== '') {
+    return `bookingUid:${String(resourceId)}:${String(bookingUid)}`;
+  }
+  const productUid = rawEvent.product_uid ?? rawEvent.productUid ?? rawEvent.metadata?.product_uid;
+  if (productUid !== undefined && productUid !== null && productUid !== '') {
+    return `productUid:${String(resourceId)}:${String(productUid)}`;
+  }
+  return ['range', String(resourceId), getRawEventStartAt(rawEvent) || '', getRawEventEndAt(rawEvent) || ''].join(':');
+}
+function bucketEventDates(params) {
+  const startAt = getRawEventStartAt(params.rawEvent);
+  const endAt = getRawEventEndAt(params.rawEvent);
+  if (!startAt || !endAt) return [];
+  try {
+    const startScalar = parseEventScalar(startAt);
+    const endScalar = parseEventScalar(endAt);
+    if (endScalar <= startScalar) return [];
+    const endInclusiveScalar = endScalar - 1000;
+    const startDate = (0, _localClock.formatLocalDate)(startScalar);
+    const endDate = (0, _localClock.formatLocalDate)(endInclusiveScalar);
+    const startOrdinal = (0, _localClock.dateOrdinalFromLocalDate)(startDate);
+    const endOrdinal = (0, _localClock.dateOrdinalFromLocalDate)(endDate);
+    if (endOrdinal < startOrdinal) return [];
+    const dates = [];
+    let cursorDate = startDate;
+    for (let ordinal = startOrdinal; ordinal <= endOrdinal; ordinal += 1) {
+      if (params.requestedDates.has(cursorDate)) {
+        dates.push(cursorDate);
+      }
+      cursorDate = (0, _localClock.nextDate)(cursorDate);
+    }
+    return dates;
+  } catch {
+    return [];
+  }
+}
+function sortEventList(events) {
+  return [...events].sort((left, right) => {
+    const leftStart = getRawEventStartAt(left) || '';
+    const rightStart = getRawEventStartAt(right) || '';
+    if (leftStart !== rightStart) return leftStart.localeCompare(rightStart);
+    const leftEnd = getRawEventEndAt(left) || '';
+    const rightEnd = getRawEventEndAt(right) || '';
+    if (leftEnd !== rightEnd) return leftEnd.localeCompare(rightEnd);
+    return buildEventIdentity(left.resource_id ?? left.resourceId ?? '', left).localeCompare(buildEventIdentity(right.resource_id ?? right.resourceId ?? '', right));
+  });
+}
+class AvailabilityRemoteOccupancyCache {
+  maxCells;
+  cells = new Map();
+  resourceMeta = new Map();
+  resourceCellCounts = new Map();
+  constructor(maxCells = 4096) {
+    this.maxCells = maxCells;
+  }
+  clear() {
+    this.cells.clear();
+    this.resourceMeta.clear();
+    this.resourceCellCounts.clear();
+  }
+  read(params) {
+    const requestedResourceIds = uniqueIds(params.resourceIds);
+    const requestedDates = buildDateList(params.dateRange);
+    if (requestedResourceIds.length === 0 || requestedDates.length === 0) return [];
+    const resources = [];
+    for (const resourceId of requestedResourceIds) {
+      const resourceKey = this.buildResourceKey(params.scopeKey, resourceId);
+      const eventList = new Map();
+      for (const date of requestedDates) {
+        const cellKey = this.buildCellKey(resourceKey, date);
+        const cell = this.touchCell(cellKey);
+        if (!cell) return null;
+        cell.eventList.forEach(rawEvent => {
+          eventList.set(buildEventIdentity(resourceId, rawEvent), (0, _lodashEs.cloneDeep)(rawEvent));
+        });
+      }
+      const metadataEntry = this.resourceMeta.get(resourceKey);
+      if (!metadataEntry) return null;
+      if (metadataEntry.status === 'absent') continue;
+      if (!metadataEntry.metadata) return null;
+      resources.push({
+        ...(0, _lodashEs.cloneDeep)(metadataEntry.metadata),
+        event_list: sortEventList(Array.from(eventList.values()))
+      });
+    }
+    return resources;
+  }
+  hasCompleteCoverage(params) {
+    const requestedResourceIds = uniqueIds(params.resourceIds);
+    const requestedDates = buildDateList(params.dateRange);
+    if (requestedResourceIds.length === 0 || requestedDates.length === 0) return true;
+    for (const resourceId of requestedResourceIds) {
+      const resourceKey = this.buildResourceKey(params.scopeKey, resourceId);
+      for (const date of requestedDates) {
+        const cell = this.cells.get(this.buildCellKey(resourceKey, date));
+        if (!cell) return false;
+      }
+    }
+    return true;
+  }
+  publish(params) {
+    const requestedResourceIds = uniqueIds(params.resourceIds);
+    const requestedDates = buildDateList(params.dateRange);
+    if (requestedResourceIds.length === 0 || requestedDates.length === 0) return;
+    const requestedDateSet = new Set(requestedDates);
+    const publishedAt = Date.now();
+    const requestedResourceKeyById = new Map(requestedResourceIds.map(resourceId => [String(resourceId), this.buildResourceKey(params.scopeKey, resourceId)]));
+    const rawResourceById = new Map();
+    (params.rawResources || []).forEach(rawResource => {
+      const resourceId = resolveResourceId(rawResource);
+      if (resourceId !== null && requestedResourceKeyById.has(String(resourceId))) {
+        rawResourceById.set(String(resourceId), rawResource);
+      }
+    });
+    requestedResourceIds.forEach(resourceId => {
+      const resourceKey = requestedResourceKeyById.get(String(resourceId));
+      if (!resourceKey) return;
+      if (!this.canPublishResourceRange(resourceKey, requestedDates, params.version)) return;
+      const rawResource = rawResourceById.get(String(resourceId));
+      const nextStatus = rawResource ? 'present' : 'absent';
+      const currentMetadata = this.resourceMeta.get(resourceKey);
+      if (currentMetadata && currentMetadata.version <= params.version && currentMetadata.status !== nextStatus) {
+        this.deleteResourceCells(resourceKey);
+      }
+      this.invalidateAdjacentOverlappingCells({
+        resourceKey,
+        requestedDates: requestedDateSet,
+        timezoneName: params.timezoneName
+      });
+      const metadata = rawResource ? (({
+        event_list: _eventList,
+        ...rest
+      }) => rest)(rawResource) : undefined;
+      this.writeResourceMeta(resourceKey, nextStatus, metadata, params.version);
+      const eventsByDate = new Map();
+      requestedDates.forEach(date => {
+        eventsByDate.set(date, new Map());
+      });
+      const eventList = Array.isArray(rawResource?.event_list) ? rawResource.event_list : [];
+      eventList.forEach(event => {
+        const rawEvent = (0, _lodashEs.cloneDeep)(event);
+        const identity = buildEventIdentity(resourceId, rawEvent);
+        bucketEventDates({
+          rawEvent,
+          timezoneName: params.timezoneName,
+          requestedDates: requestedDateSet
+        }).forEach(date => {
+          eventsByDate.get(date)?.set(identity, rawEvent);
+        });
+      });
+      requestedDates.forEach(date => {
+        this.writeCell({
+          key: this.buildCellKey(resourceKey, date),
+          resourceKey,
+          version: params.version,
+          eventList: sortEventList(Array.from(eventsByDate.get(date)?.values() || [])),
+          fetchedAt: publishedAt,
+          lastAccessedAt: publishedAt
+        });
+      });
+    });
+  }
+  buildResourceKey(scopeKey, resourceId) {
+    return `${scopeKey}:${String(resourceId)}`;
+  }
+  buildCellKey(resourceKey, date) {
+    return `${resourceKey}:${date}`;
+  }
+  touchCell(cellKey) {
+    const entry = this.cells.get(cellKey);
+    if (!entry) return null;
+    entry.lastAccessedAt = Date.now();
+    this.cells.delete(cellKey);
+    this.cells.set(cellKey, entry);
+    return entry;
+  }
+
+  /**
+   * A response is one coherent resource snapshot for its requested range. If any overlapping day
+   * already contains a newer response, publishing only the older response's remaining days would
+   * let a cross-midnight event leak back into that newer day when ranges are recomposed.
+   */
+  canPublishResourceRange(resourceKey, requestedDates, version) {
+    const metadata = this.resourceMeta.get(resourceKey);
+    if (metadata && metadata.version > version) return false;
+    return requestedDates.every(date => {
+      const current = this.cells.get(this.buildCellKey(resourceKey, date));
+      return !current || current.version <= version;
+    });
+  }
+
+  /**
+   * A day cell stores the original event range so it can be reconstructed without losing server
+   * identity. When a newer adjacent-day response replaces that event, evict older neighbour cells
+   * whose event overlaps the refreshed range. The next wider read becomes a cache miss instead of
+   * reintroducing stale occupancy from the neighbour.
+   */
+  invalidateAdjacentOverlappingCells(params) {
+    const keysToDelete = [];
+    this.cells.forEach((cell, cellKey) => {
+      if (cell.resourceKey !== params.resourceKey) return;
+      const cellDate = cellKey.slice(cell.resourceKey.length + 1);
+      if (params.requestedDates.has(cellDate)) return;
+      const overlapsRequestedDate = cell.eventList.some(rawEvent => bucketEventDates({
+        rawEvent,
+        timezoneName: params.timezoneName,
+        requestedDates: params.requestedDates
+      }).length > 0);
+      if (overlapsRequestedDate) keysToDelete.push(cellKey);
+    });
+    keysToDelete.forEach(cellKey => this.deleteCell(cellKey));
+  }
+  deleteCell(cellKey) {
+    const entry = this.cells.get(cellKey);
+    if (!entry) return;
+    this.cells.delete(cellKey);
+    const nextCount = (this.resourceCellCounts.get(entry.resourceKey) || 1) - 1;
+    if (nextCount <= 0) {
+      this.resourceCellCounts.delete(entry.resourceKey);
+      this.resourceMeta.delete(entry.resourceKey);
+      return;
+    }
+    this.resourceCellCounts.set(entry.resourceKey, nextCount);
+  }
+  deleteResourceCells(resourceKey) {
+    const keysToDelete = [];
+    this.cells.forEach((cell, cellKey) => {
+      if (cell.resourceKey === resourceKey) keysToDelete.push(cellKey);
+    });
+    keysToDelete.forEach(cellKey => this.deleteCell(cellKey));
+  }
+  writeResourceMeta(resourceKey, status, metadata, version) {
+    const current = this.resourceMeta.get(resourceKey);
+    if (current && current.version > version) return;
+    this.resourceMeta.set(resourceKey, {
+      version,
+      status,
+      metadata: metadata ? (0, _lodashEs.cloneDeep)(metadata) : undefined
+    });
+  }
+  writeCell(entry) {
+    const current = this.cells.get(entry.key);
+    if (current && current.version > entry.version) return;
+    if (!current) {
+      this.resourceCellCounts.set(entry.resourceKey, (this.resourceCellCounts.get(entry.resourceKey) || 0) + 1);
+    } else {
+      this.cells.delete(entry.key);
+    }
+    this.cells.set(entry.key, {
+      ...entry,
+      eventList: (0, _lodashEs.cloneDeep)(entry.eventList)
+    });
+    while (this.cells.size > this.maxCells) {
+      const oldest = this.cells.entries().next().value;
+      if (!oldest) break;
+      const [oldestKey] = oldest;
+      this.deleteCell(oldestKey);
+    }
+  }
+}
+exports.AvailabilityRemoteOccupancyCache = AvailabilityRemoteOccupancyCache;

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

@@ -1,91 +1,189 @@
-import type { ResourcePlannerModule } from '../../modules';
 import type { OpenDataConfig } from '../../modules/OpenData';
-import type { ResourcePlannerAssignment, ResourcePlannerAssignableSlotResult, ResourcePlannerContextInput, ResourcePlannerProjection, ResourcePlannerQuery, ResourcePlannerSelectionPatch, ResourcePlannerSnapshot, ResourcePlannerValidationResult } from '../../modules/ResourcePlanner';
-import type { ProductListLoadProductsParams } from '../../modules/ProductList';
+import type { ProductListLoadProductsParams, ProductListStoreQueryParams } from '../../modules/ProductList';
+import type { ProductData } from '../../modules/Product/types';
 import type { LoadScheduleAvailableDateParams } from '../../modules/Schedule/types';
+import type { AvailabilityDateRange, AvailabilityErrorCode, AvailabilityId, AvailabilityOccupancy, AvailabilityProduct, AvailabilityProjection, AvailabilityQuery, AvailabilityRequirementSelection, AvailabilityResource, AvailabilitySelectionValidationResult, DateAvailabilityQueryResult, GetProductTimeRangesRequest, ProductAvailabilityQueryResult, ProductTimeRange, ProductTimeRangeGroup, ResourceAvailabilityGroup, ResourceAvailabilityRangeGroup, TimeAvailabilityGroup, TimeAvailabilityItem } from '../../modules/ResourcePlanner';
 import type { BookingTicketState } from '../BookingTicket/types';
-export declare enum UnifiedBookingSalesHooks {
-    onPlannerContextLoaded = "unifiedBookingSales:onPlannerContextLoaded",
-    onPlannerCommitted = "unifiedBookingSales:onPlannerCommitted"
-}
+import type { AllergyRequirement } from '../../model/strategy/adapter/itemRule';
+import type { SalesNoteDraftInput } from '../../modules/Order/types';
+export type { ProductListStoreQueryParams } from '../../modules/ProductList';
+export type { AvailabilityAbsoluteRange, AvailabilityAssignment, AvailabilityCell, AvailabilityDateRange, AvailabilityDisplayRange, AvailabilityErrorCode, AvailabilityId, AvailabilityMode, AvailabilityOccupancy, AvailabilityProduct, AvailabilityProductKind, AvailabilityProjection, AvailabilityProjectionInput, AvailabilityProjectionMeta, AvailabilityQuery, AvailabilityQueryResult, AvailabilityRequirementGroup, AvailabilityRequirementGroupResult, AvailabilityRequirementSelection, AvailabilityResource, AvailabilityResourceOption, AvailabilityResourceType, AvailabilityResourceWindow, AvailabilityScheduleMode, AvailabilityScheduleRef, AvailabilityScheduleRule, AvailabilitySelectionValidationParams, AvailabilitySelectionValidationResult, AvailabilitySessionRange, AvailabilityStatus, DateAvailabilityGroup, DateAvailabilityItem, DateAvailabilityQuery, DateAvailabilityQueryResult, GetProductTimeRangesRequest, ProductAvailabilityGroup, ProductAvailabilityItem, ProductAvailabilityQuery, ProductAvailabilityQueryResult, ProductTimeRange, ProductTimeRangeGroup, QueryAvailabilityBaseRequest, ResourceAvailabilityGroup, ResourceAvailabilityQuery, ResourceAvailabilityQueryResult, ResourceAvailabilityRangeGroup, TimeAvailabilityGroup, TimeAvailabilityItem, TimeAvailabilityQuery, TimeAvailabilityQueryResult, } from '../../modules/ResourcePlanner';
 export interface UnifiedBookingSalesState extends BookingTicketState {
-    resourcePlanner: ResourcePlannerModule;
+}
+export interface UnifiedBookingSalesPolicy {
+    id?: AvailabilityId;
+    title?: unknown;
+    content?: string;
+    [key: string]: unknown;
+}
+export interface UnifiedBookingSalesPolicyResponse {
+    data?: UnifiedBookingSalesPolicy;
+    [key: string]: unknown;
+}
+export declare enum UnifiedBookingSalesHooks {
+    onAvailabilityProjectionPrepared = "unifiedBookingSales:onAvailabilityProjectionPrepared",
+    onAvailabilitySelectionCommitted = "unifiedBookingSales:onAvailabilitySelectionCommitted",
+    onAvailabilityProjectionDiagnostic = "unifiedBookingSales:onAvailabilityProjectionDiagnostic"
 }
 export interface UnifiedBookingSalesOtherParams extends Record<string, any> {
-    /**
-     * Persist the active order workspace in sessionStorage, partitioned by cacheId.
-     * Disabled by default and ignored when cacheId is missing.
-     */
     enableSessionStoragePersist?: boolean;
 }
-/** Explicit OpenData target used by page-level UnifiedBookingSales skins. */
+export type UnifiedBookingSalesAllergyRequirement = AllergyRequirement;
+export interface UnifiedBookingSalesResolveProductAllergyRequirementParams {
+    productId: number | string;
+    productVariantId?: number | string;
+    channel?: string;
+}
 export interface UnifiedBookingSalesLoadOpenDataParams {
     businessCode: string;
     channel: string;
-    /** Bypasses the target-scoped in-memory cache. */
     force?: boolean;
 }
-export interface UnifiedBookingSalesLoadPlannerContextParams extends ResourcePlannerQuery {
-    /** ProductList request options used only when products are not supplied as raw/context data. */
-    productLoadParams?: ProductListLoadProductsParams;
-    /** Escape hatch for tests or callers that already own raw ProductList records. */
-    rawProducts?: Record<string, any>[];
-    /** Escape hatch for tests or callers that already own raw resource records. */
-    rawResources?: Record<string, any>[];
-    /** Fully normalized Planner context; takes precedence over API loading for supplied fields. */
-    context?: ResourcePlannerContextInput;
-    /** Enables the v2 resource API + schedule materialization path. */
-    useResourceDateApi?: boolean;
-}
-export interface UnifiedBookingSalesCommitPlannerSelectionParams {
-    /** Optional selection patch applied before validation and order mutation. */
-    selection?: ResourcePlannerSelectionPatch;
-    /** Directly supplies selected resource/time facts, usually from resolveAssignableSlots(). */
-    assignments?: ResourcePlannerAssignment[];
-    /** Defaults to false. True performs the real BaseSales / OrderModule submit after tempOrder is written. */
-    submitAfterCommit?: boolean;
-}
 export interface UnifiedBookingSalesLoadProductsByScheduleDateParams extends Omit<ProductListLoadProductsParams, 'schedule_date' | 'product_ids'> {
-    /** The chosen calendar date, used for both availability lookup and ProductList schedule_date. */
     date: string;
-    /** Optional caller-side filter applied after the availability result produces its product pool. */
     product_ids?: number[];
-    /** Required by the availability API; this is not the low-code page id. */
     custom_page_id?: number;
-    /** Availability API channel, commonly pc. ProductList keeps its own sales application channel. */
     channel?: string;
 }
-export interface UnifiedBookingSalesStagePlannerProductsParams {
-    /** Products the customer selected before a time/resource booking exists. */
+export type UnifiedBookingSalesCatalogScope = {
+    type: 'schedule';
+    customPageId: number;
+    channel: string;
+} | {
+    type: 'productList';
+    params: ProductListLoadProductsParams;
+};
+export interface UnifiedBookingSalesPrepareAvailabilityProjectionParams {
+    productIds?: number[];
+    resourceIds?: AvailabilityId[];
+    dateRange?: Partial<AvailabilityDateRange>;
+    catalogScope?: UnifiedBookingSalesCatalogScope;
+    rawProducts?: Record<string, any>[];
+    rawResources?: Record<string, any>[];
+    rawOccupancies?: AvailabilityOccupancy[];
+    editingProductLineUids?: string[];
+    timezone?: string;
+    slotStepMinutes?: number;
+    businessHours?: {
+        startTime: string;
+        endTime: string;
+    };
+    mode?: 'appointment' | 'scan_order' | 'venue_grid';
+}
+export interface AvailabilityContextRef {
+    contextId: string;
+}
+export interface ContextualProductTimeRange extends ProductTimeRange {
+    availabilityContextId: string;
+    availabilityContextVersion: number;
+}
+export interface ContextualProductTimeRangeGroup extends Omit<ProductTimeRangeGroup, 'ranges'> {
+    ranges: ContextualProductTimeRange[];
+}
+export type ContextualAvailabilityQuery = Omit<Extract<AvailabilityQuery, {
+    target: 'product';
+}>, never> | Omit<Extract<AvailabilityQuery, {
+    target: 'date';
+}>, never> | (Omit<Extract<AvailabilityQuery, {
+    target: 'time';
+}>, 'candidates'> & {
+    candidates: ContextualProductTimeRange[];
+}) | (Omit<Extract<AvailabilityQuery, {
+    target: 'resource';
+}>, 'selectedRanges'> & {
+    selectedRanges: ContextualProductTimeRange[];
+});
+export type ContextualTimeAvailabilityItem = Omit<TimeAvailabilityItem, keyof ProductTimeRange> & ContextualProductTimeRange;
+export interface ContextualTimeAvailabilityGroup extends Omit<TimeAvailabilityGroup, 'times'> {
+    times: ContextualTimeAvailabilityItem[];
+}
+export interface ContextualResourceAvailabilityRangeGroup extends Omit<ResourceAvailabilityRangeGroup, 'range'> {
+    range: ContextualProductTimeRange;
+}
+export interface ContextualResourceAvailabilityGroup extends Omit<ResourceAvailabilityGroup, 'ranges'> {
+    ranges: ContextualResourceAvailabilityRangeGroup[];
+}
+type ContextualAvailabilityQueryResultMeta = {
+    contextId: string;
+    contextVersion: number;
+    refreshed: boolean;
+};
+export type ContextualAvailabilityQueryResult = (ProductAvailabilityQueryResult & ContextualAvailabilityQueryResultMeta) | (DateAvailabilityQueryResult & ContextualAvailabilityQueryResultMeta) | ({
+    target: 'time';
+    evaluatedAt: string;
+    snapshotId: string;
+    data: ContextualTimeAvailabilityGroup[];
+} & ContextualAvailabilityQueryResultMeta) | ({
+    target: 'resource';
+    evaluatedAt: string;
+    snapshotId: string;
+    data: ContextualResourceAvailabilityGroup[];
+} & ContextualAvailabilityQueryResultMeta);
+export type UnifiedBookingSalesAvailabilityCandidate = ContextualProductTimeRange;
+export type UnifiedBookingSalesProductTimeRangeGroup = ContextualProductTimeRangeGroup;
+export type UnifiedBookingSalesAvailabilityQueryResult = ContextualAvailabilityQueryResult;
+export interface UnifiedBookingSalesAvailabilityPreparedPayload {
+    context: AvailabilityContextRef;
+    contextVersion: number;
+    projection: AvailabilityProjection;
+    refreshed: boolean;
+    reason?: string;
+    previousOrderRevision?: AvailabilityId;
+}
+export interface UnifiedBookingSalesAvailabilityDiagnosticPayload {
+    contextId: string | null;
+    contextVersion: number | null;
+    reason: string;
+    projection: AvailabilityProjection | null;
+    action: 'prepare' | 'refresh' | 'release' | 'destroy' | 'set_other_params_reset' | 'commit_lock_wait' | 'commit_lock_acquired' | 'commit_lock_released';
+    snapshotId?: string;
+    orderRevision?: AvailabilityId;
+    previousOrderRevision?: AvailabilityId;
+    registrySize: number;
+    projectionPoolSize: number;
+}
+export interface UnifiedBookingSalesStageRetailProductsParams {
     productIds: Array<number | string>;
     productLoadParams?: ProductListLoadProductsParams;
     rawProducts?: Record<string, any>[];
 }
-/** Ordinary retail product staging. No resource, time, or booking facts are required. */
-export type UnifiedBookingSalesStageRetailProductsParams = UnifiedBookingSalesStagePlannerProductsParams;
-/** Adds one ordinary retail product without replacing other retail lines already in the cart. */
 export interface UnifiedBookingSalesAddRetailProductParams {
-    /** Prefer a supplied catalog record when the UI has already loaded it. */
     product?: Record<string, any>;
-    /** Used to resolve a product from the current catalog or load it on demand. */
     productId?: number | string;
-    /** Defaults to one. */
     quantity?: number;
-    /** Only used when the product is not already present in the solution catalog. */
     productLoadParams?: ProductListLoadProductsParams;
 }
-export interface UnifiedBookingSalesCommitResult {
+export interface ContextualCommitAvailabilitySelectionParams {
+    mode: 'add' | 'edit';
+    productLineUid?: string;
+    orderProduct: Record<string, any>;
+    candidate: ContextualProductTimeRange;
+    requirementSelections: AvailabilityRequirementSelection[];
+    partySize: number;
+    bookingCount?: number;
+    /** 新增商品行时与商品、预约在同一次 Order mutation 内写入的 Sales Notes。 */
+    salesNotes?: SalesNoteDraftInput[];
+    /** 编辑预约时，允许本次显式报价覆盖已落库订单行的历史价格。 */
+    allowBookingReprice?: boolean;
+    /** 编辑预约重报价后，允许订单模块重新应用已选编辑态折扣。 */
+    allowBookingDiscountReapply?: boolean;
+}
+export type UnifiedBookingSalesCommitAvailabilitySelectionParams = ContextualCommitAvailabilitySelectionParams;
+export interface UnifiedBookingSalesCommitAvailabilitySelectionResult {
+    contextId: string;
+    contextVersion: number;
     tempOrder: Record<string, any> | null;
-    assignments: ResourcePlannerAssignment[];
-    validation: ResourcePlannerValidationResult;
-    submitResult?: unknown;
+    validation: AvailabilitySelectionValidationResult;
+    candidate: ContextualProductTimeRange;
+    productLineUid?: string;
+    bookingUid?: string;
+    productLineUids?: string[];
+    bookingUids?: string[];
 }
+export type UnifiedBookingSalesAvailabilityErrorCode = AvailabilityErrorCode;
 export interface UnifiedBookingSalesApplyPlannerDiscountsParams {
-    /** Customer whose cards/coupons should be loaded. Defaults to tempOrder.customer_id. */
     customerId?: number | string;
-    /** Optional explicit card/coupon id. When provided, Rules applies this card instead of auto-picking another card. */
     preferredDiscountId?: number | string;
-    /** Defaults to true: after loading eligible cards, let Rules choose the best valid combination. */
     applyBestDiscount?: boolean;
 }
 export interface UnifiedBookingSalesDiscountItem {
@@ -110,7 +208,6 @@ export interface UnifiedBookingSalesDiscountResult {
     status: 'applied' | 'loaded' | 'no_customer';
     customerId: number | null;
     preferredDiscountFound?: boolean;
-    /** True only when the requested card is both selected and written into a planner product line. */
     preferredDiscountApplied?: boolean;
     availableDiscounts: UnifiedBookingSalesDiscountItem[];
     selectedDiscounts: UnifiedBookingSalesDiscountItem[];
@@ -119,32 +216,19 @@ export interface UnifiedBookingSalesDiscountResult {
     summaryAfter?: unknown;
 }
 export interface UnifiedBookingSalesApi {
-    /** Loads board OpenData for a concrete business + channel target. */
     loadOpenData: (params: UnifiedBookingSalesLoadOpenDataParams) => Promise<OpenDataConfig>;
-    /** Returns the latest OpenData payload cached by this solution instance. */
-    getOpenData: () => OpenDataConfig | null;
-    /** Date-first calendar availability backed by ScheduleModule. */
+    getOpenData: () => Promise<OpenDataConfig | null>;
     loadScheduleAvailableDate: (params: LoadScheduleAvailableDateParams) => Promise<unknown>;
-    /** Date-first product pool derived from schedule date ids and globally sellable products. */
     loadProductsByScheduleDate: (params: UnifiedBookingSalesLoadProductsByScheduleDateParams) => Promise<unknown[]>;
-    /** Adds product lines only; booking creation is intentionally deferred. */
-    stagePlannerProducts: (params: UnifiedBookingSalesStagePlannerProductsParams) => Promise<Record<string, any> | null>;
-    /** Adds ordinary product lines only. It never creates bookings or invokes ResourcePlanner. */
+    queryProducts: (params?: ProductListStoreQueryParams) => Promise<ProductData[]>;
     stageRetailProducts: (params: UnifiedBookingSalesStageRetailProductsParams) => Promise<Record<string, any> | null>;
-    /** Adds one ordinary retail line while preserving all existing cart lines. */
     addRetailProduct: (params: UnifiedBookingSalesAddRetailProductParams) => Promise<Record<string, any>[]>;
-    /** Loads and normalizes all IO data needed for the pure ResourcePlanner. */
-    loadPlannerContext: (params?: UnifiedBookingSalesLoadPlannerContextParams) => Promise<ResourcePlannerSnapshot>;
-    /** Reads continuous availability cells and UI-oriented aggregates. */
-    queryPlannerAvailability: (query?: ResourcePlannerQuery) => Promise<ResourcePlannerProjection>;
-    /** Produces selectable slots and the assignments required to commit them. */
-    resolveAssignableSlots: (query?: ResourcePlannerQuery) => ResourcePlannerAssignableSlotResult;
-    setPlannerSelection: (patch: ResourcePlannerSelectionPatch) => ResourcePlannerSnapshot;
-    autoAssignPlanner: (query?: ResourcePlannerQuery) => Promise<ResourcePlannerSnapshot>;
-    validatePlannerSelection: () => ResourcePlannerValidationResult;
-    /** Validates, writes to tempOrder, and only optionally makes a real submit request. */
-    commitPlannerSelection: (params?: UnifiedBookingSalesCommitPlannerSelectionParams) => Promise<UnifiedBookingSalesCommitResult>;
-    /** Loads the current customer's cards/coupons, optionally applies the best one, and reports line applications. */
+    prepareAvailabilityProjection: (params: UnifiedBookingSalesPrepareAvailabilityProjectionParams) => Promise<AvailabilityContextRef>;
+    getProductTimeRanges: (contextId: string, request?: GetProductTimeRangesRequest) => Promise<ContextualProductTimeRangeGroup[]>;
+    queryBookingAvailability: (contextId: string, request: ContextualAvailabilityQuery) => Promise<ContextualAvailabilityQueryResult>;
+    commitAvailabilitySelection: (contextId: string, params: ContextualCommitAvailabilitySelectionParams) => Promise<UnifiedBookingSalesCommitAvailabilitySelectionResult>;
+    releaseAvailabilityContext: (contextId: string) => void;
     applyPlannerDiscounts: (params?: UnifiedBookingSalesApplyPlannerDiscountsParams) => Promise<UnifiedBookingSalesDiscountResult>;
-    getPlannerSnapshot: () => ResourcePlannerSnapshot;
 }
+export type UnifiedBookingSalesNormalizedProduct = AvailabilityProduct;
+export type UnifiedBookingSalesNormalizedResource = AvailabilityResource;