diff --git a/packages/devextreme/js/__internal/scheduler/__tests__/workspace.base.test.ts b/packages/devextreme/js/__internal/scheduler/__tests__/workspace.base.test.ts
index aa107fcc7977..04865c7268f1 100644
--- a/packages/devextreme/js/__internal/scheduler/__tests__/workspace.base.test.ts
+++ b/packages/devextreme/js/__internal/scheduler/__tests__/workspace.base.test.ts
@@ -4,13 +4,13 @@ import {
 import { logger } from '@ts/core/utils/m_console';
 
 import { getResourceManagerMock } from '../__mock__/resource_manager.mock';
-import SchedulerTimelineDay from '../workspaces/m_timeline_day';
-import SchedulerTimelineMonth from '../workspaces/m_timeline_month';
-import SchedulerTimelineWeek from '../workspaces/m_timeline_week';
 import type SchedulerWorkSpace from '../workspaces/m_work_space';
-import SchedulerWorkSpaceDay from '../workspaces/m_work_space_day';
-import SchedulerWorkSpaceMonth from '../workspaces/m_work_space_month';
-import SchedulerWorkSpaceWeek from '../workspaces/m_work_space_week';
+import SchedulerTimelineDay from '../workspaces/timeline_day';
+import SchedulerTimelineMonth from '../workspaces/timeline_month';
+import SchedulerTimelineWeek from '../workspaces/timeline_week';
+import SchedulerWorkSpaceDay from '../workspaces/work_space_day';
+import SchedulerWorkSpaceMonth from '../workspaces/work_space_month';
+import SchedulerWorkSpaceWeek from '../workspaces/work_space_week';
 import { setupSchedulerTestEnvironment } from './__mock__/m_mock_scheduler';
 
 jest.mock('@ts/core/m_devices', () => {
diff --git a/packages/devextreme/js/__internal/scheduler/m_scheduler.ts b/packages/devextreme/js/__internal/scheduler/m_scheduler.ts
index 985099ed3a92..2c8eafe77a85 100644
--- a/packages/devextreme/js/__internal/scheduler/m_scheduler.ts
+++ b/packages/devextreme/js/__internal/scheduler/m_scheduler.ts
@@ -33,6 +33,7 @@ import type {
 } from '@js/ui/scheduler';
 import errors from '@js/ui/widget/ui.errors';
 import { dateUtilsTs } from '@ts/core/utils/date';
+import type { OptionChanged } from '@ts/core/widget/types';
 
 import { createA11yStatusContainer } from './a11y_status/a11y_status_render';
 import { getA11yStatusText } from './a11y_status/a11y_status_text';
@@ -79,19 +80,19 @@ import type { IFieldExpr } from './utils/index';
 import { macroTaskArray } from './utils/index';
 import { isAgendaWorkspaceComponent } from './utils/is_agenda_workpace_component';
 import { VIEWS } from './utils/options/constants_view';
-import type { NormalizedView } from './utils/options/types';
+import type { NormalizedView, SafeSchedulerOptions } from './utils/options/types';
 import { getAppointmentGroupValues, setAppointmentGroupValues } from './utils/resource_manager/appointment_groups_utils';
 import { ResourceManager } from './utils/resource_manager/resource_manager';
 import AppointmentLayoutManager from './view_model/appointments_layout_manager';
 import { AppointmentDataSource } from './view_model/m_appointment_data_source';
 import type { AppointmentViewModelPlain } from './view_model/types';
-import SchedulerAgenda from './workspaces/m_agenda';
-import SchedulerTimelineDay from './workspaces/m_timeline_day';
-import SchedulerTimelineMonth from './workspaces/m_timeline_month';
-import SchedulerTimelineWeek from './workspaces/m_timeline_week';
-import SchedulerWorkSpaceDay from './workspaces/m_work_space_day';
-import SchedulerWorkSpaceMonth from './workspaces/m_work_space_month';
-import SchedulerWorkSpaceWeek from './workspaces/m_work_space_week';
+import SchedulerAgenda from './workspaces/agenda';
+import SchedulerTimelineDay from './workspaces/timeline_day';
+import SchedulerTimelineMonth from './workspaces/timeline_month';
+import SchedulerTimelineWeek from './workspaces/timeline_week';
+import SchedulerWorkSpaceDay from './workspaces/work_space_day';
+import SchedulerWorkSpaceMonth from './workspaces/work_space_month';
+import SchedulerWorkSpaceWeek from './workspaces/work_space_week';
 
 const toMs = dateUtils.dateToMilliseconds;
 
@@ -266,7 +267,7 @@ class Scheduler extends SchedulerOptionsBaseWidget {
     return resolveCallbacks.promise();
   }
 
-  _optionChanged(args) {
+  _optionChanged(args: OptionChanged<SafeSchedulerOptions>): void {
     this.schedulerOptionChanged(args);
 
     const { value, name } = args;
diff --git a/packages/devextreme/js/__internal/scheduler/m_table_creator.ts b/packages/devextreme/js/__internal/scheduler/m_table_creator.ts
index 766e45e5bee2..d38fdba2f3f1 100644
--- a/packages/devextreme/js/__internal/scheduler/m_table_creator.ts
+++ b/packages/devextreme/js/__internal/scheduler/m_table_creator.ts
@@ -1,13 +1,29 @@
+import type { Orientation } from '@js/common';
 import domAdapter from '@js/core/dom_adapter';
 import { getPublicElement } from '@js/core/element';
 import { data as elementData } from '@js/core/element_data';
+import type { dxElementWrapper } from '@js/core/renderer';
 import $ from '@js/core/renderer';
+import type { TemplateBase } from '@js/core/templates/template_base';
 import { isFunction } from '@js/core/utils/type';
 
+import type { ResourceLoader } from './utils/loader/resource_loader';
 import type { GroupNode } from './utils/resource_manager/types';
 
 const ROW_SELECTOR = 'tr';
 
+export interface GroupCssClasses {
+  groupHeaderRowClass?: string;
+  groupRowClass?: string;
+  groupHeaderClass: string | ((index: number) => string);
+  groupHeaderContentClass?: string;
+}
+
+export interface GroupRows {
+  elements: dxElementWrapper | dxElementWrapper[];
+  cellTemplates: (() => dxElementWrapper)[];
+}
+
 class SchedulerTableCreator {
   readonly VERTICAL = 'vertical';
 
@@ -129,16 +145,20 @@ class SchedulerTableCreator {
     return templateCallbacks;
   }
 
-  makeGroupedTable(type, groups, cssClasses, cellCount, cellTemplate, rowCount, groupByDate) {
-    let rows: any = [];
-
+  makeGroupedTable(
+    type: Orientation,
+    groups: ResourceLoader[],
+    cssClasses: GroupCssClasses,
+    cellCount: number,
+    cellTemplate: TemplateBase | null | undefined,
+    rowCount: number,
+    groupByDate: boolean,
+  ): GroupRows {
     if (type === this.VERTICAL) {
-      rows = this.makeVerticalGroupedRows(groups, cssClasses, cellTemplate, rowCount);
-    } else {
-      rows = this.makeHorizontalGroupedRows(groups, cssClasses, cellCount, cellTemplate, groupByDate);
+      return this.makeVerticalGroupedRows(groups, cssClasses, cellTemplate, rowCount);
     }
 
-    return rows;
+    return this.makeHorizontalGroupedRows(groups, cssClasses, cellCount, cellTemplate, groupByDate);
   }
 
   makeGroupedTableFromJSON(tree: GroupNode[], config?) {
diff --git a/packages/devextreme/js/__internal/scheduler/utils/options/types.ts b/packages/devextreme/js/__internal/scheduler/utils/options/types.ts
index 9fe83fedd2b9..c526fe3868bc 100644
--- a/packages/devextreme/js/__internal/scheduler/utils/options/types.ts
+++ b/packages/devextreme/js/__internal/scheduler/utils/options/types.ts
@@ -30,6 +30,7 @@ export interface SchedulerInternalOptions {
   disabledExpr: string;
   visibleExpr: string;
   allowMultipleCellSelection: boolean;
+  skippedDays?: number[];
 }
 
 export interface SchedulerOptionsRule {
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_agenda.ts b/packages/devextreme/js/__internal/scheduler/workspaces/agenda.ts
similarity index 61%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_agenda.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/agenda.ts
index 6fbc5e2ada1d..777d5b59a30a 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_agenda.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/agenda.ts
@@ -2,14 +2,17 @@ import dateLocalization from '@js/common/core/localization/date';
 import registerComponent from '@js/core/component_registrator';
 import domAdapter from '@js/core/dom_adapter';
 import { getPublicElement } from '@js/core/element';
-import $ from '@js/core/renderer';
+import $, { type dxElementWrapper } from '@js/core/renderer';
+import type { TemplateBase } from '@js/core/templates/template_base';
 import { noop } from '@js/core/utils/common';
 import dateUtils from '@js/core/utils/date';
 import { extend } from '@js/core/utils/extend';
 import { each } from '@js/core/utils/iterator';
 import { setHeight, setOuterHeight } from '@js/core/utils/size';
+import type { OptionChanged } from '@ts/core/widget/types';
 import { EMPTY_ACTIVE_STATE_UNIT } from '@ts/core/widget/widget';
 
+import type { Rect } from '../appointments/resizing/types';
 import {
   DATE_TABLE_CLASS,
   DATE_TABLE_ROW_CLASS,
@@ -17,13 +20,14 @@ import {
   GROUP_ROW_CLASS,
   TIME_PANEL_CLASS,
 } from '../m_classes';
-import tableCreatorModule from '../m_table_creator';
+import tableCreatorModule, { type GroupRows } from '../m_table_creator';
 import { agendaUtils, formatWeekday, getVerticalGroupCountClass } from '../r1/utils/index';
+import type { ResourceId } from '../utils/loader/types';
 import { VIEWS } from '../utils/options/constants_view';
 import { reduceResourcesTree } from '../utils/resource_manager/agenda_group_utils';
 import type { GroupNode } from '../utils/resource_manager/types';
 import type { ListEntity } from '../view_model/types';
-import WorkSpace from './m_work_space';
+import WorkSpace, { type WorkspaceOptionsInternal } from './m_work_space';
 
 const { tableCreator } = tableCreatorModule;
 
@@ -40,40 +44,48 @@ const LAST_ROW_CLASS = 'dx-scheduler-date-table-last-row';
 const INNER_CELL_MARGIN = 5;
 const OUTER_CELL_MARGIN = 20;
 
+interface AgendaRenderOptions {
+  container: Element;
+  rowCount?: number;
+  cellCount?: number;
+  rowClass?: string;
+  cellClass?: string;
+  cellTemplate?: TemplateBase | null;
+  getStartDate?: (rowIndex: number) => Date;
+}
+
 class SchedulerAgenda extends WorkSpace {
-  private startViewDate: any;
+  private startViewDate!: Date;
 
   private rows: number[][] = [];
 
-  private $rows: any;
+  private $rows: dxElementWrapper[] = [];
 
-  private $noDataContainer: any;
+  private $noDataContainer?: dxElementWrapper;
 
-  // eslint-disable-next-line class-methods-use-this
   protected _activeStateUnit(): string {
     return EMPTY_ACTIVE_STATE_UNIT;
   }
 
-  get type() { return VIEWS.AGENDA; }
+  get type(): string { return VIEWS.AGENDA; }
 
-  getStartViewDate() {
+  getStartViewDate(): Date {
     return this.startViewDate;
   }
 
-  _init() {
+  _init(): void {
     super._init();
   }
 
-  _getDefaultOptions() {
+  _getDefaultOptions(): WorkspaceOptionsInternal {
     return extend(super._getDefaultOptions(), {
-      // Number | "month"
       agendaDuration: 7,
       rowHeight: 60,
       noDataText: '',
-    });
+    }) as WorkspaceOptionsInternal;
   }
 
-  _optionChanged(args) {
+  _optionChanged(args: OptionChanged<WorkspaceOptionsInternal>): void {
     const { name } = args;
     const { value } = args;
 
@@ -85,7 +97,7 @@ class SchedulerAgenda extends WorkSpace {
         this.recalculateAgenda(this.rows);
         break;
       case 'groups':
-        if (!value?.length) {
+        if (!Array.isArray(value) || !value.length) {
           if (this.$groupTable) {
             this.$groupTable.remove();
             this.$groupTable = null;
@@ -93,7 +105,9 @@ class SchedulerAgenda extends WorkSpace {
           }
         } else if (!this.$groupTable) {
           this.initGroupTable();
-          this.$dateTableScrollable.$content().prepend(this.$groupTable);
+          if (this.$groupTable) {
+            this.$dateTableScrollable.$content().prepend(this.$groupTable);
+          }
         }
         super._optionChanged(args);
         break;
@@ -102,41 +116,41 @@ class SchedulerAgenda extends WorkSpace {
     }
   }
 
-  _renderFocusState() { return noop(); }
+  _renderFocusState(): void { return noop(); }
 
-  _renderFocusTarget() { return noop(); }
+  _renderFocusTarget(): void { return noop(); }
 
-  _cleanFocusState() { return noop(); }
+  _cleanFocusState(): void { return noop(); }
 
-  supportAllDayRow() {
+  supportAllDayRow(): boolean {
     return false;
   }
 
-  protected override isVerticalGroupedWorkSpace() {
+  protected override isVerticalGroupedWorkSpace(): boolean {
     return false;
   }
 
-  protected override getElementClass() {
+  protected override getElementClass(): string {
     return AGENDA_CLASS;
   }
 
-  protected override getRowCount() {
-    return this.option('agendaDuration') as number;
+  protected override getRowCount(): number {
+    return this.option('agendaDuration');
   }
 
-  getCellCount() {
+  getCellCount(): number {
     return 1;
   }
 
-  protected override getTimePanelRowCount() {
-    return this.option('agendaDuration') as number;
+  protected override getTimePanelRowCount(): number {
+    return this.option('agendaDuration');
   }
 
-  protected renderAllDayPanel() { return noop(); }
+  protected renderAllDayPanel(): void { return noop(); }
 
-  protected override updateAllDayVisibility() { return noop(); }
+  protected override updateAllDayVisibility(): void { return noop(); }
 
-  protected override initWorkSpaceUnits() {
+  protected override initWorkSpaceUnits(): void {
     this.initGroupTable();
     this.$timePanel = $('<table>').attr('aria-hidden', true).addClass(TIME_PANEL_CLASS);
     this.$dateTable = $('<table>').attr('aria-hidden', true).addClass(DATE_TABLE_CLASS);
@@ -144,14 +158,14 @@ class SchedulerAgenda extends WorkSpace {
     this.$dateTableContainer = $('<div>').addClass('dx-scheduler-date-table-container');
   }
 
-  private initGroupTable() {
+  private initGroupTable(): void {
     const groups = this.option('groups');
     if (groups?.length) {
       this.$groupTable = $('<table>').attr('aria-hidden', true).addClass(GROUP_TABLE_CLASS);
     }
   }
 
-  protected override renderView() {
+  protected override renderView(): void {
     this.startViewDate = agendaUtils.calculateStartViewDate(
       this.option('currentDate'),
       this.option('startDayHour'),
@@ -159,8 +173,8 @@ class SchedulerAgenda extends WorkSpace {
     this.rows = [];
   }
 
-  private recalculateAgenda(rows) {
-    let cellTemplates = [];
+  private recalculateAgenda(rows: number[][]): void {
+    let cellTemplates: (() => dxElementWrapper)[] = [];
     this.cleanView();
 
     if (this.rowsIsEmpty(rows)) {
@@ -180,21 +194,22 @@ class SchedulerAgenda extends WorkSpace {
     this.$dateTableScrollable.update();
   }
 
-  private renderNoData() {
+  private renderNoData(): void {
     this.$noDataContainer = $('<div>').addClass(NODATA_CONTAINER_CLASS)
-      .html(this.option('noDataText') as any);
+      .html(this.option('noDataText'));
 
     this.$dateTableScrollable.$content().append(this.$noDataContainer);
   }
 
-  protected override setTableSizes() { return noop(); }
+  protected override setTableSizes(): void { return noop(); }
 
-  protected override toggleHorizontalScrollClass() { return noop(); }
+  protected override toggleHorizontalScrollClass(): void { return noop(); }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected override createCrossScrollingConfig(argument?: any) { return noop(); }
+  protected override needCreateCrossScrolling(): boolean {
+    return false;
+  }
 
-  private setGroupHeaderCellsHeight() {
+  private setGroupHeaderCellsHeight(): void {
     const $cells = this.getGroupHeaderCells().filter((_, element) => !element.getAttribute('rowSpan'));
     const rows = this.removeEmptyRows(this.rows);
 
@@ -202,72 +217,56 @@ class SchedulerAgenda extends WorkSpace {
       return;
     }
 
-    for (let i = 0; i < $cells.length; i++) {
+    for (let i = 0; i < $cells.length; i += 1) {
       const $cellContent = $cells.eq(i).find('.dx-scheduler-group-header-content');
       setOuterHeight($cellContent, this.getGroupRowHeight(rows[i]));
     }
   }
 
-  private rowsIsEmpty(rows) {
-    let result = true;
-
-    for (let i = 0; i < rows.length; i++) {
-      const groupRow = rows[i];
-
-      for (let j = 0; j < groupRow.length; j++) {
-        if (groupRow[j]) {
-          result = false;
-          break;
-        }
-      }
-    }
-
-    return result;
+  private rowsIsEmpty(rows: number[][]): boolean {
+    return rows.every((groupRow) => groupRow.every((cell) => !cell));
   }
 
-  protected override attachGroupCountClass() {
+  protected override attachGroupCountClass(): void {
     const className = getVerticalGroupCountClass(this.option('groups'));
-    (this.$element() as any).addClass(className);
-  }
-
-  private removeEmptyRows(rows) {
-    const result: any[] = [];
-    const isEmpty = function (data) {
-      return !data.some((value) => value > 0);
-    };
-
-    for (let i = 0; i < rows.length; i++) {
-      if (rows[i].length && !isEmpty(rows[i])) {
-        result.push(rows[i]);
-      }
+    if (className) {
+      this.$element().addClass(className);
     }
+  }
 
-    return result;
+  private removeEmptyRows(rows: number[][]): number[][] {
+    const isEmpty = (data: number[]): boolean => !data.some((value) => value > 0);
+    return rows.filter((row) => row.length && !isEmpty(row));
   }
 
-  protected override getGroupHeaderContainer() {
+  protected override getGroupHeaderContainer(): dxElementWrapper | null | undefined {
     return this.$groupTable;
   }
 
-  protected override makeGroupRows() {
+  protected override makeGroupRows(): GroupRows {
     const resourceManager = this.option('getResourceManager')();
-    const allAppointments = (this.option('getFilteredItems') as any)() as ListEntity[];
+    const allAppointments = (this.option('getFilteredItems') as () => ListEntity[])();
     const tree = reduceResourcesTree(
       resourceManager.resourceById,
       resourceManager.groupsTree,
       allAppointments,
     );
 
-    const cellTemplate: any = this.option('resourceCellTemplate');
+    const cellTemplate = this.option('resourceCellTemplate');
     const getGroupHeaderContentClass = GROUP_HEADER_CONTENT_CLASS;
-    const cellTemplates: any[] = [];
+    const cellTemplates: (() => dxElementWrapper)[] = [];
 
     const table = tableCreator.makeGroupedTableFromJSON(tree, {
       cellTag: 'th',
       groupTableClass: GROUP_TABLE_CLASS,
       groupRowClass: GROUP_ROW_CLASS,
       groupCellClass: this.getGroupHeaderClass(),
-      groupCellCustomContent(cell: HTMLDivElement, cellTextElement: HTMLElement, index: number, node: GroupNode) {
+      groupCellCustomContent(
+        cell: HTMLDivElement,
+        cellTextElement: HTMLElement,
+        index: number,
+        node: GroupNode,
+      ) {
         const container = domAdapter.createElement('div');
         container.className = getGroupHeaderContentClass;
         const value = node.grouped[node.resourceIndex];
@@ -305,7 +304,7 @@ class SchedulerAgenda extends WorkSpace {
     };
   }
 
-  protected override cleanView() {
+  protected override cleanView(): void {
     this.$dateTable.empty();
     this.$timePanel.empty();
 
@@ -321,11 +320,11 @@ class SchedulerAgenda extends WorkSpace {
     }
   }
 
-  protected override createWorkSpaceElements() {
+  protected override createWorkSpaceElements(): void {
     this.createWorkSpaceStaticElements();
   }
 
-  protected override createWorkSpaceStaticElements() {
+  protected override createWorkSpaceStaticElements(): void {
     this.$dateTableContainer.append(this.$dateTable);
     this.$dateTableScrollable.$content().append(this.$dateTableScrollableContent);
 
@@ -337,7 +336,7 @@ class SchedulerAgenda extends WorkSpace {
     this.$element().append(this.$dateTableScrollable.$element());
   }
 
-  protected renderDateTable() {
+  protected renderDateTable(): void {
     this.renderTableBody({
       container: getPublicElement(this.$dateTable),
       rowClass: DATE_TABLE_ROW_CLASS,
@@ -345,15 +344,29 @@ class SchedulerAgenda extends WorkSpace {
     });
   }
 
-  protected override attachTablesEvents() { return noop(); }
+  protected override attachTablesEvents(): void { return noop(); }
 
-  protected override attachEvents() { return noop(); }
+  protected override attachEvents(): void { return noop(); }
 
-  isIndicationAvailable() {
+  isIndicationAvailable(): boolean {
     return false;
   }
 
-  private prepareCellTemplateOptions(text, date, rowIndex, $cell) {
+  private prepareCellTemplateOptions(
+    text: string,
+    date: Date | undefined,
+    rowIndex: number,
+    $cell: dxElementWrapper,
+  ): {
+    model: {
+      text: string;
+      date: Date | undefined;
+      groups: Record<string, ResourceId>;
+      groupIndex: number | undefined;
+    };
+    container: Element;
+    index: number;
+  } {
     const leaf = this.resourceManager.groupsLeafs[rowIndex];
     const groups = leaf?.grouped ?? {};
     const groupIndex = leaf?.groupIndex;
@@ -370,31 +383,38 @@ class SchedulerAgenda extends WorkSpace {
     };
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected renderTableBody(options: any, delayCellTemplateRendering?: any) {
-    const cellTemplates: any[] = [];
+  protected renderTableBody(
+    options: AgendaRenderOptions,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    delayCellTemplateRendering?: boolean,
+  ): void {
+    const cellTemplates: (() => dxElementWrapper)[] = [];
     const cellTemplateOpt = options.cellTemplate;
 
     this.$rows = [];
-    let i;
+    let i = 0;
 
-    const fillTableBody = function (rowIndex, rowSize) {
+    const fillTableBody = (rowIndex: number, rowSize: number): void => {
       if (rowSize) {
-        let date;
-        let cellDateNumber;
-        let cellDayName;
+        const date = options.getStartDate?.(rowIndex);
+        let cellDateNumber = '';
+        let cellDayName = '';
         const $row = $('<tr>');
         const $td = $('<td>');
         setHeight($td, this.getRowHeight(rowSize));
 
-        if (options.getStartDate) {
-          date = options.getStartDate?.(rowIndex);
-          cellDateNumber = dateLocalization.format(date, 'd');
-          cellDayName = dateLocalization.format(date, formatWeekday);
+        if (date) {
+          cellDateNumber = String(dateLocalization.format(date, 'd'));
+          cellDayName = String(dateLocalization.format(date, formatWeekday));
         }
 
         if (cellTemplateOpt?.render) {
-          const templateOptions = this.prepareCellTemplateOptions(`${cellDateNumber} ${cellDayName}`, date, i, $td);
+          const templateOptions = this.prepareCellTemplateOptions(
+            `${cellDateNumber} ${cellDayName}`,
+            date,
+            i,
+            $td,
+          );
 
           cellTemplates.push(cellTemplateOpt.render.bind(cellTemplateOpt, templateOptions));
         } else if (cellDateNumber && cellDayName) {
@@ -412,9 +432,9 @@ class SchedulerAgenda extends WorkSpace {
         $row.append($td);
         this.$rows.push($row);
       }
-    }.bind(this);
+    };
 
-    for (i = 0; i < this.rows.length; i++) {
+    for (i = 0; i < this.rows.length; i += 1) {
       each(this.rows[i], fillTableBody);
       this.setLastRowClass();
     }
@@ -423,7 +443,7 @@ class SchedulerAgenda extends WorkSpace {
     this.applyCellTemplates(cellTemplates);
   }
 
-  private setLastRowClass() {
+  private setLastRowClass(): void {
     if (this.rows.length > 1 && this.$rows.length) {
       const $lastRow = this.$rows[this.$rows.length - 1];
 
@@ -431,7 +451,7 @@ class SchedulerAgenda extends WorkSpace {
     }
   }
 
-  protected renderTimePanel() {
+  protected renderTimePanel(): void {
     this.renderTableBody({
       container: getPublicElement(this.$timePanel),
       rowCount: this.getTimePanelRowCount(),
@@ -443,32 +463,26 @@ class SchedulerAgenda extends WorkSpace {
     });
   }
 
-  private getTimePanelStartDate(rowIndex) {
+  private getTimePanelStartDate(rowIndex: number): Date {
     return agendaUtils.getDateByIndex(
       this.getStartViewDate(),
       rowIndex,
     );
   }
 
-  private getRowHeight(rowSize) {
-    const baseHeight = this.option('rowHeight') as any;
+  private getRowHeight(rowSize: number): number {
+    const baseHeight = this.option('rowHeight');
     const innerOffset = (rowSize - 1) * INNER_CELL_MARGIN;
 
     return rowSize ? (baseHeight * rowSize) + innerOffset + OUTER_CELL_MARGIN : 0;
   }
 
-  private getGroupRowHeight(groupRows) {
+  private getGroupRowHeight(groupRows: number[] | undefined): number {
     if (!groupRows) {
-      return;
-    }
-
-    let result = 0;
-
-    for (let i = 0; i < groupRows.length; i++) {
-      result += this.getRowHeight(groupRows[i]);
+      return 0;
     }
 
-    return result;
+    return groupRows.reduce((result, groupRow) => result + this.getRowHeight(groupRow), 0);
   }
 
   renderAgendaLayout(appointments: ListEntity[]): void {
@@ -476,43 +490,41 @@ class SchedulerAgenda extends WorkSpace {
 
     const rows = agendaUtils.calculateRows(
       appointments,
-      this.option('agendaDuration') as number,
+      this.option('agendaDuration'),
       this.getStartViewDate(),
       this.resourceManager.groupCount(),
     );
     this.recalculateAgenda(rows);
   }
 
-  getAgendaVerticalStepHeight() {
+  getAgendaVerticalStepHeight(): number {
     return this.option('rowHeight');
   }
 
-  getEndViewDate() {
+  getEndViewDate(): Date {
     return agendaUtils.calculateEndViewDate(
       this.getStartViewDate(),
-      this.option('endDayHour') as any,
-      this.option('agendaDuration') as any,
+      this.option('endDayHour'),
+      this.option('agendaDuration'),
     );
   }
 
-  getEndViewDateByEndDayHour() {
+  getEndViewDateByEndDayHour(): Date {
     return this.getEndViewDate();
   }
 
-  updateScrollPosition(date) {
+  updateScrollPosition(date: Date): void {
     const newDate = this.timeZoneCalculator.createDate(date, 'toGrid');
 
-    const bounds = this.getVisibleBounds();
-    const startDateHour = newDate.getHours();
-    const startDateMinutes = newDate.getMinutes();
-
-    if (this.needUpdateScrollPosition(startDateHour, startDateMinutes, bounds, newDate)) {
+    if (this.needUpdateScrollPosition(newDate)) {
       this.scrollTo(newDate);
     }
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  needUpdateScrollPosition(hours, minutes, bounds, newData?: any) {
+  override needUpdateScrollPosition(date: Date): boolean {
+    const bounds = this.getVisibleBounds();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
     let isUpdateNeeded = false;
 
     if (hours < bounds.top.hours || hours > bounds.bottom.hours) {
@@ -523,29 +535,37 @@ class SchedulerAgenda extends WorkSpace {
       isUpdateNeeded = true;
     }
 
-    if (hours === bounds.bottom.hours && minutes > bounds.top.minutes) {
+    if (hours === bounds.bottom.hours && minutes > bounds.bottom.minutes) {
       isUpdateNeeded = true;
     }
 
     return isUpdateNeeded;
   }
 
-  renovatedRenderSupported() { return false; }
+  renovatedRenderSupported(): boolean { return false; }
 
-  override isVirtualScrolling() { return false; }
+  override isVirtualScrolling(): boolean { return false; }
 
-  protected override getTotalViewDuration() {
-    return dateUtils.dateToMilliseconds('day') * (this.option('intervalCount') as any);
+  protected override getTotalViewDuration(): number {
+    return dateUtils.dateToMilliseconds('day') * this.option('intervalCount');
   }
 
-  getDOMElementsMetaData() {
+  getDOMElementsMetaData(): {
+    dateTableCellsMeta: Rect[][];
+    allDayPanelCellsMeta: Rect[];
+  } {
     return {
-      dateTableCellsMeta: [[{}]],
-      allDayPanelCellsMeta: [{}],
+      dateTableCellsMeta: [[{
+        top: 0, left: 0, width: 0, height: 0,
+      }]],
+      allDayPanelCellsMeta: [{
+        top: 0, left: 0, width: 0, height: 0,
+      }],
     };
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 registerComponent('dxSchedulerAgenda', SchedulerAgenda as any);
 
 export default SchedulerAgenda;
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_month.ts b/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_month.ts
deleted file mode 100644
index 96478987146a..000000000000
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_month.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import registerComponent from '@js/core/component_registrator';
-import dateUtils from '@js/core/utils/date';
-// NOTE: Renovation component import.
-import { HeaderPanelComponent } from '@ts/scheduler/r1/components/index';
-import { formatWeekdayAndDay, monthUtils } from '@ts/scheduler/r1/utils/index';
-
-import { VIEWS } from '../utils/options/constants_view';
-import SchedulerTimeline from './m_timeline';
-
-const TIMELINE_CLASS = 'dx-scheduler-timeline-month';
-
-class SchedulerTimelineMonth extends SchedulerTimeline {
-  get type() { return VIEWS.TIMELINE_MONTH; }
-
-  readonly viewDirection = 'horizontal';
-
-  get renovatedHeaderPanelComponent() { return HeaderPanelComponent; }
-
-  protected override renderView() {
-    super.renderView();
-
-    this.updateScrollable();
-  }
-
-  protected override getElementClass() {
-    return TIMELINE_CLASS;
-  }
-
-  protected override getDateHeaderTemplate() {
-    return this.option('dateCellTemplate');
-  }
-
-  protected override calculateDurationInCells(timeDiff) {
-    return timeDiff / this.getCellDuration();
-  }
-
-  isIndicatorVisible() {
-    return true;
-  }
-
-  protected override getFormat() {
-    return formatWeekdayAndDay;
-  }
-
-  protected override getIntervalBetween(currentDate) {
-    const firstViewDate = this.getStartViewDate();
-    const timeZoneOffset = dateUtils.getTimezonesDifference(firstViewDate, currentDate);
-
-    return currentDate.getTime() - (firstViewDate.getTime() - (this.option('startDayHour') as any) * 3600000) - timeZoneOffset;
-  }
-
-  protected override getViewStartByOptions() {
-    return monthUtils.getViewStartByOptions(
-      this.option('startDate') as any,
-      this.option('currentDate') as any,
-      this.option('intervalCount') as any,
-      dateUtils.getFirstMonthDate(this.option('startDate') as any) as any,
-    );
-  }
-
-  generateRenderOptions() {
-    const options = super.generateRenderOptions(true);
-    return {
-      ...options,
-      getDateForHeaderText: (_, date) => date,
-    };
-  }
-
-  keepOriginalHours() {
-    return true;
-  }
-}
-
-registerComponent('dxSchedulerTimelineMonth', SchedulerTimelineMonth as any);
-
-export default SchedulerTimelineMonth;
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space.ts b/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space.ts
index 42e146c7bbfb..c98fb1299f0f 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space.ts
@@ -13,6 +13,7 @@ import domAdapter from '@js/core/dom_adapter';
 import { getPublicElement } from '@js/core/element';
 import type { dxElementWrapper } from '@js/core/renderer';
 import $ from '@js/core/renderer';
+import type { TemplateBase } from '@js/core/templates/template_base';
 import { noop } from '@js/core/utils/common';
 import { compileGetter } from '@js/core/utils/data';
 import dateUtils from '@js/core/utils/date';
@@ -28,10 +29,12 @@ import {
 } from '@js/core/utils/size';
 import { isDefined } from '@js/core/utils/type';
 import { getWindow, hasWindow } from '@js/core/utils/window';
-import type { dxSchedulerOptions } from '@js/ui/scheduler';
+import type { AllDayPanelMode, CellClickEvent, CellContextMenuEvent } from '@js/ui/scheduler';
+import type { ScrollEvent } from '@js/ui/scroll_view';
 import errors from '@js/ui/widget/ui.errors';
 import Widget from '@js/ui/widget/ui.widget';
 import { getMemoizeScrollTo } from '@ts/core/utils/scroll';
+import type { OptionChanged } from '@ts/core/widget/types';
 import {
   AllDayPanelTitleComponent,
   AllDayTableComponent,
@@ -41,6 +44,7 @@ import {
   TimePanelComponent,
 } from '@ts/scheduler/r1/components/index';
 import type { ViewContext } from '@ts/scheduler/r1/components/types';
+import type { TimeZoneCalculator } from '@ts/scheduler/r1/timezone_calculator/calculator';
 import {
   calculateIsGroupedAllDayPanel,
   calculateViewStartDate,
@@ -49,8 +53,8 @@ import {
   getViewStartByOptions,
   isDateAndTimeView,
 } from '@ts/scheduler/r1/utils/index';
-import type { ViewType } from '@ts/scheduler/types';
-import Scrollable from '@ts/ui/scroll_view/scrollable';
+import type { GroupOrientation, ViewType } from '@ts/scheduler/types';
+import Scrollable, { type ScrollableProperties } from '@ts/ui/scroll_view/scrollable';
 
 import type NotifyScheduler from '../base/widget_notify_scheduler';
 import { APPOINTMENT_SETTINGS_KEY } from '../constants';
@@ -68,9 +72,10 @@ import {
 } from '../m_classes';
 import { CompactAppointmentsHelper } from '../m_compact_appointments_helper';
 import type { SubscribeKey, SubscribeMethods } from '../m_subscribes';
-import tableCreatorModule from '../m_table_creator';
+import tableCreatorModule, { type GroupRows } from '../m_table_creator';
 import { utils } from '../m_utils';
 import VerticalShader from '../shaders/current_time_shader_vertical';
+import type { ViewCellData } from '../types';
 import type { ResourceLoader } from '../utils/loader/resource_loader';
 import {
   getAppointmentGroupIndex,
@@ -80,6 +85,7 @@ import { getLeafGroupValues } from '../utils/resource_manager/group_utils';
 import type { ResourceManager } from '../utils/resource_manager/resource_manager';
 import type { GroupValues, RawGroupValues } from '../utils/resource_manager/types';
 import { getSkippedDaysCount as countSkippedDays } from '../utils/skipped_days';
+import type { ListEntity } from '../view_model/types';
 import {
   getAllDayHeight,
   getCellHeight,
@@ -107,6 +113,19 @@ interface RenderRWorkspaceOptions {
   generateNewData: boolean;
 }
 
+export interface ViewDateGenerationOptions {
+  startDayHour: number;
+  endDayHour: number;
+  hoursInterval: number;
+  interval?: number;
+  intervalCount: number;
+  startViewDate: Date;
+  firstDayOfWeek: number;
+  skippedDays?: number[];
+  viewOffset: number;
+  viewType: ViewType;
+}
+
 const { tableCreator } = tableCreatorModule;
 
 // The constant is needed so that the dragging is not sharp. To prevent small twitches
@@ -190,18 +209,69 @@ const DEFAULT_WORKSPACE_RENDER_OPTIONS: RenderRWorkspaceOptions = {
   generateNewData: true,
 };
 
-type WorkspaceOptionsInternal = Omit<dxSchedulerOptions, 'groups'> & {
-  groups: ResourceLoader[];
+export interface WorkspaceOptionsInternal {
+  newAppointments: boolean;
+  resources: ResourceLoader[];
   getResourceManager: () => ResourceManager;
-  startDate?: Date;
-  currentDate: Date;
-  intervalCount: number;
-  hoursInterval: number;
+  getFilteredItems: () => ListEntity[];
+  noDataText: string;
+  firstDayOfWeek: number;
   startDayHour: number;
   endDayHour: number;
-  skippedDays?: number[];
+  viewOffset: number;
+  tabIndex: number;
+  accessKey: string;
+  focusStateEnabled: boolean;
+  showAllDayPanel: boolean;
+  showCurrentTimeIndicator: boolean;
+  indicatorTime: Date;
+  indicatorUpdateInterval: number;
+  shadeUntilCurrentTime: boolean;
+  crossScrollingEnabled: boolean;
+  dataCellTemplate: TemplateBase | null;
+  timeCellTemplate: TemplateBase | null;
+  resourceCellTemplate: TemplateBase | null;
+  dateCellTemplate: TemplateBase | null;
+  allowMultipleCellSelection: boolean;
+  selectedCellData: ViewCellData[];
+  onSelectionChanged: ((args: { selectedCellData: ViewCellData[] }) => void);
+  onSelectionEnd: ((args: { selectedCellData: ViewCellData[] }) => void);
+  groupByDate: boolean;
+  skippedDays: number[];
+  scrolling: {
+    mode: 'standard' | 'virtual';
+    orientation: 'horizontal' | 'vertical' | 'both';
+  };
+  draggingMode: 'outlook' | 'default';
+  timeZoneCalculator: TimeZoneCalculator;
+  schedulerHeight: string | number | undefined;
+  schedulerWidth: string | number | undefined;
+  allDayPanelMode: AllDayPanelMode;
+  onSelectedCellsClick: (result: object, groups: GroupValues) => void;
+  renderAppointments: () => void;
+  onShowAllDayPanel: (isVisible: boolean) => void;
+  getHeaderHeight: (() => number);
+  onScrollEnd: () => void;
+  onInitialized: (e: { element: dxElementWrapper }) => void;
+  onDisposing: () => void;
+
+  notifyScheduler: NotifyScheduler;
+  groups: ResourceLoader[];
+  onCellClick: ((e: CellClickEvent) => void) | undefined;
+  onCellContextMenu: ((e: CellContextMenuEvent) => void) | undefined;
+  currentDate: Date;
+  hoursInterval: number;
+  allDayExpanded: boolean;
+
+  agendaDuration: number;
+  intervalCount: number;
+  rowHeight: number;
+  startDate?: Date;
   type?: ViewType;
-};
+  groupOrientation: GroupOrientation;
+  width?: number | string | undefined;
+}
+
 class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
   private viewDataProviderValue: any;
 
@@ -261,7 +331,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
 
   private contextMenuAction: any;
 
-  protected $groupTable: any;
+  protected $groupTable: dxElementWrapper | null | undefined;
 
   protected $thead: any;
 
@@ -661,8 +731,8 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     this.$allDayTitle = $('<div>').appendTo(this.$headerPanelEmptyCell);
   }
 
-  protected dateTableScrollableConfig() {
-    let config: any = {
+  protected dateTableScrollableConfig(): ScrollableProperties {
+    let config: ScrollableProperties = {
       useKeyboard: false,
       bounceEnabled: false,
       updateManually: true,
@@ -675,14 +745,14 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
       // To prevent scroll container focus in native mode we set tabindex -1 to container
       // In simulated mode focusable behavior prevented by useKeyboard: false private option
       onInitialized: ({ component }) => {
-        const useKeyboardDisabled = component.option('useKeyboard') === false;
-        const useNativeEnabled = component.option('useNative') === true;
+        const useKeyboardDisabled = component?.option().useKeyboard === false;
+        const useNativeEnabled = component?.option().useNative === true;
         if (useKeyboardDisabled && useNativeEnabled) {
-          $(component.container()).attr('tabindex', -1);
+          $(component?.container()).attr('tabindex', -1);
         }
       },
       onOptionChanged: ({ fullName, value, component }) => {
-        const useKeyboardDisabled = component.option('useKeyboard') === false;
+        const useKeyboardDisabled = component.option().useKeyboard === false;
         if (useKeyboardDisabled && fullName === 'useNative' && value === true) {
           $(component.container()).attr('tabindex', -1);
         }
@@ -694,12 +764,12 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     }
 
     if (this.isVirtualScrolling()
-            && (this.virtualScrollingDispatcher.horizontalScrollingAllowed
-                || this.virtualScrollingDispatcher.height)) {
+      && (this.virtualScrollingDispatcher.horizontalScrollingAllowed
+        || this.virtualScrollingDispatcher.height)) {
       const currentOnScroll = config.onScroll;
       config = {
         ...config,
-        onScroll: (e) => {
+        onScroll: (e: ScrollEvent) => {
           currentOnScroll?.(e);
 
           this.virtualScrollingDispatcher.handleOnScrollEvent(e?.scrollOffset);
@@ -710,14 +780,24 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     return config;
   }
 
-  protected createCrossScrollingConfig({ onScroll }): any {
+  protected createCrossScrollingConfig(
+    { onScroll }: Pick<ScrollableProperties, 'onScroll'>,
+  ): Pick<ScrollableProperties, 'direction' | 'onScroll' | 'onEnd'> {
     return {
       direction: 'both',
-      onScroll: (event) => {
-        onScroll?.();
+      onScroll: (event: ScrollEvent) => {
+        onScroll?.(event);
+
+        const top = event.scrollOffset?.top;
+        const left = event.scrollOffset?.left;
 
-        this.scrollSync.sidebar({ top: event.scrollOffset.top });
-        this.scrollSync.header({ left: event.scrollOffset.left });
+        if (top !== undefined) {
+          this.scrollSync.sidebar({ top });
+        }
+
+        if (left !== undefined) {
+          this.scrollSync.header({ left });
+        }
       },
       onEnd: () => {
         (this.option('onScrollEnd') as any)();
@@ -725,7 +805,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     };
   }
 
-  protected headerScrollableConfig() {
+  protected headerScrollableConfig(): ScrollableProperties {
     return {
       useKeyboard: false,
       showScrollbar: 'never',
@@ -733,7 +813,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
       useNative: false,
       updateManually: true,
       bounceEnabled: false,
-      onScroll: (event) => {
+      onScroll: (event: ScrollEvent) => {
         this.scrollSync.dateTable({ left: event.scrollOffset.left });
       },
     };
@@ -862,14 +942,14 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     );
   }
 
-  generateRenderOptions(isProvideVirtualCellsWidth?: any): ViewDataProviderOptions {
+  generateRenderOptions(isProvideVirtualCellsWidth = false): ViewDataProviderOptions {
     const groupCount = this.getGroupCount();
 
     const groupOrientation = groupCount > 0
       ? this.option('groupOrientation')
       : this.getDefaultGroupStrategy();
 
-    const options = {
+    const options: ViewDataProviderOptions = {
       groupByDate: this.option('groupByDate'),
       startRowIndex: 0,
       startCellIndex: 0,
@@ -1135,7 +1215,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     return this.groupedStrategy.getTotalCellCount(groupCount);
   }
 
-  protected getTotalRowCount(groupCount, includeAllDayPanelRows?: any) {
+  protected getTotalRowCount(groupCount: number, includeAllDayPanelRows?: boolean) {
     let result = this.groupedStrategy.getTotalRowCount(groupCount);
 
     if (includeAllDayPanelRows && this.isAllDayPanelVisible) {
@@ -1249,7 +1329,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     });
   }
 
-  protected getFormat() { return abstract(); }
+  protected getFormat(): string | ((date: Date) => string) { return abstract(); }
 
   getWorkArea() {
     return this.$dateTableContainer;
@@ -1305,7 +1385,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     };
   }
 
-  protected getDateGenerationOptions() {
+  protected getDateGenerationOptions(): ViewDateGenerationOptions {
     return {
       startDayHour: this.option('startDayHour'),
       endDayHour: this.option('endDayHour'),
@@ -1316,7 +1396,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
       firstDayOfWeek: this.firstDayOfWeek(),
       skippedDays: this.option('skippedDays'),
       viewOffset: 0,
-      viewType: this.type,
+      viewType: this.type as ViewType,
     };
   }
 
@@ -1535,8 +1615,8 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
 
   isGroupedByDate() {
     return this.option('groupByDate')
-            && this.isHorizontalGroupedWorkSpace()
-            && this.getGroupCount() > 0;
+      && this.isHorizontalGroupedWorkSpace()
+      && this.getGroupCount() > 0;
   }
 
   // TODO: refactor current time indicator
@@ -1769,9 +1849,9 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
       const cellEndTime = cellEndDate.getTime();
 
       if (((!inAllDayRow && cellStartTime <= time
-                && time < cellEndTime)
-                || (inAllDayRow && trimmedTime === cellStartTime))
-                && groupIndex === cellGroupIndex) {
+        && time < cellEndTime)
+        || (inAllDayRow && trimmedTime === cellStartTime))
+        && groupIndex === cellGroupIndex) {
         return false;
       }
       return currentResult;
@@ -1812,9 +1892,9 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
       const rowIndex = index / totalColumnCount;
 
       if (scrolledColumnCount <= columnIndex
-                && columnIndex < columnCount
-                && scrolledRowCount <= rowIndex
-                && rowIndex < rowCount) {
+        && columnIndex < columnCount
+        && scrolledRowCount <= rowIndex
+        && rowIndex < rowCount) {
         result.push($cell);
       }
     });
@@ -1868,7 +1948,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
   }
 
   private isValidScrollDate(date, throwWarning = true) {
-    const viewOffset = this.option('viewOffset') as number;
+    const viewOffset = this.option('viewOffset');
     const min = new Date(this.getStartViewDate().getTime() + viewOffset);
     const max = new Date(this.getEndViewDate().getTime() + viewOffset);
 
@@ -2183,7 +2263,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     const elements = (domAdapter as any).elementsFromPoint(point.x, point.y);
 
     const cell = elements.find((element) => element.classList.contains('dx-scheduler-date-table-cell')
-        || element.classList.contains('dx-scheduler-all-day-table-cell'));
+      || element.classList.contains('dx-scheduler-all-day-table-cell'));
 
     return cell ? $(cell) : null;
   }
@@ -2297,9 +2377,9 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     this.virtualScrollingDispatcher.dispose();
   }
 
-  _getDefaultOptions() {
+  _getDefaultOptions(): WorkspaceOptionsInternal {
     // @ts-expect-error
-    return extend(super._getDefaultOptions(), {
+    const defaultOptions = extend(super._getDefaultOptions(), {
       currentDate: new Date(),
       intervalCount: 1,
       startDate: null,
@@ -2333,18 +2413,20 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
       allDayPanelMode: 'all',
       height: undefined,
       draggingMode: 'outlook',
-      onScrollEnd: () => {},
+      onScrollEnd: noop,
       getHeaderHeight: undefined,
-      renderAppointments: () => {},
-      onShowAllDayPanel: () => {},
-      onSelectedCellsClick: () => {},
+      renderAppointments: noop,
+      onShowAllDayPanel: noop,
+      onSelectedCellsClick: noop,
       timeZoneCalculator: undefined,
       schedulerHeight: undefined,
       schedulerWidth: undefined,
     });
+
+    return defaultOptions;
   }
 
-  _optionChanged(args) {
+  _optionChanged(args: OptionChanged<WorkspaceOptionsInternal>): void {
     switch (args.name) {
       case 'startDayHour':
       case 'endDayHour':
@@ -2823,7 +2905,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     this.$element().addClass(className);
   }
 
-  protected getDateHeaderTemplate() {
+  protected getDateHeaderTemplate(): TemplateBase | null | undefined {
     return this.option('dateCellTemplate');
   }
 
@@ -2934,7 +3016,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
   protected renderGroupHeader() {
     const $container = this.getGroupHeaderContainer();
     const groupCount = this.getGroupCount();
-    let cellTemplates = [];
+    let cellTemplates: (() => dxElementWrapper)[] = [];
     if (groupCount) {
       const groupRows = this.makeGroupRows(this.option('groups'), this.option('groupByDate'));
       this.attachGroupCountClass();
@@ -2953,7 +3035,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     });
   }
 
-  protected makeGroupRows(groups, groupByDate): any {
+  protected makeGroupRows(groups: ResourceLoader[], groupByDate: boolean): GroupRows {
     const tableCreatorStrategy = this.isVerticalGroupedWorkSpace() ? tableCreator.VERTICAL : tableCreator.HORIZONTAL;
 
     return tableCreator.makeGroupedTable(
@@ -2986,7 +3068,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     return {};
   }
 
-  protected getHeaderPanelCellClass(i) {
+  protected getHeaderPanelCellClass(i: number): string {
     const cellClass = `${HEADER_PANEL_CELL_CLASS} ${HORIZONTAL_SIZES_CLASS}`;
 
     return this.groupedStrategy.addAdditionalGroupCellClasses(cellClass, i + 1, undefined, undefined, this.isGroupedByDate());
@@ -3109,10 +3191,10 @@ const createDragBehaviorConfig = (
       const isCurrentSchedulerElement = dateTables.find(el).length === 1;
 
       return isCurrentSchedulerElement
-                && (
-                  classList.contains(DATE_TABLE_CELL_CLASS)
-                    || classList.contains(ALL_DAY_TABLE_CELL_CLASS)
-                );
+        && (
+          classList.contains(DATE_TABLE_CELL_CLASS)
+          || classList.contains(ALL_DAY_TABLE_CELL_CLASS)
+        );
     });
 
     if (droppableCell) {
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_vertical.ts b/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_vertical.ts
index 428b6e95d240..efc3e7a20fc5 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_vertical.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_vertical.ts
@@ -1,6 +1,6 @@
 import { formatWeekdayAndDay } from '@ts/scheduler/r1/utils/index';
 
-import SchedulerWorkSpaceIndicator from './m_work_space_indicator';
+import SchedulerWorkSpaceIndicator from './work_space_indicator';
 
 class SchedulerWorkspaceVertical extends SchedulerWorkSpaceIndicator {
   protected override getFormat() {
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline.ts b/packages/devextreme/js/__internal/scheduler/workspaces/timeline.ts
similarity index 64%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_timeline.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/timeline.ts
index 4628643d9f52..5cd7ab0abd71 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/timeline.ts
@@ -1,5 +1,6 @@
 import registerComponent from '@js/core/component_registrator';
-import $ from '@js/core/renderer';
+import $, { type dxElementWrapper } from '@js/core/renderer';
+import type { TemplateBase } from '@js/core/templates/template_base';
 import { noop } from '@js/core/utils/common';
 import dateUtils from '@js/core/utils/date';
 import { extend } from '@js/core/utils/extend';
@@ -7,19 +8,22 @@ import { getBoundingRect } from '@js/core/utils/position';
 import { getOuterHeight, getOuterWidth, setHeight } from '@js/core/utils/size';
 import { hasWindow } from '@js/core/utils/window';
 import { getGlobalFormatByDataType } from '@ts/core/m_global_format_config';
-// NOTE: Renovation component import.
 import { HeaderPanelTimelineComponent } from '@ts/scheduler/r1/components/index';
 import { timelineWeekUtils } from '@ts/scheduler/r1/utils/index';
+import type { ScrollableProperties } from '@ts/ui/scroll_view/scrollable';
 
 import {
   GROUP_HEADER_CONTENT_CLASS,
   GROUP_ROW_CLASS,
 } from '../m_classes';
-import tableCreatorModule from '../m_table_creator';
+import tableCreatorModule, { type GroupRows } from '../m_table_creator';
 import timezoneUtils from '../m_utils_time_zone';
 import HorizontalShader from '../shaders/current_time_shader_horizontal';
+import type { ResourceLoader } from '../utils/loader/resource_loader';
 import { getFirstVisibleDate } from '../utils/skipped_days';
-import SchedulerWorkSpace from './m_work_space_indicator';
+import type { WorkspaceOptionsInternal } from './m_work_space';
+import type { ViewDataProviderOptions } from './view_model/m_types';
+import SchedulerWorkSpace from './work_space_indicator';
 
 const { tableCreator } = tableCreatorModule;
 
@@ -35,79 +39,85 @@ const HORIZONTAL = 'horizontal';
 const toMs = dateUtils.dateToMilliseconds;
 
 class SchedulerTimeline extends SchedulerWorkSpace {
-  protected override $sidebarTable: any;
+  protected override $sidebarTable!: dxElementWrapper;
 
-  get verticalGroupTableClass() { return GROUP_TABLE_CLASS; }
+  get verticalGroupTableClass(): string { return GROUP_TABLE_CLASS; }
 
   readonly viewDirection = 'horizontal';
 
-  get renovatedHeaderPanelComponent() { return HeaderPanelTimelineComponent; }
+  get renovatedHeaderPanelComponent(): typeof HeaderPanelTimelineComponent {
+    return HeaderPanelTimelineComponent;
+  }
 
-  getGroupTableWidth() {
-    return this.$sidebarTable ? getOuterWidth(this.$sidebarTable) : 0;
+  getGroupTableWidth(): number {
+    return this.$sidebarTable ? getOuterWidth(this.$sidebarTable) as number : 0;
   }
 
-  protected override getTotalRowCount(groupCount) {
+  protected override getTotalRowCount(
+    groupCount: number,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    includeAllDayPanelRows?: boolean,
+  ): number {
     if (this.isHorizontalGroupedWorkSpace()) {
       return this.getRowCount();
     }
-    groupCount = groupCount || 1;
-    return this.getRowCount() * groupCount;
+    const totalGroupCount = groupCount || 1;
+    return this.getRowCount() * totalGroupCount;
   }
 
-  protected override getFormat(): any {
-    return getGlobalFormatByDataType('time') || 'shorttime';
+  protected override getFormat(): string | ((date: Date) => string) {
+    return getGlobalFormatByDataType('time') as string | ((date: Date) => string) || 'shorttime';
   }
 
-  private getWorkSpaceHeight() {
+  private getWorkSpaceHeight(): number {
     if (this.option('crossScrollingEnabled') && hasWindow()) {
-      return getBoundingRect(this.$dateTable.get(0)).height;
+      return getBoundingRect(this.$dateTable.get(0)).height as number;
     }
 
-    return getBoundingRect((this.$element() as any).get(0)).height;
+    return getBoundingRect(this.$element().get(0)).height as number;
   }
 
-  protected override dateTableScrollableConfig() {
+  protected override dateTableScrollableConfig(): ScrollableProperties {
     const config = super.dateTableScrollableConfig();
     const timelineConfig = {
       direction: HORIZONTAL,
     };
 
-    return this.option('crossScrollingEnabled') ? config : extend(config, timelineConfig);
+    return this.option('crossScrollingEnabled') ? config : extend(config, timelineConfig) as ScrollableProperties;
   }
 
-  protected override needCreateCrossScrolling() {
+  protected override needCreateCrossScrolling(): boolean {
     return true;
   }
 
-  protected override headerScrollableConfig() {
+  protected override headerScrollableConfig(): ScrollableProperties {
     const config = super.headerScrollableConfig();
 
     return extend(config, {
       scrollByContent: true,
-    });
+    }) as ScrollableProperties;
   }
 
-  supportAllDayRow() {
+  supportAllDayRow(): boolean {
     return false;
   }
 
-  protected override getGroupHeaderContainer() {
+  protected override getGroupHeaderContainer(): dxElementWrapper {
     if (this.isHorizontalGroupedWorkSpace()) {
-      return this.$thead;
+      return this.$thead as dxElementWrapper;
     }
     return this.$sidebarTable;
   }
 
-  protected override insertAllDayRowsIntoDateTable() {
+  protected override insertAllDayRowsIntoDateTable(): boolean {
     return false;
   }
 
-  protected needRenderWeekHeader() {
+  protected needRenderWeekHeader(): boolean {
     return false;
   }
 
-  protected incrementDate(date) {
+  protected incrementDate(date: Date): void {
     const skippedDays = this.option('skippedDays') ?? [];
     const nextDate = new Date(date);
     nextDate.setDate(nextDate.getDate() + 1);
@@ -115,7 +125,7 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     const nextVisibleDate = getFirstVisibleDate(
       nextDate,
       skippedDays,
-      (currentDate) => {
+      (currentDate: Date) => {
         const result = new Date(currentDate);
         result.setDate(result.getDate() + 1);
         return result;
@@ -125,12 +135,12 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     date.setTime(nextVisibleDate.getTime());
   }
 
-  getIndicationCellCount() {
+  getIndicationCellCount(): number {
     const timeDiff = this.getTimeDiff();
     return this.calculateDurationInCells(timeDiff);
   }
 
-  private getTimeDiff() {
+  private getTimeDiff(): number {
     let today = this.getToday();
     const date = this.getIndicationFirstViewDate();
 
@@ -144,16 +154,16 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     return today.getTime() - date.getTime();
   }
 
-  protected calculateDurationInCells(timeDiff) {
+  protected calculateDurationInCells(timeDiff: number): number {
     const today = this.getToday();
     const differenceInDays = Math.floor(timeDiff / toMs('day'));
     const skippedDaysCount = this.getSkippedDaysCount(
       this.getIndicationFirstViewDate(),
       differenceInDays,
     );
-    let duration = (timeDiff - differenceInDays * toMs('day') - (this.option('startDayHour') as any) * toMs('hour')) / this.getCellDuration();
+    let duration = (timeDiff - differenceInDays * toMs('day') - this.option('startDayHour') * toMs('hour')) / this.getCellDuration();
 
-    if (today.getHours() > (this.option('endDayHour') as any)) {
+    if (today.getHours() > this.option('endDayHour')) {
       duration = this.getCellCountInDay();
     }
 
@@ -163,7 +173,7 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     return (differenceInDays - skippedDaysCount) * this.getCellCountInDay() + duration;
   }
 
-  getIndicationWidth() {
+  getIndicationWidth(): number {
     if (this.isGroupedByDate()) {
       const cellCount = this.getIndicationCellCount();
       const integerPart = Math.floor(cellCount);
@@ -174,15 +184,15 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     return this.getIndicationCellCount() * this.getCellWidth();
   }
 
-  protected override isVerticalShader() {
+  protected override isVerticalShader(): boolean {
     return false;
   }
 
-  protected override isCurrentTimeHeaderCell() {
+  protected override isCurrentTimeHeaderCell(): boolean {
     return false;
   }
 
-  protected override setTableSizes() {
+  protected override setTableSizes(): void {
     super.setTableSizes();
 
     const minHeight = this.getWorkSpaceMinHeight();
@@ -192,7 +202,7 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     this.virtualScrollingDispatcher.updateDimensions();
   }
 
-  private getWorkSpaceMinHeight() {
+  private getWorkSpaceMinHeight(): number {
     let minHeight = this.getWorkSpaceHeight();
 
     const workspaceContainerHeight = getOuterHeight(this.$flexContainer, true);
@@ -204,32 +214,37 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     return minHeight;
   }
 
-  protected override getCellCoordinatesByIndex(index) {
+  protected override getCellCoordinatesByIndex(
+    index: number,
+  ): { columnIndex: number; rowIndex: number } {
     return {
       columnIndex: index % this.getCellCount(),
       rowIndex: 0,
     };
   }
 
-  protected override getCellElementByPosition(cellCoordinates, groupIndex) {
+  protected override getCellElementByPosition(
+    cellCoordinates: { rowIndex: number; columnIndex: number },
+    groupIndex: number,
+  ): dxElementWrapper {
     const indexes = this.groupedStrategy.prepareCellIndexes(cellCoordinates, groupIndex);
 
     return this.$dateTable
       .find('tr')
       .eq(indexes.rowIndex)
       .find('td')
-      .eq(indexes.columnIndex);
+      .eq(indexes.columnIndex) as dxElementWrapper;
   }
 
-  protected override getWorkSpaceWidth() {
-    return getOuterWidth(this.$dateTable, true);
+  protected override getWorkSpaceWidth(): number {
+    return getOuterWidth(this.$dateTable, true) as number;
   }
 
-  private getIndicationFirstViewDate() {
-    return dateUtils.trimTime(new Date(this.getStartViewDate()));
+  private getIndicationFirstViewDate(): Date {
+    return dateUtils.trimTime(new Date(this.getStartViewDate())) as Date;
   }
 
-  protected override getIntervalBetween(currentDate, allDay) {
+  protected override getIntervalBetween(currentDate: Date, allDay?: boolean): number {
     const startDayHour = this.option('startDayHour');
     const endDayHour = this.option('endDayHour');
     const firstViewDate = this.getStartViewDate();
@@ -244,7 +259,7 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     const skippedDaysCount = this.getSkippedDaysCount(firstViewDate, fullDays);
     const cellCount = this.getCellCountInDay() * (fullDays - skippedDaysCount);
     const gapBeforeAppt = apptStart - dateUtils.trimTime(new Date(currentDate)).getTime();
-    let result = cellCount * (this.option('hoursInterval') as any) * toMs('hour');
+    let result = cellCount * this.option('hoursInterval') * toMs('hour');
 
     if (!allDay) {
       const hour = currentDate.getHours();
@@ -272,34 +287,33 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     return result;
   }
 
-  getAllDayContainer() {
+  getAllDayContainer(): null {
     return null;
   }
 
-  getTimePanelWidth() {
+  getTimePanelWidth(): number {
     return 0;
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  getIntervalDuration(allDay) {
+  getIntervalDuration(allDay: boolean): number {
     return this.getCellDuration();
   }
 
-  getCellMinWidth() {
+  getCellMinWidth(): number {
     return 0;
   }
 
-  getWorkSpaceLeftOffset() {
+  getWorkSpaceLeftOffset(): number {
     return 0;
   }
 
-  renderRAllDayPanel() {}
+  renderRAllDayPanel(): void {}
 
-  renderRTimeTable() {}
+  renderRTimeTable(): void {}
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  generateRenderOptions(argument?: any) {
-    const options = super.generateRenderOptions(true);
+  generateRenderOptions(isProvideVirtualCellsWidth?: boolean): ViewDataProviderOptions {
+    const options = super.generateRenderOptions(isProvideVirtualCellsWidth ?? true);
 
     return {
       ...options,
@@ -312,39 +326,42 @@ class SchedulerTimeline extends SchedulerWorkSpace {
   // We need these methods for now but they are useless for renovation
   // -------------
 
-  _init() {
+  _init(): void {
     super._init();
 
-    (this.$element() as any).addClass(TIMELINE_CLASS);
+    this.$element().addClass(TIMELINE_CLASS);
     this.$sidebarTable = $('<div>')
       .addClass(GROUP_TABLE_CLASS);
   }
 
-  protected override getDefaultGroupStrategy() {
+  protected override getDefaultGroupStrategy(): 'vertical' {
     return 'vertical';
   }
 
-  protected override toggleGroupingDirectionClass() {
-    (this.$element() as any).toggleClass(HORIZONTAL_GROUPED_WORKSPACE_CLASS, this.isHorizontalGroupedWorkSpace());
+  protected override toggleGroupingDirectionClass(): void {
+    this.$element().toggleClass(
+      HORIZONTAL_GROUPED_WORKSPACE_CLASS,
+      this.isHorizontalGroupedWorkSpace(),
+    );
   }
 
-  _getDefaultOptions() {
+  _getDefaultOptions(): WorkspaceOptionsInternal {
     return extend(super._getDefaultOptions(), {
       groupOrientation: 'vertical',
-    });
+    }) as WorkspaceOptionsInternal;
   }
 
-  protected override createWorkSpaceElements() {
+  protected override createWorkSpaceElements(): void {
     this.createWorkSpaceScrollableElements();
   }
 
-  protected override updateAllDayVisibility() { return noop(); }
+  protected override updateAllDayVisibility(): void { return noop(); }
 
-  protected override getDateHeaderTemplate() {
+  protected override getDateHeaderTemplate(): TemplateBase | null | undefined {
     return this.option('timeCellTemplate');
   }
 
-  protected override renderView() {
+  protected override renderView(): void {
     this.renderWorkSpace();
     this.virtualScrollingDispatcher.updateDimensions();
 
@@ -359,14 +376,14 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     this.updateHeaderEmptyCellWidth();
   }
 
-  protected override setHorizontalGroupHeaderCellsHeight() { return noop(); }
+  protected override setHorizontalGroupHeaderCellsHeight(): void { return noop(); }
 
-  protected override getTimePanelCells() {
-    return (this.$element() as any)
+  protected override getTimePanelCells(): dxElementWrapper {
+    return this.$element()
       .find(`.${HEADER_PANEL_CELL_CLASS}:not(.${HEADER_PANEL_WEEK_CELL_CLASS})`);
   }
 
-  getCurrentTimePanelCellIndices() {
+  getCurrentTimePanelCellIndices(): number[] {
     const columnCountPerGroup = this.getCellCount();
     const today = this.getToday();
     const index = this.getCellIndexByDate(today);
@@ -384,8 +401,14 @@ class SchedulerTimeline extends SchedulerWorkSpace {
       .map((_, groupIndex) => columnCountPerGroup * groupIndex + currentTimeColumnIndex);
   }
 
-  protected override renderIndicator(height, rtlOffset, $container, groupCount) {
-    let $indicator;
+  protected override renderIndicator(
+    height: number,
+    rtlOffset: number,
+    $container: dxElementWrapper,
+    groupCount: number,
+  ): void {
+    // eslint-disable-next-line @typescript-eslint/init-declarations
+    let $indicator: dxElementWrapper | undefined;
     const width = this.getIndicationWidth();
 
     if (this.option('groupOrientation') === 'vertical') {
@@ -393,8 +416,9 @@ class SchedulerTimeline extends SchedulerWorkSpace {
       setHeight($indicator, getBoundingRect($container.get(0)).height);
       $indicator.css('left', rtlOffset ? rtlOffset - width : width);
     } else {
-      for (let i = 0; i < groupCount; i++) {
-        const offset = this.isGroupedByDate() ? i * this.getCellWidth() : this.getCellCount() * this.getCellWidth() * i;
+      for (let i = 0; i < groupCount; i += 1) {
+        const offset = this.isGroupedByDate() ? i * this.getCellWidth()
+          : this.getCellCount() * this.getCellWidth() * i;
         $indicator = this.createIndicator($container);
         setHeight($indicator, getBoundingRect($container.get(0)).height);
 
@@ -403,7 +427,10 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     }
   }
 
-  protected override makeGroupRows(groups, groupByDate) {
+  protected override makeGroupRows(
+    groups: ResourceLoader[],
+    groupByDate: boolean,
+  ): GroupRows {
     const tableCreatorStrategy = this.option('groupOrientation') === 'vertical' ? tableCreator.VERTICAL : tableCreator.HORIZONTAL;
 
     return tableCreator.makeGroupedTable(
@@ -423,5 +450,6 @@ class SchedulerTimeline extends SchedulerWorkSpace {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 registerComponent('dxSchedulerTimeline', SchedulerTimeline as any);
 export default SchedulerTimeline;
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_day.ts b/packages/devextreme/js/__internal/scheduler/workspaces/timeline_day.ts
similarity index 61%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_day.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/timeline_day.ts
index 415c4a32cd01..96bedf714a6e 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_day.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/timeline_day.ts
@@ -1,22 +1,23 @@
 import registerComponent from '@js/core/component_registrator';
 
 import { VIEWS } from '../utils/options/constants_view';
-import SchedulerTimeline from './m_timeline';
+import SchedulerTimeline from './timeline';
 
 const TIMELINE_CLASS = 'dx-scheduler-timeline-day';
 
 class SchedulerTimelineDay extends SchedulerTimeline {
-  get type() { return VIEWS.TIMELINE_DAY; }
+  get type(): string { return VIEWS.TIMELINE_DAY; }
 
-  protected override getElementClass() {
+  protected override getElementClass(): string {
     return TIMELINE_CLASS;
   }
 
-  protected override needRenderWeekHeader() {
+  protected override needRenderWeekHeader(): boolean {
     return this.isWorkSpaceWithCount();
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 registerComponent('dxSchedulerTimelineDay', SchedulerTimelineDay as any);
 
 export default SchedulerTimelineDay;
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/timeline_month.ts b/packages/devextreme/js/__internal/scheduler/workspaces/timeline_month.ts
new file mode 100644
index 000000000000..3e0301003fc9
--- /dev/null
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/timeline_month.ts
@@ -0,0 +1,85 @@
+import registerComponent from '@js/core/component_registrator';
+import type { TemplateBase } from '@js/core/templates/template_base';
+import dateUtils from '@js/core/utils/date';
+import { HeaderPanelComponent } from '@ts/scheduler/r1/components/index';
+import { formatWeekdayAndDay, monthUtils } from '@ts/scheduler/r1/utils/index';
+
+import { VIEWS } from '../utils/options/constants_view';
+import SchedulerTimeline from './timeline';
+import type { ViewDataProviderOptions } from './view_model/m_types';
+
+const TIMELINE_CLASS = 'dx-scheduler-timeline-month';
+
+class SchedulerTimelineMonth extends SchedulerTimeline {
+  get type(): string { return VIEWS.TIMELINE_MONTH; }
+
+  readonly viewDirection = 'horizontal';
+
+  get renovatedHeaderPanelComponent(): typeof HeaderPanelComponent { return HeaderPanelComponent; }
+
+  protected override renderView(): void {
+    super.renderView();
+
+    this.updateScrollable();
+  }
+
+  protected override getElementClass(): string {
+    return TIMELINE_CLASS;
+  }
+
+  protected override getDateHeaderTemplate(): TemplateBase | null | undefined {
+    return this.option('dateCellTemplate');
+  }
+
+  protected override calculateDurationInCells(timeDiff: number): number {
+    return timeDiff / this.getCellDuration();
+  }
+
+  isIndicatorVisible(): boolean {
+    return true;
+  }
+
+  protected override getFormat(): (date: Date) => string {
+    return formatWeekdayAndDay;
+  }
+
+  protected override getIntervalBetween(currentDate: Date): number {
+    const firstViewDate = this.getStartViewDate();
+    const timeZoneOffset = dateUtils.getTimezonesDifference(firstViewDate, currentDate);
+    const startDayHour = this.option('startDayHour');
+
+    return currentDate.getTime()
+      - (firstViewDate.getTime() - startDayHour * 3600000)
+      - timeZoneOffset;
+  }
+
+  protected override getViewStartByOptions(): Date {
+    const currentDate: Date = this.option('currentDate') ?? new Date();
+    const startDate: Date = this.option('startDate') ?? currentDate;
+    const firstMonthDate = dateUtils.getFirstMonthDate(startDate) ?? startDate;
+
+    return monthUtils.getViewStartByOptions(
+      startDate,
+      currentDate,
+      this.option('intervalCount'),
+      firstMonthDate,
+    );
+  }
+
+  generateRenderOptions(): ViewDataProviderOptions {
+    const options = super.generateRenderOptions(true);
+    return {
+      ...options,
+      getDateForHeaderText: (_, date: Date): Date => date,
+    };
+  }
+
+  keepOriginalHours(): boolean {
+    return true;
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+registerComponent('dxSchedulerTimelineMonth', SchedulerTimelineMonth as any);
+
+export default SchedulerTimelineMonth;
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_week.ts b/packages/devextreme/js/__internal/scheduler/workspaces/timeline_week.ts
similarity index 73%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_week.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/timeline_week.ts
index 0d1a9eec32b4..8b1bba366d13 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_week.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/timeline_week.ts
@@ -1,7 +1,7 @@
 import registerComponent from '@js/core/component_registrator';
 
 import { VIEWS } from '../utils/options/constants_view';
-import SchedulerTimeline from './m_timeline';
+import SchedulerTimeline from './timeline';
 
 const TIMELINE_CLASS = 'dx-scheduler-timeline-week';
 const TIMELINE_WORK_WEEK_CLASS = 'dx-scheduler-timeline-work-week';
@@ -11,13 +11,14 @@ export default class SchedulerTimelineWeek extends SchedulerTimeline {
     return this.option('type') ?? VIEWS.TIMELINE_WEEK;
   }
 
-  protected override getElementClass() {
+  protected override getElementClass(): string {
     return this.type === VIEWS.TIMELINE_WORK_WEEK ? TIMELINE_WORK_WEEK_CLASS : TIMELINE_CLASS;
   }
 
-  protected override needRenderWeekHeader() {
+  protected override needRenderWeekHeader(): boolean {
     return true;
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 registerComponent('dxSchedulerTimelineWeek', SchedulerTimelineWeek as any);
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_day.ts b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_day.ts
similarity index 76%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_day.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/work_space_day.ts
index 1d6c689f2c7b..d36bd53066c9 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_day.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_day.ts
@@ -6,13 +6,13 @@ import SchedulerWorkSpaceVertical from './m_work_space_vertical';
 const DAY_CLASS = 'dx-scheduler-work-space-day';
 
 class SchedulerWorkSpaceDay extends SchedulerWorkSpaceVertical {
-  get type() { return VIEWS.DAY; }
+  get type(): string { return VIEWS.DAY; }
 
-  protected override getElementClass() {
+  protected override getElementClass(): string {
     return DAY_CLASS;
   }
 
-  renderRHeaderPanel() {
+  renderRHeaderPanel(): void {
     if (this.option('intervalCount') === 1) {
       super.renderRHeaderPanel(false);
     } else {
@@ -21,6 +21,7 @@ class SchedulerWorkSpaceDay extends SchedulerWorkSpaceVertical {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 registerComponent('dxSchedulerWorkSpaceDay', SchedulerWorkSpaceDay as any);
 
 export default SchedulerWorkSpaceDay;
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_indicator.ts b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_indicator.ts
similarity index 80%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_indicator.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/work_space_indicator.ts
index 637110fc6e29..443cb28b4c2b 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_indicator.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_indicator.ts
@@ -1,27 +1,30 @@
 import registerComponent from '@js/core/component_registrator';
-import $ from '@js/core/renderer';
+import $, { type dxElementWrapper } from '@js/core/renderer';
 import dateUtils from '@js/core/utils/date';
 import { extend } from '@js/core/utils/extend';
 import { getBoundingRect } from '@js/core/utils/position';
 import { setWidth } from '@js/core/utils/size';
 import { hasWindow } from '@js/core/utils/window';
 import { dateUtilsTs } from '@ts/core/utils/date';
+import type { OptionChanged } from '@ts/core/widget/types';
 import { getToday } from '@ts/scheduler/r1/utils/index';
 
 import { HEADER_CURRENT_TIME_CELL_CLASS } from '../m_classes';
 import timezoneUtils from '../m_utils_time_zone';
-import SchedulerWorkSpace from './m_work_space';
+import SchedulerWorkSpace, {
+  type WorkspaceOptionsInternal,
+} from './m_work_space';
 
 const toMs = dateUtils.dateToMilliseconds;
 
 const SCHEDULER_DATE_TIME_INDICATOR_CLASS = 'dx-scheduler-date-time-indicator';
 
 class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
-  private indicatorInterval: any;
+  private indicatorInterval?: ReturnType<typeof setInterval>;
 
   protected getToday(): Date {
-    const viewOffset = this.option('viewOffset') as number;
-    const today = getToday(this.option('indicatorTime') as Date, this.timeZoneCalculator);
+    const viewOffset = this.option('viewOffset');
+    const today = getToday(this.option('indicatorTime'), this.timeZoneCalculator);
     return dateUtilsTs.addOffsets(today, -viewOffset);
   }
 
@@ -35,7 +38,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return false;
   }
 
-  isIndicationAvailable() {
+  isIndicationAvailable(): boolean {
     if (!hasWindow()) {
       return false;
     }
@@ -45,7 +48,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return today >= dateUtils.trimTime(new Date(this.getStartViewDate()));
   }
 
-  isIndicatorVisible() {
+  isIndicatorVisible(): boolean {
     const today = this.getToday();
 
     // Subtracts 1 ms from the real endViewDate instead of 1 minute
@@ -57,10 +60,15 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return dateUtils.dateInRange(today, firstViewDate, endViewDate);
   }
 
-  protected renderIndicator(height, rtlOffset, $container, groupCount) {
+  protected renderIndicator(
+    height: number,
+    rtlOffset: number,
+    $container: dxElementWrapper,
+    groupCount: number,
+  ): void {
     const groupedByDate = this.isGroupedByDate();
     const repeatCount = groupedByDate ? 1 : groupCount;
-    for (let i = 0; i < repeatCount; i++) {
+    for (let i = 0; i < repeatCount; i += 1) {
       const $indicator = this.createIndicator($container);
 
       setWidth(
@@ -71,41 +79,42 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     }
   }
 
-  protected createIndicator($container) {
+  protected createIndicator($container: dxElementWrapper): dxElementWrapper {
     const $indicator = $('<div>').addClass(SCHEDULER_DATE_TIME_INDICATOR_CLASS);
     $container.append($indicator);
 
     return $indicator;
   }
 
-  private getRtlOffset(width) {
+  private getRtlOffset(width: number): number {
     return this.option('rtlEnabled') ? getBoundingRect(this.$dateTableScrollable.$content().get(0)).width - this.getTimePanelWidth() - width : 0;
   }
 
-  protected setIndicationUpdateInterval() {
+  protected setIndicationUpdateInterval(): void {
     if (!this.option('showCurrentTimeIndicator') || this.option('indicatorUpdateInterval') === 0) {
       return;
     }
 
     this.clearIndicatorUpdateInterval();
 
+    // eslint-disable-next-line no-restricted-globals
     this.indicatorInterval = setInterval(() => {
       this.renderCurrentDateTimeIndication();
     }, this.option('indicatorUpdateInterval'));
   }
 
-  private clearIndicatorUpdateInterval() {
+  private clearIndicatorUpdateInterval(): void {
     if (this.indicatorInterval) {
       clearInterval(this.indicatorInterval);
       delete this.indicatorInterval;
     }
   }
 
-  protected isVerticalShader() {
+  protected isVerticalShader(): boolean {
     return true;
   }
 
-  getIndicationWidth() {
+  getIndicationWidth(): number {
     const cellCount = this.getCellCount();
     const cellSpan = Math.min(this.getIndicatorDaysSpan(), cellCount);
     const width = cellSpan * this.getCellWidth();
@@ -114,7 +123,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return Math.min(width, maxWidth);
   }
 
-  getIndicatorOffset() {
+  getIndicatorOffset(): number {
     const cellSpan = this.getIndicatorDaysSpan() - 1;
     const offset = cellSpan * this.getCellWidth();
 
@@ -137,7 +146,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return Math.ceil((timeDiff + 1) / toMs('day'));
   }
 
-  getIndicationHeight() {
+  getIndicationHeight(): number {
     const today = timezoneUtils.getDateWithoutTimezoneChange(this.getToday());
     const cellHeight = this.getCellHeight();
     const date = new Date(this.getStartViewDate());
@@ -152,9 +161,9 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return cellCount * cellHeight;
   }
 
-  _dispose() {
+  _dispose(): void {
     this.clearIndicatorUpdateInterval();
-    super._dispose.apply(this, arguments as any);
+    super._dispose();
   }
 
   renderCurrentDateTimeIndication(): void {
@@ -186,7 +195,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return false;
   }
 
-  protected override getHeaderPanelCellClass(i) {
+  protected override getHeaderPanelCellClass(i: number): string {
     const cellClass = super.getHeaderPanelCellClass(i);
 
     if (this.isCurrentTimeHeaderCell(i)) {
@@ -196,30 +205,30 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return cellClass;
   }
 
-  protected override cleanView() {
+  protected override cleanView(): void {
     super.cleanView();
 
     this.cleanDateTimeIndicator();
   }
 
-  _dimensionChanged() {
+  _dimensionChanged(): void {
     super._dimensionChanged();
 
     this.renderCurrentDateTimeLineAndShader();
   }
 
-  private cleanDateTimeIndicator() {
-    (this.$element() as any).find(`.${SCHEDULER_DATE_TIME_INDICATOR_CLASS}`).remove();
+  private cleanDateTimeIndicator(): void {
+    this.$element().find(`.${SCHEDULER_DATE_TIME_INDICATOR_CLASS}`).remove();
   }
 
-  protected override cleanWorkSpace() {
+  protected override cleanWorkSpace(): void {
     super.cleanWorkSpace();
 
     this.renderDateTimeIndication();
     this.setIndicationUpdateInterval();
   }
 
-  _optionChanged(args) {
+  _optionChanged(args: OptionChanged<WorkspaceOptionsInternal>): void {
     switch (args.name) {
       case 'showCurrentTimeIndicator':
       case 'indicatorTime':
@@ -242,16 +251,16 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     }
   }
 
-  _getDefaultOptions() {
+  _getDefaultOptions(): WorkspaceOptionsInternal {
     return extend(super._getDefaultOptions(), {
       showCurrentTimeIndicator: true,
       indicatorTime: new Date(),
       indicatorUpdateInterval: 5 * toMs('minute'),
       shadeUntilCurrentTime: true,
-    });
+    }) as WorkspaceOptionsInternal;
   }
 
-  protected getCurrentTimePanelCellIndices() {
+  protected getCurrentTimePanelCellIndices(): number[] {
     const rowCountPerGroup = this.getTimePanelRowCount();
     const today = this.getToday();
     const index = this.getCellIndexByDate(today);
@@ -261,10 +270,9 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
       return [];
     }
 
-    let cellIndices;
-    if (currentTimeRowIndex === 0) {
-      cellIndices = [currentTimeRowIndex];
-    } else {
+    let cellIndices: number[] = [currentTimeRowIndex];
+
+    if (currentTimeRowIndex !== 0) {
       cellIndices = currentTimeRowIndex % 2 === 0
         ? [currentTimeRowIndex - 1, currentTimeRowIndex]
         : [currentTimeRowIndex, currentTimeRowIndex + 1];
@@ -275,7 +283,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
       : 1;
 
     return [...new Array(verticalGroupCount)]
-      .reduce((currentIndices, _, groupIndex) => [
+      .reduce<number[]>((currentIndices, _, groupIndex) => [
         ...currentIndices,
         ...cellIndices.map((cellIndex) => rowCountPerGroup * groupIndex + cellIndex),
       ], []);
@@ -307,5 +315,6 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 registerComponent('dxSchedulerWorkSpace', SchedulerWorkSpaceIndicator as any);
 export default SchedulerWorkSpaceIndicator;
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_month.ts b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_month.ts
similarity index 59%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_month.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/work_space_month.ts
index 7585eb598a71..b0b81f198bb8 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_month.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_month.ts
@@ -3,37 +3,41 @@ import { noop } from '@js/core/utils/common';
 import dateUtils from '@js/core/utils/date';
 import { getBoundingRect } from '@js/core/utils/position';
 import { hasWindow } from '@js/core/utils/window';
-// NOTE: Renovation component import.
 import { DateTableMonthComponent } from '@ts/scheduler/r1/components/index';
 import { formatWeekday, monthUtils } from '@ts/scheduler/r1/utils/index';
 
 import { utils } from '../m_utils';
 import { VIEWS } from '../utils/options/constants_view';
-import SchedulerWorkSpace from './m_work_space_indicator';
+import type { ViewDateGenerationOptions } from './m_work_space';
+import SchedulerWorkSpace from './work_space_indicator';
 
 const MONTH_CLASS = 'dx-scheduler-work-space-month';
 
 const toMs = dateUtils.dateToMilliseconds;
 
 class SchedulerWorkSpaceMonth extends SchedulerWorkSpace {
-  get type() { return VIEWS.MONTH; }
+  get type(): string { return VIEWS.MONTH; }
 
-  protected override getElementClass() {
+  protected override getElementClass(): string {
     return MONTH_CLASS;
   }
 
-  protected override getFormat() {
+  protected override getFormat(): (date: Date) => string {
     return formatWeekday;
   }
 
-  protected override getIntervalBetween(currentDate) {
+  protected override getIntervalBetween(currentDate: Date): number {
     const firstViewDate = this.getStartViewDate();
     const timeZoneOffset = dateUtils.getTimezonesDifference(firstViewDate, currentDate);
+    const startDayHour = this.option('startDayHour');
 
-    return currentDate.getTime() - (firstViewDate.getTime() - (this.option('startDayHour') as any) * 3600000) - timeZoneOffset;
+    return currentDate.getTime()
+      - (firstViewDate.getTime() - startDayHour * 3600000)
+      - timeZoneOffset;
   }
 
-  protected override getDateGenerationOptions() {
+  protected override getDateGenerationOptions(): ViewDateGenerationOptions
+  & { cellCountInDay: number } {
     return {
       ...super.getDateGenerationOptions(),
       cellCountInDay: 1,
@@ -45,8 +49,8 @@ class SchedulerWorkSpaceMonth extends SchedulerWorkSpace {
    *   getCellWidth method need remove. Details in T712431 there is a test for this bug,
    *   when changing the layout, the test will also be useless
    */
-  getCellWidth() {
-    return this.cache.memo('cellWidth', () => {
+  getCellWidth(): number | undefined {
+    const cellWidth = this.cache.memo('cellWidth', (): number | undefined => {
       const DAYS_IN_WEEK = 7;
 
       let averageWidth = 0;
@@ -57,13 +61,17 @@ class SchedulerWorkSpaceMonth extends SchedulerWorkSpace {
 
       return cells.length === 0 ? undefined : averageWidth / DAYS_IN_WEEK;
     });
+
+    return cellWidth as number | undefined;
   }
 
-  protected override insertAllDayRowsIntoDateTable() {
+  protected override insertAllDayRowsIntoDateTable(): boolean {
     return false;
   }
 
-  protected override getCellCoordinatesByIndex(index) {
+  protected override getCellCoordinatesByIndex(
+    index: number,
+  ): { rowIndex: number; columnIndex: number } {
     const rowIndex = Math.floor(index / this.getCellCount());
     const columnIndex = index - this.getCellCount() * rowIndex;
 
@@ -73,61 +81,60 @@ class SchedulerWorkSpaceMonth extends SchedulerWorkSpace {
     };
   }
 
-  protected override needCreateCrossScrolling() {
-    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+  protected override needCreateCrossScrolling(): boolean {
     return this.option('crossScrollingEnabled') || this.isVerticalGroupedWorkSpace();
   }
 
-  protected override getViewStartByOptions() {
+  protected override getViewStartByOptions(): Date {
     return monthUtils.getViewStartByOptions(
-      this.option('startDate') as any,
-      this.option('currentDate') as any,
-      this.option('intervalCount') as any,
-      dateUtils.getFirstMonthDate(this.option('startDate')) as any,
+      this.option('startDate'),
+      this.option('currentDate'),
+      this.option('intervalCount'),
+      dateUtils.getFirstMonthDate(this.option('startDate')) as Date,
     );
   }
 
-  protected override updateIndex(index) {
+  protected override updateIndex(index: number): number {
     return index;
   }
 
-  isIndicationAvailable() {
+  isIndicationAvailable(): boolean {
     return false;
   }
 
-  getIntervalDuration() {
+  getIntervalDuration(): number {
     return toMs('day');
   }
 
-  getTimePanelWidth() {
+  getTimePanelWidth(): number {
     return 0;
   }
 
-  supportAllDayRow() {
+  supportAllDayRow(): boolean {
     return false;
   }
 
-  keepOriginalHours() {
+  keepOriginalHours(): boolean {
     return true;
   }
 
-  getWorkSpaceLeftOffset() {
+  getWorkSpaceLeftOffset(): number {
     return 0;
   }
 
-  needApplyCollectorOffset() {
+  needApplyCollectorOffset(): boolean {
     return true;
   }
 
-  protected override getHeaderDate() {
+  protected override getHeaderDate(): Date {
     return this.getViewStartByOptions();
   }
 
-  renderRAllDayPanel() {}
+  renderRAllDayPanel(): void {}
 
-  renderRTimeTable() {}
+  renderRTimeTable(): void {}
 
-  renderRDateTable() {
+  renderRDateTable(): void {
     utils.renovation.renderComponent(
       this,
       this.$dateTable,
@@ -141,7 +148,7 @@ class SchedulerWorkSpaceMonth extends SchedulerWorkSpace {
   // We need these methods for now but they are useless for renovation
   // -------------
 
-  protected override createWorkSpaceElements() {
+  protected override createWorkSpaceElements(): void {
     if (this.isVerticalGroupedWorkSpace()) {
       this.createWorkSpaceScrollableElements();
     } else {
@@ -149,9 +156,10 @@ class SchedulerWorkSpaceMonth extends SchedulerWorkSpace {
     }
   }
 
-  protected override updateAllDayVisibility() { return noop(); }
+  protected override updateAllDayVisibility(): void { return noop(); }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 registerComponent('dxSchedulerWorkSpaceMonth', SchedulerWorkSpaceMonth as any);
 
 export default SchedulerWorkSpaceMonth;
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_week.ts b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_week.ts
similarity index 78%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_week.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/work_space_week.ts
index 62087a0b31e6..3676aae58f25 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_week.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_week.ts
@@ -11,15 +11,16 @@ class SchedulerWorkSpaceWeek extends SchedulerWorkSpaceVertical {
     return this.option('type') ?? VIEWS.WEEK;
   }
 
-  protected override getElementClass() {
+  protected override getElementClass(): string {
     return this.type === VIEWS.WORK_WEEK ? WORK_WEEK_CLASS : WEEK_CLASS;
   }
 
-  protected override calculateViewStartDate() {
-    return weekUtils.calculateViewStartDate(this.option('startDate') as any, this.firstDayOfWeek());
+  protected override calculateViewStartDate(): Date {
+    return weekUtils.calculateViewStartDate(this.option('startDate') as Date, this.firstDayOfWeek());
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 registerComponent('dxSchedulerWorkSpaceWeek', SchedulerWorkSpaceWeek as any);
 
 export default SchedulerWorkSpaceWeek;
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/agenda.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/agenda.tests.js
index d326f8bdb558..c797bb82269a 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/agenda.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/agenda.tests.js
@@ -1,5 +1,5 @@
 import $ from 'jquery';
-import SchedulerAgenda from '__internal/scheduler/workspaces/m_agenda';
+import SchedulerAgenda from '__internal/scheduler/workspaces/agenda';
 import dateLocalization from 'common/core/localization/date';
 
 import { getEmptyResourceManager } from '../../helpers/scheduler/mockResourceManager.js';
@@ -186,8 +186,12 @@ module('Agenda', {}, () => {
         assert.deepEqual(
             instance.getDOMElementsMetaData(),
             {
-                dateTableCellsMeta: [[{}]],
-                allDayPanelCellsMeta: [{}],
+                dateTableCellsMeta: [[{
+                    top: 0, left: 0, width: 0, height: 0,
+                }]],
+                allDayPanelCellsMeta: [{
+                    top: 0, left: 0, width: 0, height: 0,
+                }],
             },
             'Correct DOM meta data',
         );
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/appointments.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/appointments.tests.js
index b8b92505bdcb..f53b5fb8b4e2 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/appointments.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/appointments.tests.js
@@ -6,7 +6,7 @@ import { mockDataAccessor } from '../../helpers/scheduler/mockDataAccessor.js';
 import { getEmptyResourceManager } from '../../helpers/scheduler/mockResourceManager.js';
 
 import $ from 'jquery';
-import '__internal/scheduler/workspaces/m_work_space_week';
+import '__internal/scheduler/workspaces/work_space_week';
 import SchedulerAppointments from '__internal/scheduler/appointments/m_appointment_collection';
 import dblclickEvent from 'common/core/events/dblclick';
 import translator from 'common/core/animation/translator';
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/common.options.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/common.options.tests.js
index 575f8438f9cd..a69ec3fa47e1 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/common.options.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/common.options.tests.js
@@ -7,7 +7,7 @@ import 'fluent_blue_light.css!';
 
 import { triggerHidingEvent, triggerShownEvent } from 'common/core/events/visibility_change';
 import $ from 'jquery';
-import dxSchedulerWorkSpaceDay from '__internal/scheduler/workspaces/m_work_space_day';
+import dxSchedulerWorkSpaceDay from '__internal/scheduler/workspaces/work_space_day';
 import keyboardMock from '../../helpers/keyboardMock.js';
 import pointerMock from '../../helpers/pointerMock.js';
 import { createWrapper, initTestMarkup } from '../../helpers/scheduler/helpers.js';
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/currentTimeIndicator.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/currentTimeIndicator.tests.js
index 4f59b1b9f1ee..7b9b551e61aa 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/currentTimeIndicator.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/currentTimeIndicator.tests.js
@@ -17,11 +17,11 @@ const SCHEDULER_DATE_TIME_INDICATOR_CLASS = 'dx-scheduler-date-time-indicator';
 
 import 'fluent_blue_light.css!';
 
-import '__internal/scheduler/workspaces/m_work_space_day';
-import '__internal/scheduler/workspaces/m_work_space_week';
-import '__internal/scheduler/workspaces/m_timeline_day';
-import '__internal/scheduler/workspaces/m_timeline_week';
-import '__internal/scheduler/workspaces/m_timeline_month';
+import '__internal/scheduler/workspaces/work_space_day';
+import '__internal/scheduler/workspaces/work_space_week';
+import '__internal/scheduler/workspaces/timeline_day';
+import '__internal/scheduler/workspaces/timeline_week';
+import '__internal/scheduler/workspaces/timeline_month';
 
 QUnit.testStart(function() {
     $('#qunit-fixture').html('<div class="dx-scheduler"><div id="scheduler-work-space-rtl"></div><div id="scheduler-work-space"></div></div>');
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/timeline.markup.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/timeline.markup.tests.js
index edf90f87d420..c86c7e5a2290 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/timeline.markup.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/timeline.markup.tests.js
@@ -1,8 +1,8 @@
 import $ from 'jquery';
-import SchedulerTimeline from '__internal/scheduler/workspaces/m_timeline';
-import SchedulerTimelineDay from '__internal/scheduler/workspaces/m_timeline_day';
-import SchedulerTimelineWeek from '__internal/scheduler/workspaces/m_timeline_week';
-import SchedulerTimelineMonth from '__internal/scheduler/workspaces/m_timeline_month';
+import SchedulerTimeline from '__internal/scheduler/workspaces/timeline';
+import SchedulerTimelineDay from '__internal/scheduler/workspaces/timeline_day';
+import SchedulerTimelineWeek from '__internal/scheduler/workspaces/timeline_week';
+import SchedulerTimelineMonth from '__internal/scheduler/workspaces/timeline_month';
 import dateLocalization from 'common/core/localization/date';
 import SchedulerWorkSpaceVerticalStrategy from '__internal/scheduler/workspaces/m_work_space_grouped_strategy_vertical';
 import SchedulerWorkSpaceHorizontalStrategy from '__internal/scheduler/workspaces/m_work_space_grouped_strategy_horizontal';
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/timeline.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/timeline.tests.js
index 260f29480ce7..46cf4849d49d 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/timeline.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/timeline.tests.js
@@ -5,10 +5,10 @@ import resizeCallbacks from 'core/utils/resize_callbacks';
 import { triggerHidingEvent, triggerShownEvent } from 'common/core/events/visibility_change';
 import 'fluent_blue_light.css!';
 import $ from 'jquery';
-import '__internal/scheduler/workspaces/m_timeline';
-import '__internal/scheduler/workspaces/m_timeline_day';
-import '__internal/scheduler/workspaces/m_timeline_month';
-import '__internal/scheduler/workspaces/m_timeline_week';
+import '__internal/scheduler/workspaces/timeline';
+import '__internal/scheduler/workspaces/timeline_day';
+import '__internal/scheduler/workspaces/timeline_month';
+import '__internal/scheduler/workspaces/timeline_week';
 import keyboardMock from '../../helpers/keyboardMock.js';
 import pointerMock from '../../helpers/pointerMock.js';
 import {
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.api.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.api.tests.js
index 98202db67e19..e989cec079e4 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.api.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.api.tests.js
@@ -1,8 +1,8 @@
 import 'fluent_blue_light.css!';
 import $ from 'jquery';
 
-import '__internal/scheduler/workspaces/m_work_space_month';
-import '__internal/scheduler/workspaces/m_work_space_week';
+import '__internal/scheduler/workspaces/work_space_month';
+import '__internal/scheduler/workspaces/work_space_week';
 
 import {
     applyWorkspaceGroups,
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.base.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.base.tests.js
index adf684903370..f7196289aba7 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.base.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.base.tests.js
@@ -4,12 +4,12 @@ import 'fluent_blue_light.css!';
 import $ from 'jquery';
 import dateLocalization from 'common/core/localization/date';
 
-import '__internal/scheduler/workspaces/m_work_space_day';
-import '__internal/scheduler/workspaces/m_work_space_week';
-import '__internal/scheduler/workspaces/m_work_space_month';
-import '__internal/scheduler/workspaces/m_timeline_day';
-import '__internal/scheduler/workspaces/m_timeline_week';
-import '__internal/scheduler/workspaces/m_timeline_month';
+import '__internal/scheduler/workspaces/work_space_day';
+import '__internal/scheduler/workspaces/work_space_week';
+import '__internal/scheduler/workspaces/work_space_month';
+import '__internal/scheduler/workspaces/timeline_day';
+import '__internal/scheduler/workspaces/timeline_week';
+import '__internal/scheduler/workspaces/timeline_month';
 
 import { getEmptyResourceManager } from '../../helpers/scheduler/mockResourceManager.js';
 
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.day.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.day.tests.js
index ff8b429828d3..1cafe7833db2 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.day.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.day.tests.js
@@ -4,7 +4,7 @@ import $ from 'jquery';
 import resizeCallbacks from 'core/utils/resize_callbacks';
 import dateLocalization from 'common/core/localization/date';
 
-import '__internal/scheduler/workspaces/m_work_space_day';
+import '__internal/scheduler/workspaces/work_space_day';
 
 import {
     applyWorkspaceGroups,
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.month.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.month.tests.js
index 8b30fd37d9a2..70f6af424931 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.month.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.month.tests.js
@@ -3,7 +3,7 @@ import resizeCallbacks from 'core/utils/resize_callbacks';
 import 'fluent_blue_light.css!';
 import $ from 'jquery';
 
-import '__internal/scheduler/workspaces/m_work_space_month';
+import '__internal/scheduler/workspaces/work_space_month';
 import { getGroupWidth } from '__internal/scheduler/workspaces/helpers/m_position_helper';
 
 import { getEmptyResourceManager, getWorkspaceResourceConfig } from '../../helpers/scheduler/mockResourceManager.js';
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.navigation.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.navigation.tests.js
index c36905404fdf..e37dccf31854 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.navigation.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.navigation.tests.js
@@ -3,9 +3,9 @@ import { noop } from 'core/utils/common';
 import { isRenderer } from 'core/utils/type';
 import $ from 'jquery';
 
-import '__internal/scheduler/workspaces/m_work_space_day';
-import '__internal/scheduler/workspaces/m_work_space_month';
-import '__internal/scheduler/workspaces/m_work_space_week';
+import '__internal/scheduler/workspaces/work_space_day';
+import '__internal/scheduler/workspaces/work_space_month';
+import '__internal/scheduler/workspaces/work_space_week';
 
 import keyboardMock from '../../helpers/keyboardMock.js';
 import memoryLeaksHelper from '../../helpers/memoryLeaksHelper.js';
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.renovation.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.renovation.tests.js
index 551cc2999625..1bb8cb716820 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.renovation.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.renovation.tests.js
@@ -5,13 +5,13 @@ import $ from 'jquery';
 
 import { supportedScrollingModes } from '../../helpers/scheduler/helpers.js';
 
-import '__internal/scheduler/workspaces/m_work_space_day';
-import '__internal/scheduler/workspaces/m_work_space_month';
-import '__internal/scheduler/workspaces/m_work_space_week';
+import '__internal/scheduler/workspaces/work_space_day';
+import '__internal/scheduler/workspaces/work_space_month';
+import '__internal/scheduler/workspaces/work_space_week';
 
-import '__internal/scheduler/workspaces/m_timeline_day';
-import '__internal/scheduler/workspaces/m_timeline_month';
-import '__internal/scheduler/workspaces/m_timeline_week';
+import '__internal/scheduler/workspaces/timeline_day';
+import '__internal/scheduler/workspaces/timeline_month';
+import '__internal/scheduler/workspaces/timeline_week';
 
 import keyboardMock from '../../helpers/keyboardMock.js';
 import { applyWorkspaceGroups, getEmptyResourceManager } from '../../helpers/scheduler/mockResourceManager.js';
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.viewOffset.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.viewOffset.tests.js
index b51e7d6b42bc..ecc6fe4c8302 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.viewOffset.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.viewOffset.tests.js
@@ -1,11 +1,11 @@
 import $ from 'jquery';
 
 // workspace imports
-import '__internal/scheduler/workspaces/m_work_space_day';
-import '__internal/scheduler/workspaces/m_work_space_week';
-import '__internal/scheduler/workspaces/m_work_space_month';
-import '__internal/scheduler/workspaces/m_timeline_day';
-import '__internal/scheduler/workspaces/m_timeline_month';
+import '__internal/scheduler/workspaces/work_space_day';
+import '__internal/scheduler/workspaces/work_space_week';
+import '__internal/scheduler/workspaces/work_space_month';
+import '__internal/scheduler/workspaces/timeline_day';
+import '__internal/scheduler/workspaces/timeline_month';
 
 import { getEmptyResourceManager } from '../../helpers/scheduler/mockResourceManager.js';
 
diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.week.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.week.tests.js
index 30fa89fd58fe..9894ae7fcd55 100644
--- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.week.tests.js
+++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.scheduler/workSpace.week.tests.js
@@ -3,7 +3,7 @@ import { triggerShownEvent } from 'common/core/events/visibility_change';
 import 'fluent_blue_light.css!';
 import $ from 'jquery';
 
-import '__internal/scheduler/workspaces/m_work_space_week';
+import '__internal/scheduler/workspaces/work_space_week';
 
 import {
     applyWorkspaceGroups,