@pisell/pisellos 2.3.71 → 2.3.73

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

@@ -1,91 +1,163 @@
-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 { 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"
-}
+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 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 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;
+}
+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 +182,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 +190,18 @@ 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. */
     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;

package/dist/solution/UnifiedBookingSales/types.js

@@ -1,11 +1,6 @@
 export var UnifiedBookingSalesHooks = /*#__PURE__*/function (UnifiedBookingSalesHooks) {
-  UnifiedBookingSalesHooks["onPlannerContextLoaded"] = "unifiedBookingSales:onPlannerContextLoaded";
-  UnifiedBookingSalesHooks["onPlannerCommitted"] = "unifiedBookingSales:onPlannerCommitted";
+  UnifiedBookingSalesHooks["onAvailabilityProjectionPrepared"] = "unifiedBookingSales:onAvailabilityProjectionPrepared";
+  UnifiedBookingSalesHooks["onAvailabilitySelectionCommitted"] = "unifiedBookingSales:onAvailabilitySelectionCommitted";
+  UnifiedBookingSalesHooks["onAvailabilityProjectionDiagnostic"] = "unifiedBookingSales:onAvailabilityProjectionDiagnostic";
   return UnifiedBookingSalesHooks;
-}({});
-
-/** Explicit OpenData target used by page-level UnifiedBookingSales skins. */
-
-/** Ordinary retail product staging. No resource, time, or booking facts are required. */
-
-/** Adds one ordinary retail product without replacing other retail lines already in the cart. */
+}({});

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

@@ -23,6 +23,7 @@ export interface OpenDataConfig {
     'reservation.auto_confirm'?: boolean;
     'reservation.auto_confirm_mode'?: string;
     'reservation.auto_confirm_delay_seconds'?: number;
+    'reservation.time_slice'?: number | string;
     'sale.allow_item_notes'?: boolean;
     'sale.allow_order_notes'?: boolean;
     'sale.enable_item_rules'?: boolean;

package/lib/modules/Order/utils.js

@@ -994,7 +994,11 @@ function buildSubmitPayload(params) {
   let submitType = type ?? tempOrder.type;
   if (!submitType) {
     if ((_a = tempOrder == null ? void 0 : tempOrder.bookings) == null ? void 0 : _a.length) {
-      submitType = "appointment_booking";
+      if (businessCode === "dine_in") {
+        submitType = "table-order";
+      } else {
+        submitType = "appointment_booking";
+      }
     } else {
       submitType = "virtual";
     }

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

@@ -1,24 +1,2 @@
-import { BaseModule } from '../BaseModule';
-import type { Module, ModuleOptions, PisellCore } from '../../types';
-import type { ResourcePlannerAssignmentResult, ResourcePlannerAssignableSlotResult, ResourcePlannerContextInput, ResourcePlannerProjection, ResourcePlannerQuery, ResourcePlannerSelectionPatch, ResourcePlannerSnapshot, ResourcePlannerValidationResult } from './types';
 export * from './types';
 export * from './planner';
-export declare enum ResourcePlannerHooks {
-    onContextChanged = "resourcePlanner:onContextChanged",
-    onSelectionChanged = "resourcePlanner:onSelectionChanged",
-    onProjectionChanged = "resourcePlanner:onProjectionChanged"
-}
-export declare class ResourcePlannerModule extends BaseModule implements Module {
-    protected defaultName: string;
-    protected defaultVersion: string;
-    private store;
-    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
-    setContext(input: ResourcePlannerContextInput): ResourcePlannerSnapshot;
-    mergeContext(input: ResourcePlannerContextInput): ResourcePlannerSnapshot;
-    setSelectionPatch(patch: ResourcePlannerSelectionPatch): ResourcePlannerSnapshot;
-    queryAvailability(query?: ResourcePlannerQuery): ResourcePlannerProjection;
-    autoAssign(query?: ResourcePlannerQuery): ResourcePlannerAssignmentResult;
-    resolveAssignableSlots(query?: ResourcePlannerQuery): ResourcePlannerAssignableSlotResult;
-    validateSelection(): ResourcePlannerValidationResult;
-    getSnapshot(): ResourcePlannerSnapshot;
-}

package/lib/modules/ResourcePlanner/index.js

@@ -2,10 +2,6 @@ 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))
@@ -19,130 +15,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // src/modules/ResourcePlanner/index.ts
 var ResourcePlanner_exports = {};
-__export(ResourcePlanner_exports, {
-  ResourcePlannerHooks: () => ResourcePlannerHooks,
-  ResourcePlannerModule: () => ResourcePlannerModule
-});
 module.exports = __toCommonJS(ResourcePlanner_exports);
-var import_BaseModule = require("../BaseModule");
-var import_planner = require("./planner");
 __reExport(ResourcePlanner_exports, require("./types"), module.exports);
 __reExport(ResourcePlanner_exports, require("./planner"), module.exports);
-var ResourcePlannerHooks = /* @__PURE__ */ ((ResourcePlannerHooks2) => {
-  ResourcePlannerHooks2["onContextChanged"] = "resourcePlanner:onContextChanged";
-  ResourcePlannerHooks2["onSelectionChanged"] = "resourcePlanner:onSelectionChanged";
-  ResourcePlannerHooks2["onProjectionChanged"] = "resourcePlanner:onProjectionChanged";
-  return ResourcePlannerHooks2;
-})(ResourcePlannerHooks || {});
-var ResourcePlannerModule = class extends import_BaseModule.BaseModule {
-  constructor() {
-    super(...arguments);
-    this.defaultName = "resourcePlanner";
-    this.defaultVersion = "1.0.0";
-  }
-  async initialize(core, options) {
-    this.core = core;
-    const initialState = options.initialState;
-    this.store = {
-      context: (0, import_planner.normalizePlannerContext)((initialState == null ? void 0 : initialState.context) || import_planner.DEFAULT_RESOURCE_PLANNER_CONTEXT),
-      selection: (initialState == null ? void 0 : initialState.selection) || { ...import_planner.DEFAULT_RESOURCE_PLANNER_SELECTION },
-      projection: (initialState == null ? void 0 : initialState.projection) || null,
-      version: (initialState == null ? void 0 : initialState.version) || 0
-    };
-  }
-  setContext(input) {
-    this.store.context = (0, import_planner.normalizePlannerContext)(input);
-    this.store.version += 1;
-    this.store.projection = null;
-    const snapshot = this.getSnapshot();
-    void this.core.effects.emit(`${this.name}:contextChanged`, snapshot);
-    return snapshot;
-  }
-  mergeContext(input) {
-    return this.setContext({
-      ...this.store.context,
-      ...input,
-      products: input.products || this.store.context.products,
-      resources: input.resources || this.store.context.resources,
-      externalEvents: input.externalEvents || this.store.context.externalEvents
-    });
-  }
-  setSelectionPatch(patch) {
-    const assignments = patch.assignments ? patch.replaceAssignments === false ? [...this.store.selection.assignments, ...patch.assignments] : patch.assignments : this.store.selection.assignments;
-    this.store.selection = {
-      ...this.store.selection,
-      ...patch,
-      productIds: patch.productIds || this.store.selection.productIds,
-      resourceIds: patch.resourceIds || this.store.selection.resourceIds,
-      assignments
-    };
-    this.store.version += 1;
-    const snapshot = this.getSnapshot();
-    void this.core.effects.emit(`${this.name}:selectionChanged`, snapshot);
-    return snapshot;
-  }
-  queryAvailability(query = {}) {
-    const mergedQuery = {
-      mode: this.store.selection.mode,
-      productIds: this.store.selection.productIds,
-      date: this.store.selection.date,
-      startTime: this.store.selection.startTime,
-      endTime: this.store.selection.endTime,
-      resourceIds: this.store.selection.resourceIds,
-      ...query
-    };
-    const projection = (0, import_planner.queryPlannerAvailability)(this.store.context, mergedQuery);
-    this.store.projection = projection;
-    this.store.version += 1;
-    void this.core.effects.emit(`${this.name}:projectionChanged`, this.getSnapshot());
-    return projection;
-  }
-  autoAssign(query = {}) {
-    const result = (0, import_planner.autoAssignResources)(this.store.context, {
-      mode: this.store.selection.mode,
-      productIds: this.store.selection.productIds,
-      date: this.store.selection.date,
-      startTime: this.store.selection.startTime,
-      endTime: this.store.selection.endTime,
-      resourceIds: this.store.selection.resourceIds,
-      ...query
-    });
-    const resourceIds = Array.from(new Map(
-      result.assignments.map((assignment) => [String(assignment.resourceId), assignment.resourceId])
-    ).values());
-    this.setSelectionPatch({
-      assignments: result.assignments,
-      ...resourceIds.length ? { resourceIds } : {}
-    });
-    return result;
-  }
-  resolveAssignableSlots(query = {}) {
-    return (0, import_planner.resolveAssignableSlots)(this.store.context, {
-      mode: this.store.selection.mode,
-      productIds: this.store.selection.productIds,
-      date: this.store.selection.date,
-      startTime: this.store.selection.startTime,
-      endTime: this.store.selection.endTime,
-      resourceIds: this.store.selection.resourceIds,
-      ...query
-    });
-  }
-  validateSelection() {
-    return (0, import_planner.validateAssignments)(this.store.context, this.store.selection);
-  }
-  getSnapshot() {
-    return {
-      context: this.store.context,
-      selection: this.store.selection,
-      projection: this.store.projection,
-      version: this.store.version
-    };
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ResourcePlannerHooks,
-  ResourcePlannerModule,
   ...require("./types"),
   ...require("./planner")
 });

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

@@ -0,0 +1,33 @@
+export interface LocalDateParts {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface LocalDateTimeParts extends LocalDateParts {
+    hour: number;
+    minute: number;
+    second: number;
+}
+type LocalDateInput = string | LocalDateParts;
+type LocalDateTimeInput = string | number | LocalDateTimeParts;
+export declare function parseLocalDate(value: string): LocalDateParts;
+export declare function parseLocalDateTime(value: string): LocalDateTimeParts;
+export declare function extractFixedOffsetMinutes(value: string | null | undefined): number | null;
+export declare function captureRuntimeOffsetMinutes(value?: Date): number;
+export declare function formatFixedOffset(offsetMinutes: number | null | undefined): string;
+export declare function localDateTimeToScalar(value: LocalDateTimeParts): number;
+export declare function localDateToScalar(value: Date): number;
+export declare function localDateToScalarStart(value: LocalDateInput): number;
+export declare function scalarToLocalDateParts(value: number): LocalDateParts;
+export declare function scalarToLocalDateTimeParts(value: number): LocalDateTimeParts;
+export declare function dateOrdinalFromLocalDate(value: LocalDateInput): number;
+export declare function weekdayFromLocalDate(value: LocalDateInput): number;
+export declare function formatLocalDate(value: LocalDateInput | number): string;
+export declare function formatLocalTime(value: LocalDateTimeInput, includeSeconds?: boolean): string;
+export declare function formatLocalDateTime(value: LocalDateTimeInput, fixedOffsetMinutes?: number | null): string;
+export declare function addLocalMinutes(value: number, minutes: number): number;
+export declare function addLocalHours(value: number, hours: number): number;
+export declare function addLocalCalendarDays(value: number, days: number): number;
+export declare function nextDate(value: LocalDateInput): string;
+export declare function ceilLocalScalarToTenMinutes(value: number): number;
+export {};