@outbuild-company/schedule-core 1.34.0-experiment.2 → 1.34.0

package/dist/index.d.ts

@@ -17,6 +17,37 @@ declare const LINK_TYPE: {
 /** Canonical stored dependency relationship. */
 type LinkType = (typeof LINK_TYPE)[keyof typeof LINK_TYPE];
 
+type ActivityId$1 = string;
+type LinkId$1 = string;
+interface LinkSnapshot {
+    id: LinkId$1;
+    source: ActivityId$1;
+    target: ActivityId$1;
+    type: LinkType;
+    lag: number;
+    freeSlackHours: number | null;
+    isCritical: boolean;
+    _sourceLag?: number;
+    _targetLag?: number;
+    _trueLag?: number;
+    _summarySourceId?: ActivityId$1;
+    _summaryTargetId?: ActivityId$1;
+    _lagActivityId?: ActivityId$1;
+    ganttId?: number;
+    sectorId?: number;
+    proplannerId?: number;
+}
+interface ScheduleFlags {
+    isPasting: boolean;
+    isBulkOperation: boolean;
+    dragWithMultiple: boolean;
+    draggingSingleMilestone: boolean;
+    creatingActivity: boolean;
+    avoidAutoScheduleBeforeDrag: boolean;
+    maxPerformance: boolean;
+    allCheckedTaskIds: ActivityId$1[];
+}
+
 /** Named normalized activity scheduling constraints. */
 declare const CONSTRAINT_TYPE: {
     readonly ASAP: "asap";
@@ -247,6 +278,8 @@ declare const DISPATCH_ACTION_KIND: {
     readonly ACTIVITY_INDENT: "activity-indent";
     readonly ACTIVITY_OUTDENT: "activity-outdent";
     readonly ACTIVITY_TYPE_SET: "activity-type-set";
+    readonly ACTIVITY_FIELDS_RESTORE: "activity-fields-restore";
+    readonly HISTORY_REVERT: "history-revert";
     readonly ACTIVITY_SET_PROGRESS: "activity-set-progress";
     readonly ACTIVITY_LOOKAHEAD_CONVERT: "activity-lookahead-convert";
     readonly SELECTION_TOGGLE: "selection-toggle";
@@ -458,6 +491,21 @@ declare function isRootParent(parent: unknown): boolean;
  */
 declare function normalizeParentKey(parent: unknown): string;
 
+interface PrefixStats {
+    min: string;
+    max: string;
+    next: string;
+    quantity: number;
+    usedSuffixes: Set<string>;
+    boundsDirty?: boolean;
+}
+interface CustomIdTrackerSnapshot {
+    readonly defaultPrefix: string;
+    readonly suffixIncrement: string;
+    readonly prefixes: Map<string, PrefixStats>;
+    readonly processedIds: Set<string>;
+}
+
 /** Sort directions accepted by visual-order rules. */
 declare const ORDER_DIRECTION: {
     readonly ASCENDING: "asc";
@@ -612,6 +660,27 @@ declare function buildGroupRowId(attributeKey: string, valueId: string): string;
  */
 declare function appendGroupRowId(parentRowId: string, attributeKey: string, valueId: string): string;
 
+/**
+ * Activity fields a user edit sets directly, which an
+ * `activity-fields-restore` command may write back. Everything else on an
+ * activity (dates of other activities, roll-ups, critical path, slack,
+ * correlatives, hierarchy) is derived again by the post-mutation passes.
+ */
+declare const RESTORABLE_ACTIVITY_FIELDS: readonly ["name", "description", "startDate", "endDate", "durationHours", "constraintType", "constraintDate", "autoScheduling", "calendarId", "progress", "cost", "usedCost", "realCost", "workHours", "realWorkHours", "ponderator", "hasCustomPonderator", "customId", "subcontractId", "responsableIds", "tagIds", "p6"];
+/** One field an `activity-fields-restore` command may write back. */
+type RestorableActivityField = (typeof RESTORABLE_ACTIVITY_FIELDS)[number];
+/**
+ * Hierarchy and type fields a structural edit (move, indent, delete, type
+ * change) sets, which only `history-revert` writes back.
+ */
+declare const STRUCTURE_ACTIVITY_FIELDS: readonly ["parentId", "type", "correlativeId"];
+/** One field a `history-revert` command may write back. */
+type RevertibleActivityField = RestorableActivityField | (typeof STRUCTURE_ACTIVITY_FIELDS)[number];
+/** Whether `field` may be written back by `history-revert`. */
+declare function isRevertibleActivityField(field: string): field is RevertibleActivityField;
+/** Whether `field` may be written back by `activity-fields-restore`. */
+declare function isRestorableActivityField(field: string): field is RestorableActivityField;
+
 /** Backend-encoded work shift consumed during calendar normalization. */
 interface BackendShiftInput {
     shift_string: string;
@@ -803,6 +872,24 @@ declare const ACTIVITY_SAVE_FIELD_POLICY: {
 type PersistableActivityField = {
     [Field in keyof typeof ACTIVITY_SAVE_FIELD_POLICY]: (typeof ACTIVITY_SAVE_FIELD_POLICY)[Field] extends typeof SAVE_FIELD_POLICY.TRACKED ? Field : never;
 }[keyof typeof ACTIVITY_SAVE_FIELD_POLICY];
+/** A persisted activity whose only change since the last save is its correlative. */
+interface RenumberedActivity {
+    readonly id: string;
+    readonly proplannerId: number;
+    readonly correlativeId: number;
+}
+/**
+ * Persisted activities pending a save, split so a renumbering stays a list of
+ * correlatives instead of whole activities.
+ */
+interface ModifiedActivityChanges {
+    /** Defensive snapshots of the modified persisted activities that are not renumbered only. */
+    readonly activities: ReadonlyArray<Readonly<CoreActivity>>;
+    /** Changed persisted fields of each of those activities, by activity ID. */
+    readonly fields: ReadonlyMap<string, ReadonlyArray<PersistableActivityField>>;
+    /** The activities whose only changed persisted field is `correlativeId`. */
+    readonly renumbered: ReadonlyArray<RenumberedActivity>;
+}
 
 /** Low-level dependency operation accepted by the canonical dispatcher. */
 type LinksBatchOperation = {
@@ -874,6 +961,24 @@ interface PersistedEntityIdentity {
 interface PersistenceCheckpoint {
     readonly activities: ReadonlyArray<Readonly<CoreActivity>>;
     readonly links: ReadonlyArray<Readonly<Link>>;
+    /**
+     * Set when the checkpoint carries only the entities pending at that point
+     * (read with `pendingOnly`); every other entity keeps its saved image.
+     */
+    readonly pending?: {
+        readonly activityIds: ReadonlyArray<string>;
+        readonly linkIds: ReadonlyArray<string>;
+        /**
+         * The pending activities whose only change is their correlative: they
+         * are not in `activities`, and the checkpoint is only acknowledged by
+         * the schedule that read it.
+         */
+        readonly renumbered?: ReadonlyArray<{
+            readonly id: string;
+            readonly proplannerId: number;
+            readonly correlativeId: number;
+        }>;
+    };
     readonly p6Settings?: Readonly<P6ScheduleSettings> | null;
     readonly p6ProjectState?: Readonly<P6ProjectState> | null;
     readonly p6LatestRunLog?: Readonly<P6ScheduleRunLog> | null;
@@ -1083,6 +1188,7 @@ type DispatchAction = {
     activities?: ReadonlyArray<PersistedEntityIdentity>;
     links?: ReadonlyArray<PersistedEntityIdentity>;
     checkpoint?: PersistenceCheckpoint;
+    retainHistory?: boolean;
 } | {
     kind: typeof DISPATCH_ACTION_KIND.PERSISTENCE_REBASE;
     remote: PersistenceRebaseInput;
@@ -1212,6 +1318,18 @@ type DispatchAction = {
     activityId: ActivityId;
     pendingRequests: ReadonlyArray<PendingRequest>;
     eventSource?: string;
+} | {
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_FIELDS_RESTORE;
+    activities: ReadonlyArray<ActivityFieldsRestoreEntry>;
+    eventSource?: string;
+} | {
+    kind: typeof DISPATCH_ACTION_KIND.HISTORY_REVERT;
+    restoreActivities: ReadonlyArray<CoreActivity>;
+    removeActivityIds: ReadonlyArray<ActivityId>;
+    activityFields: ReadonlyArray<HistoryRevertFieldsEntry>;
+    restoreLinks: ReadonlyArray<HistoryRevertLink>;
+    removeLinkIds: ReadonlyArray<LinkId>;
+    eventSource?: string;
 } | {
     kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC;
     activityIds: ReadonlyArray<ActivityId>;
@@ -1254,6 +1372,12 @@ interface DispatchOptions {
     skipCriticalPath?: boolean;
     /** Rejects create/update commands that touch an activity with children. */
     rejectParentLinkMutations?: boolean;
+    /**
+     * Instant the operation happens at. Replaces the clock and the system time
+     * for this operation, so replicas that apply the same operations reach the
+     * same state.
+     */
+    at?: Date;
     /** Confirmation kinds the caller grants for this operation. */
     confirmations?: readonly ConfirmationKind[];
     /**
@@ -1346,7 +1470,6 @@ declare const SCHEDULE_EFFECT_KIND: {
 declare const SIR_AUTO_REJECT_REASON: {
     readonly DATE_CHANGED: "date_changed";
     readonly ACTIVITY_DELETED: "activity_deleted";
-    readonly ACTIVITY_COMPLETED: "activity_completed";
 };
 /** Consumer integration effect included in a change set. */
 type ScheduleEffect = {
@@ -1438,6 +1561,24 @@ interface ChangeSet {
     p6Settings?: P6SettingsChange;
     p6ProjectPlannedStart?: P6ProjectPlannedStartChange;
 }
+/** Input fields of one activity written back as they were, keyed by field. */
+interface ActivityFieldsRestoreEntry {
+    readonly activityId: ActivityId;
+    readonly fields: Readonly<Partial<Pick<CoreActivity, RestorableActivityField>>>;
+}
+/** Fields of one activity a `history-revert` command writes back. */
+interface HistoryRevertFieldsEntry {
+    readonly activityId: ActivityId;
+    readonly fields: Readonly<Partial<Pick<CoreActivity, RevertibleActivityField>>>;
+}
+/** A deleted link a `history-revert` command brings back, lag in hours. */
+interface HistoryRevertLink {
+    readonly linkId: LinkId;
+    readonly source: ActivityId;
+    readonly target: ActivityId;
+    readonly type: LinkType;
+    readonly lagHours: number;
+}
 
 declare const P6_CRITICAL_ACTIVITY_METHOD: {
     readonly TOTAL_FLOAT: "total_float";
@@ -1844,13 +1985,13 @@ interface CoreActivity {
     subcontractId: number | null;
     isLookahead: boolean;
     hasLookaheadTasks: boolean;
-    newActivityIds: ActivityId[];
+    newActivityIds: ReadonlyArray<ActivityId>;
     hasNewActivities: boolean;
     isNewActivity?: true | null;
-    pendingRequestIds: string[];
-    responsableIds: string[];
-    tagIds: string[];
-    baselinePoints: CoreBaselinePoint[];
+    pendingRequestIds: ReadonlyArray<string>;
+    responsableIds: ReadonlyArray<string>;
+    tagIds: ReadonlyArray<string>;
+    baselinePoints: ReadonlyArray<CoreBaselinePoint>;
     baselineSnapshot: ActivityBaselineSnapshot | null;
     /** Summary roll-up duration in working hours. */
     recursiveDurationHours: number;
@@ -1882,6 +2023,17 @@ interface CoreActivity {
     criticalPath: CriticalPathResult | null;
     p6?: P6ActivityDraftState;
 }
+interface PromotionSnapshot {
+    type: typeof ACTIVITY_TYPE.TASK | typeof ACTIVITY_TYPE.MILESTONE;
+    startDate: Date;
+    endDate: Date;
+    durationHours: number;
+    expectedProgressBaseline: number | null;
+    constraintType: ConstraintType;
+    constraintDate: Date | null;
+    progress: number;
+    p6?: P6ActivityDraftState;
+}
 /** Normalized dependency-link snapshot. */
 interface Link {
     id: LinkId;
@@ -1968,6 +2120,8 @@ interface EntityChange<T> {
     }> | undefined;
     /** Complete post-change snapshot, or `null` for deletion. */
     after: Readonly<T> | null;
+    /** Complete pre-change snapshot of a deleted entity, to bring it back. */
+    before?: Readonly<T> | undefined;
 }
 
 declare const CREATION_OVERRIDE_FIELD_LIST: readonly ["name", "description", "type", "startDate", "durationHours", "constraintType", "constraintDate", "calendarId", "assignedDefaultCalendar", "autoScheduling", "progress", "cost", "usedCost", "realCost", "workHours", "realWorkHours", "ponderator", "hasCustomPonderator", "customId", "subcontractId", "responsableIds", "tagIds", "isLookahead"];
@@ -2158,6 +2312,18 @@ interface ActivityBatchInput extends MutationContext {
     readonly items: ReadonlyArray<ActivityBatchItemInput>;
     readonly links: ReadonlyArray<ActivityBatchLinkInput>;
 }
+/** Input fields of activities written back as they were before an edit. */
+interface ActivityFieldsRestoreInput extends MutationContext {
+    readonly activities: ReadonlyArray<ActivityFieldsRestoreEntry>;
+}
+/** One earlier edit reverted: what to bring back, remove and write back. */
+interface HistoryRevertInput extends MutationContext {
+    readonly restoreActivities: ReadonlyArray<CoreActivity>;
+    readonly removeActivityIds: ReadonlyArray<ActivityId>;
+    readonly activityFields: ReadonlyArray<HistoryRevertFieldsEntry>;
+    readonly restoreLinks: ReadonlyArray<HistoryRevertLink>;
+    readonly removeLinkIds: ReadonlyArray<LinkId>;
+}
 /** Consumer lookahead state synchronized into core-owned activity state. */
 interface ActivityLookaheadSyncInput extends MutationContext {
     readonly activityIds: ReadonlyArray<ActivityId>;
@@ -2379,9 +2545,10 @@ interface ScheduleActivitiesApi {
      *
      * @param activityIds - IDs to delete.
      * @param context - Optional consumer event source.
+     * @param options - Per-operation autoschedule and critical-path controls.
      * @returns The complete dispatch result.
      */
-    remove(activityIds: ReadonlyArray<ActivityId>, context?: MutationContext): Promise<DispatchResult>;
+    remove(activityIds: ReadonlyArray<ActivityId>, context?: MutationContext, options?: DispatchOptions): Promise<DispatchResult>;
     /** Plans one canonical Schedule-to-Lookahead conversion without mutation. */
     planLookaheadConversion(input: LookaheadConversionInput): LookaheadConversionPlan;
     /** Applies the same conversion intent under its planned state revision. */
@@ -2480,6 +2647,22 @@ interface ScheduleActivitiesApi {
      * @returns The complete dispatch result.
      */
     lookaheadSync(input: ActivityLookaheadSyncInput): Promise<DispatchResult>;
+    /**
+     * Writes input fields of activities back to earlier values and derives the
+     * rest again, reverting one edit without undoing later ones.
+     *
+     * @param input - The activities and the field values to write back.
+     * @returns The complete dispatch result.
+     */
+    restoreFields(input: ActivityFieldsRestoreInput): Promise<DispatchResult>;
+    /**
+     * Reverts one earlier edit, structure included: brings back what it
+     * deleted, removes what it created and writes back what it changed.
+     *
+     * @param input - What to bring back, remove and write back.
+     * @returns The complete dispatch result.
+     */
+    revert(input: HistoryRevertInput): Promise<DispatchResult>;
     /** Runs canonical autoscheduling for one activity or the whole schedule. */
     autoSchedule(activityId?: ActivityId, options?: DispatchOptions): Promise<DispatchResult>;
     /**
@@ -2737,6 +2920,16 @@ interface SchedulePersistenceApi {
     modifiedActivities(): ReadonlyArray<Readonly<CoreActivity>>;
     /** @returns Modified persisted fields grouped by activity ID. */
     modifiedActivityFields(): ReadonlyMap<string, ReadonlyArray<PersistableActivityField>>;
+    /**
+     * Reads the modified persisted activities in one pass, with the ones whose
+     * only change is `correlativeId` returned as `{ id, proplannerId,
+     * correlativeId }` instead of whole snapshots.
+     *
+     * @returns `activities` and `fields` as {@link SchedulePersistenceApi.modifiedActivities}
+     * and {@link SchedulePersistenceApi.modifiedActivityFields} return them minus
+     * the renumbered ones, plus `renumbered`.
+     */
+    modifiedActivityChanges(): ModifiedActivityChanges;
     /** @returns Defensive snapshots of not-yet-persisted activities. */
     newActivities(): ReadonlyArray<Readonly<CoreActivity>>;
     /** @returns Deleted persisted activity identities since the last save. */
@@ -2888,6 +3081,31 @@ interface ScheduleApiNamespaces {
     readonly diagnostics: ScheduleDiagnosticsApi;
 }
 
+interface SerializedCalendar {
+    id: CalendarId;
+    worktime?: {
+        hours?: (string | number)[];
+        days?: Array<boolean | string[]>;
+        dates?: Record<string, false | string[]>;
+        customWeeks?: Record<string, unknown>;
+    } | undefined;
+    [key: string]: unknown;
+}
+interface StateSnapshot {
+    activities: CoreActivity[];
+    links: LinkSnapshot[];
+    calendars: SerializedCalendar[];
+    takenAt?: string;
+    defaultCalendarId?: CalendarId | null;
+    autoScheduleConfig?: {
+        auto_scheduling: boolean;
+        auto_scheduling_initial: boolean;
+        auto_scheduling_use_progress: boolean;
+        schedule_from_end: boolean;
+    };
+    runtimeFlags?: Record<string, boolean | string>;
+}
+
 /** Consumer diagnostics sink for normalization and background failures. */
 interface ScheduleCoreReporter {
     /** Reports a recoverable warning with optional safe context. */
@@ -2896,35 +3114,24 @@ interface ScheduleCoreReporter {
     error(message: string, cause?: unknown): void;
 }
 
-/** Stable validation reasons for rejected dependency operations. */
-declare const LINK_REJECTION_REASON: {
-    readonly SELF_LINK: "self-link";
-    readonly CYCLE: "cycle";
-    readonly DUPLICATE: "duplicate";
-    readonly ACTIVITY_MISSING: "activity-missing";
-    readonly LINK_MISSING: "link-missing";
-    readonly HIERARCHY_LINK: "hierarchy-link";
-};
-/** Stable validation reason for a rejected dependency operation. */
-type LinkRejection = (typeof LINK_REJECTION_REASON)[keyof typeof LINK_REJECTION_REASON];
+interface ViewStateSnapshot {
+    readonly checked: ReadonlySet<ActivityId>;
+    readonly hidden: ReadonlySet<ActivityId>;
+    readonly activeFilter: FilterState | null;
+    readonly activeOrder: OrderState | null;
+}
 
-declare const LOAD_DIAGNOSTIC_CODE: {
-    readonly INVALID_BASELINE_POINT: "invalid_baseline_point";
-    readonly UNKNOWN_CONSTRAINT: "unknown_constraint";
-    readonly PROGRESS_OUT_OF_RANGE: "progress_out_of_range";
-    readonly ORPHAN_ACTIVITY: "orphan_activity";
-    readonly INVALID_LINK: "invalid_link";
-    readonly DUPLICATE_LINK: "duplicate_link";
-};
-/** Data-quality anomaly category detected while loading a schedule. */
-type LoadDiagnosticCode = (typeof LOAD_DIAGNOSTIC_CODE)[keyof typeof LOAD_DIAGNOSTIC_CODE];
-/** Aggregated load anomaly count with bounded representative IDs. */
-interface LoadDiagnostic {
-    readonly code: LoadDiagnosticCode;
-    readonly count: number;
-    readonly sampleIds: readonly string[];
+interface ScheduleStateSnapshot {
+    readonly activities: CoreActivity[];
+    readonly links: LinkSnapshot[];
+    readonly calendars: StateSnapshot['calendars'];
+    readonly viewState: ViewStateSnapshot;
+    readonly lastStartDate: Map<ActivityId, Date>;
+    readonly promotionSnapshot: Map<ActivityId, PromotionSnapshot>;
+    readonly progressFallback: Map<ActivityId, number>;
+    readonly flags: ScheduleFlags;
+    readonly scheduleSettled: boolean;
 }
-type LoadDiagnosticRecorder = (code: LoadDiagnosticCode, sampleId: string) => void;
 
 /** Reason a Data Date operation is refused before any state is written. */
 type P6CapabilityErrorCode = 'capability_not_enabled' | 'data_date_required' | 'activity_scheduling_state_required' | 'P6_ACTIVITY_STATE_INVARIANT' | 'EXTERNAL_RELATIONSHIP_F9_NOT_CERTIFIED';
@@ -2994,13 +3201,56 @@ interface ScheduleP6Api {
         changes: ChangeSet;
     }>;
     /** Dispatches a P6 activity update and returns the resulting ChangeSet. */
-    updateActivity(activityId: ActivityId, patch: Readonly<P6ActivityInputPatch>): Promise<{
+    updateActivity(activityId: ActivityId, patch: Readonly<P6ActivityInputPatch>, options?: Readonly<P6CommandOptions>): Promise<{
         changes: ChangeSet;
     }>;
     /** Runs F9 with the current settings merged with `patch` and applies the projection. */
-    schedule(patch?: Readonly<Partial<P6ScheduleSettings>>): Promise<P6ScheduleResult>;
+    schedule(patch?: Readonly<Partial<P6ScheduleSettings>>, options?: Readonly<P6CommandOptions>): Promise<P6ScheduleResult>;
+}
+/** Options of a Data Date command, as {@link DispatchOptions} for dispatch. */
+interface P6CommandOptions {
+    /** Instant the command happens at; stamps the run log a schedule writes. */
+    readonly at?: Date;
+}
+
+/** The Data Date state a schedule snapshot carries beside its activities. */
+interface DataDateSnapshot {
+    readonly settings: P6ScheduleSettings | null;
+    readonly projectState: P6ProjectState | null;
+    readonly latestRunLog: P6ScheduleRunLog | null;
+    readonly externalRelationshipIds: readonly string[];
 }
 
+/** Stable validation reasons for rejected dependency operations. */
+declare const LINK_REJECTION_REASON: {
+    readonly SELF_LINK: "self-link";
+    readonly CYCLE: "cycle";
+    readonly DUPLICATE: "duplicate";
+    readonly ACTIVITY_MISSING: "activity-missing";
+    readonly LINK_MISSING: "link-missing";
+    readonly HIERARCHY_LINK: "hierarchy-link";
+};
+/** Stable validation reason for a rejected dependency operation. */
+type LinkRejection = (typeof LINK_REJECTION_REASON)[keyof typeof LINK_REJECTION_REASON];
+
+declare const LOAD_DIAGNOSTIC_CODE: {
+    readonly INVALID_BASELINE_POINT: "invalid_baseline_point";
+    readonly UNKNOWN_CONSTRAINT: "unknown_constraint";
+    readonly PROGRESS_OUT_OF_RANGE: "progress_out_of_range";
+    readonly ORPHAN_ACTIVITY: "orphan_activity";
+    readonly INVALID_LINK: "invalid_link";
+    readonly DUPLICATE_LINK: "duplicate_link";
+};
+/** Data-quality anomaly category detected while loading a schedule. */
+type LoadDiagnosticCode = (typeof LOAD_DIAGNOSTIC_CODE)[keyof typeof LOAD_DIAGNOSTIC_CODE];
+/** Aggregated load anomaly count with bounded representative IDs. */
+interface LoadDiagnostic {
+    readonly code: LoadDiagnosticCode;
+    readonly count: number;
+    readonly sampleIds: readonly string[];
+}
+type LoadDiagnosticRecorder = (code: LoadDiagnosticCode, sampleId: string) => void;
+
 /**
  * Lifecycle health states observable without awaiting initialization.
  * `ready` means alive, not initialized; await {@link ScheduleCore.ready} before
@@ -3031,6 +3281,16 @@ interface ScheduleCoreInput extends BackendScheduleInput {
     clock?: () => Date;
     /** Makes `ready` wait for initial critical-path calculation when `true`. */
     criticalPathOnLoad?: boolean;
+    /**
+     * Keeps a settled critical-path result until `criticalPathReady` is read;
+     * defaults to `true`. Hosts that never read it pass `false`.
+     */
+    retainCriticalPathResult?: boolean;
+    /**
+     * Tracks changes since the last acknowledged save; defaults to `true`.
+     * Hosts that persist each ChangeSet pass `false`.
+     */
+    trackPersistence?: boolean;
     /** Initial baseline- or actual-based status mode. */
     statusCriteria?: StatusCriteria;
     /** Optional consumer schedule identifier retained in sector metadata. */
@@ -3042,6 +3302,39 @@ interface ScheduleCoreInput extends BackendScheduleInput {
     p6?: P6ScheduleInput;
 }
 
+declare const SCHEDULE_CORE_SNAPSHOT_VERSION = 1;
+/**
+ * Where the generators of new activity, link and unique correlative ids
+ * continue from.
+ */
+interface IdCounters {
+    readonly activity: number;
+    readonly link: number;
+    readonly uniqueCorrelative: number;
+}
+/**
+ * Complete shared state of one schedule core, enough for another core to
+ * continue from it and reach the same results. Per-user state such as undo
+ * history, clipboards, and active filters is not included. Carry it between
+ * processes with `encodeWireValue` / `decodeWireValue`.
+ */
+interface ScheduleCoreSnapshot {
+    readonly version: typeof SCHEDULE_CORE_SNAPSHOT_VERSION;
+    readonly sector: SectorMetadata;
+    readonly calendars: Calendar[];
+    readonly baseCalendars: Calendar[];
+    readonly state: ScheduleStateSnapshot;
+    readonly activityIdCounter: number;
+    readonly linkIdCounter: number;
+    readonly uniqueCorrelativeIdCounter: number;
+    readonly customIds: CustomIdTrackerSnapshot;
+    readonly criticalPathSettled: boolean;
+    readonly lastOperationAt: Date | null;
+    readonly dataDate: DataDateSnapshot | null;
+}
+/** Host options for a core restored from a {@link ScheduleCoreSnapshot}. */
+type ScheduleCoreRestoreOptions = Pick<ScheduleCoreInput, 'clock' | 'reporter' | 'isDataDateEnabled' | 'retainCriticalPathResult' | 'trackPersistence'>;
+
 /** Summary of logical links and projected effective dependency edges. */
 interface EffectiveGraphAudit {
     /** Number of current activities. */
@@ -3120,6 +3413,18 @@ declare class ScheduleCore {
      * @param input - Backend schedule data plus initialization options.
      */
     constructor(input: ScheduleCoreInput);
+    private _initSaveTracker;
+    /**
+     * Captures the shared state after every queued operation, so another core
+     * restored with {@link ScheduleCore.fromSnapshot} reaches the same results.
+     */
+    exportSnapshot(): Promise<ScheduleCoreSnapshot>;
+    /**
+     * Restores a core from {@link ScheduleCore.exportSnapshot} without
+     * normalization or initial passes. The new core takes ownership of the
+     * snapshot.
+     */
+    static fromSnapshot(snapshot: ScheduleCoreSnapshot, options?: ScheduleCoreRestoreOptions): ScheduleCore;
     /**
      * Resolves after initialization, and after initial critical path when
      * `criticalPathOnLoad` is enabled.
@@ -3138,13 +3443,17 @@ declare class ScheduleCore {
      * Tracks the critical-path job current when this property is read.
      *
      * Later automatic work, including undo or redo recomputation, can replace
-     * the promise returned by subsequent reads. Use `whenSettled()` to wait for
-     * the current schedule revision.
+     * the promise returned by subsequent reads. Once a job has been read and has
+     * resolved, the engine releases its result: later reads resolve to `null`
+     * until a newer job starts. Use `whenSettled()` to wait for the current
+     * schedule revision.
      * Apply a non-null `changes` value to the consumer-owned projection.
      */
     get criticalPathReady(): Promise<{
         changes: ChangeSet;
     } | null>;
+    private _trackCriticalPathJob;
+    private _releaseCriticalPathResult;
     /**
      * Current lifecycle health; `ready` can be observed before initialization
      * finishes, so await {@link ScheduleCore.ready} before normal use.
@@ -3358,12 +3667,18 @@ declare class ScheduleCore {
     getModifiedActivities(): ReadonlyArray<Readonly<CoreActivity>>;
     /** @returns Modified persisted fields grouped by activity ID; no I/O occurs. */
     getModifiedActivityFields(): ReadonlyMap<string, ReadonlyArray<PersistableActivityField>>;
+    /** @returns Modified persisted activities with renumber-only ones split out; no I/O occurs. */
+    getModifiedActivityChanges(): ModifiedActivityChanges;
     /** @returns Defensive snapshots of not-yet-persisted activities; no I/O occurs. */
     getNewActivities(): ReadonlyArray<Readonly<CoreActivity>>;
     /** @returns Whether tracked state differs from the acknowledged save baseline. */
     hasUnsavedChanges(): boolean;
     /** @returns The P6 schedule settings pending persistence, or `null` when unchanged since the last acknowledge. */
     getModifiedDataDateSettings(): Readonly<P6ScheduleSettings> | null;
+    /** @returns The latest P6 schedule run pending persistence, or `null` when unchanged since the last acknowledge. */
+    getModifiedDataDateLatestRunLog(): {
+        readonly latestRunLog: Readonly<P6ScheduleRunLog> | null;
+    } | null;
     /** @returns The P6 state of every activity whose Data Date fields changed since the last acknowledge, keyed by activity id. */
     getModifiedDataDateActivities(): ReadonlyMap<string, Readonly<P6ActivityDraftState>>;
     /** @returns The monotonic scheduling revision without a readiness guard. */
@@ -3372,10 +3687,24 @@ declare class ScheduleCore {
     getStateRevision(): number;
     /** @returns The undo-history boundary for an external save checkpoint. */
     capturePersistenceHistoryBoundary(): number;
-    /** @returns A defensive checkpoint for consumer-owned persistence. */
-    readPersistenceCheckpoint(): PersistenceCheckpoint;
+    /**
+     * @param options - `pendingOnly` reads only the entities that may differ
+     * from the last acknowledged save, for a consumer that persists those.
+     * @returns A defensive checkpoint for consumer-owned persistence.
+     */
+    readPersistenceCheckpoint(options?: {
+        readonly pendingOnly?: boolean;
+    }): PersistenceCheckpoint;
     /** @returns A deterministic serialization digest of canonical schedule state. */
     getCanonicalDigest(): string;
+    /**
+     * Fingerprints the state every replica of a live schedule shares: the
+     * canonical state without the backend ids that only the saving server
+     * learns.
+     *
+     * @returns A fixed-size deterministic fingerprint.
+     */
+    getReplicaFingerprint(): string;
     /** @returns A fixed-size deterministic fingerprint of canonical schedule state. */
     getCanonicalFingerprint(): string;
     private _getP6ScheduleStateFingerprint;
@@ -3406,6 +3735,7 @@ declare class ScheduleCore {
     private _scheduleP6;
     private _runP6Schedule;
     private _applyPreparedP6Schedule;
+    private _operationNow;
     private _buildP6ScheduleRunLog;
     private _requireDataDateCapability;
     private _changeSetIsSubstantive;
@@ -3495,6 +3825,14 @@ declare class ScheduleCore {
     canUndo(): boolean;
     /** @returns Whether a redo entry is available; readiness is not required. */
     canRedo(): boolean;
+    /** @returns Where the generators of new ids continue from. */
+    readIdCounters(): IdCounters;
+    /**
+     * Continues id generation from `counters`, so a copy replaying a command
+     * creates the same ids as the copy that ran it first, even when the two
+     * were loaded from different sources (a snapshot or the database).
+     */
+    restoreIdCounters(counters: IdCounters): void;
     /** Clears undo and redo history without changing schedule state. */
     clearHistory(): void;
     /** @returns Current undo depth; readiness is not required. */
@@ -3507,8 +3845,11 @@ declare class ScheduleCore {
     destroy(): void;
     private readonly _initPromise;
     private _criticalPathReady;
+    private _settledCriticalPathJob;
     private readonly _ready;
     private _saveTracker;
+    private _retainCriticalPathResult;
+    private _lastOperationAt;
     private assertReady;
     private _rollback;
 }
@@ -3523,6 +3864,100 @@ declare class ScheduleCore {
  */
 declare function createSchedule(input: ScheduleCoreInput): Promise<ScheduleCore>;
 
+declare const PONDERATOR_CRITERIA: readonly ["DURATION", "COST", "HH"];
+/** Everything a host loads to open a schedule the way every host opens it. */
+interface HostScheduleSource extends BackendScheduleInput {
+    /** The project's ponderator criterion; overrides the sector's when set. */
+    readonly projectActivityCriterion?: string | null;
+    readonly baselinePoints?: readonly BaselinePoint[];
+    readonly statusCriteria?: StatusCriteria;
+    readonly ganttId?: number;
+    /** Stored Data Date state, passed only while the Data Date rollout is on. */
+    readonly p6?: ScheduleCoreInput['p6'];
+    /** Whether Data Date scheduling is allowed right now (rollout and preference). */
+    readonly isDataDateEnabled?: () => boolean;
+    /** The clock the engine reads the current instant from. */
+    readonly clock: () => Date;
+    readonly reporter?: ScheduleCoreReporter;
+}
+/** The sector flags that ask the first editor to reconcile on load. */
+interface LoadTimeSectorFlags {
+    readonly activity_creter?: string | null;
+    readonly update_save_handle_for_calendar_update?: boolean | null;
+    readonly update_ponderators_masterplan?: boolean | null;
+}
+/** One reconciliation the first editor dispatches after a schedule loads. */
+type LoadTimeAction = {
+    readonly kind: typeof DISPATCH_ACTION_KIND.CALENDAR_RECONCILE;
+} | {
+    readonly kind: typeof DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET;
+    readonly criterion: (typeof PONDERATOR_CRITERIA)[number];
+};
+/**
+ * The reconciliations a load asks for: the actions to dispatch, whether the
+ * calendars and ponderators need them, and a requested ponderator criterion
+ * the engine does not know.
+ */
+interface LoadTimeWork {
+    readonly actions: readonly LoadTimeAction[];
+    readonly calendar: boolean;
+    readonly ponderators: boolean;
+    readonly unresolvedPonderatorCriterion?: string;
+}
+/**
+ * Builds the {@link ScheduleCoreInput} for a schedule loaded from the
+ * backend, applying the same defaults in every host so a browser and a server
+ * that load the same rows build the same engine.
+ */
+declare function hostScheduleInput(source: HostScheduleSource): ScheduleCoreInput;
+/**
+ * The reconciliation the sector asks for on load: a calendar reconcile and a
+ * ponderator recompute under the effective criterion.
+ */
+declare function loadTimeWork(sector: LoadTimeSectorFlags): LoadTimeWork;
+/**
+ * `true` when loading moved some activity's start to another UTC day than the
+ * stored one, which means the schedule has to be saved after the load.
+ */
+declare function rescheduledOnLoad(stored: readonly Pick<BackendActivityInput, 'unique_id' | 'start_date'>[], startDateOf: (activityId: string) => Date | null): boolean;
+
+/**
+ * `true` when a stored backend date and the engine's date fall on different
+ * UTC days. Unreadable values never count as moved.
+ */
+declare function movedToAnotherUtcDay(stored: unknown, current: unknown): boolean;
+
+/** A row the backend schedule save accepts, keyed by its wire column names. */
+type BackendRow = Record<string, unknown>;
+/** Where the rows go and how the engine's units map to the backend's. */
+interface BackendRowScope {
+    readonly sectorId: number | string;
+    readonly ganttId: number | string;
+    readonly hoursPerDay: number;
+    /** Whether an activity has children, sent as the row's `has_childs`. */
+    readonly hasChildren: (activityId: string) => boolean;
+}
+/** Per-activity facts the save needs beyond the engine state. */
+interface ActivityRowFacts {
+    /** The stored wire values of the row, as the backend served them. */
+    readonly origin?: Readonly<Record<string, unknown>> | null;
+    /** Engine fields changed since the last acknowledged save. */
+    readonly changedFields?: Iterable<string>;
+    readonly progressChangedByActionButton?: boolean;
+    readonly progressModifiedBySDK?: boolean;
+    /** Persist the engine's dates even when they stay on the stored day. */
+    readonly persistCalendarAlignedDates?: boolean;
+}
+/**
+ * The backend save row of one activity. Unchanged protected fields (dates,
+ * duration, constraint, progress) keep their stored value unless the start
+ * moved to another UTC day, so a save never rewrites what the user did not
+ * touch.
+ */
+declare function activityBackendRow(activity: Readonly<CoreActivity>, scope: BackendRowScope, facts?: ActivityRowFacts): BackendRow;
+/** The backend save row of one link. */
+declare function linkBackendRow(link: Readonly<Link>, scope: BackendRowScope): BackendRow;
+
 /** Fully normalized data returned by the backend parsing boundary. */
 interface ParsedInput {
     sector: SectorMetadata;
@@ -3546,6 +3981,15 @@ interface ParsedInput {
  */
 declare function parseFromBackend(input: BackendScheduleInput, reporter?: ScheduleCoreReporter, recordDiagnostic?: LoadDiagnosticRecorder): ParsedInput;
 
+/**
+ * Encodes an operation, its options, or a snapshot into plain JSON values.
+ * Dates, Maps, and Sets survive `JSON.stringify` and {@link decodeWireValue};
+ * object keys holding `undefined` are dropped.
+ */
+declare function encodeWireValue(value: unknown): unknown;
+/** Restores a value produced by {@link encodeWireValue} after `JSON.parse`. */
+declare function decodeWireValue(value: unknown): unknown;
+
 /**
  * Selects the normalized baseline point marked as active.
  *
@@ -3594,6 +4038,77 @@ interface ExpectedProgressAdapter {
  */
 declare function computeExpectedProgress(rootIds: readonly string[], now: Date, adapter: ExpectedProgressAdapter, defaultBaseCalendarId?: string | null): string[];
 
+type UtcTimestamp = string;
+type NullableUtcTimestamp = UtcTimestamp | null;
+type WithTimestamps<Shape, Keys extends keyof Shape> = Omit<Shape, Keys> & {
+    readonly [Key in Keys]: undefined extends Shape[Key] ? NullableUtcTimestamp | undefined : NullableUtcTimestamp;
+};
+declare const SETTINGS_DATE_FIELDS: readonly ["dataDate", "projectMustFinishBy", "projectForecastStart"];
+declare const ACTIVITY_DATE_FIELDS: readonly ["actualStart", "actualFinish", "plannedStart", "plannedFinish", "expectedFinish", "suspendDate", "resumeDate", "primaryConstraintDate", "secondaryConstraintDate", "remainingEarlyStart", "remainingEarlyFinish", "remainingLateStart", "remainingLateFinish", "earlyStart", "earlyFinish", "lateStart", "lateFinish", "primaryBaselineStart", "primaryBaselineFinish"];
+declare const PERSISTED_DURATION_TYPE: Readonly<{
+    readonly fixed_duration_and_units: "fixed_units_time";
+    readonly fixed_duration_and_units_per_time: "fixed_duration_units";
+    readonly fixed_units_time: "fixed_units_time";
+    readonly fixed_duration_units: "fixed_duration_units";
+    readonly fixed_units: "fixed_units";
+    readonly fixed_duration_units_time: "fixed_duration_units_time";
+}>;
+type PersistedDurationType = (typeof PERSISTED_DURATION_TYPE)[keyof typeof PERSISTED_DURATION_TYPE];
+type ResourceAssignmentDto = WithTimestamps<P6ResourceAssignment, 'actualStart' | 'actualFinish'>;
+/** Data Date settings as the backend stores and serves them (UTC ISO timestamps). */
+type P6ScheduleSettingsDto = WithTimestamps<P6ScheduleSettings, (typeof SETTINGS_DATE_FIELDS)[number]>;
+/** One activity's Data Date state as the backend stores and serves it. */
+type P6ActivityStateDto = Omit<WithTimestamps<P6ActivityDraftState, (typeof ACTIVITY_DATE_FIELDS)[number]>, 'durationType' | 'resourceAssignments'> & {
+    readonly durationType?: PersistedDurationType | P6ActivityDraftState['durationType'];
+    readonly resourceAssignments?: readonly ResourceAssignmentDto[];
+};
+/** A schedule-run warning as the backend stores and serves it. */
+type P6ScheduleDiagnosticDto = Omit<P6ScheduleDiagnostic, 'dataDate' | 'dates'> & {
+    readonly dataDate: UtcTimestamp;
+    readonly dates: {
+        readonly actualStart: NullableUtcTimestamp;
+        readonly actualFinish: NullableUtcTimestamp;
+    };
+};
+/** The latest schedule run as the backend stores and serves it. */
+type P6ScheduleRunLogDto = Omit<P6ScheduleRunLog, 'calculatedAt' | 'dataDate' | 'settings' | 'warnings'> & {
+    readonly calculatedAt: NullableUtcTimestamp;
+    readonly dataDate: UtcTimestamp;
+    readonly settings: P6ScheduleSettingsDto;
+    readonly warnings: readonly P6ScheduleDiagnosticDto[];
+};
+/** A schedule's whole Data Date state as the backend stores and serves it. */
+interface P6ScheduleDto {
+    readonly settings: P6ScheduleSettingsDto;
+    readonly projectPlannedStart: NullableUtcTimestamp;
+    readonly activities: Readonly<Record<string, P6ActivityStateDto>>;
+    readonly externalRelationshipIds?: readonly string[];
+    readonly latestRunLog?: P6ScheduleRunLogDto | null;
+}
+/** The engine-side Data Date state to serialize for the backend. */
+interface P6SerializableState {
+    readonly settings: Readonly<P6ScheduleSettings> | null;
+    readonly projectState: Readonly<P6ProjectState> | null;
+    readonly activities: readonly Readonly<CoreActivity>[];
+    readonly externalRelationshipIds?: readonly string[];
+    readonly latestRunLog?: Readonly<P6ScheduleRunLog> | null;
+}
+/**
+ * Converts the backend's stored Data Date state into the `p6` input of
+ * {@link createSchedule}. Throws on a timestamp that is not a canonical UTC
+ * ISO string.
+ */
+declare function p6InputFromDto(dto: P6ScheduleDto): P6ScheduleInput;
+/** Serializes Data Date settings for the backend. */
+declare function serializeP6Settings(settings: Readonly<P6ScheduleSettings>): P6ScheduleSettingsDto;
+/** Serializes one activity's Data Date state for the backend. */
+declare function serializeP6Activity(activity: Readonly<P6ActivityDraftState>): P6ActivityStateDto;
+/**
+ * Serializes the engine's Data Date state for the backend; `null` when the
+ * schedule has no Data Date settings.
+ */
+declare function serializeP6State(input: P6SerializableState): P6ScheduleDto | null;
+
 /**
  * Activity fields safe to prefill before identity, placement, dates, duration,
  * calendar, and unique correlative ID are chosen.
@@ -3629,10 +4144,10 @@ interface WithProplannerId {
 declare const getUnsavedActivities: <T extends WithProplannerId>(activities?: readonly T[]) => T[];
 
 /**
- * Yields one browser message-channel turn without introducing a timer.
+ * Yields one event-loop turn without introducing a timer: a message-channel
+ * turn in a browser, a `setImmediate` turn in Node.
  *
- * @returns An already-resolved promise outside a browser or without
- * `MessageChannel` support.
+ * @returns An already-resolved promise in a browser without `MessageChannel`.
  */
 declare function yieldToBrowser(): Promise<void>;
 
@@ -4004,6 +4519,7 @@ declare const REJECTION_REASON: {
     readonly HIERARCHY_CYCLE: "hierarchy_cycle";
     readonly MANUAL_SCHEDULING_ACTIVE: "manual_scheduling_active";
     readonly SANDBOX_PERSISTENCE_FORBIDDEN: "sandbox_persistence_forbidden";
+    readonly PERSISTENCE_TRACKING_DISABLED: "persistence_tracking_disabled";
     readonly STALE_STATE_REVISION: "stale-state-revision";
     readonly INVALID_PROGRESS_VALUE: "invalid_progress_value_must_be_0_or_100";
 };
@@ -4021,4 +4537,4 @@ declare const DISPATCH_TRACK_EVENT: {
 /** Consumer analytics event name emitted by a schedule mutation. */
 type DispatchTrackEvent = (typeof DISPATCH_TRACK_EVENT)[keyof typeof DISPATCH_TRACK_EVENT];
 
-export { ACTIVITY_BATCH_ACTION_KIND, ACTIVITY_BATCH_MODE, ACTIVITY_DATE_EDGE, ACTIVITY_FIELD, ACTIVITY_PONDERATOR_CRITERION, ACTIVITY_PROGRESS_ORIGIN, ACTIVITY_TYPE, type ActivityBaselineSnapshot, type ActivityBatchAction, type ActivityBatchInput, type ActivityBatchItem, type ActivityBatchItemInput, type ActivityBatchLinkInput$1 as ActivityBatchLinkInput, type ActivityBatchMode, type ActivityBatchParentReference, type ActivityBatchReference, type ActivityBulkEdit, type ActivityClipboardEntry, type ActivityClipboardReferences, type ActivityClipboardSnapshot, type ActivityCreateInput, type ActivityCreationOverrides, type ActivityCreter, type ActivityDateEdge, type ActivityDateEdit, type ActivityField, type ActivityFieldEdit, type ActivityFieldValue, type ActivityId, type ActivityLookaheadSyncInput, type ActivityMoveInput, type ActivityPasteDestination, type ActivityStatus, type ActivityType, type ApplyLookaheadConversionInput, BASELINE_ROLE, type BackendActivityInput, type BackendCalendarExceptionInput, type BackendCalendarInput, type BackendLinkInput, type BackendScheduleInput, type BackendSectorInput, type BackendShiftInput, type BaselinePoint, type BaselineRole, type BaselineVersion, type BranchOrderChange, CALENDAR_UNIT, CHANGE_SET_SOURCE_KIND, COLUMN, COMPLETED_PROGRESS, CONFIRMATION_KIND, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CONSTRAINT_WARNING_KIND, CREATION_KIND, type Calendar, type CalendarId, type CalendarLike, type CalendarReaderInput, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ChangeSetSource, type ColumnName, type ConfirmationAlternative, type ConfirmationKind, type ConfirmationRequest, type ConstraintType, type ConstraintWarning, type CoreActivity, type CoreBaselinePoint, type CreationKind, type CriticalPathResult, P6_PROPERTY_CONTRACT as DATA_DATE_PROPERTY_CONTRACT, DATE_GESTURE_KIND, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_LINK_OPERATION_KIND, DISPATCH_TRACK_EVENT, type P6ActivityCalculationInputs as DataDateActivityCalculationInputs, type P6ActivityColumnKey as DataDateActivityColumnKey, type P6ActivityData as DataDateActivityData, type P6ActivityDraftState as DataDateActivityDraftState, type P6ActivityInputPatch as DataDateActivityInputPatch, type P6ActivityState as DataDateActivityState, type P6ActivityType as DataDateActivityType, P6CapabilityError as DataDateCapabilityError, type P6CapabilityErrorCode as DataDateCapabilityErrorCode, type P6DependencyReference as DataDateDependencyReference, type P6DiagnosticProjectIdentity as DataDateDiagnosticProjectIdentity, type P6DiagnosticRelationship as DataDateDiagnosticRelationship, type P6DiagnosticRelationshipType as DataDateDiagnosticRelationshipType, type P6DurationType as DataDateDurationType, type P6EndingActivityOption as DataDateEndingActivityOption, type P6EndingActivityPage as DataDateEndingActivityPage, type P6EndingActivitySearch as DataDateEndingActivitySearch, type P6MappedScheduleOptions as DataDateMappedScheduleOptions, type P6MissingActivityInput as DataDateMissingActivityInput, type P6OutOfSequencePolicy as DataDateOutOfSequencePolicy, type P6ProjectPlannedStartChange as DataDateProjectPlannedStartChange, type P6ProjectState as DataDateProjectState, type P6PropertyContractRow as DataDatePropertyContractRow, type P6PropertyEdgeCases as DataDatePropertyEdgeCases, type P6RawProjectOptions as DataDateRawProjectOptions, type P6RawScheduleOptions as DataDateRawScheduleOptions, type P6RequiredHistoricalField as DataDateRequiredHistoricalField, type P6ResourceAssignment as DataDateResourceAssignment, type P6ScheduleDiagnostic as DataDateScheduleDiagnostic, type P6ScheduleDiagnosticCode as DataDateScheduleDiagnosticCode, type P6ScheduleInput as DataDateScheduleInput, type P6ScheduleReadiness as DataDateScheduleReadiness, type P6ScheduleResult as DataDateScheduleResult, type P6ScheduleRunLog as DataDateScheduleRunLog, type P6ScheduleSettings as DataDateScheduleSettings, type P6ScheduleWarning as DataDateScheduleWarning, type P6SettingsChange as DataDateSettingsChange, type DateGesture, type DateGestureKind, type DateGesturePreview, type DatesBatchVerdict, type DeletedActivitySnapshot, type DeletedLinkSnapshot, type DispatchAction, type DispatchActionKind, type DispatchConfirmationRequest, type DispatchManyAction, type DispatchManyChangeSetSource, type DispatchManyResult, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, EDIT_ALERT_KEY, EDIT_DENIAL_REASON, ENTITY_CHANGE_KIND, type EditAlertKey, type EditDenialReason, type EditResult, type EditableColumnName, type EffectiveGraphAudit, type EntityChange, type ActivityBatchLinkInput as ErgonomicActivityBatchLinkInput, type ExpectedProgressAdapter, FILTER_FIELD, FILTER_LOGIC, FILTER_OPERATOR, FILTER_REJECTION_REASON, FILTER_VALUE_KIND, FLAT_WBS_DEPTH, type FilterCriterion, type FilterCriterionGroup, type FilterCriterionValue, type FilterDateRange, type FilterField, type FilterLogic, type FilterOperator, type FilterRejection, type FilterState, type FilterValueKind, GROUP_ID_PREFIX, GROUP_ID_SEPARATOR, type GroupCriterion, type GroupCriterionInput, type GroupLevelWindow, type GroupState, type GroupStateInput, type ImpactRequestSyncInput, LINK_BATCH_OPERATION_KIND, LINK_CODE, LINK_CODE_TO_TYPE, LINK_REJECTION_REASON, LINK_RELATIONSHIP, LINK_TYPE, LINK_TYPE_CODE, LOOKAHEAD_CONFIRMATION_KIND, type Link, type LinkBatchOperationKind, type LinkBatchRequest, type LinkBatchVerdict, type LinkCreateRequest, type LinkId, type LinkPatchRequest, type LinkRejection, type LinkRelationship, type LinkType, type LinkTypeCode, type LinkUpdateAction, type LinksBatchOperation, type LoadDiagnostic, type LoadDiagnosticCode, type LookaheadActualIntent, LookaheadActualTransitionError, type LookaheadActualTransitionErrorCode, type LookaheadConfirmationRequest, type LookaheadConversionFormerParent, type LookaheadConversionGroup, type LookaheadConversionInput, type LookaheadConversionMilestoneMove, type LookaheadConversionPlan, type LookaheadConversionResult, type LookaheadDerivedCalendars, type LookaheadDerivedFields, type LookaheadDerivedFieldsResolver, type LookaheadDerivedInput, type LookaheadProgressActualActivityState, type LookaheadProgressActualInput, type LookaheadProgressActualPlan, MINIMUM_GROUP_DEPTH, MINIMUM_GROUP_LEVEL, type MutationContext, NEW_ACTIVITY_DEFAULTS, NOT_STARTED_PROGRESS, ORDER_DIRECTION, ORDER_MODE, type OrderDirection, type OrderMode, type OrderRule, type OrderState, PASTE_PLACEMENT, PERSISTENCE_REBASE_CONFLICT_KIND, PERSISTENCE_REBASE_ENTITY, type ParsedInput, type PendingRequest, type PersistableActivityField, type PersistedEntityIdentity, type PersistenceCheckpoint, type PersistenceRebaseConflict, type PersistenceRebaseConflictKind, type PersistenceRebaseEntity, type PersistenceRebaseInput, type PersistenceRebaseRekey, type PersistenceRebaseRemoteChange, type PersistenceRebaseReport, type PipelineColumnName, type ProjectWorkHours, REJECTION_REASON, ROOT_PARENT_ID, SCHEDULE_CORE_STATUS, SCHEDULE_EFFECT_KIND, SIR_AUTO_REJECT_REASON, STATUS, STATUS_CRITERIA, type ScheduleActivitiesApi, type ScheduleApiNamespaces, type ScheduleAutoScheduleAction, type ScheduleBaselinesApi, type ScheduleCalendarsApi, type ScheduleCellsApi, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleCriticalPathApi, type ScheduleP6Api as ScheduleDataDatesApi, type ScheduleDiagnosticsApi, type ScheduleEffect, type ScheduleHistoryApi, type ScheduleImpactRequestsApi, type ScheduleLinksApi, type SchedulePersistenceApi, type ScheduleProjectionApi, type ScheduleSelectionApi, type ScheduleViewApi, type SectorMetadata, type SelectionToggleInput, type StandaloneCalendar, type StandaloneCalendarReader, type StaticActivityDefaults, type StatusCriteria, type TrackingEvent, UNASSIGNED_GROUP_LABEL, UNASSIGNED_VALUE_ID, type UndoOptions, VIEW_ATTRIBUTE_KIND, VISUAL_ROW_KIND, type ViewAttributeAssignmentInput, type ViewAttributeCatalogInput, type ViewAttributeFilterCriterion, type ViewAttributeOrderRule, type ViewAttributeValueInput, type ViewFilterInput, type ViewStateChange, type ViewStatePropChange, type VisualRow, WORK_TIME_DIRECTION, type WbsDepth, type WithProplannerId, type WorkTimeDirection, type WorkTimeQuery, allowedSecondaryConstraintTypes, appendGroupRowId, buildGroupRowId, checkNoUpdatedLinks, computeExpectedProgress, createCalendarReader, createLookaheadDerivedFields, createOutbuildP6ScheduleSettings as createOutbuildDataDateScheduleSettings, createSchedule, expectedProgressFromBaseline, formatUtcAsP6WallDate, getActiveBaseline, getUnsavedActivities, isRootParent, isViewAttributeCriterion, isViewAttributeOrderRule, mapP6ScheduleOptions as mapDataDateScheduleOptions, normalizeParentKey, parseFromBackend, parseP6DayAsCalendarStart, parseP6WallDateAsUtc, planLookaheadProgressActuals, prepareLookaheadProgressActuals, resolveExpectedFinishDateSelection, resolveLookaheadActualDateSelection, willRunCriticalPath, yieldToBrowser };
+export { ACTIVITY_BATCH_ACTION_KIND, ACTIVITY_BATCH_MODE, ACTIVITY_DATE_EDGE, ACTIVITY_FIELD, ACTIVITY_PONDERATOR_CRITERION, ACTIVITY_PROGRESS_ORIGIN, ACTIVITY_TYPE, type ActivityBaselineSnapshot, type ActivityBatchAction, type ActivityBatchInput, type ActivityBatchItem, type ActivityBatchItemInput, type ActivityBatchLinkInput$1 as ActivityBatchLinkInput, type ActivityBatchMode, type ActivityBatchParentReference, type ActivityBatchReference, type ActivityBulkEdit, type ActivityClipboardEntry, type ActivityClipboardReferences, type ActivityClipboardSnapshot, type ActivityCreateInput, type ActivityCreationOverrides, type ActivityCreter, type ActivityDateEdge, type ActivityDateEdit, type ActivityField, type ActivityFieldEdit, type ActivityFieldValue, type ActivityFieldsRestoreEntry, type ActivityFieldsRestoreInput, type ActivityId, type ActivityLookaheadSyncInput, type ActivityMoveInput, type ActivityPasteDestination, type ActivityRowFacts, type ActivityStatus, type ActivityType, type ApplyLookaheadConversionInput, BASELINE_ROLE, type BackendActivityInput, type BackendCalendarExceptionInput, type BackendCalendarInput, type BackendLinkInput, type BackendRow, type BackendRowScope, type BackendScheduleInput, type BackendSectorInput, type BackendShiftInput, type BaselinePoint, type BaselineRole, type BaselineVersion, type BranchOrderChange, CALENDAR_UNIT, CHANGE_SET_SOURCE_KIND, COLUMN, COMPLETED_PROGRESS, CONFIRMATION_KIND, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CONSTRAINT_WARNING_KIND, CREATION_KIND, type Calendar, type CalendarId, type CalendarLike, type CalendarReaderInput, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ChangeSetSource, type ColumnName, type ConfirmationAlternative, type ConfirmationKind, type ConfirmationRequest, type ConstraintType, type ConstraintWarning, type CoreActivity, type CoreBaselinePoint, type CreationKind, type CriticalPathResult, P6_PROPERTY_CONTRACT as DATA_DATE_PROPERTY_CONTRACT, DATE_GESTURE_KIND, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_LINK_OPERATION_KIND, DISPATCH_TRACK_EVENT, type P6ActivityCalculationInputs as DataDateActivityCalculationInputs, type P6ActivityColumnKey as DataDateActivityColumnKey, type P6ActivityData as DataDateActivityData, type P6ActivityDraftState as DataDateActivityDraftState, type P6ActivityInputPatch as DataDateActivityInputPatch, type P6ActivityState as DataDateActivityState, type P6ActivityStateDto as DataDateActivityStateDto, type P6ActivityType as DataDateActivityType, P6CapabilityError as DataDateCapabilityError, type P6CapabilityErrorCode as DataDateCapabilityErrorCode, type P6DependencyReference as DataDateDependencyReference, type P6DiagnosticProjectIdentity as DataDateDiagnosticProjectIdentity, type P6DiagnosticRelationship as DataDateDiagnosticRelationship, type P6DiagnosticRelationshipType as DataDateDiagnosticRelationshipType, type P6DurationType as DataDateDurationType, type P6EndingActivityOption as DataDateEndingActivityOption, type P6EndingActivityPage as DataDateEndingActivityPage, type P6EndingActivitySearch as DataDateEndingActivitySearch, type P6MappedScheduleOptions as DataDateMappedScheduleOptions, type P6MissingActivityInput as DataDateMissingActivityInput, type P6OutOfSequencePolicy as DataDateOutOfSequencePolicy, type P6ProjectPlannedStartChange as DataDateProjectPlannedStartChange, type P6ProjectState as DataDateProjectState, type P6PropertyContractRow as DataDatePropertyContractRow, type P6PropertyEdgeCases as DataDatePropertyEdgeCases, type P6RawProjectOptions as DataDateRawProjectOptions, type P6RawScheduleOptions as DataDateRawScheduleOptions, type P6RequiredHistoricalField as DataDateRequiredHistoricalField, type P6ResourceAssignment as DataDateResourceAssignment, type P6ScheduleDiagnostic as DataDateScheduleDiagnostic, type P6ScheduleDiagnosticCode as DataDateScheduleDiagnosticCode, type P6ScheduleDiagnosticDto as DataDateScheduleDiagnosticDto, type P6ScheduleDto as DataDateScheduleDto, type P6ScheduleInput as DataDateScheduleInput, type P6ScheduleReadiness as DataDateScheduleReadiness, type P6ScheduleResult as DataDateScheduleResult, type P6ScheduleRunLog as DataDateScheduleRunLog, type P6ScheduleRunLogDto as DataDateScheduleRunLogDto, type P6ScheduleSettings as DataDateScheduleSettings, type P6ScheduleSettingsDto as DataDateScheduleSettingsDto, type P6ScheduleWarning as DataDateScheduleWarning, type P6SerializableState as DataDateSerializableState, type P6SettingsChange as DataDateSettingsChange, type DateGesture, type DateGestureKind, type DateGesturePreview, type DatesBatchVerdict, type DeletedActivitySnapshot, type DeletedLinkSnapshot, type DispatchAction, type DispatchActionKind, type DispatchConfirmationRequest, type DispatchManyAction, type DispatchManyChangeSetSource, type DispatchManyResult, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, EDIT_ALERT_KEY, EDIT_DENIAL_REASON, ENTITY_CHANGE_KIND, type EditAlertKey, type EditDenialReason, type EditResult, type EditableColumnName, type EffectiveGraphAudit, type EntityChange, type ActivityBatchLinkInput as ErgonomicActivityBatchLinkInput, type ExpectedProgressAdapter, FILTER_FIELD, FILTER_LOGIC, FILTER_OPERATOR, FILTER_REJECTION_REASON, FILTER_VALUE_KIND, FLAT_WBS_DEPTH, type FilterCriterion, type FilterCriterionGroup, type FilterCriterionValue, type FilterDateRange, type FilterField, type FilterLogic, type FilterOperator, type FilterRejection, type FilterState, type FilterValueKind, GROUP_ID_PREFIX, GROUP_ID_SEPARATOR, type GroupCriterion, type GroupCriterionInput, type GroupLevelWindow, type GroupState, type GroupStateInput, type HistoryRevertFieldsEntry, type HistoryRevertInput, type HistoryRevertLink, type HostScheduleSource, type IdCounters, type ImpactRequestSyncInput, LINK_BATCH_OPERATION_KIND, LINK_CODE, LINK_CODE_TO_TYPE, LINK_REJECTION_REASON, LINK_RELATIONSHIP, LINK_TYPE, LINK_TYPE_CODE, LOOKAHEAD_CONFIRMATION_KIND, type Link, type LinkBatchOperationKind, type LinkBatchRequest, type LinkBatchVerdict, type LinkCreateRequest, type LinkId, type LinkPatchRequest, type LinkRejection, type LinkRelationship, type LinkType, type LinkTypeCode, type LinkUpdateAction, type LinksBatchOperation, type LoadDiagnostic, type LoadDiagnosticCode, type LoadTimeAction, type LoadTimeSectorFlags, type LoadTimeWork, type LookaheadActualIntent, LookaheadActualTransitionError, type LookaheadActualTransitionErrorCode, type LookaheadConfirmationRequest, type LookaheadConversionFormerParent, type LookaheadConversionGroup, type LookaheadConversionInput, type LookaheadConversionMilestoneMove, type LookaheadConversionPlan, type LookaheadConversionResult, type LookaheadDerivedCalendars, type LookaheadDerivedFields, type LookaheadDerivedFieldsResolver, type LookaheadDerivedInput, type LookaheadProgressActualActivityState, type LookaheadProgressActualInput, type LookaheadProgressActualPlan, MINIMUM_GROUP_DEPTH, MINIMUM_GROUP_LEVEL, type ModifiedActivityChanges, type MutationContext, NEW_ACTIVITY_DEFAULTS, NOT_STARTED_PROGRESS, ORDER_DIRECTION, ORDER_MODE, type OrderDirection, type OrderMode, type OrderRule, type OrderState, PASTE_PLACEMENT, PERSISTENCE_REBASE_CONFLICT_KIND, PERSISTENCE_REBASE_ENTITY, type ParsedInput, type PendingRequest, type PersistableActivityField, type PersistedEntityIdentity, type PersistenceCheckpoint, type PersistenceRebaseConflict, type PersistenceRebaseConflictKind, type PersistenceRebaseEntity, type PersistenceRebaseInput, type PersistenceRebaseRekey, type PersistenceRebaseRemoteChange, type PersistenceRebaseReport, type PipelineColumnName, type ProjectWorkHours, REJECTION_REASON, RESTORABLE_ACTIVITY_FIELDS, ROOT_PARENT_ID, type RenumberedActivity, type RestorableActivityField, type RevertibleActivityField, SCHEDULE_CORE_STATUS, SCHEDULE_EFFECT_KIND, SIR_AUTO_REJECT_REASON, STATUS, STATUS_CRITERIA, STRUCTURE_ACTIVITY_FIELDS, type ScheduleActivitiesApi, type ScheduleApiNamespaces, type ScheduleAutoScheduleAction, type ScheduleBaselinesApi, type ScheduleCalendarsApi, type ScheduleCellsApi, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreRestoreOptions, type ScheduleCoreSnapshot, type ScheduleCoreStatus, type ScheduleCriticalPathApi, type ScheduleP6Api as ScheduleDataDatesApi, type ScheduleDiagnosticsApi, type ScheduleEffect, type ScheduleHistoryApi, type ScheduleImpactRequestsApi, type ScheduleLinksApi, type SchedulePersistenceApi, type ScheduleProjectionApi, type ScheduleSelectionApi, type ScheduleViewApi, type SectorMetadata, type SelectionToggleInput, type StandaloneCalendar, type StandaloneCalendarReader, type StaticActivityDefaults, type StatusCriteria, type TrackingEvent, UNASSIGNED_GROUP_LABEL, UNASSIGNED_VALUE_ID, type UndoOptions, VIEW_ATTRIBUTE_KIND, VISUAL_ROW_KIND, type ViewAttributeAssignmentInput, type ViewAttributeCatalogInput, type ViewAttributeFilterCriterion, type ViewAttributeOrderRule, type ViewAttributeValueInput, type ViewFilterInput, type ViewStateChange, type ViewStatePropChange, type VisualRow, WORK_TIME_DIRECTION, type WbsDepth, type WithProplannerId, type WorkTimeDirection, type WorkTimeQuery, activityBackendRow, allowedSecondaryConstraintTypes, appendGroupRowId, buildGroupRowId, checkNoUpdatedLinks, computeExpectedProgress, createCalendarReader, createLookaheadDerivedFields, createOutbuildP6ScheduleSettings as createOutbuildDataDateScheduleSettings, createSchedule, p6InputFromDto as dataDateInputFromDto, decodeWireValue, encodeWireValue, expectedProgressFromBaseline, formatUtcAsP6WallDate, getActiveBaseline, getUnsavedActivities, hostScheduleInput, isRestorableActivityField, isRevertibleActivityField, isRootParent, isViewAttributeCriterion, isViewAttributeOrderRule, linkBackendRow, loadTimeWork, mapP6ScheduleOptions as mapDataDateScheduleOptions, movedToAnotherUtcDay, normalizeParentKey, parseFromBackend, parseP6DayAsCalendarStart, parseP6WallDateAsUtc, planLookaheadProgressActuals, prepareLookaheadProgressActuals, rescheduledOnLoad, resolveExpectedFinishDateSelection, resolveLookaheadActualDateSelection, serializeP6Activity as serializeDataDateActivity, serializeP6Settings as serializeDataDateSettings, serializeP6State as serializeDataDateState, willRunCriticalPath, yieldToBrowser };