@pisell/pisellos 2.3.72 → 2.3.73

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

@@ -1,227 +1,386 @@
-export type ResourcePlannerMode = 'appointment' | 'scan_order' | 'venue_grid';
-export type ResourcePlannerProductKind = 'normal' | 'duration' | 'session' | 'venue_slot';
-export type ResourcePlannerResourceType = 'single' | 'multiple' | 'capacity';
-export type ResourcePlannerStatus = 'available' | 'limited' | 'full' | 'conflict' | 'unavailable' | 'past';
-export interface ResourcePlannerTimeRange {
-    start_at: string;
-    end_at: string;
-}
-export interface ResourcePlannerEvent extends ResourcePlannerTimeRange {
-    resourceId?: number | string;
-    resource_id?: number | string;
-    pax?: number;
-    product_uid?: string;
-    source?: 'remote' | 'cart' | 'selection';
-    [key: string]: any;
+export type AvailabilityId = number | string;
+export type AvailabilityMode = 'appointment' | 'scan_order' | 'venue_grid';
+export type AvailabilityProductKind = 'normal' | 'duration' | 'session' | 'venue_slot';
+export type AvailabilityResourceType = 'single' | 'multiple' | 'capacity';
+export type AvailabilityStatus = 'available' | 'limited' | 'full' | 'conflict' | 'unavailable' | 'past';
+export type AvailabilityScheduleMode = 'daily' | 'weekly' | 'designation';
+export type AvailabilityErrorCode = 'MISSING_ANCHOR' | 'MISSING_CATALOG_SCOPE' | 'AVAILABILITY_CONTEXT_NOT_FOUND' | 'AVAILABILITY_SELECTION_STALE' | 'AVAILABILITY_COMMIT_IN_PROGRESS' | 'OPERATING_HOURS_RESOLVE_FAILED' | 'INVALID_DATE_RANGE' | 'RANGE_TOO_LARGE' | 'OUT_OF_PROJECTION_COVERAGE' | 'STALE_PROJECTION' | 'INVALID_TARGET_FILTER' | 'MISSING_TIME_CANDIDATES' | 'MISSING_SELECTED_RANGE' | 'PRODUCT_LINE_NOT_FOUND' | 'SELF_EXCLUSION_RESOLVE_FAILED' | 'INVALID_RESERVATION_QUANTITY' | 'REVALIDATION_FAILED';
+export interface AvailabilityAbsoluteRange {
+    startAt: string;
+    endAt: string;
 }
-export interface ResourcePlannerResourceRequirement {
-    formId?: number | string;
-    resourceIds?: Array<number | string>;
-    resourceType?: ResourcePlannerResourceType;
-    capacityRequired?: number;
+export interface AvailabilityDisplayRange extends AvailabilityAbsoluteRange {
+    date: string;
+    startTime: string;
+    endTime: string;
+    timezone: string;
+}
+export interface AvailabilityDateRange {
+    startDate: string;
+    endDate: string;
+}
+export interface AvailabilityScheduleRef {
+    scheduleId?: AvailabilityId;
+    timeSlotId?: AvailabilityId;
+    ruleId?: string;
+    source?: string;
+    label?: string;
+}
+export interface AvailabilityScheduleRule {
+    id: string;
+    mode: AvailabilityScheduleMode;
+    startTime: string;
+    endTime: string;
+    startDate?: string;
+    endDate?: string;
+    frequency?: number;
+    weekdays?: number[];
+    dates?: string[];
+    includeDates?: string[];
+    excludeDates?: string[];
+    scheduleRef?: AvailabilityScheduleRef;
+}
+export interface AvailabilitySessionRange extends AvailabilityAbsoluteRange {
+    scheduleRefs?: AvailabilityScheduleRef[];
+}
+export interface AvailabilityRequirementGroup {
+    id: string;
+    formId?: AvailabilityId;
+    title?: string;
+    code?: string;
+    resourceType: AvailabilityResourceType;
     required?: boolean;
+    min?: number;
+    max?: number;
+    resourceIds?: AvailabilityId[];
+    capacityRequired?: number;
+    raw?: Record<string, any>;
 }
-export interface ResourcePlannerProduct {
-    id: number | string;
+export type AvailabilityCutOffPolicy = {
+    type: 'ongoing';
+    mode: 'before_end';
+    futureDay?: number;
+} | {
+    type: 'ongoing';
+    mode: 'after_start';
+    graceMinutes: number;
+    futureDay?: number;
+} | {
+    type: 'before_start';
+    futureDay?: number;
+} | {
+    type: 'advance';
+    unit: number;
+    unitType: 'days' | 'hours' | 'minutes';
+    futureDay?: number;
+} | {
+    type: 'invalid';
+    reason: string;
+};
+export interface AvailabilityProduct {
+    id: AvailabilityId;
     title?: string;
-    kind: ResourcePlannerProductKind;
+    kind: AvailabilityProductKind;
     durationMinutes?: number;
-    schedule?: ResourcePlannerTimeRange[];
-    resourceRequirements?: ResourcePlannerResourceRequirement[];
-    capacityRequired?: number;
     quantity?: number;
-    price?: string | number | null;
+    capacityRequired?: number;
+    cutOffPolicy?: AvailabilityCutOffPolicy;
+    requirementGroups?: AvailabilityRequirementGroup[];
+    sessionRules?: AvailabilityScheduleRule[];
+    sessionRanges?: AvailabilitySessionRange[];
+    raw?: Record<string, any>;
+}
+export interface AvailabilityResourceWindow extends AvailabilityAbsoluteRange {
+    source?: string;
     raw?: Record<string, any>;
 }
-export interface ResourcePlannerResource {
-    id: number | string;
-    formId?: number | string;
+export type AvailabilityOperatingHoursSource = 'prepare_business_hours' | 'open_data_schedule' | 'default_business_hours';
+export interface AvailabilityOperatingHoursSnapshot {
+    source: AvailabilityOperatingHoursSource;
+    scheduleIds: AvailabilityId[];
+    missingScheduleIds: AvailabilityId[];
+    windows: AvailabilityResourceWindow[];
+}
+export interface AvailabilityResource {
+    id: AvailabilityId;
+    formId?: AvailabilityId;
     name?: string;
-    resourceType: ResourcePlannerResourceType;
+    code?: string;
+    resourceType: AvailabilityResourceType;
     capacity: number;
-    times: Array<ResourcePlannerTimeRange & {
-        event_list?: ResourcePlannerEvent[];
-        [key: string]: any;
-    }>;
-    childResourceIds?: Array<number | string>;
+    windows: AvailabilityResourceWindow[];
     raw?: Record<string, any>;
 }
-export interface ResourcePlannerContextInput {
-    products?: ResourcePlannerProduct[];
-    resources?: ResourcePlannerResource[];
-    externalEvents?: ResourcePlannerEvent[];
-    slotDurationMinutes?: number;
-    businessStartTime?: string;
-    businessEndTime?: string;
-}
-export interface ResourcePlannerQuery {
-    mode?: ResourcePlannerMode;
-    productIds?: Array<number | string>;
-    date?: string;
-    dateRange?: {
-        start: string;
-        end: string;
-    };
-    startTime?: string;
-    endTime?: string;
-    resourceIds?: Array<number | string>;
-    serviceObjectIds?: Array<number | string>;
-    holderIds?: Array<number | string>;
+export interface AvailabilityOccupancy extends AvailabilityAbsoluteRange {
+    id?: string;
+    resourceId: AvailabilityId;
     pax?: number;
-    slotDurationMinutes?: number;
-}
-export interface ResourcePlannerSelection {
-    productIds: Array<number | string>;
-    date?: string;
-    startTime?: string;
-    endTime?: string;
-    resourceIds: Array<number | string>;
-    assignments: ResourcePlannerAssignment[];
-    mode?: ResourcePlannerMode;
+    source?: 'remote' | 'cart' | 'selection';
+    serverEventId?: AvailabilityId;
+    bookingUid?: AvailabilityId;
+    productUid?: AvailabilityId;
+    scheduleEventId?: AvailabilityId;
+    raw?: Record<string, any>;
 }
-export interface ResourcePlannerSelectionPatch extends Partial<ResourcePlannerSelection> {
-    replaceAssignments?: boolean;
+export interface AvailabilityProjectionMeta {
+    readonly snapshotId: string;
+    readonly preparedAt: string;
+    readonly timezone: string;
+    readonly orderRevision?: AvailabilityId;
+    readonly mode: AvailabilityMode;
+    readonly coverage: Readonly<AvailabilityDateRange & AvailabilityAbsoluteRange>;
+    readonly defaults: {
+        readonly slotStepMinutes: number;
+        readonly businessHours: {
+            readonly startTime: string;
+            readonly endTime: string;
+        };
+        readonly operatingHours: Readonly<AvailabilityOperatingHoursSnapshot>;
+    };
+    readonly now: string;
+    readonly durationCandidateAnchorAt: string;
+    readonly prepareParams?: Readonly<Record<string, any>>;
+    readonly anchors?: {
+        readonly productIds?: readonly AvailabilityId[];
+        readonly resourceIds?: readonly AvailabilityId[];
+        readonly dateRange?: Readonly<AvailabilityDateRange>;
+    };
 }
-export interface ResourcePlannerDemandInterval {
-    id: string;
-    productId: number | string;
-    source: Extract<ResourcePlannerProductKind, 'duration' | 'session' | 'venue_slot'>;
-    date: string;
-    start_at: string;
-    end_at: string;
-    durationMinutes: number;
-    quantity: number;
-    capacityRequired: number;
-    resourceRequirements: ResourcePlannerResourceRequirement[];
-}
-export interface ResourcePlannerConflict {
-    type: 'outside_resource_time' | 'remote_event_overlap' | 'cart_overlap' | 'capacity_full' | 'missing_time' | 'missing_resource' | 'missing_assignment' | 'past';
-    message: string;
-    event?: ResourcePlannerEvent;
-    resourceId?: number | string;
-    productId?: number | string;
+export interface AvailabilityProjectionInput {
+    products: AvailabilityProduct[];
+    resources: AvailabilityResource[];
+    resourceOccupancies?: AvailabilityOccupancy[];
+    mode?: AvailabilityMode;
+    timezone: string;
+    coverage: AvailabilityDateRange;
+    slotStepMinutes?: number;
+    businessHours?: {
+        startTime: string;
+        endTime: string;
+    };
+    operatingHours?: AvailabilityOperatingHoursSnapshot;
+    snapshotId?: string;
+    preparedAt?: string;
+    now?: string;
+    durationCandidateAnchorAt?: string;
+    orderRevision?: AvailabilityId;
+    anchors?: AvailabilityProjectionMeta['anchors'];
+    prepareParams?: Record<string, any>;
 }
-export interface ResourcePlannerAvailabilityCell {
+export interface AvailabilityCell extends AvailabilityDisplayRange {
     key: string;
-    productId: number | string;
-    resourceId?: number | string;
-    date?: string;
-    start_at: string;
-    end_at: string;
-    startTime?: string;
-    endTime?: string;
-    durationMinutes?: number;
-    cellType: 'availability_range' | 'fixed_interval' | 'unavailable';
-    status: ResourcePlannerStatus;
+    productId: AvailabilityId;
+    requirementGroupId?: string;
+    requirementFormId?: AvailabilityId;
+    resourceId?: AvailabilityId;
+    resourceName?: string;
+    resourceType?: AvailabilityResourceType;
+    status: AvailabilityStatus;
     remainingCapacity?: number;
     maxCapacity?: number;
     reasonCodes: string[];
-    conflicts: ResourcePlannerConflict[];
+    occupancyRefs: Array<{
+        id?: string;
+        resourceId: AvailabilityId;
+        source?: AvailabilityOccupancy['source'];
+        serverEventId?: AvailabilityId;
+        bookingUid?: AvailabilityId;
+        productUid?: AvailabilityId;
+        scheduleEventId?: AvailabilityId;
+    }>;
+}
+export interface AvailabilityProjection {
+    readonly meta: AvailabilityProjectionMeta;
+    readonly products: readonly AvailabilityProduct[];
+    readonly resources: readonly AvailabilityResource[];
+    readonly resourceOccupancies: readonly AvailabilityOccupancy[];
+    readonly cells: readonly AvailabilityCell[];
 }
-export interface ResourcePlannerProductOption {
-    productId: number | string;
+export interface ProductTimeRange extends AvailabilityDisplayRange {
+    key: string;
+    productId: AvailabilityId;
+    source: 'session_schedule' | 'duration_window';
+    /** Actual interval start used by availability evaluation, assignments, and cart booking. */
+    bookingStartAt: string;
+    /** Actual interval end kept explicitly for availability evaluation and cart compatibility. */
+    bookingEndAt: string;
+    scheduleRefs: AvailabilityScheduleRef[];
+    primaryScheduleRef?: AvailabilityScheduleRef;
+}
+export interface ProductTimeRangeGroup {
+    productId: AvailabilityId;
     title?: string;
-    status: ResourcePlannerStatus;
-    reasonCodes: string[];
+    kind: AvailabilityProductKind;
+    ranges: ProductTimeRange[];
+}
+export interface AvailabilityAssignment extends AvailabilityAbsoluteRange {
+    productId: AvailabilityId;
+    resourceId: AvailabilityId;
+    formId?: AvailabilityId;
+    capacityRequired?: number;
+    scheduleId?: AvailabilityId;
+    timeSlotId?: AvailabilityId;
 }
-export interface ResourcePlannerResourceOption {
-    resourceId: number | string;
+export interface AvailabilityRequirementSelection {
+    requirementGroupId?: string;
+    formId?: AvailabilityId;
+    resourceIds: AvailabilityId[];
+}
+export interface GetProductTimeRangesRequest {
+    productIds?: AvailabilityId[];
+    dateRange?: Partial<AvailabilityDateRange>;
+    resourceIds?: AvailabilityId[];
+    partySize?: number;
+}
+export interface QueryAvailabilityBaseRequest {
+    productIds?: AvailabilityId[];
+    resourceIds?: AvailabilityId[];
+    partySize?: number;
+}
+export interface ProductAvailabilityQuery extends QueryAvailabilityBaseRequest {
+    target: 'product';
+    dateRange?: Partial<AvailabilityDateRange>;
+}
+export interface DateAvailabilityQuery extends QueryAvailabilityBaseRequest {
+    target: 'date';
+    dateRange?: Partial<AvailabilityDateRange>;
+}
+export interface TimeAvailabilityQuery extends QueryAvailabilityBaseRequest {
+    target: 'time';
+    candidates: ProductTimeRange[];
+}
+export interface ResourceAvailabilityQuery extends QueryAvailabilityBaseRequest {
+    target: 'resource';
+    selectedRanges: ProductTimeRange[];
+}
+export type AvailabilityQuery = ProductAvailabilityQuery | DateAvailabilityQuery | TimeAvailabilityQuery | ResourceAvailabilityQuery;
+export interface AvailabilityResourceOption {
+    resourceId: AvailabilityId;
     resourceName?: string;
-    resourceFormId?: number | string;
-    resourceType: ResourcePlannerResourceType;
-    status: ResourcePlannerStatus;
+    resourceFormId?: AvailabilityId;
+    resourceType: AvailabilityResourceType;
+    status: AvailabilityStatus;
+    remainingCapacity?: number;
+    maxCapacity?: number;
+    maxPartySize: number;
+    reasonCodes: string[];
+}
+export interface AvailabilityRequirementGroupResult {
+    groupId: string;
+    formId?: AvailabilityId;
+    title?: string;
+    code?: string;
+    resourceType: AvailabilityResourceType;
+    required: boolean;
+    min: number;
+    max: number;
+    status: AvailabilityStatus;
+    availableResourceCount: number;
+    totalResourceCount: number;
+    maxPartySize: number;
     remainingCapacity?: number;
     maxCapacity?: number;
     reasonCodes: string[];
+    options: AvailabilityResourceOption[];
+}
+export interface TimeAvailabilityItem extends ProductTimeRange {
+    status: AvailabilityStatus;
+    maxPartySize: number;
+    reasonCodes: string[];
+    requirementGroups: AvailabilityRequirementGroupResult[];
+}
+export interface ProductAvailabilityItem {
+    productId: AvailabilityId;
+    title?: string;
+    status: AvailabilityStatus;
+    reasonCodes: string[];
+    availableDateCount: number;
+    totalDateCount: number;
+    availableTimeCount: number;
+    totalTimeCount: number;
+    maxPartySize: number;
 }
-export interface ResourcePlannerDateSummary {
+export interface DateAvailabilityItem {
     date: string;
-    status: ResourcePlannerStatus;
+    status: AvailabilityStatus;
     availableCount: number;
     totalCount: number;
+    maxPartySize: number;
+    remainingCapacity: number;
+    maxCapacity: number;
+    reasonCodes: string[];
 }
-export interface ResourcePlannerTimeSlot {
-    startTime: string;
-    endTime: string;
-    status: ResourcePlannerStatus;
-    resourceId: number | string;
-    productId?: number | string;
-    remainingCapacity?: number;
-    maxCapacity?: number;
+export interface ProductAvailabilityGroup {
+    productId: AvailabilityId;
+    title?: string;
+    item: ProductAvailabilityItem;
+}
+export interface DateAvailabilityGroup {
+    productId: AvailabilityId;
+    title?: string;
+    dates: DateAvailabilityItem[];
+}
+export interface TimeAvailabilityGroup {
+    productId: AvailabilityId;
+    title?: string;
+    times: TimeAvailabilityItem[];
+}
+export interface ResourceAvailabilityRangeGroup {
+    range: ProductTimeRange;
+    status: AvailabilityStatus;
+    maxPartySize: number;
     reasonCodes: string[];
+    requirementGroups: AvailabilityRequirementGroupResult[];
 }
-export interface ResourcePlannerTimeGridRow {
-    resourceId: number | string;
-    resourceName?: string;
-    resourceFormId?: number | string;
-    slots: ResourcePlannerTimeSlot[];
-}
-export interface ResourcePlannerTimeGrid {
-    date?: string;
-    timeLabels: string[];
-    resources: ResourcePlannerTimeGridRow[];
-}
-export interface ResourcePlannerProjection {
-    query: ResourcePlannerQuery;
-    demandIntervals: ResourcePlannerDemandInterval[];
-    productOptions: ResourcePlannerProductOption[];
-    resourceOptions: ResourcePlannerResourceOption[];
-    dateSummary: ResourcePlannerDateSummary[];
-    timeGrid: ResourcePlannerTimeGrid;
-    cells: ResourcePlannerAvailabilityCell[];
-}
-export interface ResourcePlannerAssignment {
-    productId: number | string;
-    resourceId: number | string;
-    start_at: string;
-    end_at: string;
-    capacityRequired?: number;
+export interface ResourceAvailabilityGroup {
+    productId: AvailabilityId;
+    title?: string;
+    ranges: ResourceAvailabilityRangeGroup[];
 }
-export interface ResourcePlannerAssignableSlotResource {
-    resourceId: number | string;
+export interface AvailabilityQueryResultBase<TTarget extends AvailabilityQuery['target'], TData> {
+    target: TTarget;
+    evaluatedAt: string;
+    snapshotId: string;
+    data: TData;
+}
+export type ProductAvailabilityQueryResult = AvailabilityQueryResultBase<'product', ProductAvailabilityGroup[]>;
+export type DateAvailabilityQueryResult = AvailabilityQueryResultBase<'date', DateAvailabilityGroup[]>;
+export type TimeAvailabilityQueryResult = AvailabilityQueryResultBase<'time', TimeAvailabilityGroup[]>;
+export type ResourceAvailabilityQueryResult = AvailabilityQueryResultBase<'resource', ResourceAvailabilityGroup[]>;
+export type AvailabilityQueryResult = ProductAvailabilityQueryResult | DateAvailabilityQueryResult | TimeAvailabilityQueryResult | ResourceAvailabilityQueryResult;
+export interface AvailabilityValidationConflict {
+    code: string;
+    message: string;
+    reasonCodes?: string[];
+    productId?: AvailabilityId;
+    requirementGroupId?: string;
+    formId?: AvailabilityId;
+    resourceId?: AvailabilityId;
     resourceName?: string;
-    resourceFormId?: number | string;
-    resourceType?: ResourcePlannerResourceType;
-    capacityRequired?: number;
+    candidateKey?: string;
+    requestedQuantity?: number;
+    availableQuantity?: number;
     remainingCapacity?: number;
-    maxCapacity?: number;
+    capacityPerBooking?: number;
 }
-export interface ResourcePlannerAssignableSlot {
-    key: string;
-    productId: number | string;
-    date: string;
-    start_at: string;
-    end_at: string;
-    startTime: string;
-    endTime: string;
-    durationMinutes: number;
-    status: ResourcePlannerStatus;
-    resources: ResourcePlannerAssignableSlotResource[];
-    assignments: ResourcePlannerAssignment[];
-    conflicts: ResourcePlannerConflict[];
-}
-export interface ResourcePlannerAssignableSlotResult {
-    projection: ResourcePlannerProjection;
-    slots: ResourcePlannerAssignableSlot[];
-    conflicts: ResourcePlannerConflict[];
-}
-export interface ResourcePlannerAssignmentResult {
-    assignments: ResourcePlannerAssignment[];
-    conflicts: ResourcePlannerConflict[];
-}
-export interface ResourcePlannerValidationResult {
+export interface AvailabilitySelectionValidationParams {
+    candidate: ProductTimeRange;
+    partySize?: number;
+    bookingCount?: number;
+    requirementSelections: AvailabilityRequirementSelection[];
+}
+export interface AvailabilitySelectionValidationResult {
     ok: boolean;
-    conflicts: ResourcePlannerConflict[];
-}
-export interface ResourcePlannerSnapshot {
-    context: Required<ResourcePlannerContextInput>;
-    selection: ResourcePlannerSelection;
-    projection: ResourcePlannerProjection | null;
-    version: number;
-}
-export interface ResourcePlannerState {
-    context: Required<ResourcePlannerContextInput>;
-    selection: ResourcePlannerSelection;
-    projection: ResourcePlannerProjection | null;
-    version: number;
+    status: AvailabilityStatus;
+    assignments: AvailabilityAssignment[];
+    conflicts: AvailabilityValidationConflict[];
+    availability: TimeAvailabilityItem;
+}
+export interface AvailabilityErrorDetails {
+    [key: string]: any;
+}
+export declare class AvailabilityError extends Error {
+    code: AvailabilityErrorCode;
+    details?: AvailabilityErrorDetails;
+    constructor(code: AvailabilityErrorCode, message: string, details?: AvailabilityErrorDetails);
 }

package/lib/modules/ResourcePlanner/types.js

@@ -2,6 +2,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -14,4 +18,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // src/modules/ResourcePlanner/types.ts
 var types_exports = {};
+__export(types_exports, {
+  AvailabilityError: () => AvailabilityError
+});
 module.exports = __toCommonJS(types_exports);
+var AvailabilityError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.name = "AvailabilityError";
+    this.code = code;
+    this.details = details;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AvailabilityError
+});

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

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

package/lib/solution/BookingTicket/index.js

@@ -1398,7 +1398,8 @@ var BookingTicketImpl = class extends import_BaseSales.BaseSalesImpl {
       date,
       presetStartTime: (extra == null ? void 0 : extra.presetStartTime) ?? (0, import_BookingContext.derivePresetStartTimeFromDate)(date),
       customerId: orderCustomerId,
-      ...extra || {}
+      ...extra || {},
+      channel: this.getSubmitOrderSalesChannel()
     };
   }
   /**

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

@@ -5,7 +5,7 @@ import type { OrderProduct, OrderProductIdentity, AddProductBookingInput } from
  * cart.addProduct 两阶段决策（与 ticketBooking `handleSelectProduct` 对齐）：
  *
  * 1. `requiresDetail`：规格 / SKU / 套餐 / Session / 称重弹窗（门禁：`isOpenDetailModal` / `cartDetailValue` / `open_sold_weight`）
- * 2. `requiresBookingEdit`：资源 / 时间编辑抽屉（门禁：`getIsAutoClose` on prepared cacheItem）
+ * 2. `requiresBookingEdit`：资源 / 时间编辑抽屉（kiosk 强制进入；其他渠道由 `getIsAutoClose` 决定）
  * 3. `add`：两关均通过，直接 transform + 加车
  */
 export type AddProductDecision = {
@@ -65,6 +65,7 @@ export interface AddProductDecideContext extends BookingCalcContext {
     type?: 'select' | 'detail';
     quantity?: number;
     customerId?: number | string;
+    channel?: string;
 }
 /**
  * 统一补齐预约商品的运行态字段。

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

@@ -57,6 +57,8 @@ function needsSpecDetailModal(item) {
 function needsBookingEdit(cacheItem, ctx) {
   if (isNormalBookingProduct(cacheItem))
     return false;
+  if ((ctx == null ? void 0 : ctx.channel) === "kiosk")
+    return true;
   const isAutoAllocationOn = (ctx == null ? void 0 : ctx.isAutoAllocationOn) || (() => true);
   return !(0, import_BookingContext.getIsAutoClose)(cacheItem, isAutoAllocationOn);
 }