@pisell/pisellos 2.3.71 → 2.3.73

package/dist/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/dist/modules/ResourcePlanner/types.js

@@ -1 +1,33 @@
-export {};
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export var AvailabilityError = /*#__PURE__*/function (_Error) {
+  _inherits(AvailabilityError, _Error);
+  var _super = _createSuper(AvailabilityError);
+  function AvailabilityError(code, message, details) {
+    var _this;
+    _classCallCheck(this, AvailabilityError);
+    _this = _super.call(this, message);
+    _defineProperty(_assertThisInitialized(_this), "code", void 0);
+    _defineProperty(_assertThisInitialized(_this), "details", void 0);
+    _this.name = 'AvailabilityError';
+    _this.code = code;
+    _this.details = details;
+    return _this;
+  }
+  return _createClass(AvailabilityError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));

package/dist/server/index.js

@@ -5628,7 +5628,8 @@ var Server = /*#__PURE__*/function () {
                     order_id: printIdentity,
                     small_ticket_data: (_params$syncedOrder = params.syncedOrder) === null || _params$syncedOrder === void 0 || (_params$syncedOrder = _params$syncedOrder.payment_info) === null || _params$syncedOrder === void 0 ? void 0 : _params$syncedOrder.small_ticket_data,
                     skip_wristband: true,
-                    skip_voucher: true
+                    skip_voucher: true,
+                    skip_discount: true
                   } : {
                     order_id: printIdentity,
                     machine_code_print_info: (_params$syncedOrder2 = params.syncedOrder) === null || _params$syncedOrder2 === void 0 || (_params$syncedOrder2 = _params$syncedOrder2.payment_info) === null || _params$syncedOrder2 === void 0 ? void 0 : _params$syncedOrder2.machine_code_print_info,

package/dist/solution/BookingTicket/index.d.ts

@@ -453,7 +453,19 @@ export declare class BookingTicketImpl extends BaseSalesImpl implements Module {
      * 加车两阶段主决策（规格弹窗 / 资源编辑 / 直接加车）。
      * 与 ticketBooking `handleSelectProduct` + `handleBooking4Service` 等价。
      */
-    decideAddProduct(item: any, options?: Partial<AddProductDecideContext>): import("./utils/addProductDecision").AddProductDecision;
+    decideAddProduct(item: any, options?: Partial<AddProductDecideContext>): {
+        action: "reloadCatalog";
+    } | {
+        action: "add";
+        cacheItem: any;
+    } | {
+        action: "requiresDetail";
+        payload: AddProductRequiresDetailPayload;
+    } | {
+        action: "requiresBookingEdit";
+        cacheItem: any;
+        payload: import("./utils/addProductDecision").AddProductRequiresBookingEditPayload;
+    };
     /** 规格弹窗 callback 后的第二段决策。 */
     decideAfterDetail(cacheItem: any, options?: Partial<AddProductDecideContext>): import("./utils/addProductDecision").AddProductDecision;
     /**

package/dist/solution/BookingTicket/index.js

@@ -2337,14 +2337,16 @@ export var BookingTicketImpl = /*#__PURE__*/function (_BaseSalesImpl) {
       var bookingContextState = this.store.bookingContext.getState();
       var date = (_extra$date2 = extra === null || extra === void 0 ? void 0 : extra.date) !== null && _extra$date2 !== void 0 ? _extra$date2 : bookingContextState.date;
       var orderCustomerId = (_ref12 = (_this$getOrderCustome4 = (_this$getOrderCustome5 = this.getOrderCustomerSnapshot()) === null || _this$getOrderCustome5 === void 0 ? void 0 : _this$getOrderCustome5.id) !== null && _this$getOrderCustome4 !== void 0 ? _this$getOrderCustome4 : (_this$store$order$get4 = this.store.order.getTempOrder()) === null || _this$store$order$get4 === void 0 ? void 0 : _this$store$order$get4.customer_id) !== null && _ref12 !== void 0 ? _ref12 : undefined;
-      return _objectSpread({
+      return _objectSpread(_objectSpread({
         bookingConfig: bookingContextState.bookingConfig,
         resourcesOrigin: bookingContextState.resourcesOrigin,
         resourcesOriginMap: bookingContextState.resourcesOriginMap,
         date: date,
         presetStartTime: (_extra$presetStartTim2 = extra === null || extra === void 0 ? void 0 : extra.presetStartTime) !== null && _extra$presetStartTim2 !== void 0 ? _extra$presetStartTim2 : derivePresetStartTimeFromDate(date),
         customerId: orderCustomerId
-      }, extra || {});
+      }, extra || {}), {}, {
+        channel: this.getSubmitOrderSalesChannel()
+      });
     }
 
     /**