@masterteam/task-schedule 0.0.3 → 0.0.5

package/types/masterteam-task-schedule.d.ts

@@ -1,9 +1,10 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy, InjectionToken } from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
 import { GanttComponent, ContextMenuOpenEventArgs, ContextMenuClickEventArgs } from '@syncfusion/ej2-angular-gantt';
-import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import { EntityData } from '@masterteam/components/entities';
+import { ModalService } from '@masterteam/components/modal';
+import { ColumnDef } from '@masterteam/components/table';
 import * as _masterteam_task_schedule from '@masterteam/task-schedule';
 
 type TaskScheduleModelKey = 'default' | 'edit' | 'baseline' | 'criticalPath' | 'resources' | 'unscheduled' | 'phaseGate' | 'custom';
@@ -12,6 +13,8 @@ type TaskScheduleModelType = TaskScheduleModelKey | TaskScheduleModelAlias | str
 interface TaskScheduleModeOption {
     value: TaskScheduleModelType;
     label?: string;
+    icon?: string;
+    color?: string;
 }
 declare function normalizeTaskScheduleModelType(modelType: TaskScheduleModelType): TaskScheduleModelKey;
 interface TaskScheduleContext {
@@ -19,8 +22,10 @@ interface TaskScheduleContext {
     modelType?: TaskScheduleModelType;
     schemaId?: number | string;
     levelDataId?: number | string;
+    taskModuleId?: number | string;
+    milestoneModuleId?: number | string;
+    deliverableModuleId?: number | string;
     customViewId?: number | string;
-    apiBaseUrl?: string;
     scheduleViewKey?: string;
     dateFormat?: string;
     height?: string;
@@ -35,7 +40,6 @@ interface TaskScheduleContext {
     pdfFonts?: TaskSchedulePdfFonts;
     customProperties?: TaskScheduleCustomProperty[];
     customColumns?: Array<Record<string, unknown>>;
-    requestHeaders?: Record<string, string>;
     langCode?: 'en' | 'ar';
     modelCacheKey?: string;
     [key: string]: unknown;
@@ -45,29 +49,33 @@ interface TaskSchedulePdfFonts {
     arabic?: string;
     size?: number;
 }
-interface TaskScheduleContextEndpoints {
+interface TaskScheduleCoreContextEndpoints {
+    processSubmit?: string;
+    scheduleRead?: string;
+    scheduleQuery?: string;
     scheduleTree?: string;
     scheduleTreePhaseGate?: string;
+}
+interface TaskScheduleFeatureContextEndpoints {
+    scheduleDependencies?: string;
+    scheduleTimeline?: string;
+    scheduleBaselines?: string;
+    scheduleBaselineByVersion?: string;
     scheduleManagerBase?: string;
     scheduleViewById?: string;
     scheduleViewsByLevel?: string;
     scheduleSettingsByLevel?: string;
-    teamMembers?: string;
-    createTask?: string;
-    updateTask?: string;
-    deleteTask?: string;
-    updateBulkTasks?: string;
-    updateParent?: string;
-    updateOrder?: string;
-    updateProgress?: string;
     importTasks?: string;
     applyImportedTasks?: string;
     setBaseline?: string;
     exportTasks?: string;
-    [key: string]: string | undefined;
 }
+type TaskScheduleContextEndpoints = TaskScheduleCoreContextEndpoints & Partial<TaskScheduleFeatureContextEndpoints> & {
+    [key: string]: string | undefined;
+};
 interface TaskScheduleTask {
     id: number | string;
+    schemaId?: number | string | null;
     title: string;
     name?: string;
     startDate?: Date | string | null;
@@ -80,6 +88,7 @@ interface TaskScheduleTask {
     actualFinishDate?: Date | string | null;
     baselineStartDate?: Date | string | null;
     baselineEndDate?: Date | string | null;
+    baselineDuration?: number | null;
     duration?: number | null;
     progress?: number | null;
     predecessor?: string | null;
@@ -92,12 +101,15 @@ interface TaskScheduleTask {
     guid?: string | null;
     uniqueID?: string | null;
     parentGuid?: string | null;
+    parentId?: number | string | null;
     assignedTo?: string | number | Record<string, unknown> | null;
     resources?: Array<number | string | {
         resourceId: number | string;
-        unit?: number;
+        unit?: number | string;
+        resourceName?: string;
     }>;
     phaseGate?: string | null;
+    phaseGateId?: number | string | null;
     criticalPath?: boolean;
     order?: number;
     customProperties?: Array<Record<string, unknown>>;
@@ -134,15 +146,31 @@ interface TaskScheduleCustomProperty {
 }
 interface TaskScheduleTaskMutation {
     assignedTo?: number | string | null;
-    name: string;
+    name?: string;
     startDate?: string | Date | null;
     finishDate?: string | Date | null;
+    actualStart?: string | Date | null;
+    actualFinish?: string | Date | null;
+    baselineStart?: string | Date | null;
+    baselineFinish?: string | Date | null;
+    baselineProgress?: number | null;
     predecessor?: string | null;
+    predecessors?: TaskScheduleDependencyMutation[] | null;
     details?: string | null;
     type?: string | null;
     duration?: number | null;
     progress?: number | null;
+    status?: string | null;
     parentGuid?: string | null;
+    parentId?: number | string | null;
+    phaseGateId?: number | string | null;
+    resources?: TaskScheduleTask['resources'];
+    attachments?: unknown;
+    isSummary?: boolean | null;
+    externalId?: string | null;
+    externalParentId?: string | null;
+    order?: number | null;
+    weight?: number | null;
     props?: Array<Record<string, unknown>>;
     [key: string]: unknown;
 }
@@ -150,6 +178,67 @@ interface TaskScheduleTaskOrderUpdate {
     taskId: number | string;
     order: number;
 }
+type TaskScheduleDependencyType = 0 | 1 | 2 | 3 | 'FinishToStart' | 'StartToStart' | 'FinishToFinish' | 'StartToFinish';
+interface TaskScheduleDependencyMutation {
+    predecessorId: number | string;
+    type?: TaskScheduleDependencyType | null;
+    lagDays?: number | null;
+}
+interface TaskScheduleDependency extends TaskScheduleDependencyMutation {
+    id: number | string;
+    successorId: number | string;
+}
+type TaskScheduleTimelineMode = 'weekly' | 'monthly' | 'quarterly' | 'biannually' | 'annually';
+interface TaskScheduleTimelineBucket {
+    name: string;
+    number: number;
+    start: Date | string | null;
+    end: Date | string | null;
+    year?: number | null;
+    id: string;
+    seq?: number | null;
+}
+interface TaskScheduleBaselineVersion {
+    version: number;
+    createdAt: Date | string | null;
+    createdBy?: string | null;
+    itemCount?: number | null;
+}
+interface TaskScheduleBaselineSnapshotItem {
+    snapshotId?: number | string | null;
+    levelDataId?: number | string | null;
+    scheduleItemId?: number | string | null;
+    currentScheduleItemId?: number | string | null;
+    name?: string | null;
+    type?: string | null;
+    typeLable?: string | null;
+    status?: string | null;
+    externalId?: string | null;
+    externalParentId?: string | null;
+    guid?: string | null;
+    parentGuid?: string | null;
+    order?: number | null;
+    isSummary?: boolean;
+    assignedTo?: string | null;
+    resources?: Array<number | string | Record<string, unknown>>;
+    baselineStart?: Date | string | null;
+    baselineFinish?: Date | string | null;
+    baselineProgress?: number | null;
+    currentStart?: Date | string | null;
+    currentFinish?: Date | string | null;
+    currentProgress?: number | null;
+    currentStatus?: string | null;
+    currentAssignedTo?: string | null;
+    currentResources?: Array<number | string | Record<string, unknown>>;
+    existsInCurrentSchedule?: boolean;
+}
+interface TaskScheduleBaselineSnapshot {
+    levelDataId: number | string;
+    version: number;
+    createdAt: Date | string | null;
+    createdBy?: string | null;
+    items: TaskScheduleBaselineSnapshotItem[];
+}
 interface TaskScheduleImportResult {
     fileName?: string | null;
     tasks: TaskScheduleTask[];
@@ -171,8 +260,16 @@ interface TaskScheduleDataResult {
     projectStartDate?: Date | string | null;
     projectEndDate?: Date | string | null;
 }
-interface TaskScheduleDataAdapter {
+interface TaskScheduleFetchDataAdapter {
     load(modelType: TaskScheduleModelType, context: TaskScheduleContext): Observable<TaskScheduleDataResult>;
+    importTasks?(context: TaskScheduleContext, file: File): Observable<TaskScheduleImportResult>;
+    exportTasks?(context: TaskScheduleContext): Observable<Blob>;
+    loadDependencies?(context: TaskScheduleContext): Observable<TaskScheduleDependency[]>;
+    loadTimeline?(context: TaskScheduleContext, mode: TaskScheduleTimelineMode): Observable<TaskScheduleTimelineBucket[]>;
+    loadBaselineVersions?(context: TaskScheduleContext): Observable<TaskScheduleBaselineVersion[]>;
+    loadBaselineSnapshot?(context: TaskScheduleContext, version?: number | 'latest'): Observable<TaskScheduleBaselineSnapshot>;
+}
+interface TaskScheduleActionDataAdapter {
     createTask?(context: TaskScheduleContext, payload: TaskScheduleTaskMutation): Observable<unknown>;
     updateTask?(context: TaskScheduleContext, taskId: number | string, payload: TaskScheduleTaskMutation): Observable<unknown>;
     deleteTask?(context: TaskScheduleContext, taskId: number | string): Observable<unknown>;
@@ -180,10 +277,8 @@ interface TaskScheduleDataAdapter {
     updateParent?(context: TaskScheduleContext, taskId: number | string, parentId: number | string | null): Observable<unknown>;
     updateOrder?(context: TaskScheduleContext, payload: TaskScheduleTaskOrderUpdate[]): Observable<unknown>;
     updateProgress?(context: TaskScheduleContext, taskId: number | string, payload: TaskScheduleTaskMutation): Observable<unknown>;
-    importTasks?(context: TaskScheduleContext, file: File): Observable<TaskScheduleImportResult>;
     applyImportedTasks?(context: TaskScheduleContext, payload: TaskScheduleApplyImportPayload): Observable<unknown>;
     setBaseline?(context: TaskScheduleContext, payload?: Record<string, unknown>): Observable<unknown>;
-    exportTasks?(context: TaskScheduleContext): Observable<Blob>;
 }
 interface TaskScheduleGanttConfig {
     taskFields: Record<string, unknown>;
@@ -203,6 +298,7 @@ interface TaskScheduleGanttConfig {
     eventMarkers?: Array<Record<string, unknown>>;
     timelineSettings?: Record<string, unknown>;
     editSettings?: Record<string, unknown>;
+    allowRowDragAndDrop?: boolean;
     addDialogFields?: Array<Record<string, unknown>>;
     editDialogFields?: Array<Record<string, unknown>>;
     contextMenuItems?: Array<string | Record<string, unknown>>;
@@ -214,10 +310,12 @@ interface TaskScheduleGanttConfig {
     projectEndDate?: Date | string | null;
 }
 
-declare const EDIT_TASK_TYPE_IDS: readonly ["Milestone", "Task", "Deliverable"];
+type EditTaskTypeId = 'Milestone' | 'Task' | 'Deliverable';
 declare class TaskSchedule implements OnInit, OnDestroy {
     ganttObj?: GanttComponent;
-    private readonly adapter;
+    private readonly fetchService;
+    private readonly actionService;
+    private readonly modal;
     private readonly queueService;
     private readonly injector;
     private loadEffect?;
@@ -225,6 +323,7 @@ declare class TaskSchedule implements OnInit, OnDestroy {
     private loadSubscription?;
     private readonly operationSub;
     private readonly contextAddTask;
+    private readonly contextAddAnchorTask;
     private readonly customProperties;
     readonly context: _angular_core.InputSignal<TaskScheduleContext | null>;
     readonly toolbarAction: _angular_core.OutputEmitterRef<string>;
@@ -244,8 +343,9 @@ declare class TaskSchedule implements OnInit, OnDestroy {
     readonly resolvedLangCode: _angular_core.Signal<"en" | "ar">;
     readonly isEditMode: _angular_core.Signal<boolean>;
     readonly editTaskTypes: _angular_core.Signal<{
-        id: (typeof EDIT_TASK_TYPE_IDS)[number];
+        id: EditTaskTypeId;
         text: string;
+        moduleId: number | string;
     }[]>;
     readonly enableRtl: _angular_core.Signal<boolean>;
     readonly tooltipTranslations: _angular_core.Signal<{
@@ -267,159 +367,159 @@ declare class TaskSchedule implements OnInit, OnDestroy {
     onDataBound(): void;
     private loadSchedule;
     private applyEditCustomProps;
-    private configureDialogState;
-    private applyDependentFieldBehavior;
+    private openScheduleDialog;
     private handleRowDropped;
-    private createTask;
     private updateTask;
     private deleteTask;
     private pushBulkUpdate;
-    private buildMutationFromTask;
     private resolveParentGuidForContextAddTask;
-    private getCustomPropsValue;
+    private buildCreateDialogTask;
+    private clearContextAddState;
+    private isContextAddAction;
+    private readEditTaskFromArgs;
+    private readAnchorTaskFromArgs;
+    private isProgressOnlyTaskbarEdit;
     private getGeneralDialogFields;
     private reloadSchedule;
-    private normalizeTasks;
-    private extractCustomProps;
-    private readNamedValue;
-    private readType;
-    private readAssignedTo;
-    private readResources;
     private extractDateValue;
     private mapColumnEditType;
-    private getDialogFieldInstance;
-    private removeValidationRule;
-    private toggleAddAndEditButtons;
-    private toggleToolbarButton;
-    private normalizeDuration;
-    private safeProgress;
     private coerceDate;
     private toApiDate;
     private exportPdfWithRetry;
-    private resolvePdfExportFont;
-    private createEmbeddedPdfFont;
-    private isFitToWidthError;
-    private resetPdfModule;
-    private wait;
-    private getErrorMessage;
     private getExportFileName;
     private hexToRgb;
-    private localizeTaskType;
-    private readLegacyHolidays;
     formatDateValue(value: unknown): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskSchedule, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TaskSchedule, "mt-task-schedule", never, { "context": { "alias": "context"; "required": false; "isSignal": true; }; }, { "toolbarAction": "toolbarAction"; "actionBegin": "actionBegin"; "actionCompleted": "actionCompleted"; "loaded": "loaded"; "loadError": "loadError"; }, never, never, true, never>;
 }
 
-declare const TASK_SCHEDULE_DATA_ADAPTER: InjectionToken<TaskScheduleDataAdapter>;
-declare class TaskScheduleBackendAdapter implements TaskScheduleDataAdapter {
+declare class TaskScheduleFetchService implements TaskScheduleFetchDataAdapter {
     private readonly http;
     load(modelType: TaskScheduleModelType, context: TaskScheduleContext): Observable<TaskScheduleDataResult>;
-    private resolveReadPayload;
-    private loadScheduleQueryPayload;
-    private loadScheduleUtilityPayload;
-    private loadLegacyPhaseGatePayload;
-    private composeFetchPayload;
-    private resolveFetchRootRecords;
-    private toFetchSchemaMap;
-    private mapFetchRecords;
-    private mapFetchRecord;
-    private readFetchCustomProps;
-    private mapFetchCustomProperties;
-    private mergeFetchCustomProperties;
-    private readFetchCellRaw;
-    private readFetchCellValue;
-    private readFetchCellDisplay;
-    private readFetchOrder;
-    createTask(context: TaskScheduleContext, payload: TaskScheduleTaskMutation): Observable<unknown>;
-    updateTask(context: TaskScheduleContext, taskId: number | string, payload: TaskScheduleTaskMutation): Observable<unknown>;
-    deleteTask(context: TaskScheduleContext, taskId: number | string): Observable<unknown>;
-    updateBulkTasks(context: TaskScheduleContext, payload: TaskScheduleTaskMutation[]): Observable<unknown>;
-    updateParent(context: TaskScheduleContext, taskId: number | string, parentId: number | string | null): Observable<unknown>;
-    updateOrder(context: TaskScheduleContext, payload: TaskScheduleTaskOrderUpdate[]): Observable<unknown>;
-    updateProgress(context: TaskScheduleContext, taskId: number | string, payload: TaskScheduleTaskMutation): Observable<unknown>;
     importTasks(context: TaskScheduleContext, file: File): Observable<TaskScheduleImportResult>;
-    applyImportedTasks(context: TaskScheduleContext, payload: TaskScheduleApplyImportPayload): Observable<unknown>;
-    setBaseline(context: TaskScheduleContext, payload?: Record<string, unknown>): Observable<unknown>;
     exportTasks(context: TaskScheduleContext): Observable<Blob>;
-    private mapRuntimeMutationPayload;
-    private mapRuntimeBulkUpdatePayload;
-    private mapRuntimeOrderUpdatePayload;
-    private resolveRuntimeScheduleItemType;
-    private loadCustomColumns;
-    private resolveTreeRouteTemplate;
-    private buildTreeRouteParams;
-    private resolveTaskMutationEndpoint;
-    private resolveApplyImportedTasksEndpoint;
-    private resolveScheduleManagerEndpoint;
-    private resolveApiUrl;
-    private readHeaders;
-    private buildIdempotencyKey;
-    private unwrapResponse;
-    private extractTaskArray;
-    private normalizeTaskRows;
-    private flattenResourceGroups;
-    private attachGroupResource;
-    private mergeTaskResources;
-    private resolveResourceIdentity;
-    private mapRuntimeTask;
-    private applyModelTransformations;
+    loadDependencies(context: TaskScheduleContext): Observable<TaskScheduleDependency[]>;
+    loadTimeline(context: TaskScheduleContext, mode: TaskScheduleTimelineMode): Observable<TaskScheduleTimelineBucket[]>;
+    loadBaselineVersions(context: TaskScheduleContext): Observable<TaskScheduleBaselineVersion[]>;
+    loadBaselineSnapshot(context: TaskScheduleContext, version?: number | 'latest'): Observable<TaskScheduleBaselineSnapshot>;
+    private loadReadResult;
+    private loadBaselineResult;
+    private loadPhaseGateResult;
+    private readScheduleMode;
+    private mapQueryTasks;
+    private mapGroupedTasks;
+    private mapLooseTasks;
+    private mapTaskSource;
+    private mapCustomProperties;
+    private mapCustomValues;
+    private buildBaselineTasks;
+    private buildTree;
     private resolveResources;
-    private mapTeamMemberResources;
-    private extractObjectValue;
-    private extractObjectArray;
-    private extractCustomProperties;
-    private mapCustomProperty;
-    private normalizeLookupOptions;
-    private readLegacyHolidaysFromLocalStorage;
-    private extractArrayCandidate;
     private extractResources;
+    private mapTeamMemberResources;
+    private loadCustomColumns;
     private mapScheduleColumns;
     private normalizeCustomColumnKey;
     private readLocalizedName;
-    private extractTaskResources;
-    private extractAssignee;
-    private extractStatus;
-    private extractProgress;
-    private extractDate;
-    private backendError;
+    private readData;
+    private levelEndpoint;
+    private requireId;
     private readEndpoint;
+    private interpolateEndpointTemplate;
+    private extractTaskRows;
+    private extractArray;
+    private readObjectValue;
+    private readSourceValue;
+    private readNestedValue;
+    private readSourceRawValue;
+    private readObjectValueByKey;
+    private unwrapValue;
+    private unwrapRawValue;
+    private normalizeTaskType;
+    private localizeTaskType;
+    private normalizeResources;
+    private mergeResources;
+    private resolveAssignedTo;
+    private resolveResourceId;
+    private readResourceName;
+    private mapDependency;
+    private mapTimelineBucket;
+    private mapBaselineVersion;
+    private mapBaselineSnapshot;
+    private normalizeDependencyType;
+    private normalizeDuration;
+    private normalizeProgress;
+    private readNamedString;
+    private toDate;
+    private readLegacyHolidays;
     private readId;
-    private firstDefined;
     private toNullableString;
     private toNullableNumber;
     private toTaskId;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleBackendAdapter, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TaskScheduleBackendAdapter>;
+    private isObject;
+    private isEmptyIdentityValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleFetchService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TaskScheduleFetchService>;
 }
 
-declare class TaskScheduleQueueService {
-    private readonly basicOrderColumns;
-    private readonly currentOrderColumns;
-    private readonly refreshTasks;
-    readonly refreshTasks$: rxjs.Observable<void>;
-    refresh(): void;
-    reorderData(tasks: TaskScheduleTask[]): TaskScheduleTask[];
-    applyStoredColumnOrder(columns: Array<Record<string, unknown>>, modelType: TaskScheduleModelType, context: TaskScheduleContext): Array<Record<string, unknown>>;
-    reorderColumn(args: any, modelType: TaskScheduleModelType, context: TaskScheduleContext): void;
-    private mapColumnsToOrder;
-    private orderColumns;
-    private getStorageKey;
-    private getLegacyStorageKey;
-    private hasDuplicateOrders;
-    private safeParseOrder;
-    private getLocalStorageItem;
-    private setLocalStorageItem;
-    private removeLocalStorageItem;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleQueueService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TaskScheduleQueueService>;
+declare class TaskScheduleActionService implements TaskScheduleActionDataAdapter {
+    private readonly http;
+    buildTaskMutation(task: unknown, options?: {
+        taskType?: unknown;
+        parentGuid?: string | null;
+        customProperties?: TaskScheduleCustomProperty[];
+        generalFields?: string[];
+    }): TaskScheduleTaskMutation;
+    createTask(context: TaskScheduleContext, payload: TaskScheduleTaskMutation): Observable<unknown>;
+    updateTask(context: TaskScheduleContext, taskId: number | string, payload: TaskScheduleTaskMutation): Observable<unknown>;
+    deleteTask(context: TaskScheduleContext, taskId: number | string): Observable<unknown>;
+    updateBulkTasks(context: TaskScheduleContext, payload: TaskScheduleTaskMutation[]): Observable<unknown>;
+    updateParent(context: TaskScheduleContext, taskId: number | string, parentId: number | string | null): Observable<unknown>;
+    updateOrder(context: TaskScheduleContext, payload: TaskScheduleTaskOrderUpdate[]): Observable<unknown>;
+    updateProgress(context: TaskScheduleContext, taskId: number | string, payload: TaskScheduleTaskMutation): Observable<unknown>;
+    applyImportedTasks(context: TaskScheduleContext, payload: TaskScheduleApplyImportPayload): Observable<unknown>;
+    setBaseline(context: TaskScheduleContext, payload?: Record<string, unknown>): Observable<unknown>;
+    private submitTaskMutation;
+    private buildProcessSubmitRequest;
+    private buildProcessSubmitFields;
+    private mapBulkItem;
+    private pushField;
+    private pushOwnField;
+    private appendCustomProps;
+    private buildCustomPropFields;
+    private resolveResourcesField;
+    private assignIfDefined;
+    private buildCustomProps;
+    private resolveParentId;
+    private serializePredecessors;
+    private dependencyTypeToken;
+    private normalizeDependencyType;
+    private resolveModuleKey;
+    private resolveTypeScope;
+    private normalizeTaskType;
+    private normalizeResources;
+    private readData;
+    private levelEndpoint;
+    private readEndpoint;
+    private interpolateEndpointTemplate;
+    private requireId;
+    private requireProcessId;
+    private readId;
+    private toTaskId;
+    private toNullableString;
+    private toNullableNumber;
+    private toNullableBoolean;
+    private readNamedString;
+    private normalizeDuration;
+    private normalizeProgress;
+    private toApiDate;
+    private coerceDate;
+    private hasOwn;
+    private isObject;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleActionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TaskScheduleActionService>;
 }
 
-declare function createGanttConfig(modelType: TaskScheduleModelKey, data: TaskScheduleDataResult, dateFormat: string, langCode?: 'en' | 'ar'): TaskScheduleGanttConfig;
-
-type TaskScheduleLanguage = 'en' | 'ar';
-declare function resolveTaskScheduleLanguage(preferred?: unknown, contextLangCode?: unknown): TaskScheduleLanguage;
-
 interface ImportPreviewRow {
     key: string;
     task: TaskScheduleTask;
@@ -429,24 +529,29 @@ interface ResourceOption {
     id: string | number;
     label: string;
 }
-declare class TaskScheduleImportModal {
-    private readonly adapter;
-    readonly visible: _angular_core.InputSignal<boolean>;
+declare class TaskScheduleImportDialog {
+    readonly modal: ModalService;
+    private readonly ref;
+    private readonly fetchService;
+    private readonly actionService;
+    private readonly transloco;
+    private readonly selectionCellTpl;
+    private readonly taskCellTpl;
+    private readonly startDateCellTpl;
+    private readonly finishDateCellTpl;
+    private readonly actualStartDateCellTpl;
+    private readonly actualFinishDateCellTpl;
+    private readonly assignedToCellTpl;
+    private readonly progressCellTpl;
     readonly context: _angular_core.InputSignal<TaskScheduleContext | null>;
-    readonly title: _angular_core.InputSignal<string | null>;
     readonly maxRows: _angular_core.InputSignal<number>;
-    readonly closed: _angular_core.OutputEmitterRef<void>;
-    readonly imported: _angular_core.OutputEmitterRef<TaskScheduleImportResult>;
-    readonly applied: _angular_core.OutputEmitterRef<{
-        overrideCurrent: boolean;
-        response: unknown;
-    }>;
-    readonly failed: _angular_core.OutputEmitterRef<string>;
     readonly selectedFile: _angular_core.WritableSignal<File | null>;
     readonly loadingImport: _angular_core.WritableSignal<boolean>;
     readonly loadingApply: _angular_core.WritableSignal<boolean>;
     readonly importResult: _angular_core.WritableSignal<TaskScheduleImportResult | null>;
     readonly selectedTaskKeys: _angular_core.WritableSignal<Set<string>>;
+    readonly errorMessage: _angular_core.WritableSignal<string | null>;
+    private readonly activeLang;
     readonly resolvedLangCode: _angular_core.Signal<"en" | "ar">;
     readonly isRtl: _angular_core.Signal<boolean>;
     readonly labels: _angular_core.Signal<{
@@ -477,21 +582,21 @@ declare class TaskScheduleImportModal {
     readonly hasSelection: _angular_core.Signal<boolean>;
     readonly canImport: _angular_core.Signal<boolean>;
     readonly canApply: _angular_core.Signal<boolean>;
+    readonly previewPageSize: _angular_core.Signal<number>;
+    readonly previewColumns: _angular_core.WritableSignal<ColumnDef[]>;
     onFileChanged(event: Event): void;
     importFile(): void;
     toggleRowSelection(rowKey: string, checked: boolean): void;
     selectAllRows(checked: boolean): void;
     applyImport(overrideCurrent: boolean): void;
     close(): void;
-    trackByRow(_index: number, row: ImportPreviewRow): string;
-    formatDate(value: unknown): string;
-    toDateInputValue(value: unknown): string;
-    resolveAssignedValue(task: TaskScheduleTask): string;
+    toDateFieldValue(value: unknown): Date | null;
+    resolveAssignedValue(task: TaskScheduleTask): string | number | null;
     normalizeProgress(value: unknown): number;
     onTaskTitleChanged(rowKey: string, value: string): void;
-    onTaskDateChanged(rowKey: string, key: 'startDate' | 'finishDate' | 'actualStartDate' | 'actualFinishDate', value: string): void;
-    onTaskAssignedToChanged(rowKey: string, value: string): void;
-    onTaskProgressChanged(rowKey: string, value: string): void;
+    onTaskDateChanged(rowKey: string, key: 'startDate' | 'finishDate' | 'actualStartDate' | 'actualFinishDate', value: unknown): void;
+    onTaskAssignedToChanged(rowKey: string, value: unknown): void;
+    onTaskProgressChanged(rowKey: string, value: unknown): void;
     toAssignedEntity(task: TaskScheduleTask): EntityData;
     toProgressEntity(task: TaskScheduleTask): EntityData;
     private updateRowTask;
@@ -508,65 +613,56 @@ declare class TaskScheduleImportModal {
     private toApiDate;
     private formatDateForApi;
     private countTasks;
-    private getErrorMessage;
-    private emitError;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleImportModal, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TaskScheduleImportModal, "mt-task-schedule-import-modal", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "imported": "imported"; "applied": "applied"; "failed": "failed"; }, never, never, true, never>;
+    private setError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleImportDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TaskScheduleImportDialog, "mt-task-schedule-import-dialog", never, { "context": { "alias": "context"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class TaskScheduleShell {
-    private readonly adapter;
+declare class TaskScheduleHeader {
+    private readonly actionService;
     private readonly queueService;
+    private readonly transloco;
+    private readonly modal;
+    private readonly activeLang;
     readonly context: _angular_core.InputSignal<TaskScheduleContext | null>;
+    readonly title: _angular_core.InputSignal<string | null>;
+    readonly modeOptions: _angular_core.InputSignal<TaskScheduleModeOption[]>;
     readonly modeChanged: _angular_core.OutputEmitterRef<string>;
     readonly baselineSet: _angular_core.OutputEmitterRef<unknown>;
-    readonly tasksExported: _angular_core.OutputEmitterRef<void>;
     readonly actionError: _angular_core.OutputEmitterRef<string>;
     readonly currentModelType: _angular_core.WritableSignal<string>;
-    readonly showImportModal: _angular_core.WritableSignal<boolean>;
     readonly settingBaseline: _angular_core.WritableSignal<boolean>;
-    readonly exportingTasks: _angular_core.WritableSignal<boolean>;
-    readonly resolvedLangCode: _angular_core.Signal<"en" | "ar">;
     readonly resolvedContext: _angular_core.Signal<TaskScheduleContext | null>;
+    readonly currentModelKey: _angular_core.Signal<_masterteam_task_schedule.TaskScheduleModelKey>;
     readonly labels: _angular_core.Signal<{
-        mode: string;
-        setBaseline: string;
+        title: string;
         pending: string;
+        setBaseline: string;
         import: string;
-        export: string;
-        exportFileName: string;
-        baselineNotSupported: string;
-        exportNotSupported: string;
-        contextMissing: string;
-        baselineDisabled: string;
     }>;
-    readonly currentModelKey: _angular_core.Signal<_masterteam_task_schedule.TaskScheduleModelKey>;
     readonly resolvedModes: _angular_core.Signal<{
         value: string;
         label: string;
+        icon: string;
+        color: string;
     }[]>;
     readonly showSetBaselineAction: _angular_core.Signal<boolean>;
+    readonly baselinePending: _angular_core.Signal<boolean>;
     readonly canSetBaselineAction: _angular_core.Signal<boolean>;
     readonly showImportAction: _angular_core.Signal<boolean>;
     readonly canOpenImport: _angular_core.Signal<boolean>;
-    readonly canExportTasks: _angular_core.Signal<boolean>;
     constructor();
     onModeChange(nextValue: string): void;
-    openImportModal(): void;
-    closeImportModal(): void;
+    openImportDialog(): void;
     setBaseline(): void;
-    exportTasks(): void;
-    onImportedTasksApplied(): void;
-    onActionError(message: unknown): void;
-    private resolveModeLabel;
-    private downloadBlob;
     private getErrorMessage;
+    private translate;
     private emitError;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleShell, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TaskScheduleShell, "mt-task-schedule-shell", never, { "context": { "alias": "context"; "required": false; "isSignal": true; }; }, { "modeChanged": "modeChanged"; "baselineSet": "baselineSet"; "tasksExported": "tasksExported"; "actionError": "actionError"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TaskScheduleHeader, "mt-task-schedule-header", never, { "context": { "alias": "context"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "modeOptions": { "alias": "modeOptions"; "required": true; "isSignal": true; }; }, { "modeChanged": "modeChanged"; "baselineSet": "baselineSet"; "actionError": "actionError"; }, never, never, true, never>;
 }
 
 declare const TASK_SCHEDULE_DEFAULT_PDF_FONT: string;
 
-export { TASK_SCHEDULE_DATA_ADAPTER, TASK_SCHEDULE_DEFAULT_PDF_FONT, TaskSchedule, TaskScheduleBackendAdapter, TaskScheduleImportModal, TaskScheduleQueueService, TaskScheduleShell, createGanttConfig, normalizeTaskScheduleModelType, resolveTaskScheduleLanguage };
-export type { TaskScheduleApplyImportPayload, TaskScheduleContext, TaskScheduleContextEndpoints, TaskScheduleCustomProperty, TaskScheduleDataAdapter, TaskScheduleDataResult, TaskScheduleGanttConfig, TaskScheduleImportResult, TaskScheduleLanguage, TaskScheduleModeOption, TaskScheduleModelAlias, TaskScheduleModelKey, TaskScheduleModelType, TaskSchedulePdfFonts, TaskSchedulePropertyDependency, TaskSchedulePropertyViewType, TaskScheduleTask, TaskScheduleTaskMutation, TaskScheduleTaskOrderUpdate };
+export { TASK_SCHEDULE_DEFAULT_PDF_FONT, TaskSchedule, TaskScheduleActionService, TaskScheduleFetchService, TaskScheduleHeader, TaskScheduleImportDialog, normalizeTaskScheduleModelType };
+export type { TaskScheduleActionDataAdapter, TaskScheduleApplyImportPayload, TaskScheduleBaselineSnapshot, TaskScheduleBaselineSnapshotItem, TaskScheduleBaselineVersion, TaskScheduleContext, TaskScheduleContextEndpoints, TaskScheduleCoreContextEndpoints, TaskScheduleCustomProperty, TaskScheduleDataResult, TaskScheduleDependency, TaskScheduleDependencyMutation, TaskScheduleDependencyType, TaskScheduleFeatureContextEndpoints, TaskScheduleFetchDataAdapter, TaskScheduleGanttConfig, TaskScheduleImportResult, TaskScheduleModeOption, TaskScheduleModelAlias, TaskScheduleModelKey, TaskScheduleModelType, TaskSchedulePdfFonts, TaskSchedulePropertyDependency, TaskSchedulePropertyViewType, TaskScheduleTask, TaskScheduleTaskMutation, TaskScheduleTaskOrderUpdate, TaskScheduleTimelineBucket, TaskScheduleTimelineMode };