@outbuild-company/schedule-core 1.10.4 → 1.12.0

package/dist/index.d.cts

@@ -1,40 +1,44 @@
-declare const LINK_TYPE: {
-    readonly FINISH_TO_START: "0";
-    readonly START_TO_START: "1";
-    readonly FINISH_TO_FINISH: "2";
-    readonly START_TO_FINISH: "3";
-};
-
-type ConstraintType = 'asap' | 'alap' | 'snet' | 'snlt' | 'fnet' | 'fnlt' | 'mso' | 'mfo';
-declare const CONSTRAINT_TYPE: {
-    readonly ASAP: "asap";
-    readonly ALAP: "alap";
-    readonly SNET: "snet";
-    readonly SNLT: "snlt";
-    readonly FNET: "fnet";
-    readonly FNLT: "fnlt";
-    readonly MSO: "mso";
-    readonly MFO: "mfo";
-};
-
+/** Canonical activity identifier inside a schedule. */
 type ActivityId = string;
+/** Canonical dependency-link identifier inside a schedule. */
 type LinkId = string;
+/** Canonical calendar identifier inside a schedule. */
 type CalendarId = string;
+/** Normalized activity shape category. */
 type ActivityType = 'project' | 'task' | 'milestone';
 
+/** Stored dependency relationship code. */
 type LinkType = '0' | '1' | '2' | '3';
+/** Direction used for calendar-aware work-time traversal. */
 type WorkTimeDirection = 'future' | 'past';
+/** Named work-time traversal directions. */
 declare const WORK_TIME_DIRECTION: {
     readonly FUTURE: "future";
     readonly PAST: "past";
 };
+/** Unit accepted by calendar duration operations. */
 type CalendarUnit = 'hour' | 'day';
+/** Named units accepted by calendar duration operations. */
 declare const CALENDAR_UNIT: {
     readonly HOUR: "hour";
     readonly DAY: "day";
 };
-type ActivityCreter = 'DURATION' | 'COST' | 'HH';
-type StatusCriteria = 'Baseline' | 'Actual';
+/** Criteria available for schedule-wide activity weighting. */
+declare const ACTIVITY_PONDERATOR_CRITERION: {
+    readonly DURATION: "DURATION";
+    readonly COST: "COST";
+    readonly WORK_HOURS: "HH";
+};
+/** Schedule-wide activity weighting criterion. */
+type ActivityCreter = (typeof ACTIVITY_PONDERATOR_CRITERION)[keyof typeof ACTIVITY_PONDERATOR_CRITERION];
+/** Modes used to derive activity status from actual or baseline progress. */
+declare const STATUS_CRITERIA: {
+    readonly BASELINE: "Baseline";
+    readonly ACTUAL: "Actual";
+};
+/** Mode used to derive activity status. */
+type StatusCriteria = (typeof STATUS_CRITERIA)[keyof typeof STATUS_CRITERIA];
+/** Backend baseline-version metadata retained during normalization. */
 interface BaselineVersion {
     id?: number;
     name?: string | null;
@@ -42,11 +46,14 @@ interface BaselineVersion {
     visible?: boolean;
     [key: string]: unknown;
 }
+/** Backend baseline point accepted at the package boundary. */
 interface BaselinePoint {
     start_date: string;
     end_date: string;
+    /** Baseline duration in working days. */
     duration: number;
     cost: number | string;
+    /** Baseline work in hours. */
     hh_work: number | string;
     sectorbaselineversion?: BaselineVersion;
     sectorbaselineversionId?: number;
@@ -55,9 +62,11 @@ interface BaselinePoint {
     hoursPerWeek?: number;
     [key: string]: unknown;
 }
+/** Minimal pending impact-request identity consumed by schedule effects. */
 interface PendingRequest {
     id: string;
 }
+/** Derived activity statuses exposed to consumers. */
 declare const STATUS: {
     readonly DONE: "Done";
     readonly OVERDUE: "Overdue";
@@ -65,24 +74,40 @@ declare const STATUS: {
     readonly WAITING: "Waiting";
     readonly DOING: "Doing";
 };
+/** Derived activity status exposed on normalized activities. */
 type ActivityStatus = (typeof STATUS)[keyof typeof STATUS];
+/** Critical-path dates and slack for one activity. */
 interface CriticalPathResult {
+    /** Earliest feasible start, or `null` when not calculated. */
     earlyStart: Date | null;
+    /** Earliest feasible finish, or `null` when not calculated. */
     earlyFinish: Date | null;
+    /** Latest feasible start, or `null` when not calculated. */
     lateStart: Date | null;
+    /** Latest feasible finish, or `null` when not calculated. */
     lateFinish: Date | null;
+    /** Total working-hour slack, or `null` when not calculated. */
     totalSlackHours: number | null;
 }
+/** Active baseline values copied onto an activity for projection. */
 interface ActivityBaselineSnapshot {
+    /** Baseline start, or `null` when unavailable. */
     startDate: Date | null;
+    /** Baseline end, or `null` when unavailable. */
     endDate: Date | null;
+    /** Baseline duration in working days. */
     durationDays: number;
     cost: number;
+    /** Baseline work in hours. */
     workHours: number;
 }
+/** Normalized baseline point retained on a core activity. */
 interface CoreBaselinePoint {
+    /** Baseline start, or `null` when the wire value is unavailable. */
     startDate: Date | null;
+    /** Baseline end, or `null` when the wire value is unavailable. */
     endDate: Date | null;
+    /** Duration in working days. */
     durationDays: number;
     cost: number;
     workHours: number;
@@ -90,9 +115,17 @@ interface CoreBaselinePoint {
     isActiveVersion: boolean;
     isVisibleVersion: boolean;
     baseCalendarId: CalendarId | null;
+    /** Calendar hours per working day, or `null` when unspecified. */
     hoursPerDay: number | null;
+    /** Calendar hours per working week, or `null` when unspecified. */
     hoursPerWeek: number | null;
 }
+/**
+ * Complete normalized activity snapshot owned by Schedule Core.
+ *
+ * Read APIs return defensive copies. Stored duration and slack fields use
+ * working hours; façade inputs use working days where documented.
+ */
 interface CoreActivity {
     id: ActivityId;
     proplannerId: number | null;
@@ -102,12 +135,17 @@ interface CoreActivity {
     type: ActivityType;
     startDate: Date;
     endDate: Date;
+    /** Stored duration in working hours. */
     durationHours: number;
+    /** Scheduling constraint, or `null` when unconstrained. */
     constraintType: ConstraintType | null;
+    /** Constraint date, or `null` when the constraint has no date. */
     constraintDate: Date | null;
     autoScheduling: boolean;
+    /** Assigned calendar ID, or `null` when no known source/default calendar resolves. */
     calendarId: CalendarId | null;
     assignedDefaultCalendar: boolean;
+    /** Consumer-origin date, or `null` when absent. */
     dateOrigin: Date | null;
     progress: number;
     cost: number;
@@ -131,47 +169,60 @@ interface CoreActivity {
     tagIds: string[];
     baselinePoints: CoreBaselinePoint[];
     baselineSnapshot: ActivityBaselineSnapshot | null;
+    /** Summary roll-up duration in working hours. */
     recursiveDurationHours: number;
     isCritical: boolean;
+    /** Free slack in working hours, or `null` when not calculated. */
     freeSlackHours: number | null;
+    /** Inclusive calendar-day span, or `null` when unavailable. */
     calendarDuration?: number | null;
+    /** Expected progress percentage, or `null` when unavailable. */
     expectedProgress: number | null;
+    /** Baseline expected progress percentage, or `null` when unavailable. */
     expectedProgressBaseline: number | null;
     status: ActivityStatus | null;
     criticalPath: CriticalPathResult | null;
 }
+/** Normalized dependency-link snapshot. */
 interface Link {
     id: LinkId;
     source: ActivityId;
     target: ActivityId;
     type: LinkType;
+    /** Stored dependency lag in working hours. */
     lag: number;
+    /** Free slack in working hours, or `null` when not calculated. */
     freeSlackHours: number | null;
     isCritical: boolean;
     ganttId?: number;
     sectorId?: number;
     proplannerId?: number;
 }
+/** Persisted identity retained after an activity is deleted. */
 interface DeletedActivitySnapshot {
     readonly id: ActivityId;
     readonly proplannerId: number;
     readonly parentId: ActivityId | null;
     readonly hadBaseline: boolean;
 }
+/** Persisted link identity and endpoints retained after deletion. */
 interface DeletedLinkSnapshot {
     readonly id: LinkId;
     readonly proplannerId: number;
     readonly source: ActivityId;
     readonly target: ActivityId;
     readonly type: LinkType;
+    /** Stored lag in working hours. */
     readonly lag: number;
 }
+/** Normalized calendar work-week, exception, and custom-week rules. */
 interface CalendarWorktime {
     days: Array<false | string[]>;
     hours: string[];
     dates?: Record<string, false | string[]>;
     customWeeks?: Record<string, unknown>;
 }
+/** Normalized schedule or base calendar snapshot. */
 interface Calendar {
     id: CalendarId;
     name: string;
@@ -183,10 +234,13 @@ interface Calendar {
         hours?: string[];
     }>;
 }
+/** Normalized schedule metadata derived from the backend `sector` field. */
 interface SectorMetadata {
     id: string;
     name: string;
+    /** Working hours per day used for day/hour conversion. */
     hoursPerDay: number;
+    /** Working hours per week. */
     hoursPerWeek: number;
     dateFormat: string;
     projectId: number;
@@ -198,6 +252,7 @@ interface SectorMetadata {
     statusCriteria: StatusCriteria;
     ganttId: number | null;
 }
+/** One created, updated, or deleted entity in a consumer projection. */
 interface EntityChange<T> {
     id: string;
     kind: 'created' | 'updated' | 'deleted';
@@ -205,9 +260,94 @@ interface EntityChange<T> {
         before: unknown;
         after: unknown;
     }> | undefined;
+    /** Complete post-change snapshot, or `null` for deletion. */
     after: Readonly<T> | null;
 }
 
+/** Normalized activity scheduling constraint. */
+type ConstraintType = 'asap' | 'alap' | 'snet' | 'snlt' | 'fnet' | 'fnlt' | 'mso' | 'mfo';
+/** Named normalized activity scheduling constraints. */
+declare const CONSTRAINT_TYPE: {
+    readonly ASAP: "asap";
+    readonly ALAP: "alap";
+    readonly SNET: "snet";
+    readonly SNLT: "snlt";
+    readonly FNET: "fnet";
+    readonly FNLT: "fnlt";
+    readonly MSO: "mso";
+    readonly MFO: "mfo";
+};
+
+/** Stored dependency relationship codes used by normalized links. */
+declare const LINK_TYPE: {
+    readonly FINISH_TO_START: "0";
+    readonly START_TO_START: "1";
+    readonly FINISH_TO_FINISH: "2";
+    readonly START_TO_FINISH: "3";
+};
+
+declare const ACTIVITY_SAVE_FIELD_POLICY: {
+    readonly id: "ignored";
+    readonly proplannerId: "ignored";
+    readonly parentId: "tracked";
+    readonly name: "tracked";
+    readonly description: "tracked";
+    readonly type: "tracked";
+    readonly startDate: "tracked";
+    readonly endDate: "tracked";
+    readonly durationHours: "tracked";
+    readonly constraintType: "tracked";
+    readonly constraintDate: "tracked";
+    readonly autoScheduling: "tracked";
+    readonly calendarId: "tracked";
+    readonly assignedDefaultCalendar: "ignored";
+    readonly dateOrigin: "tracked";
+    readonly progress: "tracked";
+    readonly cost: "tracked";
+    readonly usedCost: "tracked";
+    readonly realCost: "tracked";
+    readonly workHours: "tracked";
+    readonly realWorkHours: "tracked";
+    readonly ponderator: "tracked";
+    readonly hasCustomPonderator: "tracked";
+    readonly correlativeId: "tracked";
+    readonly uniqueCorrelativeId: "tracked";
+    readonly customId: "tracked";
+    readonly subcontractId: "tracked";
+    readonly isLookahead: "tracked";
+    readonly hasLookaheadTasks: "ignored";
+    readonly newActivityIds: "tracked";
+    readonly hasNewActivities: "tracked";
+    readonly isNewActivity: "ignored";
+    readonly pendingRequestIds: "ignored";
+    readonly responsableIds: "tracked";
+    readonly tagIds: "tracked";
+    readonly baselinePoints: "ignored";
+    readonly baselineSnapshot: "ignored";
+    readonly recursiveDurationHours: "ignored";
+    readonly isCritical: "ignored";
+    readonly freeSlackHours: "ignored";
+    readonly calendarDuration: "ignored";
+    readonly expectedProgress: "ignored";
+    readonly expectedProgressBaseline: "ignored";
+    readonly status: "ignored";
+    readonly criticalPath: "ignored";
+};
+/**
+ * Activity field included in consumer persistence comparisons.
+ *
+ * Derived scheduling, baseline, selection, and backend identity fields are
+ * intentionally excluded.
+ */
+type PersistableActivityField = {
+    [Field in keyof typeof ACTIVITY_SAVE_FIELD_POLICY]: (typeof ACTIVITY_SAVE_FIELD_POLICY)[Field] extends 'tracked' ? Field : never;
+}[keyof typeof ACTIVITY_SAVE_FIELD_POLICY];
+
+/** Progress percentage representing a not-started activity. */
+declare const NOT_STARTED_PROGRESS = 0;
+/** Progress percentage representing a completed activity. */
+declare const COMPLETED_PROGRESS = 100;
+
 declare const EDITABLE: {
     readonly TEXT: "text";
     readonly DESCRIPTION: "description";
@@ -228,6 +368,7 @@ declare const EDITABLE: {
     readonly CUSTOM_PREDECESSORS: "custom_predecessors";
     readonly CUSTOM_SUCESSORS: "custom_sucessors";
 };
+/** Canonical editable and read-only column names at dispatch boundaries. */
 declare const COLUMN: {
     readonly REAL_WORK: "real_work";
     readonly REAL_COST: "real_cost";
@@ -269,29 +410,149 @@ declare const COLUMN: {
     readonly CUSTOM_PREDECESSORS: "custom_predecessors";
     readonly CUSTOM_SUCESSORS: "custom_sucessors";
 };
+/** Canonical column handled by an edit pipeline or dependency display. */
 type EditableColumnName = (typeof EDITABLE)[keyof typeof EDITABLE];
+/** Canonical editable or read-only column name. */
 type ColumnName = (typeof COLUMN)[keyof typeof COLUMN];
 
+/** Editable column handled by the canonical field-mutation pipeline. */
 type PipelineColumnName = Exclude<(typeof EDITABLE)[keyof typeof EDITABLE], typeof COLUMN.CUSTOM_PREDECESSORS | typeof COLUMN.CUSTOM_SUCESSORS>;
 
 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"];
 type CreationOverrideField = (typeof CREATION_OVERRIDE_FIELD_LIST)[number];
 type CreationOverrides = Partial<Pick<CoreActivity, CreationOverrideField>>;
 
-type StringOperator = 'includes' | 'notIncludes' | 'is' | 'isNot';
-type NumberOperator = 'equals' | 'notEquals' | 'greaterThan' | 'lessThan' | 'greaterOrEqual' | 'lessOrEqual';
-type DateOperator = 'after' | 'before';
-type MembershipOperator = 'someOf' | 'notSomeOf';
-type FilterOperator = StringOperator | NumberOperator | DateOperator | 'between' | MembershipOperator;
-type StringFilterField = 'name' | 'description' | 'customId';
-type NumberFilterField = 'correlativeId' | 'uniqueCorrelativeId' | 'progress' | 'durationDays' | 'calendarDuration' | 'cost' | 'usedCost' | 'realCost' | 'workHours' | 'realWorkHours' | 'ponderator' | 'freeSlackDays' | 'totalSlackDays' | 'expectedProgressBaseline' | 'baselineDurationDays' | 'baselineCost' | 'baselineWorkHours' | 'expectedProgress';
-type DateFilterField = 'startDate' | 'endDate' | 'constraintDate' | 'baselineStartDate' | 'baselineEndDate' | 'earlyStart' | 'earlyFinish' | 'lateStart' | 'lateFinish';
-type IdArrayFilterField = 'responsableIds' | 'tagIds';
-type EnumFilterField = 'status' | 'constraintType';
-type ReferenceFilterField = 'calendarId' | 'subcontractId';
-type BooleanFilterField = 'isCritical';
+/** Discriminators for commands accepted by {@link ScheduleCore.dispatch}. */
+declare const DISPATCH_ACTION_KIND: {
+    readonly ACTIVITY_CLIPBOARD_CLEAR: "activity-clipboard-clear";
+    readonly ACTIVITY_COPY: "activity-copy";
+    readonly CALENDAR_RECONCILE: "calendar-reconcile";
+    readonly ACTIVITY_PASTE_COPIED: "activity-paste-copied";
+    readonly PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge";
+    readonly BASELINE_APPLY: "baseline-apply";
+    readonly PONDERATOR_CRITERION_SET: "ponderator-criterion-set";
+    readonly STATUS_CRITERIA_SET: "status-criteria-set";
+    readonly INLINE_EDIT: "inline-edit";
+    readonly DATES_BATCH: "dates-batch";
+    readonly BULK_EDIT: "bulk-edit";
+    readonly LINK_CREATE: "link-create";
+    readonly LINK_UPDATE: "link-update";
+    readonly LINK_DELETE: "link-delete";
+    readonly LINKS_BATCH: "links-batch";
+    readonly ACTIVITY_CREATE: "activity-create";
+    readonly ACTIVITY_DELETE: "activity-delete";
+    readonly ACTIVITY_MOVE: "activity-move";
+    readonly ACTIVITY_INDENT: "activity-indent";
+    readonly ACTIVITY_OUTDENT: "activity-outdent";
+    readonly ACTIVITY_SET_PROGRESS: "activity-set-progress";
+    readonly SELECTION_TOGGLE: "selection-toggle";
+    readonly SELECTION_REPLACE: "selection-replace";
+    readonly VISIBILITY_SET: "visibility-set";
+    readonly FILTER_SET: "filter-set";
+    readonly SORT_SET: "sort-set";
+    readonly SIR_SYNC: "sir-sync";
+    readonly ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync";
+};
+/** Discriminator accepted by {@link ScheduleCore.applyActivityBatch}. */
+declare const ACTIVITY_BATCH_ACTION_KIND: "activity-batch";
+/** Low-level create, update, and delete dependency operation kinds. */
+declare const DISPATCH_LINK_OPERATION_KIND: {
+    readonly CREATE: "create";
+    readonly UPDATE: "update";
+    readonly DELETE: "delete";
+};
+/** Discriminator of a public dispatch command. */
+type DispatchActionKind = (typeof DISPATCH_ACTION_KIND)[keyof typeof DISPATCH_ACTION_KIND];
+/** Read-only catalog of every public dispatch command discriminator. */
+declare const DISPATCH_ACTION_KINDS: ReadonlyArray<DispatchActionKind>;
+
+/** Runtime value categories used to validate filter criteria. */
+declare const FILTER_VALUE_KIND: {
+    readonly STRING: "string";
+    readonly NUMBER: "number";
+    readonly DATE: "date";
+    readonly ID_ARRAY: "id-array";
+    readonly ENUM: "enum";
+    readonly BOOLEAN: "boolean";
+    readonly REFERENCE: "reference";
+};
+/** Runtime value category associated with a filter field. */
+type FilterValueKind = (typeof FILTER_VALUE_KIND)[keyof typeof FILTER_VALUE_KIND];
+/** Public filterable activity fields, including derived day-based values. */
+declare const FILTER_FIELD: {
+    readonly NAME: "name";
+    readonly DESCRIPTION: "description";
+    readonly CUSTOM_ID: "customId";
+    readonly CORRELATIVE_ID: "correlativeId";
+    readonly UNIQUE_CORRELATIVE_ID: "uniqueCorrelativeId";
+    readonly PROGRESS: "progress";
+    readonly DURATION_DAYS: "durationDays";
+    readonly CALENDAR_DURATION: "calendarDuration";
+    readonly COST: "cost";
+    readonly USED_COST: "usedCost";
+    readonly REAL_COST: "realCost";
+    readonly WORK_HOURS: "workHours";
+    readonly REAL_WORK_HOURS: "realWorkHours";
+    readonly PONDERATOR: "ponderator";
+    readonly FREE_SLACK_DAYS: "freeSlackDays";
+    readonly TOTAL_SLACK_DAYS: "totalSlackDays";
+    readonly EXPECTED_PROGRESS_BASELINE: "expectedProgressBaseline";
+    readonly BASELINE_DURATION_DAYS: "baselineDurationDays";
+    readonly BASELINE_COST: "baselineCost";
+    readonly BASELINE_WORK_HOURS: "baselineWorkHours";
+    readonly EXPECTED_PROGRESS: "expectedProgress";
+    readonly START_DATE: "startDate";
+    readonly END_DATE: "endDate";
+    readonly CONSTRAINT_DATE: "constraintDate";
+    readonly BASELINE_START_DATE: "baselineStartDate";
+    readonly BASELINE_END_DATE: "baselineEndDate";
+    readonly EARLY_START: "earlyStart";
+    readonly EARLY_FINISH: "earlyFinish";
+    readonly LATE_START: "lateStart";
+    readonly LATE_FINISH: "lateFinish";
+    readonly RESPONSABLE_IDS: "responsableIds";
+    readonly TAG_IDS: "tagIds";
+    readonly STATUS: "status";
+    readonly CONSTRAINT_TYPE: "constraintType";
+    readonly CALENDAR_ID: "calendarId";
+    readonly SUBCONTRACT_ID: "subcontractId";
+    readonly IS_CRITICAL: "isCritical";
+};
+/** Operators accepted by typed filter criteria. */
+declare const FILTER_OPERATOR: {
+    readonly INCLUDES: "includes";
+    readonly NOT_INCLUDES: "notIncludes";
+    readonly IS: "is";
+    readonly IS_NOT: "isNot";
+    readonly EQUALS: "equals";
+    readonly NOT_EQUALS: "notEquals";
+    readonly GREATER_THAN: "greaterThan";
+    readonly LESS_THAN: "lessThan";
+    readonly GREATER_OR_EQUAL: "greaterOrEqual";
+    readonly LESS_OR_EQUAL: "lessOrEqual";
+    readonly AFTER: "after";
+    readonly BEFORE: "before";
+    readonly BETWEEN: "between";
+    readonly SOME_OF: "someOf";
+    readonly NOT_SOME_OF: "notSomeOf";
+};
+type StringOperator = typeof FILTER_OPERATOR.INCLUDES | typeof FILTER_OPERATOR.NOT_INCLUDES | typeof FILTER_OPERATOR.IS | typeof FILTER_OPERATOR.IS_NOT;
+type NumberOperator = typeof FILTER_OPERATOR.EQUALS | typeof FILTER_OPERATOR.NOT_EQUALS | typeof FILTER_OPERATOR.GREATER_THAN | typeof FILTER_OPERATOR.LESS_THAN | typeof FILTER_OPERATOR.GREATER_OR_EQUAL | typeof FILTER_OPERATOR.LESS_OR_EQUAL;
+type DateOperator = typeof FILTER_OPERATOR.AFTER | typeof FILTER_OPERATOR.BEFORE;
+type MembershipOperator = typeof FILTER_OPERATOR.SOME_OF | typeof FILTER_OPERATOR.NOT_SOME_OF;
+/** Operator accepted by at least one public filter field. */
+type FilterOperator = StringOperator | NumberOperator | DateOperator | typeof FILTER_OPERATOR.BETWEEN | MembershipOperator;
+type StringFilterField = typeof FILTER_FIELD.NAME | typeof FILTER_FIELD.DESCRIPTION | typeof FILTER_FIELD.CUSTOM_ID;
+type NumberFilterField = typeof FILTER_FIELD.CORRELATIVE_ID | typeof FILTER_FIELD.UNIQUE_CORRELATIVE_ID | typeof FILTER_FIELD.PROGRESS | typeof FILTER_FIELD.DURATION_DAYS | typeof FILTER_FIELD.CALENDAR_DURATION | typeof FILTER_FIELD.COST | typeof FILTER_FIELD.USED_COST | typeof FILTER_FIELD.REAL_COST | typeof FILTER_FIELD.WORK_HOURS | typeof FILTER_FIELD.REAL_WORK_HOURS | typeof FILTER_FIELD.PONDERATOR | typeof FILTER_FIELD.FREE_SLACK_DAYS | typeof FILTER_FIELD.TOTAL_SLACK_DAYS | typeof FILTER_FIELD.EXPECTED_PROGRESS_BASELINE | typeof FILTER_FIELD.BASELINE_DURATION_DAYS | typeof FILTER_FIELD.BASELINE_COST | typeof FILTER_FIELD.BASELINE_WORK_HOURS | typeof FILTER_FIELD.EXPECTED_PROGRESS;
+type DateFilterField = typeof FILTER_FIELD.START_DATE | typeof FILTER_FIELD.END_DATE | typeof FILTER_FIELD.CONSTRAINT_DATE | typeof FILTER_FIELD.BASELINE_START_DATE | typeof FILTER_FIELD.BASELINE_END_DATE | typeof FILTER_FIELD.EARLY_START | typeof FILTER_FIELD.EARLY_FINISH | typeof FILTER_FIELD.LATE_START | typeof FILTER_FIELD.LATE_FINISH;
+type IdArrayFilterField = typeof FILTER_FIELD.RESPONSABLE_IDS | typeof FILTER_FIELD.TAG_IDS;
+type EnumFilterField = typeof FILTER_FIELD.STATUS | typeof FILTER_FIELD.CONSTRAINT_TYPE;
+type ReferenceFilterField = typeof FILTER_FIELD.CALENDAR_ID | typeof FILTER_FIELD.SUBCONTRACT_ID;
+type BooleanFilterField = typeof FILTER_FIELD.IS_CRITICAL;
+/** Activity field accepted by the filter pipeline. */
 type FilterField = StringFilterField | NumberFilterField | DateFilterField | IdArrayFilterField | EnumFilterField | ReferenceFilterField | BooleanFilterField;
 type FilterScalarValue = string | number | Date;
+/** Scalar or membership-array value accepted by a filter criterion. */
 type FilterCriterionValue = FilterScalarValue | ReadonlyArray<string | number | boolean>;
 interface Criterion<Field extends FilterField, Operator, Value> {
     readonly field: Field;
@@ -300,63 +561,117 @@ interface Criterion<Field extends FilterField, Operator, Value> {
 }
 interface BetweenCriterion<Field extends FilterField, Value> {
     readonly field: Field;
-    readonly operator: 'between';
+    readonly operator: typeof FILTER_OPERATOR.BETWEEN;
     readonly value: Value;
     readonly valueTo: Value;
 }
+/**
+ * Field-aware criterion that restricts operators and values by field kind.
+ *
+ * Duration and slack fields whose names end in `Days` use working days.
+ */
 type FilterCriterion = Criterion<StringFilterField, StringOperator, string> | Criterion<NumberFilterField, NumberOperator, string | number> | BetweenCriterion<NumberFilterField, string | number> | Criterion<DateFilterField, DateOperator, string | number | Date> | BetweenCriterion<DateFilterField, string | number | Date> | Criterion<IdArrayFilterField, MembershipOperator, ReadonlyArray<string | number>> | Criterion<EnumFilterField, MembershipOperator, ReadonlyArray<string>> | Criterion<ReferenceFilterField, MembershipOperator, ReadonlyArray<string | number>> | Criterion<BooleanFilterField, MembershipOperator, ReadonlyArray<boolean>>;
+/** Inclusive date range used to constrain filter projection. */
 interface FilterDateRange {
     readonly start: Date;
     readonly end: Date;
 }
+/** Logical modes for combining multiple filter criteria. */
+declare const FILTER_LOGIC: {
+    readonly AND: "and";
+    readonly OR: "or";
+};
+/** Logical mode used to combine filter criteria. */
+type FilterLogic = (typeof FILTER_LOGIC)[keyof typeof FILTER_LOGIC];
+/** Immutable active filter projection state. */
 interface FilterState {
     readonly criteria: ReadonlyArray<FilterCriterion>;
-    readonly logic: 'and' | 'or';
+    readonly logic: FilterLogic;
     readonly dateRange?: FilterDateRange;
 }
 
+/** Canonical parent ID used for root-level activities. */
+declare const ROOT_PARENT_ID: "0";
+/** @returns Whether a value is a nullish, numeric, or string root parent. */
+declare function isRootParent(parent: unknown): boolean;
+/**
+ * Converts root sentinels to {@link ROOT_PARENT_ID} and stringifies other IDs.
+ *
+ * @param parent - Backend or domain parent value.
+ */
+declare function normalizeParentKey(parent: unknown): string;
+
+/** Sort directions accepted by visual-order rules. */
+declare const ORDER_DIRECTION: {
+    readonly ASCENDING: "asc";
+    readonly DESCENDING: "desc";
+};
+/** Ascending or descending visual sort direction. */
+type OrderDirection = (typeof ORDER_DIRECTION)[keyof typeof ORDER_DIRECTION];
+/** One filter-field and direction used for visual ordering. */
 interface OrderRule {
     readonly field: FilterField;
-    readonly direction: 'asc' | 'desc';
+    readonly direction: OrderDirection;
 }
+/** Immutable ordered rule set active on a schedule. */
 interface OrderState {
     readonly rules: ReadonlyArray<OrderRule>;
 }
+/** Complete child-ID order projected for one hierarchy branch. */
 interface BranchOrderChange {
     readonly parentId: string;
     readonly childIds: ReadonlyArray<string>;
 }
 
+/** Low-level dependency operation accepted by the canonical dispatcher. */
 type LinksBatchOperation = {
-    kind: 'create';
+    kind: typeof DISPATCH_LINK_OPERATION_KIND.CREATE;
     source: ActivityId;
     target: ActivityId;
     type: LinkType;
+    /** Lag in working days; dispatch converts it to stored working hours. */
     lag?: number;
     linkId?: LinkId;
 } | {
-    kind: 'update';
+    kind: typeof DISPATCH_LINK_OPERATION_KIND.UPDATE;
     linkId: LinkId;
     type?: LinkType;
+    /** Replacement lag in working days; dispatch converts it to stored hours. */
     lag?: number;
 } | {
-    kind: 'delete';
+    kind: typeof DISPATCH_LINK_OPERATION_KIND.DELETE;
     linkId: LinkId;
 };
+/** Backend identity used to acknowledge an entity as persisted. */
 interface PersistedEntityIdentity {
     readonly id: string;
     readonly proplannerId: number;
 }
+/**
+ * Defensive schedule snapshot captured for consumer-owned persistence.
+ *
+ * The package does not write this data; acknowledge the exact checkpoint only
+ * after external storage succeeds.
+ */
 interface PersistenceCheckpoint {
     readonly activities: ReadonlyArray<Readonly<CoreActivity>>;
     readonly links: ReadonlyArray<Readonly<Link>>;
     readonly historyBoundary: number;
 }
-type ActivityBatchMode = 'append' | 'replace';
+/** Available activity-batch replacement policies. */
+declare const ACTIVITY_BATCH_MODE: {
+    readonly APPEND: "append";
+    readonly REPLACE: "replace";
+};
+/** Activity-batch append or replace policy. */
+type ActivityBatchMode = (typeof ACTIVITY_BATCH_MODE)[keyof typeof ACTIVITY_BATCH_MODE];
+/** Existing activity ID or local batch-item reference. */
 type ActivityBatchReference = ActivityId | {
     readonly batchId: string;
 };
-type ActivityBatchParentReference = '0' | ActivityBatchReference;
+/** Root, existing activity, or local batch-item parent reference. */
+type ActivityBatchParentReference = typeof ROOT_PARENT_ID | ActivityBatchReference;
+/** One activity to create during a low-level activity batch. */
 interface ActivityBatchItem {
     readonly batchId: string;
     readonly parent: ActivityBatchParentReference;
@@ -364,61 +679,71 @@ interface ActivityBatchItem {
     readonly activityId?: ActivityId;
     readonly overrides?: ActivityCreationOverrides;
 }
-interface ActivityBatchLinkInput {
+/** One dependency to create between activity-batch references. */
+interface ActivityBatchLinkInput$1 {
     readonly source: ActivityBatchReference;
     readonly target: ActivityBatchReference;
     readonly type: LinkType;
-    readonly lag: number;
+    /** Lag in working days; omitted lag defaults to zero. */
+    readonly lag?: number;
     readonly linkId?: LinkId;
 }
+/** Low-level activity creation batch handled separately from {@link DispatchAction}. */
 interface ActivityBatchAction {
-    readonly kind: 'activity-batch';
+    readonly kind: typeof ACTIVITY_BATCH_ACTION_KIND;
     readonly mode: ActivityBatchMode;
     readonly items: ReadonlyArray<ActivityBatchItem>;
-    readonly links: ReadonlyArray<ActivityBatchLinkInput>;
+    readonly links: ReadonlyArray<ActivityBatchLinkInput$1>;
     readonly eventSource?: string;
 }
-
+/**
+ * Complete union of public commands accepted by {@link ScheduleCore.dispatch}.
+ *
+ * Link `lag` inputs are working days and are converted to stored working hours.
+ * Consumer analytics context is carried by optional `eventSource` fields.
+ */
 type DispatchAction = {
-    kind: 'activity-copy';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_COPY;
     eventSource?: string;
 } | {
-    kind: 'activity-clipboard-clear';
+    kind: typeof DISPATCH_ACTION_KIND.CALENDAR_RECONCILE;
+} | {
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR;
     eventSource?: string;
 } | {
-    kind: 'activity-paste-copied';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED;
     destination: {
         afterSiblingId: ActivityId;
     };
     eventSource?: string;
 } | {
-    kind: 'persistence-acknowledge';
+    kind: typeof DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE;
     activities?: ReadonlyArray<PersistedEntityIdentity>;
     links?: ReadonlyArray<PersistedEntityIdentity>;
     checkpoint?: PersistenceCheckpoint;
 } | {
-    kind: 'baseline-apply';
+    kind: typeof DISPATCH_ACTION_KIND.BASELINE_APPLY;
     points: ReadonlyArray<BaselinePoint>;
 } | {
-    kind: 'ponderator-criterion-set';
+    kind: typeof DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET;
     criterion: ActivityCreter;
 } | {
-    kind: 'status-criteria-set';
+    kind: typeof DISPATCH_ACTION_KIND.STATUS_CRITERIA_SET;
     criteria: StatusCriteria;
 } | {
-    kind: 'inline-edit';
+    kind: typeof DISPATCH_ACTION_KIND.INLINE_EDIT;
     activityId: ActivityId;
     column: EditableColumnName;
     newValue: unknown;
 } | {
-    kind: 'dates-batch';
+    kind: typeof DISPATCH_ACTION_KIND.DATES_BATCH;
     edits: ReadonlyArray<{
         activityId: ActivityId;
-        column: 'start_date' | 'end_date';
+        column: typeof COLUMN.START_DATE | typeof COLUMN.END_DATE;
         newValue: unknown;
     }>;
 } | {
-    kind: 'bulk-edit';
+    kind: typeof DISPATCH_ACTION_KIND.BULK_EDIT;
     edits: ReadonlyArray<{
         activityId: ActivityId;
         column: PipelineColumnName;
@@ -426,88 +751,90 @@ type DispatchAction = {
     }>;
     eventSource?: string;
 } | {
-    kind: 'link-create';
+    kind: typeof DISPATCH_ACTION_KIND.LINK_CREATE;
     source: ActivityId;
     target: ActivityId;
     type: LinkType;
-    lag: number;
+    /** Dependency lag in working days; omitted lag defaults to zero. */
+    lag?: number;
     linkId?: LinkId;
 } | {
-    kind: 'link-update';
+    kind: typeof DISPATCH_ACTION_KIND.LINK_UPDATE;
     linkId: LinkId;
     type?: LinkType;
+    /** Replacement lag in working days; dispatch converts it to stored hours. */
     lag?: number;
 } | {
-    kind: 'link-delete';
+    kind: typeof DISPATCH_ACTION_KIND.LINK_DELETE;
     linkId: LinkId;
 } | {
-    kind: 'links-batch';
+    kind: typeof DISPATCH_ACTION_KIND.LINKS_BATCH;
     operations: ReadonlyArray<LinksBatchOperation>;
 } | {
-    kind: 'activity-create';
-    parentId: ActivityId | '0';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_CREATE;
+    parentId: ActivityId | typeof ROOT_PARENT_ID;
     afterSiblingId?: ActivityId | undefined;
     beforeSiblingId?: ActivityId | undefined;
     overrides?: ActivityCreationOverrides;
     activityId?: ActivityId;
     eventSource?: string | undefined;
 } | {
-    kind: 'activity-delete';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_DELETE;
     activityIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
-    kind: 'activity-move';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_MOVE;
     activityId: ActivityId;
-    parentId: ActivityId | '0';
+    parentId: ActivityId | typeof ROOT_PARENT_ID;
     afterSiblingId?: ActivityId;
     beforeSiblingId?: ActivityId;
     eventSource?: string;
 } | {
-    kind: 'activity-indent';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_INDENT;
     activityIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
-    kind: 'activity-outdent';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_OUTDENT;
     activityIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
-    kind: 'activity-set-progress';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_SET_PROGRESS;
     activityId: ActivityId;
-    newValue: 0 | 100;
+    newValue: typeof NOT_STARTED_PROGRESS | typeof COMPLETED_PROGRESS;
     origin?: 'action-button';
     eventSource?: string;
 } | {
-    kind: 'selection-toggle';
+    kind: typeof DISPATCH_ACTION_KIND.SELECTION_TOGGLE;
     activityId: ActivityId;
     isChecked: boolean;
     frozenIds?: ReadonlyArray<ActivityId>;
     autoCheckParents?: boolean;
     eventSource?: string;
 } | {
-    kind: 'selection-replace';
+    kind: typeof DISPATCH_ACTION_KIND.SELECTION_REPLACE;
     activityIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
-    kind: 'visibility-set';
+    kind: typeof DISPATCH_ACTION_KIND.VISIBILITY_SET;
     visibleIds: ReadonlyArray<ActivityId>;
     eventSource?: string;
 } | {
-    kind: 'filter-set';
+    kind: typeof DISPATCH_ACTION_KIND.FILTER_SET;
     criteria: ReadonlyArray<FilterCriterion>;
-    logic: 'and' | 'or';
+    logic: FilterLogic;
     dateRange?: FilterDateRange;
     eventSource?: string;
 } | {
-    kind: 'sort-set';
+    kind: typeof DISPATCH_ACTION_KIND.SORT_SET;
     rules: ReadonlyArray<OrderRule>;
     eventSource?: string;
 } | {
-    kind: 'sir-sync';
+    kind: typeof DISPATCH_ACTION_KIND.SIR_SYNC;
     activityId: ActivityId;
     pendingRequests: ReadonlyArray<PendingRequest>;
     eventSource?: string;
 } | {
-    kind: 'activity-lookahead-sync';
+    kind: typeof DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC;
     activityIds: ReadonlyArray<ActivityId>;
     isLookahead: boolean;
     hasLookaheadTasks: boolean;
@@ -515,14 +842,28 @@ type DispatchAction = {
     acknowledgePersistedLookahead?: boolean;
     eventSource?: string;
 };
+/**
+ * Supported creation fields with duration expressed in working days.
+ *
+ * Omitted fields retain core-owned creation defaults.
+ */
 type ActivityCreationOverrides = Omit<CreationOverrides, 'durationHours'> & {
     readonly durationDays?: number;
 };
 type InternalDispatchAction = DispatchAction | ActivityBatchAction;
+/** Per-operation derived-work controls; both default to `false`. */
 interface DispatchOptions {
+    /** Skips autoscheduling for this operation when `true`. */
     skipAutoSchedule?: boolean;
+    /** Skips critical-path work for this operation when `true`. */
     skipCriticalPath?: boolean;
 }
+/**
+ * Complete accepted or rejected command result returned unchanged by public APIs.
+ *
+ * Accepted results always include the consumer projection {@link ChangeSet} and
+ * may include per-item verdicts. Rejected results leave state unchanged.
+ */
 type DispatchResult = {
     ok: true;
     changes: ChangeSet;
@@ -534,6 +875,7 @@ type DispatchResult = {
     reason: string;
     alertKey?: string | undefined;
 };
+/** Per-activity acceptance result for a dates batch. */
 type DatesBatchVerdict = {
     activityId: string;
     ok: true;
@@ -543,6 +885,7 @@ type DatesBatchVerdict = {
     reason: string;
     alertKey?: string | undefined;
 };
+/** Per-operation acceptance result for a dependency batch. */
 type LinkBatchVerdict = {
     operationIndex: number;
     kind: LinksBatchOperation['kind'];
@@ -555,117 +898,815 @@ type LinkBatchVerdict = {
     reason: string;
 };
 
+/** Consumer-owned analytics event emitted by an accepted command. */
 interface TrackingEvent {
     name: string;
     properties: Record<string, unknown>;
 }
+/** Integration effects that consumers must handle outside the core. */
+declare const SCHEDULE_EFFECT_KIND: {
+    readonly SIR_AUTO_REJECT: "sir-auto-reject";
+};
+/** Reasons a schedule mutation automatically rejects an impact request. */
+declare const SIR_AUTO_REJECT_REASON: {
+    readonly DATE_CHANGED: "date_changed";
+    readonly ACTIVITY_DELETED: "activity_deleted";
+};
+/** Consumer integration effect included in a change set. */
 type ScheduleEffect = {
-    kind: 'sir-auto-reject';
+    kind: typeof SCHEDULE_EFFECT_KIND.SIR_AUTO_REJECT;
     activityId: ActivityId;
     sirId: string;
-    reason: 'date_changed' | 'activity_deleted';
+    reason: (typeof SIR_AUTO_REJECT_REASON)[keyof typeof SIR_AUTO_REJECT_REASON];
+};
+/** Non-fatal schedule warning kinds. */
+declare const CONSTRAINT_WARNING_KIND: {
+    readonly VIOLATION: "constraint_violation";
 };
+/** Non-fatal constraint violation produced by projected scheduling dates. */
 interface ConstraintWarning {
-    kind: 'constraint_violation';
+    kind: typeof CONSTRAINT_WARNING_KIND.VIOLATION;
     activityId: ActivityId;
     constraintType: ConstraintType;
     constraintDate: Date;
     projectedDate: Date;
     messageKey: string;
 }
+/** Boolean value before and after a view-state mutation. */
 interface ViewStatePropChange {
     readonly before: boolean;
     readonly after: boolean;
 }
+/** Selection and/or visibility projection change for one activity. */
 interface ViewStateChange {
     readonly activityId: ActivityId;
     readonly checked?: ViewStatePropChange;
     readonly visible?: ViewStatePropChange;
 }
+/** Lifecycle sources used when no public dispatch command initiated a change set. */
+declare const CHANGE_SET_SOURCE_KIND: {
+    readonly INIT: "init";
+    readonly UNDO: "undo";
+    readonly REDO: "redo";
+};
+/** Public command, activity batch, or lifecycle operation that produced changes. */
 type ChangeSetSource = InternalDispatchAction | {
-    kind: 'init';
-} | {
-    kind: 'undo';
-} | {
-    kind: 'redo';
+    kind: (typeof CHANGE_SET_SOURCE_KIND)[keyof typeof CHANGE_SET_SOURCE_KIND];
 };
+/**
+ * Complete ordered projection payload produced by an accepted operation.
+ *
+ * Consumers apply every populated collection in result order. Applying a change
+ * set updates external projection only; persistence remains consumer-owned.
+ */
 interface ChangeSet {
+    /** Command or lifecycle operation that produced the payload. */
     source: ChangeSetSource;
+    /** Activity create, update, and delete records. */
     activities: ReadonlyArray<EntityChange<CoreActivity>>;
+    /** Link create, update, and delete records; lag fields use stored hours. */
     links: ReadonlyArray<EntityChange<Link>>;
+    /** Calendar create, update, and delete records. */
     calendars: ReadonlyArray<EntityChange<Calendar>>;
+    /** Consumer-owned analytics events. */
     trackingEvents: ReadonlyArray<TrackingEvent>;
+    /** Optional checked/visible projection updates. */
     viewState?: ReadonlyArray<ViewStateChange>;
+    /** Optional visual child order grouped by parent. */
     order?: ReadonlyArray<BranchOrderChange>;
+    /** Optional integration effects for consumer handling. */
     effects?: ReadonlyArray<ScheduleEffect>;
+    /** Optional non-fatal warnings for consumer presentation. */
     warnings?: ReadonlyArray<ConstraintWarning>;
 }
 
+/** Earliest start and latest end from the default calendar's work ranges. */
 interface ProjectWorkHours {
     startHour: string;
     endHour: string;
 }
 
-declare const ACTIVITY_SAVE_FIELD_POLICY: {
-    readonly id: "ignored";
-    readonly proplannerId: "ignored";
-    readonly parentId: "tracked";
-    readonly name: "tracked";
-    readonly description: "tracked";
-    readonly type: "tracked";
-    readonly startDate: "tracked";
-    readonly endDate: "tracked";
-    readonly durationHours: "tracked";
-    readonly constraintType: "tracked";
-    readonly constraintDate: "tracked";
-    readonly autoScheduling: "tracked";
-    readonly calendarId: "tracked";
-    readonly assignedDefaultCalendar: "ignored";
-    readonly dateOrigin: "tracked";
-    readonly progress: "tracked";
-    readonly cost: "tracked";
-    readonly usedCost: "tracked";
-    readonly realCost: "tracked";
-    readonly workHours: "tracked";
-    readonly realWorkHours: "tracked";
-    readonly ponderator: "tracked";
-    readonly hasCustomPonderator: "tracked";
-    readonly correlativeId: "tracked";
-    readonly uniqueCorrelativeId: "tracked";
-    readonly customId: "tracked";
-    readonly subcontractId: "tracked";
-    readonly isLookahead: "tracked";
-    readonly hasLookaheadTasks: "ignored";
-    readonly newActivityIds: "tracked";
-    readonly hasNewActivities: "tracked";
-    readonly isNewActivity: "ignored";
-    readonly pendingRequestIds: "ignored";
-    readonly responsableIds: "tracked";
-    readonly tagIds: "tracked";
-    readonly baselinePoints: "ignored";
-    readonly baselineSnapshot: "ignored";
-    readonly recursiveDurationHours: "ignored";
-    readonly isCritical: "ignored";
-    readonly freeSlackHours: "ignored";
-    readonly calendarDuration: "ignored";
-    readonly expectedProgress: "ignored";
-    readonly expectedProgressBaseline: "ignored";
-    readonly status: "ignored";
-    readonly criticalPath: "ignored";
+/** Move and resize gestures supported by date prediction. */
+declare const DATE_GESTURE_KIND: {
+    readonly MOVE: "move";
+    readonly RESIZE_START: "resize-start";
+    readonly RESIZE_END: "resize-end";
 };
-type PersistableActivityField = {
-    [Field in keyof typeof ACTIVITY_SAVE_FIELD_POLICY]: (typeof ACTIVITY_SAVE_FIELD_POLICY)[Field] extends 'tracked' ? Field : never;
-}[keyof typeof ACTIVITY_SAVE_FIELD_POLICY];
+/** Move or edge-resize date gesture kind. */
+type DateGestureKind = (typeof DATE_GESTURE_KIND)[keyof typeof DATE_GESTURE_KIND];
+/**
+ * Revision-bound move or resize request used to build a date preview.
+ *
+ * Move gestures require a non-empty participant list containing the anchor.
+ */
+type DateGesture = {
+    readonly kind: typeof DATE_GESTURE_KIND.MOVE;
+    readonly activityIds: readonly ActivityId[];
+    readonly anchorActivityId: ActivityId;
+} | {
+    readonly kind: typeof DATE_GESTURE_KIND.RESIZE_START | typeof DATE_GESTURE_KIND.RESIZE_END;
+    readonly activityId: ActivityId;
+};
+/** Read-only date prediction captured for one schedule revision. */
+interface DateGesturePreview {
+    /**
+     * Predicts one participant or affected ancestor's dates.
+     *
+     * @param activityId - Participant or ancestor activity ID.
+     * @param proposedEdgeTimeMs - Proposed moved/resized edge as Unix milliseconds.
+     * @returns Predicted start/end Unix milliseconds, or `null` when unaffected.
+     * @throws When the time is invalid, bounds are incomplete, or the preview is stale.
+     */
+    getDates(activityId: ActivityId, proposedEdgeTimeMs: number): {
+        startTimeMs: number;
+        endTimeMs: number;
+    } | null;
+}
+
+/** Canonical fields accepted by typed activity-edit APIs. */
+declare const ACTIVITY_FIELD: {
+    readonly NAME: "name";
+    readonly DESCRIPTION: "description";
+    readonly DURATION_DAYS: "durationDays";
+    readonly PROGRESS: "progress";
+    readonly COST: "cost";
+    readonly USED_COST: "usedCost";
+    readonly WORK_HOURS: "workHours";
+    readonly START_DATE: "startDate";
+    readonly END_DATE: "endDate";
+    readonly CONSTRAINT_TYPE: "constraintType";
+    readonly CONSTRAINT_DATE: "constraintDate";
+    readonly CALENDAR_ID: "calendarId";
+    readonly CUSTOM_ID: "customId";
+    readonly SUBCONTRACT_ID: "subcontractId";
+    readonly RESPONSABLE_IDS: "responsableIds";
+    readonly TAG_IDS: "tagIds";
+};
+/** Value type associated with each canonical activity-edit field. */
+interface ActivityFieldValue {
+    readonly name: string;
+    readonly description: string;
+    /** Duration in working days. */
+    readonly durationDays: number;
+    readonly progress: number;
+    readonly cost: number;
+    readonly usedCost: number;
+    readonly workHours: number;
+    readonly startDate: Date;
+    readonly endDate: Date;
+    /** Constraint type, or `null` to remove the constraint. */
+    readonly constraintType: ConstraintType | null;
+    /** Constraint date, or `null` to clear it. */
+    readonly constraintDate: Date | null;
+    /** Calendar ID, or `null` to use default resolution. */
+    readonly calendarId: CalendarId | null;
+    /** Consumer custom ID, or `null` to clear it. */
+    readonly customId: string | null;
+    /** Subcontract identifier, or `null` to clear it. */
+    readonly subcontractId: number | null;
+    readonly responsableIds: readonly string[];
+    readonly tagIds: readonly string[];
+}
+/** Canonical activity field accepted by typed edits. */
+type ActivityField = (typeof ACTIVITY_FIELD)[keyof typeof ACTIVITY_FIELD];
+/** Discriminated field/value edit that preserves value type by field. */
+type ActivityFieldEdit = {
+    readonly [Field in ActivityField]: {
+        readonly field: Field;
+        readonly value: ActivityFieldValue[Field];
+    };
+}[ActivityField];
+/** Typed field edit paired with its target activity. */
+type ActivityBulkEdit = ActivityFieldEdit & {
+    readonly activityId: ActivityId;
+};
+/** Activity edges accepted by date-gesture and drag APIs. */
+declare const ACTIVITY_DATE_EDGE: {
+    readonly START: "start";
+    readonly END: "end";
+};
+/** Start or end edge of an activity date range. */
+type ActivityDateEdge = (typeof ACTIVITY_DATE_EDGE)[keyof typeof ACTIVITY_DATE_EDGE];
+/** One activity edge and proposed date in a drag batch. */
+interface ActivityDateEdit {
+    readonly activityId: ActivityId;
+    readonly edge: ActivityDateEdge;
+    readonly value: Date;
+}
+/** Optional consumer context copied into tracking metadata. */
+interface MutationContext {
+    readonly eventSource?: string;
+}
+/** Ergonomic input for creating one activity. */
+interface ActivityCreateInput extends MutationContext {
+    readonly parentId: ActivityId | typeof ROOT_PARENT_ID;
+    readonly afterSiblingId?: ActivityId;
+    readonly beforeSiblingId?: ActivityId;
+    readonly overrides?: ActivityCreationOverrides;
+    readonly activityId?: ActivityId;
+}
+/** Ergonomic input for moving one activity in the hierarchy. */
+interface ActivityMoveInput extends MutationContext {
+    readonly activityId: ActivityId;
+    readonly parentId: ActivityId | typeof ROOT_PARENT_ID;
+    readonly afterSiblingId?: ActivityId;
+    readonly beforeSiblingId?: ActivityId;
+}
+/** One activity item in an ergonomic creation batch. */
+interface ActivityBatchItemInput {
+    readonly batchId: string;
+    readonly parent: ActivityBatchParentReference;
+    readonly index?: number;
+    readonly activityId?: ActivityId;
+    readonly overrides?: ActivityCreationOverrides;
+}
+/** One named dependency in an ergonomic activity batch. */
+interface ActivityBatchLinkInput {
+    readonly source: ActivityBatchReference;
+    readonly target: ActivityBatchReference;
+    readonly relationship: LinkRelationship;
+    /** Dependency lag in working days; omitted lag defaults to zero. */
+    readonly lagDays?: number;
+    readonly linkId?: LinkId;
+}
+/** Ergonomic append/replace activity and dependency batch. */
+interface ActivityBatchInput extends MutationContext {
+    readonly mode: ActivityBatchMode;
+    readonly items: ReadonlyArray<ActivityBatchItemInput>;
+    readonly links: ReadonlyArray<ActivityBatchLinkInput>;
+}
+/** Consumer lookahead state synchronized into core-owned activity state. */
+interface ActivityLookaheadSyncInput extends MutationContext {
+    readonly activityIds: ReadonlyArray<ActivityId>;
+    readonly isLookahead: boolean;
+    readonly hasLookaheadTasks: boolean;
+    /**
+     * Externally persisted progress. When supplied with acknowledgement enabled,
+     * a successful synchronization clears all undo and redo history.
+     */
+    readonly persistedProgress?: number;
+    /**
+     * Acknowledges lookahead persistence. Combined with `persistedProgress`, a
+     * successful synchronization clears all undo and redo history.
+     */
+    readonly acknowledgePersistedLookahead?: boolean;
+}
+/** Named dependency relationships accepted by the façade. */
+declare const LINK_RELATIONSHIP: {
+    readonly FINISH_TO_START: "finish-to-start";
+    readonly START_TO_START: "start-to-start";
+    readonly FINISH_TO_FINISH: "finish-to-finish";
+    readonly START_TO_FINISH: "start-to-finish";
+};
+/** Named dependency relationship accepted by the façade. */
+type LinkRelationship = (typeof LINK_RELATIONSHIP)[keyof typeof LINK_RELATIONSHIP];
+/** Ergonomic dependency creation request. */
+interface LinkCreateRequest {
+    readonly sourceId: ActivityId;
+    readonly targetId: ActivityId;
+    readonly relationship: LinkRelationship;
+    /** Dependency lag in working days; omitted lag defaults to zero. */
+    readonly lagDays?: number;
+    readonly linkId?: LinkId;
+}
+/** Optional dependency fields to replace. */
+interface LinkPatchRequest {
+    readonly relationship?: LinkRelationship;
+    /** Replacement lag in working days. */
+    readonly lagDays?: number;
+}
+/** Dependency operations accepted by the ergonomic batch façade. */
+declare const LINK_BATCH_OPERATION_KIND: {
+    readonly CREATE: "create";
+    readonly UPDATE: "update";
+    readonly REMOVE: "remove";
+};
+/** Dependency operation kind accepted by the ergonomic batch façade. */
+type LinkBatchOperationKind = (typeof LINK_BATCH_OPERATION_KIND)[keyof typeof LINK_BATCH_OPERATION_KIND];
+/** Ergonomic dependency create, update, or remove request. */
+type LinkBatchRequest = ({
+    readonly kind: typeof LINK_BATCH_OPERATION_KIND.CREATE;
+} & LinkCreateRequest) | {
+    readonly kind: typeof LINK_BATCH_OPERATION_KIND.UPDATE;
+    readonly linkId: LinkId;
+    readonly relationship?: LinkRelationship;
+    readonly lagDays?: number;
+} | {
+    readonly kind: typeof LINK_BATCH_OPERATION_KIND.REMOVE;
+    readonly linkId: LinkId;
+};
+/** Input for toggling one activity's checked state. */
+interface SelectionToggleInput extends MutationContext {
+    readonly activityId: ActivityId;
+    readonly checked: boolean;
+    readonly frozenIds?: ReadonlyArray<ActivityId>;
+    readonly autoCheckParents?: boolean;
+}
+/** Input for replacing the active filter projection. */
+interface ViewFilterInput extends MutationContext {
+    readonly criteria: ReadonlyArray<FilterCriterion>;
+    readonly logic: FilterLogic;
+    readonly dateRange?: FilterDateRange;
+}
+/** Input for replacing an activity's pending impact requests. */
+interface ImpactRequestSyncInput extends MutationContext {
+    readonly activityId: ActivityId;
+    readonly pendingRequests: ReadonlyArray<PendingRequest>;
+}
+
+/** Activity reads and canonical activity mutations for a ready schedule. */
+interface ScheduleActivitiesApi {
+    /**
+     * Reads a defensive activity snapshot.
+     *
+     * @param id - Canonical activity ID.
+     * @returns The activity, or `null` when the ID is absent.
+     */
+    get(id: ActivityId): Readonly<CoreActivity> | null;
+    /** @returns Defensive snapshots of every current activity. */
+    list(): ReadonlyArray<Readonly<CoreActivity>>;
+    /** @returns A read-only snapshot of all current activity IDs. */
+    ids(): readonly string[];
+    /**
+     * Visits each current activity ID without exposing mutable state.
+     *
+     * @param visit - Callback invoked once per current ID.
+     */
+    forEachId(visit: (id: string) => void): void;
+    /**
+     * Reads one cloned activity property.
+     *
+     * @param id - Canonical activity ID.
+     * @param property - Property to read.
+     * @returns The cloned value, or `null` when the activity is absent.
+     */
+    property<Property extends keyof CoreActivity>(id: ActivityId, property: Property): CoreActivity[Property] | null;
+    /**
+     * Reads direct children in correlative order.
+     *
+     * @param parentId - Parent activity ID, or the root ID.
+     * @returns Defensive child snapshots.
+     */
+    children(parentId: ActivityId | typeof ROOT_PARENT_ID): ReadonlyArray<Readonly<CoreActivity>>;
+    /**
+     * Reads direct child IDs in visual order.
+     *
+     * @param parentId - Parent activity ID, or the root ID.
+     */
+    childIds(parentId: ActivityId | typeof ROOT_PARENT_ID): ReadonlyArray<ActivityId>;
+    /** @returns Whether the parent currently has at least one direct child. */
+    hasChildren(parentId: ActivityId | typeof ROOT_PARENT_ID): boolean;
+    /**
+     * Computes the parent IDs available to an indent operation.
+     *
+     * @param ids - Activities being considered for indentation.
+     */
+    indentTargetParentIds(ids: ReadonlyArray<ActivityId | string>): readonly string[];
+    /**
+     * Checks custom-ID uniqueness while optionally excluding the current value.
+     *
+     * @param customId - Candidate custom ID.
+     * @param currentCustomId - Existing value to ignore, or `null`.
+     */
+    isCustomIdInUse(customId: string, currentCustomId?: string | null): boolean;
+    /**
+     * Creates one activity through the canonical dispatch pipeline.
+     *
+     * Creation durations use working days; accepted commands mutate core state.
+     * @param input - Parent, placement, optional ID, and creation overrides.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result, including changes and metadata.
+     */
+    create(input: ActivityCreateInput, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Creates a related activity/link batch atomically through the batch pipeline.
+     *
+     * Durations and link lags at this façade are working days.
+     * @param input - Append/replace batch with local or existing references.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    applyBatch(input: ActivityBatchInput, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Applies one inline field edit through the canonical dispatch pipeline.
+     *
+     * @param activityId - Canonical activity ID.
+     * @param edit - A field/value pair derived from {@link ACTIVITY_FIELD}.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result, including changes and verdict metadata.
+     */
+    editInline(activityId: ActivityId, edit: ActivityFieldEdit, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Applies start/end drag edits as one dates-batch command.
+     *
+     * Accepted edits mutate schedule dates and may trigger derived scheduling.
+     * @param edits - Activity edges and proposed `Date` values.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result with per-activity verdicts when present.
+     */
+    applyDragBatch(edits: ReadonlyArray<ActivityDateEdit>, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Applies typed field edits as one bulk command.
+     *
+     * Duration values are working days at this boundary.
+     * @param edits - Activity IDs paired with typed field edits.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    editFields(edits: ReadonlyArray<ActivityBulkEdit>, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Deletes activities through the canonical dispatch pipeline.
+     *
+     * @param activityIds - IDs to delete.
+     * @param context - Optional consumer event source.
+     * @returns The complete dispatch result.
+     */
+    remove(activityIds: ReadonlyArray<ActivityId>, context?: MutationContext): Promise<DispatchResult>;
+    /**
+     * Moves an activity within the hierarchy.
+     *
+     * @param input - Activity, destination parent, and optional sibling anchor.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    move(input: ActivityMoveInput, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Indents activities beneath the nearest eligible sibling.
+     *
+     * @param activityIds - IDs to indent.
+     * @param context - Optional consumer event source.
+     * @returns The complete dispatch result.
+     */
+    indent(activityIds: ReadonlyArray<ActivityId>, context?: MutationContext): Promise<DispatchResult>;
+    /**
+     * Outdents activities one hierarchy level.
+     *
+     * @param activityIds - IDs to outdent.
+     * @param context - Optional consumer event source.
+     * @returns The complete dispatch result.
+     */
+    outdent(activityIds: ReadonlyArray<ActivityId>, context?: MutationContext): Promise<DispatchResult>;
+    /**
+     * Sets an activity to the public not-started or completed progress sentinel.
+     *
+     * @param activityId - Activity to update.
+     * @param progress - Either {@link NOT_STARTED_PROGRESS} or
+     * {@link COMPLETED_PROGRESS}.
+     * @param context - Optional consumer event source.
+     * @returns The complete dispatch result.
+     */
+    setProgress(activityId: ActivityId, progress: typeof COMPLETED_PROGRESS | typeof NOT_STARTED_PROGRESS, context?: MutationContext): Promise<DispatchResult>;
+    /** @returns The complete result of copying the current selection to core-owned clipboard state. */
+    copy(context?: MutationContext): Promise<DispatchResult>;
+    /**
+     * Pastes copied activities after a sibling.
+     *
+     * @param afterSiblingId - Placement anchor.
+     * @param context - Optional consumer event source.
+     * @returns The complete dispatch result.
+     */
+    paste(afterSiblingId: ActivityId, context?: MutationContext): Promise<DispatchResult>;
+    /** @returns The complete result of clearing core-owned clipboard state. */
+    clearClipboard(context?: MutationContext): Promise<DispatchResult>;
+    /**
+     * Synchronizes consumer-owned lookahead metadata into core state.
+     *
+     * Persisted-progress acknowledgement changes persistence tracking when
+     * requested. When `acknowledgePersistedLookahead` is `true` and
+     * `persistedProgress` is supplied, a successful command clears all undo and
+     * redo history.
+     * @param input - Lookahead flags, IDs, and optional persisted progress.
+     * @returns The complete dispatch result.
+     */
+    lookaheadSync(input: ActivityLookaheadSyncInput): Promise<DispatchResult>;
+    /**
+     * Creates a read-only date prediction bound to the current schedule revision.
+     *
+     * @param gesture - Move or resize gesture to preview.
+     * @returns A preview that throws after the schedule revision changes.
+     */
+    createDateGesturePreview(gesture: DateGesture): DateGesturePreview;
+}
+/** Dependency-link reads and mutations for a ready schedule. */
+interface ScheduleLinksApi {
+    /** @returns A defensive link snapshot, or `null` when the ID is absent. */
+    get(id: LinkId): Readonly<Link> | null;
+    /** @returns Defensive snapshots of every current link. */
+    list(): ReadonlyArray<Readonly<Link>>;
+    /** @returns Unique incoming and outgoing links for the activity. */
+    forActivity(activityId: ActivityId): ReadonlyArray<Readonly<Link>>;
+    /**
+     * Creates a dependency through the canonical dispatch pipeline.
+     *
+     * @param input - Endpoints, named relationship, and lag in working days.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    create(input: LinkCreateRequest, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Updates a dependency relationship and/or lag.
+     *
+     * @param linkId - Link to update.
+     * @param patch - Optional relationship and lag in working days.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    update(linkId: LinkId, patch: LinkPatchRequest, options?: DispatchOptions): Promise<DispatchResult>;
+    /** @returns The complete result of deleting the identified link. */
+    remove(linkId: LinkId, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Applies dependency operations as one command.
+     *
+     * Link lag inputs are working days; stored link snapshots expose hours.
+     * @param operations - Ordered create, update, or remove requests.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete result with per-operation verdicts when present.
+     */
+    batch(operations: ReadonlyArray<LinkBatchRequest>, options?: DispatchOptions): Promise<DispatchResult>;
+}
+/** Calendar snapshots, project hours, and reconciliation. */
+interface ScheduleCalendarsApi {
+    /** @returns A defensive calendar snapshot, or `null` when absent. */
+    get(id: CalendarId): Readonly<Calendar> | null;
+    /** @returns Defensive snapshots of schedule calendars. */
+    list(): ReadonlyArray<Readonly<Calendar>>;
+    /** @returns Defensive snapshots of base calendars. */
+    listBase(): ReadonlyArray<Readonly<Calendar>>;
+    /** @returns The default calendar's earliest start/latest end, or `null`. */
+    projectWorkHours(): ProjectWorkHours | null;
+    /**
+     * Reconciles activities against the current calendars.
+     *
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    reconcile(options?: DispatchOptions): Promise<DispatchResult>;
+}
+/** Core-owned activity selection state. */
+interface ScheduleSelectionApi {
+    /** @returns A snapshot of selected activity IDs. */
+    ids(): readonly string[];
+    /**
+     * Toggles one activity and optionally propagates selection to parents.
+     *
+     * @param input - Activity, checked state, and optional frozen IDs/context.
+     * @returns The complete dispatch result including view-state changes.
+     */
+    toggle(input: SelectionToggleInput): Promise<DispatchResult>;
+    /**
+     * Replaces the selected ID set.
+     *
+     * @param activityIds - New selected IDs.
+     * @param context - Optional consumer event source.
+     * @returns The complete dispatch result including view-state changes.
+     */
+    replace(activityIds: ReadonlyArray<ActivityId>, context?: MutationContext): Promise<DispatchResult>;
+}
+/** Filtering, visibility, and visual-order state. */
+interface ScheduleViewApi {
+    /** @returns A snapshot of explicitly hidden activity IDs. */
+    hiddenActivityIds(): readonly string[];
+    /** @returns A snapshot of activity IDs not currently hidden. */
+    visibleActivityIds(): readonly string[];
+    /** @returns Activity IDs in the current projected traversal order. */
+    visualOrderIds(): ReadonlyArray<ActivityId>;
+    /** @returns A defensive active-filter snapshot, or `null`. */
+    filter(): Readonly<FilterState> | null;
+    /**
+     * Replaces the active filter and rebuilds visibility projection.
+     *
+     * @param input - Criteria, logical operator, optional date range and context.
+     * @returns The complete dispatch result including view-state changes.
+     */
+    setFilter(input: ViewFilterInput): Promise<DispatchResult>;
+    /** @returns A defensive active-order snapshot, or `null`. */
+    order(): Readonly<OrderState> | null;
+    /**
+     * Replaces visual sort rules.
+     *
+     * @param rules - Ordered field/direction rules.
+     * @param context - Optional consumer event source.
+     * @returns The complete dispatch result including branch order changes.
+     */
+    setOrder(rules: ReadonlyArray<OrderRule>, context?: MutationContext): Promise<DispatchResult>;
+    /**
+     * Replaces the visible activity ID set.
+     *
+     * @param activityIds - IDs that should remain visible.
+     * @param context - Optional consumer event source.
+     * @returns The complete dispatch result including view-state changes.
+     */
+    setVisibility(activityIds: ReadonlyArray<ActivityId>, context?: MutationContext): Promise<DispatchResult>;
+    /**
+     * Changes the criterion used for derived activity status.
+     *
+     * @param criteria - Baseline- or actual-based status mode.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    setStatusCriteria(criteria: StatusCriteria, options?: DispatchOptions): Promise<DispatchResult>;
+}
+/** Baseline overlays and baseline-aware reads. */
+interface ScheduleBaselinesApi {
+    /**
+     * Replaces normalized baseline overlays.
+     *
+     * @param points - Backend baseline points to normalize and apply.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    refresh(points: ReadonlyArray<BaselinePoint>, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Applies baseline visibility metadata from backend points.
+     *
+     * @param points - Baseline points carrying version visibility.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    setVisibility(points: ReadonlyArray<BaselinePoint>, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Changes the schedule-wide ponderator criterion.
+     *
+     * @param criterion - Duration, cost, or work-hours criterion.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result.
+     */
+    setPonderatorCriterion(criterion: ActivityCreter, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Selects the active normalized baseline for display.
+     *
+     * @param activity - Activity snapshot to inspect.
+     * @returns The active point, or `null` when none is active.
+     */
+    activeFor(activity: Readonly<CoreActivity>): Readonly<CoreBaselinePoint> | null;
+}
+/** Pending impact-request synchronization. */
+interface ScheduleImpactRequestsApi {
+    /**
+     * Replaces pending requests for an activity.
+     *
+     * @param input - Activity, request snapshots, and optional event source.
+     * @returns The complete dispatch result, including integration effects.
+     */
+    sync(input: ImpactRequestSyncInput): Promise<DispatchResult>;
+}
+/**
+ * Read-only persistence tracking plus external-save acknowledgement.
+ *
+ * This namespace never performs storage I/O. Forks disable dirty tracking, so
+ * `hasChanges()` is always false and modified/new/deleted collections are empty;
+ * persistence acknowledgement is rejected.
+ */
+interface SchedulePersistenceApi {
+    /** @returns Whether tracked state differs from the acknowledged save baseline. */
+    hasChanges(): boolean;
+    /** @returns Defensive snapshots of modified persisted activities. */
+    modifiedActivities(): ReadonlyArray<Readonly<CoreActivity>>;
+    /** @returns Modified persisted fields grouped by activity ID. */
+    modifiedActivityFields(): ReadonlyMap<string, ReadonlyArray<PersistableActivityField>>;
+    /** @returns Defensive snapshots of not-yet-persisted activities. */
+    newActivities(): ReadonlyArray<Readonly<CoreActivity>>;
+    /** @returns Deleted persisted activity identities since the last save. */
+    deletedActivities(): ReadonlyArray<Readonly<DeletedActivitySnapshot>>;
+    /** @returns Defensive snapshots of modified persisted links. */
+    modifiedLinks(): ReadonlyArray<Readonly<Link>>;
+    /** @returns Defensive snapshots of not-yet-persisted links. */
+    newLinks(): ReadonlyArray<Readonly<Link>>;
+    /** @returns Deleted persisted link identities since the last save. */
+    deletedLinks(): ReadonlyArray<Readonly<DeletedLinkSnapshot>>;
+    /** @returns The undo-history boundary for an external save checkpoint. */
+    captureHistoryBoundary(): number;
+    /**
+     * Captures the current activity/link snapshots and matching history boundary.
+     *
+     * @returns A defensive checkpoint; no storage I/O occurs.
+     */
+    readSnapshot(): PersistenceCheckpoint;
+    /**
+     * Acknowledges an exact checkpoint after consumer-owned storage succeeds.
+     *
+     * This updates save tracking and discards history through the checkpoint. A
+     * fork returns a rejected dispatch result.
+     * @param checkpoint - The exact externally persisted snapshot.
+     * @returns The complete dispatch result.
+     */
+    acknowledge(checkpoint: PersistenceCheckpoint): Promise<DispatchResult>;
+}
+/** Serialized undo/redo history for the schedule instance. */
+interface ScheduleHistoryApi {
+    /**
+     * Applies the latest inverse operation.
+     *
+     * @param options - Optional depth guard and critical-path suppression.
+     * @returns The complete projection change set, or `null` when unavailable or
+     * when the expected depth does not match.
+     */
+    undo(options?: UndoOptions): Promise<ChangeSet | null>;
+    /**
+     * Reapplies the latest undone operation.
+     *
+     * @param options - Optional critical-path suppression.
+     * @returns The complete projection change set, or `null` when unavailable.
+     */
+    redo(options?: {
+        readonly skipCriticalPath?: boolean;
+    }): Promise<ChangeSet | null>;
+    /** @returns Whether an undo entry is available; readiness is not required. */
+    canUndo(): boolean;
+    /** @returns Whether a redo entry is available; readiness is not required. */
+    canRedo(): boolean;
+    /** Clears undo and redo history without changing schedule state. */
+    clear(): void;
+    /** @returns Current undo depth; readiness is not required. */
+    depth(): number;
+}
+/** Change-set projection between isolated schedule owners. */
+interface ScheduleProjectionApi {
+    /**
+     * Produces changes that transform a projection of `source` into this schedule.
+     *
+     * Both schedules must be ready. Neither instance is mutated or merged.
+     * @param source - Schedule currently represented by the consumer projection.
+     * @returns A complete consumer projection change set.
+     */
+    changeSetFrom(source: ScheduleCore): ChangeSet;
+}
+/** Critical-path job lifecycle for the current schedule revision. */
+interface ScheduleCriticalPathApi {
+    /**
+     * Tracks the critical-path job current when this property is read.
+     *
+     * Later automatic work, including undo or redo recomputation, can replace
+     * what subsequent reads return. Use {@link ScheduleCriticalPathApi.whenSettled}
+     * to wait for the current schedule revision.
+     * A non-null result contains a complete consumer projection update.
+     */
+    readonly ready: Promise<{
+        changes: ChangeSet;
+    } | null>;
+    /**
+     * Queues critical-path calculation for the current revision.
+     *
+     * @returns A complete projection update, or `null` when already current,
+     * destroyed, or superseded.
+     */
+    recompute(): Promise<{
+        changes: ChangeSet;
+    } | null>;
+    /** @returns Whether no mutation or calculation remains for the current revision. */
+    isSettled(): boolean;
+    /** Resolves after repeatedly recomputing until the current revision is settled. */
+    whenSettled(): Promise<void>;
+}
+/** Read-only diagnostics for integration checks and deterministic comparison. */
+interface ScheduleDiagnosticsApi {
+    /** @returns Counts and circular components from the effective dependency graph. */
+    auditEffectiveGraph(): EffectiveGraphAudit;
+    /** @returns The monotonic scheduling revision; readiness is not required. */
+    revision(): number;
+    /** @returns A deterministic serialization digest of canonical schedule state. */
+    canonicalDigest(): string;
+}
+/** Namespaced façade attached to each {@link ScheduleCore} instance. */
+interface ScheduleApiNamespaces {
+    /** Activity reads and mutations. */
+    readonly activities: ScheduleActivitiesApi;
+    /** Dependency-link reads and mutations. */
+    readonly links: ScheduleLinksApi;
+    /** Calendar reads and reconciliation. */
+    readonly calendars: ScheduleCalendarsApi;
+    /** Core-owned activity selection. */
+    readonly selection: ScheduleSelectionApi;
+    /** Visibility, filtering, and order projection. */
+    readonly view: ScheduleViewApi;
+    /** Baseline overlays and selection. */
+    readonly baselines: ScheduleBaselinesApi;
+    /** Pending impact-request synchronization. */
+    readonly impactRequests: ScheduleImpactRequestsApi;
+    /** External persistence tracking without I/O. */
+    readonly persistence: SchedulePersistenceApi;
+    /** Undo and redo history. */
+    readonly history: ScheduleHistoryApi;
+    /** Cross-instance projection change sets. */
+    readonly projection: ScheduleProjectionApi;
+    /** Critical-path job lifecycle. */
+    readonly criticalPath: ScheduleCriticalPathApi;
+    /** Effective-graph, revision, and digest diagnostics. */
+    readonly diagnostics: ScheduleDiagnosticsApi;
+}
 
+/** Backend-encoded work shift consumed during calendar normalization. */
 interface BackendShiftInput {
     shift_string: string;
 }
+/** Backend calendar exception range and optional replacement shifts. */
 interface BackendCalendarExceptionInput {
     from_date: string;
     to_date: string;
     workable: boolean;
     shifts?: BackendShiftInput[];
 }
+/** Calendar payload accepted at the backend normalization boundary. */
 interface BackendCalendarInput {
     id: number;
     name: string;
@@ -678,6 +1719,12 @@ interface BackendCalendarInput {
     exceptiondays: BackendCalendarExceptionInput[];
     baseexceptiondays?: BackendCalendarExceptionInput[];
 }
+/**
+ * Activity payload accepted at the backend normalization boundary.
+ *
+ * Date fields are backend strings, `duration` is in working days, and nullable
+ * wire values are normalized into the stricter {@link CoreActivity} shape.
+ */
 interface BackendActivityInput {
     id: number | null;
     unique_id: string;
@@ -689,6 +1736,7 @@ interface BackendActivityInput {
     type: 'project' | 'task' | 'milestone';
     start_date: string;
     end_date: string;
+    /** Duration in working days. */
     duration: number;
     constraint: string | null;
     constraint_date?: string | null;
@@ -727,6 +1775,7 @@ interface BackendActivityInput {
     createdAt: string;
     updatedAt: string;
 }
+/** Dependency payload accepted at the backend normalization boundary. */
 interface BackendLinkInput {
     id: number | string;
     unique_id?: string | null;
@@ -735,14 +1784,18 @@ interface BackendLinkInput {
     source?: number | string;
     target?: number | string;
     type?: unknown;
+    /** Dependency lag in working days, or `null` for zero. */
     lag: number | null;
     ganttId?: number;
     sectorId?: number;
 }
+/** Schedule metadata accepted from the backend's legacy `sector` field. */
 interface BackendSectorInput {
     id: number;
     name: string;
+    /** Working hours per day used for input day/hour conversion. */
     hoursPerDay: number;
+    /** Working hours per week. */
     hoursPerWeek: number;
     dateFormat: string;
     projectId: number;
@@ -753,6 +1806,11 @@ interface BackendSectorInput {
     custom_id_increment?: string | number | null;
     calendars?: BackendCalendarInput[];
 }
+/**
+ * Complete consumer-owned backend payload normalized during construction.
+ *
+ * Calendars are optional; omitted collections normalize to package defaults.
+ */
 interface BackendScheduleInput {
     sector: BackendSectorInput;
     activities: BackendActivityInput[];
@@ -761,55 +1819,117 @@ interface BackendScheduleInput {
     baseCalendars?: BackendCalendarInput[] | undefined;
 }
 
+/** Consumer diagnostics sink for normalization and background failures. */
 interface ScheduleCoreReporter {
+    /** Reports a recoverable warning with optional safe context. */
     warn(message: string, context?: unknown): void;
+    /** Reports an unexpected failure with its optional cause. */
     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];
+
+/**
+ * Lifecycle health states observable without awaiting initialization.
+ * `ready` means alive, not initialized; await {@link ScheduleCore.ready} before
+ * normal reads or commands.
+ */
 type ScheduleCoreStatus = 'ready' | 'destroyed' | 'poisoned';
+/** Named lifecycle states for integration checks. */
 declare const SCHEDULE_CORE_STATUS: {
     readonly READY: "ready";
     readonly DESTROYED: "destroyed";
     readonly POISONED: "poisoned";
 };
+/**
+ * Backend payload plus options used to construct a {@link ScheduleCore}.
+ *
+ * Construction parses the backend fields and begins initialization immediately.
+ */
 interface ScheduleCoreInput extends BackendScheduleInput {
+    /** Skips the initial autoschedule pass when `true`; defaults to `false`. */
     skipInitialAutoSchedule?: boolean;
+    /** Optional baseline overlay applied before initial passes. */
     baselinePoints?: readonly BaselinePoint[];
+    /**
+     * Supplies deterministic current dates. When omitted, clock-dependent
+     * recomputations are skipped rather than reading the system clock.
+     */
     clock?: () => Date;
+    /** Makes `ready` wait for initial critical-path calculation when `true`. */
     criticalPathOnLoad?: boolean;
+    /** Initial baseline- or actual-based status mode. */
     statusCriteria?: StatusCriteria;
+    /** Optional consumer schedule identifier retained in sector metadata. */
     ganttId?: number;
+    /** Optional normalization and background-error diagnostics sink. */
     reporter?: ScheduleCoreReporter;
 }
 
-type DateGesture = {
-    readonly kind: 'move';
-    readonly activityIds: readonly ActivityId[];
-    readonly anchorActivityId: ActivityId;
-} | {
-    readonly kind: 'resize-start' | 'resize-end';
-    readonly activityId: ActivityId;
-};
-interface DateGesturePreview {
-    getDates(activityId: ActivityId, proposedEdgeTimeMs: number): {
-        startTimeMs: number;
-        endTimeMs: number;
-    } | null;
-}
-
+/** Summary of logical links and projected effective dependency edges. */
 interface EffectiveGraphAudit {
+    /** Number of current activities. */
     readonly activityCount: number;
+    /** Number of stored logical links. */
     readonly logicalLinkCount: number;
+    /** Number of effective edges after summary-link projection. */
     readonly effectiveEdgeCount: number;
+    /** Strongly connected activity-ID components that are circular. */
     readonly circularComponents: ReadonlyArray<ReadonlyArray<string>>;
+    /** Number of activities in the largest circular component. */
     readonly largestComponentSize: number;
 }
+/** Controls an undo operation without changing the recorded entry. */
 interface UndoOptions {
+    /** Suppresses automatic critical-path recomputation for this undo. */
     readonly skipCriticalPath?: boolean;
+    /** Causes undo to return `null` unless the current depth matches. */
     readonly expectedUndoDepth?: number;
 }
 
+/**
+ * Owns one normalized schedule, its serialized mutation queue, derived
+ * scheduling state, persistence tracking, and history.
+ *
+ * Construction parses backend input and starts initialization immediately.
+ * Await {@link ScheduleCore.ready} before normal reads or commands. Consumers
+ * own backend I/O and projection of returned change sets.
+ */
 declare class ScheduleCore {
+    /** Activity reads and mutations. */
+    readonly activities: ScheduleApiNamespaces['activities'];
+    /** Dependency-link reads and mutations. */
+    readonly links: ScheduleApiNamespaces['links'];
+    /** Calendar reads and reconciliation. */
+    readonly calendars: ScheduleApiNamespaces['calendars'];
+    /** Core-owned activity selection. */
+    readonly selection: ScheduleApiNamespaces['selection'];
+    /** Visibility, filtering, and order projection. */
+    readonly view: ScheduleApiNamespaces['view'];
+    /** Baseline overlays and selection. */
+    readonly baselines: ScheduleApiNamespaces['baselines'];
+    /** Pending impact-request synchronization. */
+    readonly impactRequests: ScheduleApiNamespaces['impactRequests'];
+    /** External persistence tracking; no storage I/O is performed. */
+    readonly persistence: ScheduleApiNamespaces['persistence'];
+    /** Undo and redo history. */
+    readonly history: ScheduleApiNamespaces['history'];
+    /** Cross-instance projection change sets. */
+    readonly projection: ScheduleApiNamespaces['projection'];
+    /** Critical-path job lifecycle. */
+    readonly criticalPath: ScheduleApiNamespaces['criticalPath'];
+    /** Effective-graph, revision, and digest diagnostics. */
+    readonly diagnostics: ScheduleApiNamespaces['diagnostics'];
     private readonly _activityClipboard;
     private _status;
     private readonly coreRuntime;
@@ -820,63 +1940,216 @@ declare class ScheduleCore {
     private _pendingScheduleRevision;
     private _criticalPathRevision;
     private _activeCriticalPath;
+    /**
+     * Creates one state owner and starts backend normalization and initial passes.
+     *
+     * @param input - Backend schedule data plus initialization options.
+     */
     constructor(input: ScheduleCoreInput);
+    /**
+     * Resolves after initialization, and after initial critical path when
+     * `criticalPathOnLoad` is enabled.
+     */
     get ready(): Promise<void>;
+    /**
+     * Creates an isolated schedule with copied state, history, and generators.
+     *
+     * The fork runs the same mutation logic but disables dirty tracking:
+     * `persistence.hasChanges()` stays false and all dirty collections stay
+     * empty. It cannot acknowledge persistence and is never merged automatically.
+     * @returns A ready isolated schedule.
+     */
     fork(): Promise<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.
+     * Apply a non-null `changes` value to the consumer-owned projection.
+     */
     get criticalPathReady(): Promise<{
         changes: ChangeSet;
     } | null>;
+    /**
+     * Current lifecycle health; `ready` can be observed before initialization
+     * finishes, so await {@link ScheduleCore.ready} before normal use.
+     */
     get status(): ScheduleCoreStatus;
+    /**
+     * Reads a defensive sector metadata snapshot without a readiness guard.
+     *
+     * @returns Cloned metadata, including values available after destruction.
+     */
     getSector(): Readonly<SectorMetadata>;
+    /**
+     * Reads a defensive activity snapshot from a ready schedule.
+     *
+     * @param id - Canonical activity ID.
+     * @returns The activity, or `null` when absent.
+     */
     getActivityView(id: ActivityId): Readonly<CoreActivity> | null;
+    /**
+     * Creates a read-only date prediction bound to the current revision.
+     *
+     * @param gesture - Move or resize gesture to preview.
+     * @returns A preview that throws after schedule state changes.
+     */
     createDateGesturePreview(gesture: DateGesture): DateGesturePreview;
+    /** @returns Defensive snapshots of every activity in the ready schedule. */
     getAllActivitiesView(): ReadonlyArray<Readonly<CoreActivity>>;
+    /**
+     * Computes the unique parent IDs allowed by the current indent plan.
+     *
+     * @param activityIds - Activities considered for indentation.
+     */
     getIndentTargetParentIds(activityIds: ReadonlyArray<ActivityId | string>): readonly string[];
-    getChildrenView(parentId: ActivityId | '0'): ReadonlyArray<Readonly<CoreActivity>>;
+    /**
+     * Reads defensive direct-child snapshots in correlative order.
+     *
+     * @param parentId - Parent activity ID, or the root ID.
+     */
+    getChildrenView(parentId: ActivityId | typeof ROOT_PARENT_ID): ReadonlyArray<Readonly<CoreActivity>>;
+    /**
+     * Reads a defensive link snapshot.
+     *
+     * @param id - Canonical link ID.
+     * @returns The link, or `null` when absent. Stored lag is in working hours.
+     */
     getLinkView(id: LinkId): Readonly<Link> | null;
+    /**
+     * Reads unique incoming and outgoing link snapshots for an activity.
+     *
+     * @param activityId - Activity whose links should be read.
+     */
     getLinksForActivityView(activityId: ActivityId): ReadonlyArray<Readonly<Link>>;
+    /** @returns Defensive snapshots of every link; stored lag is in working hours. */
     getAllLinksView(): ReadonlyArray<Readonly<Link>>;
+    /** @returns Counts and circular components from the effective dependency graph. */
     auditEffectiveGraph(): EffectiveGraphAudit;
+    /**
+     * Reads and clones one activity property.
+     *
+     * @param activityId - Canonical activity ID.
+     * @param property - Property to read.
+     * @returns The cloned value, or `null` when the activity is absent.
+     */
     getProperty<Property extends keyof CoreActivity>(activityId: ActivityId, property: Property): CoreActivity[Property] | null;
+    /** @returns A read-only snapshot of all current activity IDs. */
     getAllIds(): readonly string[];
+    /**
+     * Visits each current activity ID without exposing mutable state.
+     *
+     * @param visit - Callback invoked once per current ID.
+     */
     forEachActivityId(visit: (id: string) => void): void;
-    getChildrenIds(parentId: ActivityId | '0'): ReadonlyArray<ActivityId>;
+    /**
+     * Reads direct child IDs in visual order.
+     *
+     * @param parentId - Parent activity ID, or the root ID.
+     */
+    getChildrenIds(parentId: ActivityId | typeof ROOT_PARENT_ID): ReadonlyArray<ActivityId>;
+    /** @returns A defensive snapshot of selected activity IDs. */
     getSelectedActivityIds(): string[];
+    /** @returns A defensive snapshot of explicitly hidden activity IDs. */
     getHiddenActivityIds(): string[];
+    /** @returns A defensive snapshot of activity IDs not currently hidden. */
     getVisibleActivityIds(): string[];
+    /** @returns A defensive active-filter snapshot, or `null`. */
     getActiveFilter(): Readonly<FilterState> | null;
+    /** @returns A defensive active-order snapshot, or `null`. */
     getActiveOrder(): Readonly<OrderState> | null;
+    /** @returns Activity IDs in the current projected traversal order. */
     getVisualOrderIds(): ReadonlyArray<ActivityId>;
-    hasChild(parentId: ActivityId | '0'): boolean;
+    /** @returns Whether the parent currently has a direct child. */
+    hasChild(parentId: ActivityId | typeof ROOT_PARENT_ID): boolean;
+    /**
+     * Reads a defensive schedule-calendar snapshot.
+     *
+     * @param id - Canonical calendar ID.
+     * @returns The calendar, or `null` when absent.
+     */
     getCalendar(id: CalendarId): Readonly<Calendar> | null;
+    /** @returns Defensive snapshots of every schedule calendar. */
     getAllCalendars(): ReadonlyArray<Readonly<Calendar>>;
+    /** @returns Defensive snapshots of every base calendar. */
     getBaseCalendars(): ReadonlyArray<Readonly<Calendar>>;
+    /**
+     * Checks custom-ID uniqueness while optionally excluding the current value.
+     *
+     * @param customId - Candidate custom ID.
+     * @param currentCustomId - Existing value to ignore, or `null`.
+     */
     isCustomIdInUse(customId: string, currentCustomId?: string | null): boolean;
+    /** @returns The default calendar's earliest start/latest end, or `null`. */
     getProjectWorkHours(): ProjectWorkHours | null;
+    /** @returns Defensive snapshots of modified persisted links; no I/O occurs. */
     getModifiedLinks(): ReadonlyArray<Readonly<Link>>;
+    /** @returns Defensive snapshots of not-yet-persisted links; no I/O occurs. */
     getNewLinks(): ReadonlyArray<Readonly<Link>>;
+    /** @returns Defensive snapshots of modified persisted activities; no I/O occurs. */
     getModifiedActivities(): ReadonlyArray<Readonly<CoreActivity>>;
+    /** @returns Modified persisted fields grouped by activity ID; no I/O occurs. */
     getModifiedActivityFields(): ReadonlyMap<string, ReadonlyArray<PersistableActivityField>>;
+    /** @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 monotonic scheduling revision without a readiness guard. */
     getScheduleRevision(): number;
+    /** @returns The undo-history boundary for an external save checkpoint. */
     capturePersistenceHistoryBoundary(): number;
+    /** @returns A deterministic serialization digest of canonical schedule state. */
     getCanonicalDigest(): string;
+    /**
+     * Produces changes that transform a projection of `source` into this schedule.
+     *
+     * Both schedules must be ready. Neither instance is mutated or merged.
+     * @param source - Schedule currently represented by the consumer projection.
+     * @returns A complete consumer projection change set.
+     */
     createProjectionChangeSetFrom(source: ScheduleCore): ChangeSet;
+    /** @returns Deleted persisted activity identities since the last save. */
     getDeletedActivitiesSinceLastSave(): ReadonlyArray<Readonly<DeletedActivitySnapshot>>;
+    /** @returns Deleted persisted link identities since the last save. */
     getDeletedLinksSinceLastSave(): ReadonlyArray<Readonly<DeletedLinkSnapshot>>;
     private _enqueue;
     private _beginScheduleMutation;
     private _admitScheduleMutation;
     private _settleScheduleMutation;
+    /**
+     * Serializes and applies one public command to core-owned state.
+     *
+     * @param action - Public command. Activity-batch commands use
+     * {@link ScheduleCore.applyActivityBatch} instead.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result unchanged, including change sets,
+     * verdicts, effects, tracking events, and warnings when present.
+     */
     dispatch(action: DispatchAction, options?: DispatchOptions): Promise<DispatchResult>;
+    /**
+     * Serializes and applies an activity creation batch.
+     *
+     * @param action - Append/replace batch using working-day link lags and
+     * activity-creation overrides. Dispatch converts lags to stored hours.
+     * @param options - Per-operation autoschedule and critical-path controls.
+     * @returns The complete dispatch result unchanged.
+     */
     applyActivityBatch(action: ActivityBatchAction, options?: DispatchOptions): Promise<DispatchResult>;
     private _dispatchInner;
     private _runDispatch;
+    /**
+     * Queues critical-path calculation for the current revision.
+     *
+     * @returns A complete projection update, or `null` when already current,
+     * destroyed, or superseded.
+     */
     recomputeCriticalPath(): Promise<{
         changes: ChangeSet;
     } | null>;
+    /** @returns Whether no mutation or calculation remains for the current revision. */
     isCriticalPathSettled(): boolean;
+    /** Resolves after repeatedly recomputing until the current revision is settled. */
     whenCriticalPathSettled(): Promise<void>;
     private _withReappliedViewState;
     private _reapplyViewState;
@@ -885,17 +2158,38 @@ declare class ScheduleCore {
     private _reapplyActiveFilter;
     private _recordScheduleMutation;
     private _startCriticalPathForCurrentRevision;
+    /**
+     * Applies the latest inverse operation through the serialized queue.
+     *
+     * @param options - Optional depth guard and critical-path suppression.
+     * @returns The complete projection change set, or `null` when unavailable or
+     * when the expected depth does not match.
+     */
     undo(options?: UndoOptions): Promise<ChangeSet | null>;
     private _runUndo;
+    /**
+     * Reapplies the latest undone operation through the serialized queue.
+     *
+     * @param options - Optional critical-path suppression.
+     * @returns The complete projection change set, or `null` when unavailable.
+     */
     redo(options?: {
         skipCriticalPath?: boolean;
     }): Promise<ChangeSet | null>;
     private _runRedo;
+    /** @returns Whether an undo entry is available; readiness is not required. */
     canUndo(): boolean;
+    /** @returns Whether a redo entry is available; readiness is not required. */
     canRedo(): boolean;
+    /** Clears undo and redo history without changing schedule state. */
     clearHistory(): void;
+    /** @returns Current undo depth; readiness is not required. */
     undoDepth(): number;
     private _resyncCustomIdTrackerFromModel;
+    /**
+     * Cancels active critical-path work, clears caches, and permanently destroys
+     * this instance. Guarded reads and operations throw afterward.
+     */
     destroy(): void;
     private readonly _initPromise;
     private _criticalPathReady;
@@ -905,6 +2199,17 @@ declare class ScheduleCore {
     private _rollback;
 }
 
+/**
+ * Constructs a schedule from backend input and waits for its configured
+ * initialization passes.
+ *
+ * @param input - Backend schedule data plus initialization options.
+ * @returns The ready {@link ScheduleCore} instance; no wrapper or second state
+ * owner is created.
+ */
+declare function createSchedule(input: ScheduleCoreInput): Promise<ScheduleCore>;
+
+/** Fully normalized data returned by the backend parsing boundary. */
 interface ParsedInput {
     sector: SectorMetadata;
     activities: CoreActivity[];
@@ -915,57 +2220,141 @@ interface ParsedInput {
         readonly hiddenIds: readonly ActivityId[];
     };
 }
+/**
+ * Normalizes backend wire data without constructing a schedule owner.
+ *
+ * Construction calls this automatically. Invalid or inconsistent input may
+ * throw; diagnostics are reported through the optional reporter.
+ * @param input - Backend schedule metadata, activities, links, and calendars.
+ * @param reporter - Optional normalization diagnostics sink.
+ * @returns Normalized domain data and initial hidden-ID view state.
+ */
 declare function parseFromBackend(input: BackendScheduleInput, reporter?: ScheduleCoreReporter): ParsedInput;
 
+/**
+ * Selects the normalized baseline point marked as active.
+ *
+ * @param activity - Baseline-bearing activity, or a nullish value.
+ * @returns The active point, or `null` when none is available.
+ */
 declare function getActiveBaseline(activity: {
     baselinePoints?: readonly CoreBaselinePoint[];
 } | null | undefined): CoreBaselinePoint | null;
 
+/** Calendar duration boundary used by expected-progress calculation. */
 interface CalendarLike {
+    /** @returns Working duration between two dates in a consistent calendar unit. */
     calculateDuration(start: Date, end: Date): number;
 }
+/**
+ * Calculates elapsed calendar duration as a percentage of baseline duration.
+ *
+ * @param start - Baseline start.
+ * @param end - Baseline end.
+ * @param now - Calculation date.
+ * @param calendar - Working-duration boundary.
+ * @returns A percentage from 0 through 100.
+ */
 declare function expectedProgressFromBaseline(start: Date, end: Date, now: Date, calendar: CalendarLike): number;
 
+/** Consumer-compatible adapter used by baseline expected-progress calculation. */
 interface ExpectedProgressAdapter {
+    /** @returns Direct child IDs for a parent or root. */
     getChildrenIds(parentId: string | 0): readonly string[];
+    /** @returns The activity record, or `null` when absent. */
     getActivity(id: string): Record<string, unknown> | null;
+    /** Writes one calculated field to adapter-owned state. */
     setActivityField(id: string, field: string, value: unknown): void;
+    /** @returns A base calendar calculation boundary, or `null` when absent. */
     getBaseCalendar(engineId: string): CalendarLike | null;
 }
+/**
+ * Calculates baseline expected progress and writes changed values through an adapter.
+ *
+ * @param rootIds - Root activities to traverse recursively.
+ * @param now - Calculation date.
+ * @param adapter - Consumer-owned read/write and calendar boundary.
+ * @param defaultBaseCalendarId - Fallback base calendar ID, or `null`.
+ * @returns IDs whose `expectedProgressBaseline` percentage changed.
+ */
 declare function computeExpectedProgress(rootIds: readonly string[], now: Date, adapter: ExpectedProgressAdapter, defaultBaseCalendarId?: string | null): string[];
 
+/**
+ * Activity fields safe to prefill before identity, placement, dates, duration,
+ * calendar, and unique correlative ID are chosen.
+ */
 type StaticActivityDefaults = Omit<CoreActivity, 'id' | 'parentId' | 'name' | 'startDate' | 'endDate' | 'durationHours' | 'calendarId' | 'uniqueCorrelativeId'>;
+/**
+ * Frozen defaults for consumer creation UI.
+ *
+ * These values do not replace the authoritative `activity-create` pipeline.
+ */
 declare const NEW_ACTIVITY_DEFAULTS: Readonly<StaticActivityDefaults>;
 
+/**
+ * Finds persisted links whose endpoints, type, or stored-hour lag changed.
+ *
+ * @param baseline - Previously saved link snapshots.
+ * @param current - Current link snapshots.
+ * @returns Current snapshots for links changed since the baseline.
+ */
 declare function checkNoUpdatedLinks(baseline: readonly Link[], current: readonly Link[]): Link[];
 
+/** Entity that may not yet have a backend persistence identifier. */
 interface WithProplannerId {
     proplannerId?: number | null;
     [key: string]: unknown;
 }
+/**
+ * Selects activities without a truthy backend persistence identifier.
+ *
+ * @param activities - Optional activity collection; defaults to empty.
+ * @returns Matching items without cloning them.
+ */
 declare const getUnsavedActivities: <T extends WithProplannerId>(activities?: readonly T[]) => T[];
 
+/**
+ * Yields one browser message-channel turn without introducing a timer.
+ *
+ * @returns An already-resolved promise outside a browser or without
+ * `MessageChannel` support.
+ */
 declare function yieldToBrowser(): Promise<void>;
 
+/**
+ * Predicts whether an action's normal derived-work policy runs critical path.
+ *
+ * Per-dispatch skip options are not represented by this action-only prediction.
+ * @param action - Public dispatch command.
+ */
 declare function willRunCriticalPath(action: DispatchAction): boolean;
 
+/** Stable reasons returned when filter input cannot be normalized. */
+declare const FILTER_REJECTION_REASON: {
+    readonly UNKNOWN_FIELD: "unknown_field";
+    readonly UNKNOWN_OPERATOR: "unknown_operator";
+    readonly INVALID_VALUE: "invalid_value";
+};
+/** Stable reason returned for rejected filter input. */
+type FilterRejection = (typeof FILTER_REJECTION_REASON)[keyof typeof FILTER_REJECTION_REASON];
+
+/** Named normalized activity shape categories. */
 declare const ACTIVITY_TYPE: {
     readonly TASK: "task";
     readonly PROJECT: "project";
     readonly MILESTONE: "milestone";
 };
 
-declare const ROOT_PARENT_ID: "0";
-declare function isRootParent(parent: unknown): boolean;
-declare function normalizeParentKey(parent: unknown): string;
-
+/** Compact dependency relationship code used by consumer text formats. */
 type LinkTypeCode = 'fs' | 'ss' | 'ff' | 'sf';
+/** Maps stored link types to compact consumer relationship codes. */
 declare const LINK_TYPE_CODE: {
     readonly "0": "fs";
     readonly "1": "ss";
     readonly "2": "ff";
     readonly "3": "sf";
 };
+/** Maps compact consumer relationship codes to stored link types. */
 declare const LINK_CODE_TO_TYPE: {
     readonly fs: "0";
     readonly ss: "1";
@@ -973,50 +2362,23 @@ declare const LINK_CODE_TO_TYPE: {
     readonly sf: "3";
 };
 
+/** Maps normalized constraint types to backend-compatible display labels. */
 declare const CONSTRAINT_TYPE_TO_LABEL: Record<ConstraintType, string>;
 
+/** Fallback working hours per day when schedule metadata is unavailable. */
 declare const DEFAULT_HOURS_PER_DAY = 8;
 
-type DispatchActionKind = DispatchAction['kind'];
-declare const DISPATCH_ACTION_KIND: {
-    readonly ACTIVITY_CLIPBOARD_CLEAR: "activity-clipboard-clear";
-    readonly ACTIVITY_COPY: "activity-copy";
-    readonly ACTIVITY_PASTE_COPIED: "activity-paste-copied";
-    readonly PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge";
-    readonly BASELINE_APPLY: "baseline-apply";
-    readonly PONDERATOR_CRITERION_SET: "ponderator-criterion-set";
-    readonly STATUS_CRITERIA_SET: "status-criteria-set";
-    readonly INLINE_EDIT: "inline-edit";
-    readonly DATES_BATCH: "dates-batch";
-    readonly BULK_EDIT: "bulk-edit";
-    readonly LINK_CREATE: "link-create";
-    readonly LINK_UPDATE: "link-update";
-    readonly LINK_DELETE: "link-delete";
-    readonly LINKS_BATCH: "links-batch";
-    readonly ACTIVITY_CREATE: "activity-create";
-    readonly ACTIVITY_DELETE: "activity-delete";
-    readonly ACTIVITY_MOVE: "activity-move";
-    readonly ACTIVITY_INDENT: "activity-indent";
-    readonly ACTIVITY_OUTDENT: "activity-outdent";
-    readonly ACTIVITY_SET_PROGRESS: "activity-set-progress";
-    readonly SELECTION_TOGGLE: "selection-toggle";
-    readonly SELECTION_REPLACE: "selection-replace";
-    readonly VISIBILITY_SET: "visibility-set";
-    readonly FILTER_SET: "filter-set";
-    readonly SORT_SET: "sort-set";
-    readonly SIR_SYNC: "sir-sync";
-    readonly ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync";
-};
-declare const DISPATCH_ACTION_KINDS: ReadonlyArray<DispatchActionKind>;
-
+/** Consumer creation contexts recognized by schedule integrations. */
 declare const CREATION_KIND: {
     readonly CHILD: "child";
     readonly CHILD_CONFIRMED: "child-confirmed";
     readonly LINE: "line";
     readonly ROOT: "root";
 };
+/** Consumer creation context recognized by schedule integrations. */
 type CreationKind = (typeof CREATION_KIND)[keyof typeof CREATION_KIND];
 
+/** Stable expected-rejection reasons returned by public dispatch commands. */
 declare const REJECTION_REASON: {
     readonly CANNOT_EDIT: "cannot_edit";
     readonly PARSE_ERROR: "parse_error";
@@ -1043,8 +2405,10 @@ declare const REJECTION_REASON: {
     readonly SANDBOX_PERSISTENCE_FORBIDDEN: "sandbox_persistence_forbidden";
     readonly INVALID_PROGRESS_VALUE: "invalid_progress_value_must_be_0_or_100";
 };
+/** Stable expected-rejection reason returned by a public command. */
 type DispatchRejectReason = (typeof REJECTION_REASON)[keyof typeof REJECTION_REASON];
 
+/** Consumer analytics event names emitted by schedule mutations. */
 declare const DISPATCH_TRACK_EVENT: {
     readonly ACTIVITY_CREATION: "schedule_activity_creation";
     readonly ACTIVITY_DELETION: "schedule_activity_deletion";
@@ -1052,6 +2416,7 @@ declare const DISPATCH_TRACK_EVENT: {
     readonly ACTIVITY_INDENT: "schedule_activity_indent";
     readonly ACTIVITY_OUTDENT: "schedule_activity_outdent";
 };
+/** Consumer analytics event name emitted by a schedule mutation. */
 type DispatchTrackEvent = (typeof DISPATCH_TRACK_EVENT)[keyof typeof DISPATCH_TRACK_EVENT];
 
-export { ACTIVITY_TYPE, type ActivityBaselineSnapshot, type ActivityBatchAction, type ActivityBatchItem, type ActivityBatchLinkInput, type ActivityBatchMode, type ActivityBatchParentReference, type ActivityBatchReference, type ActivityCreationOverrides, type ActivityCreter, type ActivityId, type ActivityStatus, type ActivityType, type BackendActivityInput, type BackendCalendarExceptionInput, type BackendCalendarInput, type BackendLinkInput, type BackendScheduleInput, type BackendSectorInput, type BackendShiftInput, type BaselinePoint, type BaselineVersion, type BranchOrderChange, CALENDAR_UNIT, COLUMN, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CREATION_KIND, type Calendar, type CalendarId, type CalendarLike, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ChangeSetSource, type ColumnName, type ConstraintType, type ConstraintWarning, type CoreActivity, type CoreBaselinePoint, type CreationKind, type CriticalPathResult, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_TRACK_EVENT, type DateGesture, type DateGesturePreview, type DatesBatchVerdict, type DeletedActivitySnapshot, type DeletedLinkSnapshot, type DispatchAction, type DispatchActionKind, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, type EditableColumnName, type EffectiveGraphAudit, type EntityChange, type ExpectedProgressAdapter, type FilterCriterion, type FilterCriterionValue, type FilterDateRange, type FilterField, type FilterOperator, type FilterState, LINK_CODE_TO_TYPE, LINK_TYPE, LINK_TYPE_CODE, type Link, type LinkBatchVerdict, type LinkId, type LinkType, type LinkTypeCode, type LinksBatchOperation, NEW_ACTIVITY_DEFAULTS, type OrderRule, type OrderState, type ParsedInput, type PendingRequest, type PersistableActivityField, type PersistedEntityIdentity, type PersistenceCheckpoint, type PipelineColumnName, type ProjectWorkHours, REJECTION_REASON, ROOT_PARENT_ID, SCHEDULE_CORE_STATUS, STATUS, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleEffect, type SectorMetadata, type StaticActivityDefaults, type StatusCriteria, type TrackingEvent, type UndoOptions, type ViewStateChange, type ViewStatePropChange, WORK_TIME_DIRECTION, type WithProplannerId, type WorkTimeDirection, checkNoUpdatedLinks, computeExpectedProgress, expectedProgressFromBaseline, getActiveBaseline, getUnsavedActivities, isRootParent, normalizeParentKey, parseFromBackend, willRunCriticalPath, yieldToBrowser };
+export { ACTIVITY_BATCH_ACTION_KIND, ACTIVITY_BATCH_MODE, ACTIVITY_DATE_EDGE, ACTIVITY_FIELD, ACTIVITY_PONDERATOR_CRITERION, 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 ActivityCreateInput, type ActivityCreationOverrides, type ActivityCreter, type ActivityDateEdge, type ActivityDateEdit, type ActivityField, type ActivityFieldEdit, type ActivityFieldValue, type ActivityId, type ActivityLookaheadSyncInput, type ActivityMoveInput, type ActivityStatus, type ActivityType, type BackendActivityInput, type BackendCalendarExceptionInput, type BackendCalendarInput, type BackendLinkInput, type BackendScheduleInput, type BackendSectorInput, type BackendShiftInput, type BaselinePoint, type BaselineVersion, type BranchOrderChange, CALENDAR_UNIT, CHANGE_SET_SOURCE_KIND, COLUMN, COMPLETED_PROGRESS, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CONSTRAINT_WARNING_KIND, CREATION_KIND, type Calendar, type CalendarId, type CalendarLike, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ChangeSetSource, type ColumnName, type ConstraintType, type ConstraintWarning, type CoreActivity, type CoreBaselinePoint, type CreationKind, type CriticalPathResult, DATE_GESTURE_KIND, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_LINK_OPERATION_KIND, DISPATCH_TRACK_EVENT, type DateGesture, type DateGestureKind, type DateGesturePreview, type DatesBatchVerdict, type DeletedActivitySnapshot, type DeletedLinkSnapshot, type DispatchAction, type DispatchActionKind, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, type EditableColumnName, type EffectiveGraphAudit, type EntityChange, type ActivityBatchLinkInput as ErgonomicActivityBatchLinkInput, type ExpectedProgressAdapter, FILTER_FIELD, FILTER_LOGIC, FILTER_OPERATOR, FILTER_REJECTION_REASON, FILTER_VALUE_KIND, type FilterCriterion, type FilterCriterionValue, type FilterDateRange, type FilterField, type FilterLogic, type FilterOperator, type FilterRejection, type FilterState, type FilterValueKind, type ImpactRequestSyncInput, LINK_BATCH_OPERATION_KIND, LINK_CODE_TO_TYPE, LINK_REJECTION_REASON, LINK_RELATIONSHIP, LINK_TYPE, LINK_TYPE_CODE, type Link, type LinkBatchOperationKind, type LinkBatchRequest, type LinkBatchVerdict, type LinkCreateRequest, type LinkId, type LinkPatchRequest, type LinkRejection, type LinkRelationship, type LinkType, type LinkTypeCode, type LinksBatchOperation, type MutationContext, NEW_ACTIVITY_DEFAULTS, NOT_STARTED_PROGRESS, ORDER_DIRECTION, type OrderDirection, type OrderRule, type OrderState, type ParsedInput, type PendingRequest, type PersistableActivityField, type PersistedEntityIdentity, type PersistenceCheckpoint, 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 ScheduleBaselinesApi, type ScheduleCalendarsApi, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleCriticalPathApi, type ScheduleDiagnosticsApi, type ScheduleEffect, type ScheduleHistoryApi, type ScheduleImpactRequestsApi, type ScheduleLinksApi, type SchedulePersistenceApi, type ScheduleProjectionApi, type ScheduleSelectionApi, type ScheduleViewApi, type SectorMetadata, type SelectionToggleInput, type StaticActivityDefaults, type StatusCriteria, type TrackingEvent, type UndoOptions, type ViewFilterInput, type ViewStateChange, type ViewStatePropChange, WORK_TIME_DIRECTION, type WithProplannerId, type WorkTimeDirection, checkNoUpdatedLinks, computeExpectedProgress, createSchedule, expectedProgressFromBaseline, getActiveBaseline, getUnsavedActivities, isRootParent, normalizeParentKey, parseFromBackend, willRunCriticalPath, yieldToBrowser };