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 17098be9585a..58712491f26f 100644
--- a/packages/devextreme/js/__internal/scheduler/__tests__/workspace.base.test.ts
+++ b/packages/devextreme/js/__internal/scheduler/__tests__/workspace.base.test.ts
@@ -4,15 +4,15 @@ 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 SchedulerTimelineWorkWeek from '../workspaces/m_timeline_work_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 SchedulerWorkSpaceWorkWeek from '../workspaces/m_work_space_work_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 42c8595262a3..522b2b6356ba 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,21 +80,21 @@ 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 SchedulerAgenda from './workspaces/agenda';
 import SchedulerTimelineWorkWeek from './workspaces/m_timeline_work_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 SchedulerWorkSpaceWorkWeek from './workspaces/m_work_space_work_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';
 
 const toMs = dateUtils.dateToMilliseconds;
 
@@ -268,7 +269,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..105ea92fbd77 100644
--- a/packages/devextreme/js/__internal/scheduler/m_table_creator.ts
+++ b/packages/devextreme/js/__internal/scheduler/m_table_creator.ts
@@ -1,13 +1,28 @@
+import type { Orientation, template } 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 { 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 +144,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: template | 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/workspaces/m_agenda.ts b/packages/devextreme/js/__internal/scheduler/workspaces/agenda.ts
similarity index 59%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_agenda.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/agenda.ts
index 75beb7059358..a75d55e1a105 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_agenda.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/agenda.ts
@@ -2,14 +2,18 @@ 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 { ScrollableProperties } from '@ts/ui/scroll_view/scrollable';
 
+import type { Rect } from '../appointments/resizing/types';
 import {
   DATE_TABLE_CLASS,
   DATE_TABLE_ROW_CLASS,
@@ -17,13 +21,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 WorkspaceOptionChangedOptions, type WorkspaceOptionsInternal } from './m_work_space';
 
 const { tableCreator } = tableCreatorModule;
 
@@ -40,40 +45,56 @@ const LAST_ROW_CLASS = 'dx-scheduler-date-table-last-row';
 const INNER_CELL_MARGIN = 5;
 const OUTER_CELL_MARGIN = 20;
 
+interface AgendaDefaultOptions extends WorkspaceOptionsInternal {
+  agendaDuration: number;
+  rowHeight: number;
+  noDataText: string;
+}
+
+interface AgendaRenderOptions {
+  container: Element;
+  rowCount?: number;
+  cellCount?: number;
+  rowClass?: string;
+  cellClass?: string;
+  cellTemplate?: TemplateBase;
+  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() {
-    return extend(super._getDefaultOptions(), {
-      // Number | "month"
+  _getDefaultOptions(): AgendaDefaultOptions {
+    const defaultOptions = extend(super._getDefaultOptions(), {
       agendaDuration: 7,
       rowHeight: 60,
       noDataText: '',
-    });
+    }) as AgendaDefaultOptions;
+
+    return defaultOptions;
   }
 
-  _optionChanged(args) {
+  _optionChanged(args: OptionChanged<WorkspaceOptionChangedOptions>): void {
     const { name } = args;
     const { value } = args;
 
@@ -85,7 +106,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 +114,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 +125,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() {
+  protected override getRowCount(): number {
     return this.option('agendaDuration') as number;
   }
 
-  getCellCount() {
+  getCellCount(): number {
     return 1;
   }
 
-  protected override getTimePanelRowCount() {
+  protected override getTimePanelRowCount(): number {
     return this.option('agendaDuration') as number;
   }
 
-  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,20 +167,20 @@ 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() {
-    this.startViewDate = agendaUtils.calculateStartViewDate(this.option('currentDate') as any, this.option('startDayHour') as any);
+  protected override renderView(): void {
+    this.startViewDate = agendaUtils.calculateStartViewDate(this.option('currentDate'), this.option('startDayHour'));
     this.rows = [];
   }
 
-  private recalculateAgenda(rows) {
-    let cellTemplates = [];
+  private recalculateAgenda(rows: number[][]): void {
+    let cellTemplates: (() => dxElementWrapper)[] = [];
     this.cleanView();
 
     if (this.rowsIsEmpty(rows)) {
@@ -177,21 +200,25 @@ 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 createCrossScrollingConfig(): Pick<ScrollableProperties, 'direction' | 'onScroll' | 'onEnd'> {
+    return {
+      onScroll: noop,
+      onEnd: noop,
+    };
+  }
 
-  private setGroupHeaderCellsHeight() {
+  private setGroupHeaderCellsHeight(): void {
     const $cells = this.getGroupHeaderCells().filter((_, element) => !element.getAttribute('rowSpan'));
     const rows = this.removeEmptyRows(this.rows);
 
@@ -199,72 +226,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') as TemplateBase | undefined;
     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];
@@ -302,7 +313,7 @@ class SchedulerAgenda extends WorkSpace {
     };
   }
 
-  protected override cleanView() {
+  protected override cleanView(): void {
     this.$dateTable.empty();
     this.$timePanel.empty();
 
@@ -318,11 +329,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);
 
@@ -334,7 +345,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,
@@ -342,15 +353,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;
@@ -367,31 +392,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) {
@@ -409,9 +441,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();
     }
@@ -420,7 +452,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];
 
@@ -428,44 +460,38 @@ class SchedulerAgenda extends WorkSpace {
     }
   }
 
-  protected renderTimePanel() {
+  protected renderTimePanel(): void {
     this.renderTableBody({
       container: getPublicElement(this.$timePanel),
       rowCount: this.getTimePanelRowCount(),
       cellCount: 1,
       rowClass: TIME_PANEL_ROW_CLASS,
       cellClass: TIME_PANEL_CELL_CLASS,
-      cellTemplate: this.option('dateCellTemplate'),
+      cellTemplate: this.option('dateCellTemplate') as TemplateBase | undefined,
       getStartDate: this.getTimePanelStartDate.bind(this),
     });
   }
 
-  private getTimePanelStartDate(rowIndex) {
-    const current = new Date(this.option('currentDate') as any);
+  private getTimePanelStartDate(rowIndex: number): Date {
+    const current = new Date(this.option('currentDate'));
     const cellDate = new Date(current.setDate(current.getDate() + rowIndex));
 
     return cellDate;
   }
 
-  private getRowHeight(rowSize) {
-    const baseHeight = this.option('rowHeight') as any;
+  private getRowHeight(rowSize: number): number {
+    const baseHeight = this.option('rowHeight') as number;
     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 {
@@ -480,39 +506,37 @@ class SchedulerAgenda extends WorkSpace {
     this.recalculateAgenda(rows);
   }
 
-  getAgendaVerticalStepHeight() {
-    return this.option('rowHeight');
+  getAgendaVerticalStepHeight(): number {
+    return this.option('rowHeight') as number;
   }
 
-  getEndViewDate() {
-    const currentDate = new Date(this.option('currentDate') as any);
-    const agendaDuration: any = this.option('agendaDuration');
+  getEndViewDate(): Date {
+    const currentDate = new Date(this.option('currentDate'));
+    const agendaDuration = this.option('agendaDuration') as number;
 
-    currentDate.setHours(this.option('endDayHour') as any);
+    currentDate.setHours(this.option('endDayHour'));
 
     const result = currentDate.setDate(currentDate.getDate() + agendaDuration - 1) - 60000;
 
     return new Date(result);
   }
 
-  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 +547,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_timeline_work_week.ts b/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_work_week.ts
index f4fe25697191..c1823c52e86b 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_work_week.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_work_week.ts
@@ -4,7 +4,7 @@ import {
 } from '@ts/scheduler/r1/utils/index';
 
 import { VIEWS } from '../utils/options/constants_view';
-import SchedulerTimelineWeek from './m_timeline_week';
+import SchedulerTimelineWeek from './timeline_week';
 
 const TIMELINE_CLASS = 'dx-scheduler-timeline-work-week';
 const LAST_DAY_WEEK_INDEX = 5;
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 d83022613360..267913858559 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space.ts
@@ -1,3 +1,4 @@
+import type { template } from '@js/common';
 import { locate, resetPosition } from '@js/common/core/animation/translator';
 import { name as clickEventName } from '@js/common/core/events/click';
 import { name as contextMenuEventName } from '@js/common/core/events/contextmenu';
@@ -10,6 +11,7 @@ import {
 import pointerEvents from '@js/common/core/events/pointer';
 import { addNamespace, isMouseEvent } from '@js/common/core/events/utils/index';
 import domAdapter from '@js/core/dom_adapter';
+import type { DxElement } from '@js/core/element';
 import { getPublicElement } from '@js/core/element';
 import type { dxElementWrapper } from '@js/core/renderer';
 import $ from '@js/core/renderer';
@@ -28,10 +30,11 @@ 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 { 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,
@@ -50,7 +54,7 @@ import {
   isDateAndTimeView,
 } from '@ts/scheduler/r1/utils/index';
 import type { ViewType } from '@ts/scheduler/types';
-import Scrollable from '@ts/ui/scroll_view/scrollable';
+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,10 +72,12 @@ 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 type { SafeSchedulerOptions } from '../utils/options/types';
 import {
   getAppointmentGroupIndex,
   getSafeGroupValues,
@@ -106,6 +112,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
@@ -188,7 +207,7 @@ const DEFAULT_WORKSPACE_RENDER_OPTIONS: RenderRWorkspaceOptions = {
   generateNewData: true,
 };
 
-type WorkspaceOptionsInternal = Omit<dxSchedulerOptions, 'groups'> & {
+export type WorkspaceOptionsInternal = Omit<SafeSchedulerOptions, 'groups'> & {
   groups: ResourceLoader[];
   getResourceManager: () => ResourceManager;
   startDate?: Date;
@@ -198,6 +217,35 @@ type WorkspaceOptionsInternal = Omit<dxSchedulerOptions, 'groups'> & {
   startDayHour: number;
   endDayHour: number;
 };
+
+export type WorkspaceOptionChangedOptions = WorkspaceOptionsInternal & {
+  onSelectionChanged?: (args: { selectedCellData: ViewCellData[] }) => void;
+  onSelectionEnd?: (args: { selectedCellData: ViewCellData[] }) => void;
+  onCellClick?: (args: { cellData: ViewCellData; cellElement: DxElement; event: Event }) => void;
+  onCellContextMenu?: (args: {
+    cellData: ViewCellData;
+    cellElement: DxElement;
+    event: Event;
+  }) => void;
+  viewOffset?: number;
+  groupOrientation?: 'horizontal' | 'vertical';
+  timeZoneCalculator?: TimeZoneCalculator;
+  allDayExpanded?: boolean;
+  width?: number | string;
+  allowMultipleCellSelection?: boolean;
+  selectedCellData?: ViewCellData[];
+  scrolling?: SafeSchedulerOptions['scrolling'];
+  schedulerHeight?: number;
+  schedulerWidth?: number;
+  agendaDuration?: number;
+  rowHeight?: number;
+  noDataText?: string;
+  showCurrentTimeIndicator?: boolean;
+  indicatorTime?: Date;
+  indicatorUpdateInterval?: number;
+  shadeUntilCurrentTime?: boolean;
+};
+
 class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
   private viewDataProviderValue: any;
 
@@ -251,7 +299,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
 
   private contextMenuAction: any;
 
-  protected $groupTable: any;
+  protected $groupTable: dxElementWrapper | null | undefined;
 
   protected $thead: any;
 
@@ -651,8 +699,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,
@@ -665,14 +713,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);
         }
@@ -689,7 +737,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
       const currentOnScroll = config.onScroll;
       config = {
         ...config,
-        onScroll: (e) => {
+        onScroll: (e: ScrollEvent) => {
           currentOnScroll?.(e);
 
           this.virtualScrollingDispatcher.handleOnScrollEvent(e?.scrollOffset);
@@ -700,14 +748,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)();
@@ -715,7 +773,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     };
   }
 
-  protected headerScrollableConfig() {
+  protected headerScrollableConfig(): ScrollableProperties {
     return {
       useKeyboard: false,
       showScrollbar: 'never',
@@ -723,7 +781,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
       useNative: false,
       updateManually: true,
       bounceEnabled: false,
-      onScroll: (event) => {
+      onScroll: (event: ScrollEvent) => {
         this.scrollSync.dateTable({ left: event.scrollOffset.left });
       },
     };
@@ -852,14 +910,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,
@@ -1104,7 +1162,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) {
@@ -1218,7 +1276,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     });
   }
 
-  protected getFormat() { return abstract(); }
+  protected getFormat(): string | ((date: Date) => string) { return abstract(); }
 
   getWorkArea() {
     return this.$dateTableContainer;
@@ -1274,7 +1332,8 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     };
   }
 
-  protected getDateGenerationOptions() {
+  protected getDateGenerationOptions(): ViewDateGenerationOptions {
+    // @ts-expect-error
     return {
       startDayHour: this.option('startDayHour'),
       endDayHour: this.option('endDayHour'),
@@ -2247,9 +2306,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,
@@ -2282,18 +2341,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<WorkspaceOptionChangedOptions>): void {
     switch (args.name) {
       case 'startDayHour':
       case 'endDayHour':
@@ -2769,7 +2830,7 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     this.$element().addClass(className);
   }
 
-  protected getDateHeaderTemplate() {
+  protected getDateHeaderTemplate(): template | undefined | null {
     return this.option('dateCellTemplate');
   }
 
@@ -2880,7 +2941,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();
@@ -2899,7 +2960,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(
@@ -2932,7 +2993,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());
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_work_space_work_week.ts b/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_work_week.ts
index c0b43a1bc5aa..10acbf950afe 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_work_week.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_work_week.ts
@@ -4,7 +4,7 @@ import {
 } from '@ts/scheduler/r1/utils/index';
 
 import { VIEWS } from '../utils/options/constants_view';
-import SchedulerWorkSpaceWeek from './m_work_space_week';
+import SchedulerWorkSpaceWeek from './work_space_week';
 
 const WORK_WEEK_CLASS = 'dx-scheduler-work-space-work-week';
 class SchedulerWorkSpaceWorkWeek extends SchedulerWorkSpaceWeek {
diff --git a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline.ts b/packages/devextreme/js/__internal/scheduler/workspaces/timeline.ts
similarity index 63%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_timeline.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/timeline.ts
index 9c7472ad4797..40ace86ccdbe 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/timeline.ts
@@ -1,23 +1,27 @@
 import registerComponent from '@js/core/component_registrator';
-import $ from '@js/core/renderer';
+import $, { type dxElementWrapper } from '@js/core/renderer';
 import { noop } from '@js/core/utils/common';
 import dateUtils from '@js/core/utils/date';
 import { extend } from '@js/core/utils/extend';
 import { getBoundingRect } from '@js/core/utils/position';
 import { getOuterHeight, getOuterWidth, setHeight } from '@js/core/utils/size';
 import { hasWindow } from '@js/core/utils/window';
+import type { dxSchedulerOptions } from '@js/ui/scheduler';
 // 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 SchedulerWorkSpace from './m_work_space_indicator';
+import type { ResourceLoader } from '../utils/loader/resource_loader';
+import type { ViewDataProviderOptions } from './view_model/m_types';
+import SchedulerWorkSpace, { type WorkSpaceIndicatorDefaultOptions } from './work_space_indicator';
 
 const { tableCreator } = tableCreatorModule;
 
@@ -32,89 +36,99 @@ const HEADER_PANEL_WEEK_CELL_CLASS = 'dx-scheduler-header-panel-week-cell';
 const HORIZONTAL = 'horizontal';
 const toMs = dateUtils.dateToMilliseconds;
 
+interface TimelineDefaultOptions extends WorkSpaceIndicatorDefaultOptions {
+  groupOrientation: 'vertical';
+}
+
 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 {
+  protected override getFormat(): string {
     return '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 {
     date.setDate(date.getDate() + 1);
   }
 
-  getIndicationCellCount() {
+  getIndicationCellCount(): number {
     const timeDiff = this.getTimeDiff();
     return this.calculateDurationInCells(timeDiff);
   }
 
-  private getTimeDiff() {
+  private getTimeDiff(): number {
     let today = this.getToday();
     const date = this.getIndicationFirstViewDate();
 
@@ -128,12 +142,12 @@ 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'));
-    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();
     }
 
@@ -143,7 +157,7 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     return differenceInDays * this.getCellCountInDay() + duration;
   }
 
-  getIndicationWidth() {
+  getIndicationWidth(): number {
     if (this.isGroupedByDate()) {
       const cellCount = this.getIndicationCellCount();
       const integerPart = Math.floor(cellCount);
@@ -154,15 +168,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();
@@ -172,7 +186,7 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     this.virtualScrollingDispatcher.updateDimensions();
   }
 
-  private getWorkSpaceMinHeight() {
+  private getWorkSpaceMinHeight(): number {
     let minHeight = this.getWorkSpaceHeight();
 
     const workspaceContainerHeight = getOuterHeight(this.$flexContainer, true);
@@ -184,32 +198,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();
@@ -223,7 +242,7 @@ class SchedulerTimeline extends SchedulerWorkSpace {
     let tailDelta = 0;
     const cellCount = this.getCellCountInDay() * (fullDays - this.getWeekendsCount(fullDays));
     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();
@@ -252,38 +271,37 @@ class SchedulerTimeline extends SchedulerWorkSpace {
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected override getWeekendsCount(argument?: any) {
+  protected override getWeekendsCount(days: number): number {
     return 0;
   }
 
-  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,
@@ -296,39 +314,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(): TimelineDefaultOptions {
     return extend(super._getDefaultOptions(), {
       groupOrientation: 'vertical',
-    });
+    }) as TimelineDefaultOptions;
   }
 
-  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(): dxSchedulerOptions['timeCellTemplate'] {
     return this.option('timeCellTemplate');
   }
 
-  protected override renderView() {
+  protected override renderView(): void {
     this.renderWorkSpace();
     this.virtualScrollingDispatcher.updateDimensions();
 
@@ -343,14 +364,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);
@@ -368,8 +389,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') {
@@ -377,8 +404,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);
 
@@ -387,7 +415,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(
@@ -407,5 +438,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..1c088ed3626f
--- /dev/null
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/timeline_month.ts
@@ -0,0 +1,87 @@
+import registerComponent from '@js/core/component_registrator';
+import type { template } from '@js/core/templates/template';
+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;
+  }
+
+  // @ts-expect-error
+  protected override getDateHeaderTemplate(): template | undefined | null {
+    return this.option('dateCellTemplate');
+  }
+
+  protected override calculateDurationInCells(timeDiff: number): number {
+    return timeDiff / this.getCellDuration();
+  }
+
+  isIndicatorVisible(): boolean {
+    return true;
+  }
+
+  // @ts-expect-error
+  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 53%
rename from packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_week.ts
rename to packages/devextreme/js/__internal/scheduler/workspaces/timeline_week.ts
index 0f38e0b3cdd5..dd2df1b419aa 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_timeline_week.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/timeline_week.ts
@@ -1,24 +1,26 @@
 import registerComponent from '@js/core/component_registrator';
+import type { ViewType } from '@js/ui/scheduler';
 
 import { VIEWS } from '../utils/options/constants_view';
-import SchedulerTimeline from './m_timeline';
+import SchedulerTimeline from './timeline';
 
 const TIMELINE_CLASS = 'dx-scheduler-timeline-week';
 
 export default class SchedulerTimelineWeek extends SchedulerTimeline {
-  get type() { return VIEWS.TIMELINE_WEEK; }
+  get type(): ViewType { return VIEWS.TIMELINE_WEEK; }
 
-  protected override getElementClass() {
+  protected override getElementClass(): string {
     return TIMELINE_CLASS;
   }
 
-  protected override needRenderWeekHeader() {
+  protected override needRenderWeekHeader(): boolean {
     return true;
   }
 
-  protected override incrementDate(date) {
+  protected override incrementDate(date: Date): void {
     date.setDate(date.getDate() + 1);
   }
 }
 
+// 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 79%
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 3f9f92ffd70e..b608a4dd3fe6 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,23 +1,34 @@
 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 WorkspaceOptionChangedOptions,
+  type WorkspaceOptionsInternal,
+} from './m_work_space';
 
 const toMs = dateUtils.dateToMilliseconds;
 
 const SCHEDULER_DATE_TIME_INDICATOR_CLASS = 'dx-scheduler-date-time-indicator';
 
+export interface WorkSpaceIndicatorDefaultOptions extends WorkspaceOptionsInternal {
+  showCurrentTimeIndicator: boolean;
+  indicatorTime: Date;
+  indicatorUpdateInterval: number;
+  shadeUntilCurrentTime: boolean;
+}
+
 class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
-  private indicatorInterval: any;
+  private indicatorInterval?: ReturnType<typeof setTimeout>;
 
   protected getToday(): Date {
     const viewOffset = this.option('viewOffset') as number;
@@ -35,7 +46,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return false;
   }
 
-  isIndicationAvailable() {
+  isIndicationAvailable(): boolean {
     if (!hasWindow()) {
       return false;
     }
@@ -45,7 +56,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 +68,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 +87,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 +131,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return Math.min(width, maxWidth);
   }
 
-  getIndicatorOffset() {
+  getIndicatorOffset(): number {
     const cellSpan = this.getIndicatorDaysSpan() - 1;
     const offset = cellSpan * this.getCellWidth();
 
@@ -134,7 +151,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());
@@ -149,9 +166,9 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     return cellCount * cellHeight;
   }
 
-  _dispose() {
+  _dispose(): void {
     this.clearIndicatorUpdateInterval();
-    super._dispose.apply(this, arguments as any);
+    super._dispose();
   }
 
   renderCurrentDateTimeIndication(): void {
@@ -183,7 +200,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)) {
@@ -193,30 +210,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<WorkspaceOptionChangedOptions>): void {
     switch (args.name) {
       case 'showCurrentTimeIndicator':
       case 'indicatorTime':
@@ -239,16 +256,16 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
     }
   }
 
-  _getDefaultOptions() {
+  _getDefaultOptions(): WorkSpaceIndicatorDefaultOptions {
     return extend(super._getDefaultOptions(), {
       showCurrentTimeIndicator: true,
       indicatorTime: new Date(),
       indicatorUpdateInterval: 5 * toMs('minute'),
       shadeUntilCurrentTime: true,
-    });
+    }) as WorkSpaceIndicatorDefaultOptions;
   }
 
-  protected getCurrentTimePanelCellIndices() {
+  protected getCurrentTimePanelCellIndices(): number[] {
     const rowCountPerGroup = this.getTimePanelRowCount();
     const today = this.getToday();
     const index = this.getCellIndexByDate(today);
@@ -258,10 +275,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];
@@ -272,7 +288,7 @@ class SchedulerWorkSpaceIndicator extends SchedulerWorkSpace {
       : 1;
 
     return [...new Array(verticalGroupCount)]
-      .reduce((currentIndices, _, groupIndex) => [
+      .reduce<number[]>((currentIndices, _, groupIndex) => [
         ...currentIndices,
         ...cellIndices.map((cellIndex) => rowCountPerGroup * groupIndex + cellIndex),
       ], []);
@@ -304,5 +320,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 65%
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 e756a49ad902..c9ab5838b778 100644
--- a/packages/devextreme/js/__internal/scheduler/workspaces/m_work_space_week.ts
+++ b/packages/devextreme/js/__internal/scheduler/workspaces/work_space_week.ts
@@ -1,4 +1,5 @@
 import registerComponent from '@js/core/component_registrator';
+import type { ViewType } from '@js/ui/scheduler';
 import { weekUtils } from '@ts/scheduler/r1/utils/index';
 
 import { VIEWS } from '../utils/options/constants_view';
@@ -6,17 +7,18 @@ import SchedulerWorkSpaceVertical from './m_work_space_vertical';
 
 const WEEK_CLASS = 'dx-scheduler-work-space-week';
 class SchedulerWorkSpaceWeek extends SchedulerWorkSpaceVertical {
-  get type() { return VIEWS.WEEK; }
+  get type(): ViewType { return VIEWS.WEEK; }
 
-  protected override getElementClass() {
+  protected override getElementClass(): string {
     return 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 763d750cb6b8..ab3898d17b81 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,12 +17,12 @@ 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/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/m_timeline_work_week';
-import '__internal/scheduler/workspaces/m_timeline_month';
+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 f433207e67af..e7ccdee90aba 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,9 +1,9 @@
 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 SchedulerTimeline from '__internal/scheduler/workspaces/timeline';
+import SchedulerTimelineDay from '__internal/scheduler/workspaces/timeline_day';
+import SchedulerTimelineWeek from '__internal/scheduler/workspaces/timeline_week';
 import SchedulerTimelineWorkWeek from '__internal/scheduler/workspaces/m_timeline_work_week';
-import SchedulerTimelineMonth from '__internal/scheduler/workspaces/m_timeline_month';
+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 5d9d239a9e94..28f270f21621 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
@@ -4,10 +4,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 '__internal/scheduler/workspaces/m_timeline_work_week';
 import keyboardMock from '../../helpers/keyboardMock.js';
 import pointerMock from '../../helpers/pointerMock.js';
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 f4475aca92ef..bff1349dd1e8 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,8 +3,8 @@ 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/work_space_day';
+import '__internal/scheduler/workspaces/work_space_month';
 import '__internal/scheduler/workspaces/m_work_space_work_week';
 
 import keyboardMock from '../../helpers/keyboardMock.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 00caa5eb920f..245e8439740d 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 '__internal/scheduler/workspaces/m_work_space_work_week';
 
 import {