@masterteam/task-schedule 0.0.1

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@masterteam/task-schedule",
+  "version": "0.0.1",
+  "publishConfig": {
+    "directory": "../../../dist/masterteam/task-schedule",
+    "linkDirectory": false,
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": "^21.0.3",
+    "@angular/core": "^21.0.3",
+    "@angular/forms": "^21.0.3",
+    "@syncfusion/ej2-angular-gantt": "^32.2.7",
+    "@syncfusion/ej2-base": "^32.2.6",
+    "@syncfusion/ej2-pdf-export": "^32.2.3",
+    "rxjs": "^7.8.2",
+    "@primeuix/themes": "^2.0.2",
+    "@tailwindcss/postcss": "^4.1.17",
+    "postcss": "^8.5.6",
+    "primeng": "21.0.1",
+    "tailwindcss": "^4.1.17",
+    "tailwindcss-primeui": "^0.6.1",
+    "@masterteam/components": "^0.0.100",
+    "@masterteam/icons": "^0.0.13"
+  },
+  "sideEffects": false,
+  "exports": {
+    "./assets/task-schedule.css": {
+      "style": "./assets/task-schedule.css"
+    },
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/masterteam-task-schedule.d.ts",
+      "default": "./fesm2022/masterteam-task-schedule.mjs"
+    }
+  },
+  "module": "fesm2022/masterteam-task-schedule.mjs",
+  "typings": "types/masterteam-task-schedule.d.ts",
+  "dependencies": {
+    "tslib": "^2.8.1"
+  }
+}

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

@@ -0,0 +1,559 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, InjectionToken } 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 * as _masterteam_task_schedule from '@masterteam/task-schedule';
+
+type TaskScheduleModelKey = 'default' | 'edit' | 'baseline' | 'criticalPath' | 'resources' | 'unscheduled' | 'phaseGate' | 'custom';
+type TaskScheduleModelAlias = 'critical-path' | 'criticalpath' | 'critical path' | 'phase-gate' | 'phasegate' | 'phase gate' | 'resource' | 'resource-view' | 'resourceview' | 'unscheduled-task' | 'unscheduled task' | 'scheduling' | 'view' | 'defauilt' | 'custom-view';
+type TaskScheduleModelType = TaskScheduleModelKey | TaskScheduleModelAlias | string;
+declare function normalizeTaskScheduleModelType(modelType: TaskScheduleModelType): TaskScheduleModelKey;
+interface TaskScheduleContext {
+    levelId: number | string;
+    schemaId?: number | string;
+    levelDataId?: number | string;
+    customViewId?: number | string;
+    apiBaseUrl?: string;
+    scheduleViewKey?: string;
+    resources?: Array<Record<string, unknown>>;
+    endpoints?: TaskScheduleContextEndpoints;
+    pdfFonts?: TaskSchedulePdfFonts;
+    customProperties?: TaskScheduleCustomProperty[];
+    customColumns?: Array<Record<string, unknown>>;
+    requestHeaders?: Record<string, string>;
+    langCode?: 'en' | 'ar';
+    modelCacheKey?: string;
+    [key: string]: unknown;
+}
+interface TaskSchedulePdfFonts {
+    regular?: string;
+    arabic?: string;
+    size?: number;
+}
+interface TaskScheduleContextEndpoints {
+    scheduleTree?: string;
+    scheduleTreeDefault?: string;
+    scheduleTreeEdit?: string;
+    scheduleTreeBaseline?: string;
+    scheduleTreeCriticalPath?: string;
+    scheduleTreeResources?: string;
+    scheduleTreeUnscheduled?: string;
+    scheduleTreePhaseGate?: string;
+    scheduleTreeCustom?: 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;
+}
+interface TaskScheduleTask {
+    id: number | string;
+    title: string;
+    name?: string;
+    startDate?: Date | string | null;
+    finishDate?: Date | string | null;
+    actualStart?: Date | string | null;
+    actualFinish?: Date | string | null;
+    baselineStart?: Date | string | null;
+    baselineFinish?: Date | string | null;
+    actualStartDate?: Date | string | null;
+    actualFinishDate?: Date | string | null;
+    baselineStartDate?: Date | string | null;
+    baselineEndDate?: Date | string | null;
+    duration?: number | null;
+    progress?: number | null;
+    predecessor?: string | null;
+    predecessors?: string | null;
+    status?: string | null;
+    type?: string | null;
+    typeLable?: string | null;
+    typeLabel?: string | null;
+    details?: string | null;
+    guid?: string | null;
+    uniqueID?: string | null;
+    parentGuid?: string | null;
+    assignedTo?: string | number | Record<string, unknown> | null;
+    resources?: Array<number | string | {
+        resourceId: number | string;
+        unit?: number;
+    }>;
+    phaseGate?: string | null;
+    criticalPath?: boolean;
+    order?: number;
+    customProperties?: Array<Record<string, unknown>>;
+    props?: Array<Record<string, unknown>>;
+    attachments?: string | null;
+    isMilestone?: boolean;
+    isSelected?: boolean;
+    subtasks?: TaskScheduleTask[];
+    children?: TaskScheduleTask[];
+    [key: string]: unknown;
+}
+type TaskSchedulePropertyViewType = 'Text' | 'Date' | 'Lookup' | 'Status' | 'Number' | 'Percentage' | 'Currency' | string;
+interface TaskSchedulePropertyDependency {
+    property: string;
+    action: {
+        name: 'disable' | 'enable' | string;
+    };
+    value: unknown;
+}
+interface TaskScheduleCustomProperty {
+    id: number | string;
+    key: string;
+    name: string;
+    viewType: TaskSchedulePropertyViewType;
+    normalizedKey?: string;
+    isRequired?: boolean;
+    isCalculated?: boolean;
+    dependsOn?: TaskSchedulePropertyDependency[];
+    lookupOptions?: Array<{
+        value: unknown;
+        text: string;
+    }>;
+    configuration?: unknown;
+}
+interface TaskScheduleTaskMutation {
+    assignedTo?: number | string | null;
+    name: string;
+    startDate?: string | Date | null;
+    finishDate?: string | Date | null;
+    predecessor?: string | null;
+    details?: string | null;
+    type?: string | null;
+    duration?: number | null;
+    progress?: number | null;
+    parentGuid?: string | null;
+    props?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+interface TaskScheduleTaskOrderUpdate {
+    taskId: number | string;
+    order: number;
+}
+interface TaskScheduleImportResult {
+    fileName?: string | null;
+    tasks: TaskScheduleTask[];
+    raw?: unknown;
+}
+interface TaskScheduleApplyImportPayload {
+    overrideCurrent: boolean;
+    data: TaskScheduleTask[];
+}
+interface TaskScheduleDataResult {
+    tasks: TaskScheduleTask[];
+    resources?: Array<Record<string, unknown>>;
+    customColumns?: Array<Record<string, unknown>>;
+    customProperties?: TaskScheduleCustomProperty[];
+    holidays?: Array<Record<string, unknown>>;
+    eventMarkers?: Array<Record<string, unknown>>;
+    addDialogFields?: Array<Record<string, unknown>>;
+    editDialogFields?: Array<Record<string, unknown>>;
+    projectStartDate?: Date | string | null;
+    projectEndDate?: Date | string | null;
+}
+interface TaskScheduleDataAdapter {
+    load(modelType: TaskScheduleModelType, context: TaskScheduleContext): Observable<TaskScheduleDataResult>;
+    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>;
+}
+interface TaskScheduleGanttConfig {
+    taskFields: Record<string, unknown>;
+    columns: Array<Record<string, unknown>>;
+    labelSettings: Record<string, unknown>;
+    splitterSettings: Record<string, unknown>;
+    toolbar: Array<string | Record<string, unknown>>;
+    gridLines: 'Both' | 'Horizontal' | 'Vertical' | 'None';
+    workWeek: string[];
+    renderBaseline?: boolean;
+    enableCriticalPath?: boolean;
+    allowUnscheduledTasks?: boolean;
+    viewType?: 'ProjectView' | 'ResourceView';
+    resourceFields?: Record<string, unknown>;
+    resources?: Array<Record<string, unknown>>;
+    holidays?: Array<Record<string, unknown>>;
+    eventMarkers?: Array<Record<string, unknown>>;
+    timelineSettings?: Record<string, unknown>;
+    editSettings?: Record<string, unknown>;
+    addDialogFields?: Array<Record<string, unknown>>;
+    editDialogFields?: Array<Record<string, unknown>>;
+    contextMenuItems?: Array<string | Record<string, unknown>>;
+    enableContextMenu?: boolean;
+    showOverAllocation?: boolean;
+    allowExcelExport?: boolean;
+    allowPdfExport?: boolean;
+    projectStartDate?: Date | string | null;
+    projectEndDate?: Date | string | null;
+}
+
+declare const EDIT_TASK_TYPE_IDS: readonly ["Milestone", "Task", "Deliverable"];
+declare class TaskSchedule implements OnInit, OnDestroy {
+    ganttObj?: GanttComponent;
+    private readonly adapter;
+    private readonly queueService;
+    private readonly injector;
+    private loadEffect?;
+    private localeEffect?;
+    private loadSubscription?;
+    private readonly operationSub;
+    private readonly contextAddTask;
+    private readonly customProperties;
+    readonly modelType: _angular_core.InputSignal<string>;
+    readonly context: _angular_core.InputSignal<TaskScheduleContext | null>;
+    readonly dateFormat: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly langCode: _angular_core.InputSignal<"en" | "ar" | null>;
+    readonly pdfFontData: _angular_core.InputSignal<string | null>;
+    readonly pdfRtlFontData: _angular_core.InputSignal<string | null>;
+    readonly pdfFontSize: _angular_core.InputSignal<number>;
+    readonly toolbarAction: _angular_core.OutputEmitterRef<string>;
+    readonly actionBegin: _angular_core.OutputEmitterRef<any>;
+    readonly actionCompleted: _angular_core.OutputEmitterRef<any>;
+    readonly loaded: _angular_core.OutputEmitterRef<TaskScheduleDataResult>;
+    readonly loadError: _angular_core.OutputEmitterRef<string>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly locale: _angular_core.WritableSignal<"en-US" | "ar-AE">;
+    readonly dataSource: _angular_core.WritableSignal<TaskScheduleTask[]>;
+    readonly ganttConfig: _angular_core.WritableSignal<TaskScheduleGanttConfig>;
+    readonly ganttId: string;
+    readonly resolvedModelType: _angular_core.Signal<TaskScheduleModelKey>;
+    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];
+        text: string;
+    }[]>;
+    readonly enableRtl: _angular_core.Signal<boolean>;
+    readonly tooltipTranslations: _angular_core.Signal<{
+        startsOn: string;
+        endsOn: string;
+        progress: string;
+        plannedStart: string;
+        plannedEnd: string;
+    }>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onToolbarClick(args: any): Promise<void>;
+    onContextMenuOpen(args: ContextMenuOpenEventArgs): void;
+    onContextMenuClick(args?: ContextMenuClickEventArgs): void;
+    onActionBegin(args: any): void;
+    onActionComplete(args: any): void;
+    onCellEdit(args: any): void;
+    onQueryTaskbarInfo(args: any): void;
+    onDataBound(): void;
+    private loadSchedule;
+    private applyEditCustomProps;
+    private configureDialogState;
+    private applyDependentFieldBehavior;
+    private handleRowDropped;
+    private createTask;
+    private updateTask;
+    private deleteTask;
+    private pushBulkUpdate;
+    private buildMutationFromTask;
+    private resolveParentGuidForContextAddTask;
+    private getCustomPropsValue;
+    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, { "modelType": { "alias": "modelType"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "langCode": { "alias": "langCode"; "required": false; "isSignal": true; }; "pdfFontData": { "alias": "pdfFontData"; "required": false; "isSignal": true; }; "pdfRtlFontData": { "alias": "pdfRtlFontData"; "required": false; "isSignal": true; }; "pdfFontSize": { "alias": "pdfFontSize"; "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 {
+    private readonly http;
+    load(modelType: TaskScheduleModelType, context: TaskScheduleContext): Observable<TaskScheduleDataResult>;
+    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 loadCustomColumns;
+    private resolveTreeRouteTemplate;
+    private buildTreeRouteParams;
+    private resolveTaskMutationEndpoint;
+    private resolveApplyImportedTasksEndpoint;
+    private resolveScheduleManagerEndpoint;
+    private resolveApiUrl;
+    private readHeaders;
+    private buildIdempotencyKey;
+    private unwrapResponse;
+    private extractTaskArray;
+    private mapRuntimeTask;
+    private applyModelTransformations;
+    private resolveResources;
+    private mapTeamMemberResources;
+    private extractObjectValue;
+    private extractObjectArray;
+    private extractCustomProperties;
+    private mapCustomProperty;
+    private normalizeLookupOptions;
+    private readLegacyHolidaysFromLocalStorage;
+    private extractArrayCandidate;
+    private extractResources;
+    private mapScheduleColumns;
+    private normalizeCustomColumnKey;
+    private readLocalizedName;
+    private extractTaskResources;
+    private extractAssignee;
+    private extractStatus;
+    private extractProgress;
+    private extractDate;
+    private backendError;
+    private readEndpoint;
+    private readId;
+    private firstDefined;
+    private toNullableString;
+    private toNullableNumber;
+    private toTaskId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TaskScheduleBackendAdapter, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TaskScheduleBackendAdapter>;
+}
+
+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 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;
+    depth: number;
+}
+interface ResourceOption {
+    id: string | number;
+    label: string;
+}
+declare class TaskScheduleImportModal {
+    private readonly adapter;
+    readonly visible: _angular_core.InputSignal<boolean>;
+    readonly context: _angular_core.InputSignal<TaskScheduleContext | null>;
+    readonly langCode: _angular_core.InputSignal<"en" | "ar" | 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 resolvedLangCode: _angular_core.Signal<"en" | "ar">;
+    readonly isRtl: _angular_core.Signal<boolean>;
+    readonly labels: _angular_core.Signal<{
+        title: string;
+        selectFile: string;
+        startImport: string;
+        cancel: string;
+        replace: string;
+        append: string;
+        task: string;
+        startDate: string;
+        finishDate: string;
+        actualStartDate: string;
+        actualFinishDate: string;
+        assignedTo: string;
+        progress: string;
+        noTasks: string;
+        missingContext: string;
+        importNotSupported: string;
+        applyNotSupported: string;
+        chooseFileFirst: string;
+        rowsLimited: string;
+    }>;
+    readonly previewRows: _angular_core.Signal<ImportPreviewRow[]>;
+    readonly resourceOptions: _angular_core.Signal<ResourceOption[]>;
+    readonly isTruncated: _angular_core.Signal<boolean>;
+    readonly allSelected: _angular_core.Signal<boolean>;
+    readonly hasSelection: _angular_core.Signal<boolean>;
+    readonly canImport: _angular_core.Signal<boolean>;
+    readonly canApply: _angular_core.Signal<boolean>;
+    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;
+    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;
+    toAssignedEntity(task: TaskScheduleTask): EntityData;
+    toProgressEntity(task: TaskScheduleTask): EntityData;
+    private updateRowTask;
+    private findTaskByRowKey;
+    private readPathFromRowKey;
+    private markImportResultDirty;
+    private buildApplyPayloadData;
+    private resolveChildTasks;
+    private resolveTaskKey;
+    private collectTaskKeys;
+    private resolveAssignedTo;
+    private resolveContextResourceIdByName;
+    private readAssignedToLabel;
+    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; }; "langCode": { "alias": "langCode"; "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>;
+}
+
+interface TaskScheduleModeOption {
+    value: TaskScheduleModelType;
+    label?: string;
+}
+declare class TaskScheduleShell {
+    private readonly adapter;
+    private readonly queueService;
+    readonly context: _angular_core.InputSignal<TaskScheduleContext | null>;
+    readonly langCode: _angular_core.InputSignal<"en" | "ar" | null>;
+    readonly dateFormat: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly modelType: _angular_core.InputSignal<string>;
+    readonly modeOptions: _angular_core.InputSignal<TaskScheduleModeOption[] | null>;
+    readonly allowEditMode: _angular_core.InputSignal<boolean>;
+    readonly allowImport: _angular_core.InputSignal<boolean>;
+    readonly allowSetBaseline: _angular_core.InputSignal<boolean>;
+    readonly hasTasks: _angular_core.InputSignal<boolean>;
+    readonly baselinePending: _angular_core.InputSignal<boolean>;
+    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 labels: _angular_core.Signal<{
+        mode: string;
+        setBaseline: string;
+        pending: 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;
+    }[]>;
+    readonly showSetBaselineAction: _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;
+    setBaseline(): void;
+    exportTasks(): void;
+    onImportedTasksApplied(): void;
+    onActionError(message: unknown): void;
+    private resolveModeLabel;
+    private downloadBlob;
+    private getErrorMessage;
+    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; }; "langCode": { "alias": "langCode"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "modelType": { "alias": "modelType"; "required": false; "isSignal": true; }; "modeOptions": { "alias": "modeOptions"; "required": false; "isSignal": true; }; "allowEditMode": { "alias": "allowEditMode"; "required": false; "isSignal": true; }; "allowImport": { "alias": "allowImport"; "required": false; "isSignal": true; }; "allowSetBaseline": { "alias": "allowSetBaseline"; "required": false; "isSignal": true; }; "hasTasks": { "alias": "hasTasks"; "required": false; "isSignal": true; }; "baselinePending": { "alias": "baselinePending"; "required": false; "isSignal": true; }; }, { "modeChanged": "modeChanged"; "baselineSet": "baselineSet"; "tasksExported": "tasksExported"; "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 };