From 94adf948462720c5778093ea4225158f0e62678e Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Thu, 23 Mar 2023 12:38:15 +0300
Subject: [PATCH 01/23] Rebase on master

---
 src/api/candlestick-series-api.ts             |   2 +-
 src/api/chart-api.ts                          |  99 +++----
 src/api/create-chart.ts                       |  99 ++++++-
 src/api/data-consumer.ts                      |  79 ++----
 src/api/data-layer.ts                         | 264 +++++++----------
 src/api/data-validators.ts                    |  25 +-
 src/api/get-series-data-creator.ts            |  51 ++--
 src/api/get-series-plot-row-creator.ts        |  55 ++--
 src/api/ichart-api.ts                         |  43 +--
 src/api/iseries-api.ts                        |  18 +-
 src/api/itime-scale-api.ts                    |  23 +-
 src/api/options/chart-options-defaults.ts     | 102 +++----
 .../options/time-scale-options-defaults.ts    |   1 +
 src/api/price-line-api.ts                     |   8 +-
 src/api/price-scale-api.ts                    |   8 +-
 src/api/series-api.ts                         |  61 ++--
 src/api/time-scale-api.ts                     |  45 +--
 src/gui/chart-widget.ts                       |  68 ++---
 src/gui/pane-separator.ts                     |  10 +-
 src/gui/pane-widget.ts                        |  52 ++--
 src/gui/price-axis-stub.ts                    |  14 +-
 src/gui/price-axis-widget.ts                  |  54 ++--
 src/gui/time-axis-widget.ts                   |  36 +--
 src/index.ts                                  |   8 +-
 src/model/chart-model.ts                      | 124 ++++----
 src/model/crosshair.ts                        |  54 ++--
 src/model/custom-price-line.ts                |  19 +-
 src/model/data-source.ts                      |  16 +-
 src/model/formatted-labels-cache.ts           |  19 +-
 src/model/grid.ts                             |   8 +-
 .../default-tick-mark-formatter.ts            |   5 +-
 .../horz-scale-behavior-time.ts               | 266 ++++++++++++++++++
 .../time-scale-point-weight-generator.ts      |  24 +-
 src/model/horz-scale-behavior-time/types.ts   | 130 +++++++++
 src/model/idata-source.ts                     |  16 +-
 src/model/ihorz-scale-behavior.ts             |  32 +++
 src/model/iprice-data-source.ts               |   9 +-
 src/model/localization-options.ts             |   7 +-
 src/model/magnet.ts                           |  11 +-
 src/model/pane.ts                             |  88 +++---
 src/model/plot-data.ts                        |   9 +-
 src/model/plot-list.ts                        |   2 +-
 src/model/price-data-source.ts                |   8 +-
 src/model/price-scale.ts                      |  30 +-
 src/model/price-tick-mark-builder.ts          |   6 +-
 src/model/series-bar-colorer.ts               | 181 ++++++------
 src/model/series-data.ts                      |  34 +--
 src/model/series-markers.ts                   |  11 +-
 src/model/series.ts                           |  86 +++---
 src/model/sort-sources.ts                     |   4 +-
 src/model/tick-marks.ts                       |  45 +--
 src/model/time-data.ts                        |  94 +------
 src/model/time-scale.ts                       | 187 +++---------
 src/model/watermark.ts                        |  10 +-
 src/renderers/itime-axis-view-renderer.ts     |   2 +-
 .../price-axis-renderer-options-provider.ts   |   6 +-
 src/renderers/time-axis-view-renderer.ts      |   2 +-
 src/views/pane/area-pane-view.ts              |   6 +-
 src/views/pane/bars-pane-view-base.ts         |  12 +-
 src/views/pane/bars-pane-view.ts              |   5 +-
 src/views/pane/baseline-pane-view.ts          |   6 +-
 src/views/pane/candlesticks-pane-view.ts      |   4 +-
 src/views/pane/crosshair-marks-pane-view.ts   |  11 +-
 src/views/pane/crosshair-pane-view.ts         |   6 +-
 src/views/pane/custom-price-line-pane-view.ts |   7 +-
 src/views/pane/grid-pane-view.ts              |   6 +-
 src/views/pane/histogram-pane-view.ts         |   4 +-
 src/views/pane/ipane-view.ts                  |   2 +-
 src/views/pane/iupdatable-pane-view.ts        |   2 +-
 src/views/pane/line-pane-view-base.ts         |  13 +-
 src/views/pane/line-pane-view.ts              |   4 +-
 src/views/pane/pane-price-axis-view.ts        |  10 +-
 .../series-horizontal-base-line-pane-view.ts  |   5 +-
 .../pane/series-horizontal-line-pane-view.ts  |   9 +-
 .../series-last-price-animation-pane-view.ts  |   6 +-
 src/views/pane/series-markers-pane-view.ts    |  19 +-
 src/views/pane/series-pane-view-base.ts       |  10 +-
 src/views/pane/series-price-line-pane-view.ts |   6 +-
 src/views/pane/watermark-pane-view.ts         |   6 +-
 .../price-axis/crosshair-price-axis-view.ts   |  12 +-
 .../custom-price-line-price-axis-view.ts      |   9 +-
 src/views/price-axis/iprice-axis-view.ts      |   4 +-
 src/views/price-axis/price-axis-view.ts       |   4 +-
 .../price-axis/series-price-axis-view.ts      |   8 +-
 .../time-axis/crosshair-time-axis-view.ts     |  12 +-
 src/views/time-axis/itime-axis-view.ts        |   4 +-
 .../default-tick-mark-formatter.spec.ts       |   5 +-
 87 files changed, 1634 insertions(+), 1353 deletions(-)
 rename src/model/{ => horz-scale-behavior-time}/default-tick-mark-formatter.ts (91%)
 create mode 100644 src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
 rename src/{api => model/horz-scale-behavior-time}/time-scale-point-weight-generator.ts (69%)
 create mode 100644 src/model/horz-scale-behavior-time/types.ts
 create mode 100644 src/model/ihorz-scale-behavior.ts

diff --git a/src/api/candlestick-series-api.ts b/src/api/candlestick-series-api.ts
index db44370cca..2453f91267 100644
--- a/src/api/candlestick-series-api.ts
+++ b/src/api/candlestick-series-api.ts
@@ -5,7 +5,7 @@ import {
 
 import { SeriesApi } from './series-api';
 
-export class CandlestickSeriesApi extends SeriesApi<'Candlestick'> {
+export class CandlestickSeriesApi<HorzScaleItem> extends SeriesApi<'Candlestick', HorzScaleItem> {
 	public override applyOptions(options: CandlestickSeriesPartialOptions): void {
 		fillUpDownCandlesticksColors(options);
 		super.applyOptions(options);
diff --git a/src/api/chart-api.ts b/src/api/chart-api.ts
index 9c638641b3..653e451d4c 100644
--- a/src/api/chart-api.ts
+++ b/src/api/chart-api.ts
@@ -6,6 +6,7 @@ import { warn } from '../helpers/logger';
 import { clone, DeepPartial, isBoolean, merge } from '../helpers/strict-type-checks';
 
 import { ChartOptions, ChartOptionsInternal } from '../model/chart-model';
+import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 import { Series } from '../model/series';
 import { SeriesPlotRow } from '../model/series-data';
 import {
@@ -24,7 +25,7 @@ import {
 	SeriesStyleOptionsMap,
 	SeriesType,
 } from '../model/series-options';
-import { Logical, Time } from '../model/time-data';
+import { Logical } from '../model/time-data';
 
 import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap } from './data-consumer';
 import { DataLayer, DataUpdateResponse, SeriesChanges } from './data-layer';
@@ -57,7 +58,7 @@ function patchPriceFormat(priceFormat?: DeepPartial<PriceFormat>): void {
 	}
 }
 
-function migrateHandleScaleScrollOptions(options: DeepPartial<ChartOptions>): void {
+function migrateHandleScaleScrollOptions<HorzScaleItem>(options: DeepPartial<ChartOptions<HorzScaleItem>>): void {
 	if (isBoolean(options.handleScale)) {
 		const handleScale = options.handleScale;
 		options.handleScale = {
@@ -99,34 +100,38 @@ function migrateHandleScaleScrollOptions(options: DeepPartial<ChartOptions>): vo
 	}
 }
 
-function toInternalOptions(options: DeepPartial<ChartOptions>): DeepPartial<ChartOptionsInternal> {
+function toInternalOptions<HorzScaleItem>(options: DeepPartial<ChartOptions<HorzScaleItem>>): DeepPartial<ChartOptionsInternal<HorzScaleItem>> {
 	migrateHandleScaleScrollOptions(options);
 
-	return options as DeepPartial<ChartOptionsInternal>;
+	return options as DeepPartial<ChartOptionsInternal<HorzScaleItem>>;
 }
 
-export type IPriceScaleApiProvider = Pick<IChartApi, 'priceScale'>;
+export type IPriceScaleApiProvider<HorzScaleItem> = Pick<IChartApi<HorzScaleItem>, 'priceScale'>;
 
-export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
-	private _chartWidget: ChartWidget;
-	private _dataLayer: DataLayer = new DataLayer();
-	private readonly _seriesMap: Map<SeriesApi<SeriesType>, Series> = new Map();
-	private readonly _seriesMapReversed: Map<Series, SeriesApi<SeriesType>> = new Map();
+export class ChartApi<HorzScaleItem> implements IChartApi<HorzScaleItem>, DataUpdatesConsumer<SeriesType, HorzScaleItem> {
+	private _chartWidget: ChartWidget<HorzScaleItem>;
+	private _dataLayer: DataLayer<HorzScaleItem>;
+	private readonly _seriesMap: Map<SeriesApi<SeriesType, HorzScaleItem>, Series<SeriesType, HorzScaleItem>> = new Map();
+	private readonly _seriesMapReversed: Map<Series<SeriesType, HorzScaleItem>, SeriesApi<SeriesType, HorzScaleItem>> = new Map();
 
-	private readonly _clickedDelegate: Delegate<MouseEventParams> = new Delegate();
-	private readonly _crosshairMovedDelegate: Delegate<MouseEventParams> = new Delegate();
+	private readonly _clickedDelegate: Delegate<MouseEventParams<HorzScaleItem>> = new Delegate();
+	private readonly _crosshairMovedDelegate: Delegate<MouseEventParams<HorzScaleItem>> = new Delegate();
 
-	private readonly _timeScaleApi: TimeScaleApi;
+	private readonly _timeScaleApi: TimeScaleApi<HorzScaleItem>;
 
-	public constructor(container: HTMLElement, options?: DeepPartial<ChartOptions>) {
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(container: HTMLElement, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, options?: DeepPartial<ChartOptions<HorzScaleItem>>) {
+		this._dataLayer = new DataLayer<HorzScaleItem>(horzScaleBehavior);
 		const internalOptions = (options === undefined) ?
-			clone(chartOptionsDefaults) :
-			merge(clone(chartOptionsDefaults), toInternalOptions(options)) as ChartOptionsInternal;
+			clone(chartOptionsDefaults<HorzScaleItem>()) :
+			merge(clone(chartOptionsDefaults()), toInternalOptions(options)) as ChartOptionsInternal<HorzScaleItem>;
 
-		this._chartWidget = new ChartWidget(container, internalOptions);
+		this._horzScaleBehavior = horzScaleBehavior;
+		this._chartWidget = new ChartWidget(container, internalOptions, horzScaleBehavior);
 
 		this._chartWidget.clicked().subscribe(
-			(paramSupplier: MouseEventParamsImplSupplier) => {
+			(paramSupplier: MouseEventParamsImplSupplier<HorzScaleItem>) => {
 				if (this._clickedDelegate.hasListeners()) {
 					this._clickedDelegate.fire(this._convertMouseParams(paramSupplier()));
 				}
@@ -134,7 +139,7 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 			this
 		);
 		this._chartWidget.crosshairMoved().subscribe(
-			(paramSupplier: MouseEventParamsImplSupplier) => {
+			(paramSupplier: MouseEventParamsImplSupplier<HorzScaleItem>) => {
 				if (this._crosshairMovedDelegate.hasListeners()) {
 					this._crosshairMovedDelegate.fire(this._convertMouseParams(paramSupplier()));
 				}
@@ -143,7 +148,7 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 		);
 
 		const model = this._chartWidget.model();
-		this._timeScaleApi = new TimeScaleApi(model, this._chartWidget.timeAxisWidget());
+		this._timeScaleApi = new TimeScaleApi(model, this._chartWidget.timeAxisWidget(), this._horzScaleBehavior);
 	}
 
 	public remove(): void {
@@ -171,33 +176,33 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 		this._chartWidget.resize(width, height, forceRepaint);
 	}
 
-	public addAreaSeries(options?: AreaSeriesPartialOptions): ISeriesApi<'Area'> {
+	public addAreaSeries(options?: AreaSeriesPartialOptions): ISeriesApi<'Area', HorzScaleItem> {
 		return this._addSeriesImpl('Area', areaStyleDefaults, options);
 	}
 
-	public addBaselineSeries(options?: BaselineSeriesPartialOptions): ISeriesApi<'Baseline'> {
+	public addBaselineSeries(options?: BaselineSeriesPartialOptions): ISeriesApi<'Baseline', HorzScaleItem> {
 		return this._addSeriesImpl('Baseline', baselineStyleDefaults, options);
 	}
 
-	public addBarSeries(options?: BarSeriesPartialOptions): ISeriesApi<'Bar'> {
+	public addBarSeries(options?: BarSeriesPartialOptions): ISeriesApi<'Bar', HorzScaleItem> {
 		return this._addSeriesImpl('Bar', barStyleDefaults, options);
 	}
 
-	public addCandlestickSeries(options: CandlestickSeriesPartialOptions = {}): ISeriesApi<'Candlestick'> {
+	public addCandlestickSeries(options: CandlestickSeriesPartialOptions = {}): ISeriesApi<'Candlestick', HorzScaleItem> {
 		fillUpDownCandlesticksColors(options);
 
 		return this._addSeriesImpl('Candlestick', candlestickStyleDefaults, options);
 	}
 
-	public addHistogramSeries(options?: HistogramSeriesPartialOptions): ISeriesApi<'Histogram'> {
+	public addHistogramSeries(options?: HistogramSeriesPartialOptions): ISeriesApi<'Histogram', HorzScaleItem> {
 		return this._addSeriesImpl('Histogram', histogramStyleDefaults, options);
 	}
 
-	public addLineSeries(options?: LineSeriesPartialOptions): ISeriesApi<'Line'> {
+	public addLineSeries(options?: LineSeriesPartialOptions): ISeriesApi<'Line', HorzScaleItem> {
 		return this._addSeriesImpl('Line', lineStyleDefaults, options);
 	}
 
-	public removeSeries(seriesApi: SeriesApi<SeriesType>): void {
+	public removeSeries(seriesApi: SeriesApi<SeriesType, HorzScaleItem>): void {
 		const series = ensureDefined(this._seriesMap.get(seriesApi));
 
 		const update = this._dataLayer.removeSeries(series);
@@ -210,27 +215,27 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 		this._seriesMapReversed.delete(series);
 	}
 
-	public applyNewData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap[TSeriesType][]): void {
+	public applyNewData<TSeriesType extends SeriesType>(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void {
 		this._sendUpdateToChart(this._dataLayer.setSeriesData(series, data));
 	}
 
-	public updateData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap[TSeriesType]): void {
+	public updateData<TSeriesType extends SeriesType>(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void {
 		this._sendUpdateToChart(this._dataLayer.updateSeriesData(series, data));
 	}
 
-	public subscribeClick(handler: MouseEventHandler): void {
+	public subscribeClick(handler: MouseEventHandler<HorzScaleItem>): void {
 		this._clickedDelegate.subscribe(handler);
 	}
 
-	public unsubscribeClick(handler: MouseEventHandler): void {
+	public unsubscribeClick(handler: MouseEventHandler<HorzScaleItem>): void {
 		this._clickedDelegate.unsubscribe(handler);
 	}
 
-	public subscribeCrosshairMove(handler: MouseEventHandler): void {
+	public subscribeCrosshairMove(handler: MouseEventHandler<HorzScaleItem>): void {
 		this._crosshairMovedDelegate.subscribe(handler);
 	}
 
-	public unsubscribeCrosshairMove(handler: MouseEventHandler): void {
+	public unsubscribeCrosshairMove(handler: MouseEventHandler<HorzScaleItem>): void {
 		this._crosshairMovedDelegate.unsubscribe(handler);
 	}
 
@@ -238,16 +243,16 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 		return new PriceScaleApi(this._chartWidget, priceScaleId);
 	}
 
-	public timeScale(): ITimeScaleApi {
+	public timeScale(): ITimeScaleApi<HorzScaleItem> {
 		return this._timeScaleApi;
 	}
 
-	public applyOptions(options: DeepPartial<ChartOptions>): void {
+	public applyOptions(options: DeepPartial<ChartOptions<HorzScaleItem>>): void {
 		this._chartWidget.applyOptions(toInternalOptions(options));
 	}
 
-	public options(): Readonly<ChartOptions> {
-		return this._chartWidget.options() as Readonly<ChartOptions>;
+	public options(): Readonly<ChartOptions<HorzScaleItem>> {
+		return this._chartWidget.options() as Readonly<ChartOptions<HorzScaleItem>>;
 	}
 
 	public takeScreenshot(): HTMLCanvasElement {
@@ -262,36 +267,36 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 		type: TSeries,
 		styleDefaults: SeriesStyleOptionsMap[TSeries],
 		options: SeriesPartialOptionsMap[TSeries] = {}
-	): ISeriesApi<TSeries> {
+	): ISeriesApi<TSeries, HorzScaleItem> {
 		patchPriceFormat(options.priceFormat);
 
 		const strictOptions = merge(clone(seriesOptionsDefaults), clone(styleDefaults), options) as SeriesOptionsMap[TSeries];
 		const series = this._chartWidget.model().createSeries(type, strictOptions);
 
-		const res = new SeriesApi<TSeries>(series, this, this);
+		const res = new SeriesApi<TSeries, HorzScaleItem>(series, this, this, this._horzScaleBehavior);
 		this._seriesMap.set(res, series);
 		this._seriesMapReversed.set(series, res);
 
 		return res;
 	}
 
-	private _sendUpdateToChart(update: DataUpdateResponse): void {
+	private _sendUpdateToChart(update: DataUpdateResponse<HorzScaleItem>): void {
 		const model = this._chartWidget.model();
 
 		model.updateTimeScale(update.timeScale.baseIndex, update.timeScale.points, update.timeScale.firstChangedPointIndex);
-		update.series.forEach((value: SeriesChanges, series: Series) => series.setData(value.data, value.info));
+		update.series.forEach((value: SeriesChanges<HorzScaleItem>, series: Series<SeriesType, HorzScaleItem>) => series.setData(value.data, value.info));
 
 		model.recalculateAllPanes();
 	}
 
-	private _mapSeriesToApi(series: Series): ISeriesApi<SeriesType> {
+	private _mapSeriesToApi(series: Series<SeriesType, HorzScaleItem>): ISeriesApi<SeriesType, HorzScaleItem> {
 		return ensureDefined(this._seriesMapReversed.get(series));
 	}
 
-	private _convertMouseParams(param: MouseEventParamsImpl): MouseEventParams {
-		const seriesData: MouseEventParams['seriesData'] = new Map();
-		param.seriesData.forEach((plotRow: SeriesPlotRow, series: Series) => {
-			const data = getSeriesDataCreator(series.seriesType())(plotRow);
+	private _convertMouseParams(param: MouseEventParamsImpl<HorzScaleItem>): MouseEventParams<HorzScaleItem> {
+		const seriesData: MouseEventParams<HorzScaleItem>['seriesData'] = new Map();
+		param.seriesData.forEach((plotRow: SeriesPlotRow<SeriesType, HorzScaleItem>, series: Series<SeriesType, HorzScaleItem>) => {
+			const data = getSeriesDataCreator<SeriesType, HorzScaleItem>(series.seriesType())(plotRow);
 			assert(isFulfilledData(data));
 			seriesData.set(this._mapSeriesToApi(series), data);
 		});
@@ -299,7 +304,7 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 		const hoveredSeries = param.hoveredSeries === undefined ? undefined : this._mapSeriesToApi(param.hoveredSeries);
 
 		return {
-			time: param.time as Time | undefined,
+			time: param.time,
 			logical: param.index as Logical | undefined,
 			point: param.point,
 			hoveredSeries,
diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index 9a91dd27a3..c6722f1f4e 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -1,9 +1,19 @@
 import { assert } from '../helpers/assertions';
-import { DeepPartial, isString } from '../helpers/strict-type-checks';
+import { Nominal } from '../helpers/nominal';
+import { DeepPartial, isString, merge } from '../helpers/strict-type-checks';
 
 import { ChartOptions } from '../model/chart-model';
+import { HorzScaleBehaviorTime } from '../model/horz-scale-behavior-time/horz-scale-behavior-time';
+import { Time } from '../model/horz-scale-behavior-time/types';
+import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../model/ihorz-scale-behavior';
+import { LocalizationOptions } from '../model/localization-options';
+import { SeriesType } from '../model/series-options';
+import { TickMark } from '../model/tick-marks';
+import { TickMarkWeightValue, TimeScalePoint } from '../model/time-data';
+import { markWithGreaterWeight, TimeMark } from '../model/time-scale';
 
 import { ChartApi } from './chart-api';
+import { SeriesDataItemTypeMap } from './data-consumer';
 import { IChartApi } from './ichart-api';
 
 /**
@@ -13,7 +23,7 @@ import { IChartApi } from './ichart-api';
  * @param options - Any subset of options to be applied at start.
  * @returns An interface to the created chart
  */
-export function createChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions>): IChartApi {
+export function createChartEx<HorzScaleItem = Time>(container: string | HTMLElement, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, options?: DeepPartial<ChartOptions<HorzScaleItem>>): IChartApi<HorzScaleItem> {
 	let htmlElement: HTMLElement;
 	if (isString(container)) {
 		const element = document.getElementById(container);
@@ -23,5 +33,88 @@ export function createChart(container: string | HTMLElement, options?: DeepParti
 		htmlElement = container;
 	}
 
-	return new ChartApi(htmlElement, options);
+	const res = new ChartApi<HorzScaleItem>(htmlElement, horzScaleBehavior, options);
+	horzScaleBehavior.setOptions(res.options());
+	return res;
+}
+
+export function createChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions<Time>>): IChartApi<Time> {
+	return createChartEx<Time>(container, new HorzScaleBehaviorTime(), merge({ localization: { dateFormat: 'dd MMM \'yy' } }, options ?? {}));
+}
+
+type Price = Nominal<number, 'Price'>;
+
+class HorzScaleBehaviorPrice implements IHorzScaleBehavior<Price> {
+	public setOptions(options: ChartOptions<Price>): void {}
+
+	public preprocessData(data: DataItem<Price> | DataItem<Price>[]): void {}
+
+	public createConverterToInternalObj(data: SeriesDataItemTypeMap<Price>[SeriesType][]): HorzScaleItemConverterToInternalObj<Price> {
+		return (price: Price) => price as unknown as InternalHorzScaleItem;
+	}
+
+	public convertInternalToHorzItem(item: InternalHorzScaleItem): Price {
+		return item as unknown as Price;
+	}
+
+	public key(item: InternalHorzScaleItem | Price): InternalHorzScaleItemKey {
+		return item as unknown as InternalHorzScaleItemKey;
+	}
+
+	public cacheKey(item: InternalHorzScaleItem): number {
+		return item as unknown as number;
+	}
+
+	public convertHorzItemToInternal(item: Price): InternalHorzScaleItem {
+		return item as unknown as InternalHorzScaleItem;
+	}
+
+	public updateFormatter(options: LocalizationOptions<Price>): void {}
+
+	public formatHorzItem(item: InternalHorzScaleItem): string {
+		const tp = item as unknown as Price;
+		return tp.toFixed(2);
+	}
+
+	public formatTickmark(tickMark: TickMark<Price>, localizationOptions: LocalizationOptions<Price>): string {
+		return (tickMark.time as unknown as Price).toFixed(2);
+	}
+
+	public maxTickMarkWeight(tickMarks: TimeMark[]): TickMarkWeightValue {
+		return tickMarks.reduce(markWithGreaterWeight, tickMarks[0]).weight;
+	}
+
+	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Price>>[], startIndex: number): void {
+		const priceWeight = (price: Price) => {
+			if (price === Math.ceil(price / 100) * 100) {
+				return 8;
+			}
+			if (price === Math.ceil(price / 50) * 50) {
+				return 7;
+			}
+			if (price === Math.ceil(price / 25) * 25) {
+				return 6;
+			}
+			if (price === Math.ceil(price / 10) * 10) {
+				return 5;
+			}
+			if (price === Math.ceil(price / 5) * 5) {
+				return 4;
+			}
+			if (price === Math.ceil(price)) {
+				return 3;
+			}
+			if (price * 2 === Math.ceil(price * 2)) {
+				return 1;
+			}
+			return 0;
+		};
+		for (let index = startIndex; index < sortedTimePoints.length; ++index) {
+			sortedTimePoints[index].timeWeight = priceWeight(sortedTimePoints[index].time as unknown as Price) as TickMarkWeightValue;
+		}
+	}
+}
+
+export function createOptionsChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions<Price>>): IChartApi<Price> {
+	return createChartEx<Price>(container, new HorzScaleBehaviorPrice(), merge({ timeScale: { uniformDistribution: true } }, options ?? {}));
 }
diff --git a/src/api/data-consumer.ts b/src/api/data-consumer.ts
index c0bde4b825..4c93ae222e 100644
--- a/src/api/data-consumer.ts
+++ b/src/api/data-consumer.ts
@@ -1,28 +1,5 @@
-import { isNumber, isString } from '../helpers/strict-type-checks';
-
 import { Series } from '../model/series';
 import { SeriesType } from '../model/series-options';
-import { BusinessDay, Time, UTCTimestamp } from '../model/time-data';
-
-/**
- * Check if a time value is a business day object.
- *
- * @param time - The time to check.
- * @returns `true` if `time` is a {@link BusinessDay} object, false otherwise.
- */
-export function isBusinessDay(time: Time): time is BusinessDay {
-	return !isNumber(time) && !isString(time);
-}
-
-/**
- * Check if a time value is a UTC timestamp number.
- *
- * @param time - The time to check.
- * @returns `true` if `time` is a {@link UTCTimestamp} number, false otherwise.
- */
-export function isUTCTimestamp(time: Time): time is UTCTimestamp {
-	return isNumber(time);
-}
 
 /**
  * Represents a whitespace data item, which is a data point without a value.
@@ -40,21 +17,21 @@ export function isUTCTimestamp(time: Time): time is UTCTimestamp {
  * ];
  * ```
  */
-export interface WhitespaceData {
+export interface WhitespaceData<HorzScaleItem> {
 	/**
 	 * The time of the data.
 	 */
-	time: Time;
+	time: HorzScaleItem;
 }
 
 /**
  * A base interface for a data point of single-value series.
  */
-export interface SingleValueData {
+export interface SingleValueData<HorzScaleItem> {
 	/**
 	 * The time of the data.
 	 */
-	time: Time;
+	time: HorzScaleItem;
 
 	/**
 	 * Price value of the data.
@@ -65,7 +42,7 @@ export interface SingleValueData {
 /**
  * Structure describing a single item of data for line series
  */
-export interface LineData extends SingleValueData {
+export interface LineData<HorzScaleItem> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -75,7 +52,7 @@ export interface LineData extends SingleValueData {
 /**
  * Structure describing a single item of data for histogram series
  */
-export interface HistogramData extends SingleValueData {
+export interface HistogramData<HorzScaleItem> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -85,7 +62,7 @@ export interface HistogramData extends SingleValueData {
 /**
  * Structure describing a single item of data for area series
  */
-export interface AreaData extends SingleValueData {
+export interface AreaData<HorzScaleItem> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional line color value for certain data item. If missed, color from options is used
 	 */
@@ -105,7 +82,7 @@ export interface AreaData extends SingleValueData {
 /**
  * Structure describing a single item of data for baseline series
  */
-export interface BaselineData extends SingleValueData {
+export interface BaselineData<HorzScaleItem> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional top area top fill color value for certain data item. If missed, color from options is used
 	 */
@@ -140,11 +117,11 @@ export interface BaselineData extends SingleValueData {
 /**
  * Represents a bar with a {@link Time} and open, high, low, and close prices.
  */
-export interface OhlcData {
+export interface OhlcData<HorzScaleItem> {
 	/**
 	 * The bar time.
 	 */
-	time: Time;
+	time: HorzScaleItem;
 
 	/**
 	 * The open price.
@@ -167,7 +144,7 @@ export interface OhlcData {
 /**
  * Structure describing a single item of data for bar series
  */
-export interface BarData extends OhlcData {
+export interface BarData<HorzScaleItem> extends OhlcData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -177,7 +154,7 @@ export interface BarData extends OhlcData {
 /**
  * Structure describing a single item of data for candlestick series
  */
-export interface CandlestickData extends OhlcData {
+export interface CandlestickData<HorzScaleItem> extends OhlcData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -192,16 +169,16 @@ export interface CandlestickData extends OhlcData {
 	wickColor?: string;
 }
 
-export function isWhitespaceData(data: SeriesDataItemTypeMap[SeriesType]): data is WhitespaceData {
-	return (data as Partial<BarData>).open === undefined && (data as Partial<LineData>).value === undefined;
+export function isWhitespaceData<HorzScaleItem>(data: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType]): data is WhitespaceData<HorzScaleItem> {
+	return (data as Partial<BarData<HorzScaleItem>>).open === undefined && (data as Partial<LineData<HorzScaleItem>>).value === undefined;
 }
 
-export function isFulfilledData<T extends SeriesDataItemTypeMap[SeriesType]>(
+export function isFulfilledData<HorzScaleItem, T extends SeriesDataItemTypeMap<HorzScaleItem>[SeriesType]>(
 	data: T
-): data is Extract<T, BarData | LineData | HistogramData> {
+): data is Extract<T, BarData<HorzScaleItem> | LineData<HorzScaleItem> | HistogramData<HorzScaleItem>> {
 	return (
-		(data as Partial<BarData>).open !== undefined ||
-		(data as Partial<LineData>).value !== undefined
+		(data as Partial<BarData<HorzScaleItem>>).open !== undefined ||
+		(data as Partial<LineData<HorzScaleItem>>).value !== undefined
 	);
 }
 
@@ -210,34 +187,34 @@ export function isFulfilledData<T extends SeriesDataItemTypeMap[SeriesType]>(
  *
  * For example a bar series contains {@link BarData} or {@link WhitespaceData}.
  */
-export interface SeriesDataItemTypeMap {
+export interface SeriesDataItemTypeMap<HorzScaleItem> {
 	/**
 	 * The types of bar series data.
 	 */
-	Bar: BarData | WhitespaceData;
+	Bar: BarData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
 	/**
 	 * The types of candlestick series data.
 	 */
-	Candlestick: CandlestickData | WhitespaceData;
+	Candlestick: CandlestickData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
 	/**
 	 * The types of area series data.
 	 */
-	Area: AreaData | WhitespaceData;
+	Area: AreaData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
 	/**
 	 * The types of baseline series data.
 	 */
-	Baseline: BaselineData | WhitespaceData;
+	Baseline: BaselineData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
 	/**
 	 * The types of line series data.
 	 */
-	Line: LineData | WhitespaceData;
+	Line: LineData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
 	/**
 	 * The types of histogram series data.
 	 */
-	Histogram: HistogramData | WhitespaceData;
+	Histogram: HistogramData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
 }
 
-export interface DataUpdatesConsumer<TSeriesType extends SeriesType> {
-	applyNewData(series: Series<TSeriesType>, data: SeriesDataItemTypeMap[TSeriesType][]): void;
-	updateData(series: Series<TSeriesType>, data: SeriesDataItemTypeMap[TSeriesType]): void;
+export interface DataUpdatesConsumer<TSeriesType extends SeriesType, HorzScaleItem> {
+	applyNewData(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void;
+	updateData(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void;
 }
diff --git a/src/api/data-layer.ts b/src/api/data-layer.ts
index 1fc36a5b63..d2fc577f9c 100644
--- a/src/api/data-layer.ts
+++ b/src/api/data-layer.ts
@@ -1,115 +1,26 @@
 /// <reference types="_build-time-constants" />
 
 import { lowerbound } from '../helpers/algorithms';
-import { ensureDefined, ensureNotNull } from '../helpers/assertions';
-import { isString } from '../helpers/strict-type-checks';
+import { ensureDefined } from '../helpers/assertions';
 
+import { IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../model/ihorz-scale-behavior';
 import { Series, SeriesUpdateInfo } from '../model/series';
 import { SeriesPlotRow } from '../model/series-data';
 import { SeriesType } from '../model/series-options';
 import {
-	BusinessDay,
-	OriginalTime,
-	Time,
-	TimePoint,
+	TickMarkWeightValue,
 	TimePointIndex,
 	TimeScalePoint,
-	UTCTimestamp,
 } from '../model/time-data';
 
 import {
-	isBusinessDay,
-	isUTCTimestamp,
 	SeriesDataItemTypeMap,
 } from './data-consumer';
 import { getSeriesPlotRowCreator, isSeriesPlotRow, WhitespacePlotRow } from './get-series-plot-row-creator';
-import { fillWeightsForPoints } from './time-scale-point-weight-generator';
 
-type TimedData = Pick<SeriesDataItemTypeMap[SeriesType], 'time'>;
-type TimeConverter = (time: Time) => TimePoint;
+export type TimedData<HorzScaleItem> = Pick<SeriesDataItemTypeMap<HorzScaleItem>[SeriesType], 'time'>;
 
-function businessDayConverter(time: Time): TimePoint {
-	if (!isBusinessDay(time)) {
-		throw new Error('time must be of type BusinessDay');
-	}
-
-	const date = new Date(Date.UTC(time.year, time.month - 1, time.day, 0, 0, 0, 0));
-
-	return {
-		timestamp: Math.round(date.getTime() / 1000) as UTCTimestamp,
-		businessDay: time,
-	};
-}
-
-function timestampConverter(time: Time): TimePoint {
-	if (!isUTCTimestamp(time)) {
-		throw new Error('time must be of type isUTCTimestamp');
-	}
-	return {
-		timestamp: time,
-	};
-}
-
-function selectTimeConverter(data: TimedData[]): TimeConverter | null {
-	if (data.length === 0) {
-		return null;
-	}
-	if (isBusinessDay(data[0].time)) {
-		return businessDayConverter;
-	}
-	return timestampConverter;
-}
-
-export function convertTime(time: Time): TimePoint {
-	if (isUTCTimestamp(time)) {
-		return timestampConverter(time);
-	}
-
-	if (!isBusinessDay(time)) {
-		return businessDayConverter(stringToBusinessDay(time));
-	}
-
-	return businessDayConverter(time);
-}
-
-const validDateRegex = /^\d\d\d\d-\d\d-\d\d$/;
-
-export function stringToBusinessDay(value: string): BusinessDay {
-	if (process.env.NODE_ENV === 'development') {
-		// in some browsers (I look at your Chrome) the Date constructor may accept invalid date string
-		// but parses them in "implementation specific" way
-		// for example 2019-1-1 isn't the same as 2019-01-01 (for Chrome both are "valid" date strings)
-		// see https://bugs.chromium.org/p/chromium/issues/detail?id=968939
-		// so, we need to be sure that date has valid format to avoid strange behavior and hours of debugging
-		// but let's do this in development build only because of perf
-		if (!validDateRegex.test(value)) {
-			throw new Error(`Invalid date string=${value}, expected format=yyyy-mm-dd`);
-		}
-	}
-
-	const d = new Date(value);
-	if (isNaN(d.getTime())) {
-		throw new Error(`Invalid date string=${value}, expected format=yyyy-mm-dd`);
-	}
-
-	return {
-		day: d.getUTCDate(),
-		month: d.getUTCMonth() + 1,
-		year: d.getUTCFullYear(),
-	};
-}
-
-function convertStringToBusinessDay(value: TimedData): void {
-	if (isString(value.time)) {
-		value.time = stringToBusinessDay(value.time);
-	}
-}
-
-function convertStringsToBusinessDays(data: TimedData[]): void {
-	return data.forEach(convertStringToBusinessDay);
-}
-
-export interface TimeScaleChanges {
+export interface TimeScaleChanges<HorzScaleItem> {
 	/**
 	 * An index of the first changed time scale point by any type of change (time, weight, etc)
 	 */
@@ -118,7 +29,7 @@ export interface TimeScaleChanges {
 	/**
 	 * An array of the new time scale points
 	 */
-	points?: readonly TimeScalePoint[];
+	points?: readonly TimeScalePoint<HorzScaleItem>[];
 
 	/**
 	 * In terms of time scale "base index" means the latest time scale point with data (there might be whitespaces)
@@ -126,65 +37,65 @@ export interface TimeScaleChanges {
 	baseIndex: TimePointIndex | null;
 }
 
-export interface SeriesChanges {
+export interface SeriesChanges<HorzScaleItem> {
 	/**
 	 * Data to be merged into series' plot list
 	 */
-	data: readonly SeriesPlotRow[];
+	data: readonly SeriesPlotRow<SeriesType, HorzScaleItem>[];
 	/**
 	 * Additional info about this change
 	 */
 	info?: SeriesUpdateInfo;
 }
 
-export interface DataUpdateResponse {
+export interface DataUpdateResponse<HorzScaleItem> {
 	/**
 	 * Contains updates for all _changed_ series (if series data doesn't changed then it will not be here)
 	 */
-	series: Map<Series, SeriesChanges>;
+	series: Map<Series<SeriesType, HorzScaleItem>, SeriesChanges<HorzScaleItem>>;
 
 	/**
 	 * Contains optional time scale points
 	 */
-	timeScale: TimeScaleChanges;
+	timeScale: TimeScaleChanges<HorzScaleItem>;
 }
 
-interface TimePointData {
+interface TimePointData<HorzScaleItem> {
 	index: TimePointIndex;
-	timePoint: TimePoint;
+	timePoint: InternalHorzScaleItem;
 
 	// actually the type of the value should be related to the series' type (generic type)
 	// here, in data layer all data for us is "mutable" by default, but to the chart we provide "readonly" data, to avoid modifying it
-	mapping: Map<Series, Mutable<SeriesPlotRow | WhitespacePlotRow>>;
+	mapping: Map<Series<SeriesType, HorzScaleItem>, Mutable<SeriesPlotRow<SeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>>>;
 }
 
-interface InternalTimeScalePoint extends Mutable<TimeScalePoint> {
-	pointData: TimePointData;
+export interface InternalTimeScalePoint<HorzScaleItem> extends Mutable<TimeScalePoint<HorzScaleItem>> {
+	pointData: TimePointData<HorzScaleItem>;
 }
 
-function createEmptyTimePointData(timePoint: TimePoint): TimePointData {
+function createEmptyTimePointData<HorzScaleItem>(timePoint: InternalHorzScaleItem): TimePointData<HorzScaleItem> {
 	return { index: 0 as TimePointIndex, mapping: new Map(), timePoint };
 }
 
 interface SeriesRowsFirstAndLastTime {
-	firstTime: UTCTimestamp;
-	lastTime: UTCTimestamp;
+	firstTime: InternalHorzScaleItemKey;
+	lastTime: InternalHorzScaleItemKey;
 }
 
-function seriesRowsFirsAndLastTime(seriesRows: SeriesPlotRow[] | undefined): SeriesRowsFirstAndLastTime | undefined {
+function seriesRowsFirsAndLastTime<TSeriesType extends SeriesType, HorzScaleItem>(seriesRows: SeriesPlotRow<TSeriesType, HorzScaleItem>[] | undefined, bh: IHorzScaleBehavior<HorzScaleItem>): SeriesRowsFirstAndLastTime | undefined {
 	if (seriesRows === undefined || seriesRows.length === 0) {
 		return undefined;
 	}
 
 	return {
-		firstTime: seriesRows[0].time.timestamp,
-		lastTime: seriesRows[seriesRows.length - 1].time.timestamp,
+		firstTime: bh.key(seriesRows[0].time),
+		lastTime: bh.key(seriesRows[seriesRows.length - 1].time),
 	};
 }
 
-function seriesUpdateInfo(seriesRows: SeriesPlotRow[] | undefined, prevSeriesRows: SeriesPlotRow[] | undefined): SeriesUpdateInfo | undefined {
-	const firstAndLastTime = seriesRowsFirsAndLastTime(seriesRows);
-	const prevFirstAndLastTime = seriesRowsFirsAndLastTime(prevSeriesRows);
+function seriesUpdateInfo<TSeriesType extends SeriesType, HorzScaleItem>(seriesRows: SeriesPlotRow<TSeriesType, HorzScaleItem>[] | undefined, prevSeriesRows: SeriesPlotRow<TSeriesType, HorzScaleItem>[] | undefined, bh: IHorzScaleBehavior<HorzScaleItem>): SeriesUpdateInfo | undefined {
+	const firstAndLastTime = seriesRowsFirsAndLastTime(seriesRows, bh);
+	const prevFirstAndLastTime = seriesRowsFirsAndLastTime(prevSeriesRows, bh);
 	if (firstAndLastTime !== undefined && prevFirstAndLastTime !== undefined) {
 		return {
 			lastBarUpdatedOrNewBarsAddedToTheRight:
@@ -196,9 +107,9 @@ function seriesUpdateInfo(seriesRows: SeriesPlotRow[] | undefined, prevSeriesRow
 	return undefined;
 }
 
-function timeScalePointTime(mergedPointData: Map<Series, SeriesPlotRow | WhitespacePlotRow>): OriginalTime {
-	let result: OriginalTime | undefined;
-	mergedPointData.forEach((v: SeriesPlotRow | WhitespacePlotRow) => {
+function timeScalePointTime<TSeriesType extends SeriesType, HorzScaleItem>(mergedPointData: Map<Series<TSeriesType, HorzScaleItem>, SeriesPlotRow<TSeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>>): HorzScaleItem {
+	let result: HorzScaleItem | undefined;
+	mergedPointData.forEach((v: SeriesPlotRow<TSeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>) => {
 		if (result === undefined) {
 			result = v.originalTime;
 		}
@@ -207,26 +118,32 @@ function timeScalePointTime(mergedPointData: Map<Series, SeriesPlotRow | Whitesp
 	return ensureDefined(result);
 }
 
-function saveOriginalTime<TSeriesType extends SeriesType>(data: SeriesDataItemWithOriginalTime<TSeriesType>): void {
+function saveOriginalTime<TSeriesType extends SeriesType, HorzScaleItem>(data: SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>): void {
 	// eslint-disable-next-line @typescript-eslint/tslint/config
 	if (data.originalTime === undefined) {
-		data.originalTime = data.time as unknown as OriginalTime;
+		data.originalTime = data.time;
 	}
 }
 
-type SeriesDataItemWithOriginalTime<TSeriesType extends SeriesType> = SeriesDataItemTypeMap[TSeriesType] & {
-	originalTime: OriginalTime;
+type SeriesDataItemWithOriginalTime<TSeriesType extends SeriesType, HorzScaleItem> = SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType] & {
+	originalTime: HorzScaleItem;
 };
 
-export class DataLayer {
+export class DataLayer<HorzScaleItem> {
 	// note that _pointDataByTimePoint and _seriesRowsBySeries shares THE SAME objects in their values between each other
 	// it's just different kind of maps to make usages/perf better
-	private _pointDataByTimePoint: Map<UTCTimestamp, TimePointData> = new Map();
-	private _seriesRowsBySeries: Map<Series, SeriesPlotRow[]> = new Map();
-	private _seriesLastTimePoint: Map<Series, TimePoint> = new Map();
+	private _pointDataByTimePoint: Map<InternalHorzScaleItemKey, TimePointData<HorzScaleItem>> = new Map();
+	private _seriesRowsBySeries: Map<Series<SeriesType, HorzScaleItem>, SeriesPlotRow<SeriesType, HorzScaleItem>[]> = new Map();
+	private _seriesLastTimePoint: Map<Series<SeriesType, HorzScaleItem>, InternalHorzScaleItem> = new Map();
 
 	// this is kind of "dest" values (in opposite to "source" ones) - we don't need to modify it manually, the only by calling _updateTimeScalePoints or updateSeriesData methods
-	private _sortedTimePoints: readonly InternalTimeScalePoint[] = [];
+	private _sortedTimePoints: readonly InternalTimeScalePoint<HorzScaleItem>[] = [];
+
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
+		this._horzScaleBehavior = horzScaleBehavior;
+	}
 
 	public destroy(): void {
 		this._pointDataByTimePoint.clear();
@@ -235,7 +152,7 @@ export class DataLayer {
 		this._sortedTimePoints = [];
 	}
 
-	public setSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap[TSeriesType][]): DataUpdateResponse {
+	public setSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): DataUpdateResponse<HorzScaleItem> {
 		let needCleanupPoints = this._pointDataByTimePoint.size !== 0;
 
 		let isTimeScaleAffected = false;
@@ -260,25 +177,31 @@ export class DataLayer {
 			}
 		}
 
-		let seriesRows: (SeriesPlotRow<TSeriesType> | WhitespacePlotRow)[] = [];
+		let seriesRows: (SeriesPlotRow<TSeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>)[] = [];
 
 		if (data.length !== 0) {
-			const extendedData = data as SeriesDataItemWithOriginalTime<TSeriesType>[];
-			extendedData.forEach((i: SeriesDataItemWithOriginalTime<TSeriesType>) => saveOriginalTime(i));
+			const extendedData = data as SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>[];
+			extendedData.forEach((i: SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>) => saveOriginalTime(i));
+
+			// convertStringsToBusinessDays(data);
+			this._horzScaleBehavior.preprocessData(data);
+
+			// const timeConverter = ensureNotNull(selectTimeConverter(data));
 
-			convertStringsToBusinessDays(data);
+			const timeConverter = this._horzScaleBehavior.createConverterToInternalObj(data);
 
-			const timeConverter = ensureNotNull(selectTimeConverter(data));
-			const createPlotRow = getSeriesPlotRowCreator(series.seriesType());
+			const createPlotRow = getSeriesPlotRowCreator<TSeriesType, HorzScaleItem>(series.seriesType());
 
-			seriesRows = extendedData.map((item: SeriesDataItemWithOriginalTime<TSeriesType>) => {
+			seriesRows = extendedData.map((item: SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>) => {
 				const time = timeConverter(item.time);
 
-				let timePointData = this._pointDataByTimePoint.get(time.timestamp);
+				const horzItemKey = this._horzScaleBehavior.key(time);
+
+				let timePointData = this._pointDataByTimePoint.get(horzItemKey);
 				if (timePointData === undefined) {
 					// the indexes will be sync later
 					timePointData = createEmptyTimePointData(time);
-					this._pointDataByTimePoint.set(time.timestamp, timePointData);
+					this._pointDataByTimePoint.set(horzItemKey, timePointData);
 					isTimeScaleAffected = true;
 				}
 
@@ -300,17 +223,17 @@ export class DataLayer {
 		if (isTimeScaleAffected) {
 			// then generate the time scale points
 			// timeWeight will be updates in _updateTimeScalePoints later
-			const newTimeScalePoints: InternalTimeScalePoint[] = [];
-			this._pointDataByTimePoint.forEach((pointData: TimePointData) => {
+			const newTimeScalePoints: InternalTimeScalePoint<HorzScaleItem>[] = [];
+			this._pointDataByTimePoint.forEach((pointData: TimePointData<HorzScaleItem>) => {
 				newTimeScalePoints.push({
-					timeWeight: 0,
+					timeWeight: 0 as TickMarkWeightValue,
 					time: pointData.timePoint,
 					pointData,
 					originalTime: timeScalePointTime(pointData.mapping),
 				});
 			});
 
-			newTimeScalePoints.sort((t1: InternalTimeScalePoint, t2: InternalTimeScalePoint) => t1.time.timestamp - t2.time.timestamp);
+			newTimeScalePoints.sort((t1: InternalTimeScalePoint<HorzScaleItem>, t2: InternalTimeScalePoint<HorzScaleItem>) => this._horzScaleBehavior.key(t1.time) - this._horzScaleBehavior.key(t2.time));
 
 			firstChangedPointIndex = this._replaceTimeScalePoints(newTimeScalePoints);
 		}
@@ -318,27 +241,30 @@ export class DataLayer {
 		return this._getUpdateResponse(
 			series,
 			firstChangedPointIndex,
-			seriesUpdateInfo(this._seriesRowsBySeries.get(series), prevSeriesRows)
+			seriesUpdateInfo(this._seriesRowsBySeries.get(series), prevSeriesRows, this._horzScaleBehavior)
 		);
 	}
 
-	public removeSeries(series: Series): DataUpdateResponse {
+	public removeSeries(series: Series<SeriesType, HorzScaleItem>): DataUpdateResponse<HorzScaleItem> {
 		return this.setSeriesData(series, []);
 	}
 
-	public updateSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap[TSeriesType]): DataUpdateResponse {
-		const extendedData = data as SeriesDataItemWithOriginalTime<TSeriesType>;
+	public updateSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): DataUpdateResponse<HorzScaleItem> {
+		const extendedData = data as SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>;
 		saveOriginalTime(extendedData);
-		convertStringToBusinessDay(data);
+		// convertStringToBusinessDay(data);
+		this._horzScaleBehavior.preprocessData(data);
+
+		const timeConverter = this._horzScaleBehavior.createConverterToInternalObj([data]);
 
-		const time = ensureNotNull(selectTimeConverter([data]))(data.time);
+		const time = timeConverter(data.time);
 
 		const lastSeriesTime = this._seriesLastTimePoint.get(series);
-		if (lastSeriesTime !== undefined && time.timestamp < lastSeriesTime.timestamp) {
-			throw new Error(`Cannot update oldest data, last time=${lastSeriesTime.timestamp}, new time=${time.timestamp}`);
+		if (lastSeriesTime !== undefined && this._horzScaleBehavior.key(time) < this._horzScaleBehavior.key(lastSeriesTime)) {
+			throw new Error(`Cannot update oldest data, last time=${lastSeriesTime}, new time=${time}`);
 		}
 
-		let pointDataAtTime = this._pointDataByTimePoint.get(time.timestamp);
+		let pointDataAtTime = this._pointDataByTimePoint.get(this._horzScaleBehavior.key(time));
 
 		// if no point data found for the new data item
 		// that means that we need to update scale
@@ -347,10 +273,10 @@ export class DataLayer {
 		if (pointDataAtTime === undefined) {
 			// the indexes will be sync later
 			pointDataAtTime = createEmptyTimePointData(time);
-			this._pointDataByTimePoint.set(time.timestamp, pointDataAtTime);
+			this._pointDataByTimePoint.set(this._horzScaleBehavior.key(time), pointDataAtTime);
 		}
 
-		const createPlotRow = getSeriesPlotRowCreator(series.seriesType());
+		const createPlotRow = getSeriesPlotRowCreator<SeriesType, HorzScaleItem>(series.seriesType());
 		const plotRow = createPlotRow(time, pointDataAtTime.index, data, extendedData.originalTime);
 		pointDataAtTime.mapping.set(series, plotRow);
 
@@ -363,30 +289,30 @@ export class DataLayer {
 			return this._getUpdateResponse(series, -1, info);
 		}
 
-		const newPoint: InternalTimeScalePoint = {
-			timeWeight: 0,
+		const newPoint: InternalTimeScalePoint<HorzScaleItem> = {
+			timeWeight: 0 as TickMarkWeightValue,
 			time: pointDataAtTime.timePoint,
 			pointData: pointDataAtTime,
 			originalTime: timeScalePointTime(pointDataAtTime.mapping),
 		};
 
-		const insertIndex = lowerbound(this._sortedTimePoints, newPoint.time.timestamp, (a: InternalTimeScalePoint, b: number) => a.time.timestamp < b);
+		const insertIndex = lowerbound(this._sortedTimePoints, this._horzScaleBehavior.key(newPoint.time), (a: InternalTimeScalePoint<HorzScaleItem>, b: number) => this._horzScaleBehavior.key(a.time) < b);
 
 		// yes, I know that this array is readonly and this change is intended to make it performative
 		// we marked _sortedTimePoints array as readonly to avoid modifying this array anywhere else
 		// but this place is exceptional case due performance reasons, sorry
-		(this._sortedTimePoints as InternalTimeScalePoint[]).splice(insertIndex, 0, newPoint);
+		(this._sortedTimePoints as InternalTimeScalePoint<HorzScaleItem>[]).splice(insertIndex, 0, newPoint);
 
 		for (let index = insertIndex; index < this._sortedTimePoints.length; ++index) {
 			assignIndexToPointData(this._sortedTimePoints[index].pointData, index as TimePointIndex);
 		}
 
-		fillWeightsForPoints(this._sortedTimePoints, insertIndex);
+		this._horzScaleBehavior.fillWeightsForPoints(this._sortedTimePoints, insertIndex);
 
 		return this._getUpdateResponse(series, insertIndex, info);
 	}
 
-	private _updateLastSeriesRow(series: Series, plotRow: SeriesPlotRow | WhitespacePlotRow): void {
+	private _updateLastSeriesRow(series: Series<SeriesType, HorzScaleItem>, plotRow: SeriesPlotRow<SeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>): void {
 		let seriesData = this._seriesRowsBySeries.get(series);
 		if (seriesData === undefined) {
 			seriesData = [];
@@ -395,7 +321,7 @@ export class DataLayer {
 
 		const lastSeriesRow = seriesData.length !== 0 ? seriesData[seriesData.length - 1] : null;
 
-		if (lastSeriesRow === null || plotRow.time.timestamp > lastSeriesRow.time.timestamp) {
+		if (lastSeriesRow === null || this._horzScaleBehavior.key(plotRow.time) > this._horzScaleBehavior.key(lastSeriesRow.time)) {
 			if (isSeriesPlotRow(plotRow)) {
 				seriesData.push(plotRow);
 			}
@@ -410,7 +336,7 @@ export class DataLayer {
 		this._seriesLastTimePoint.set(series, plotRow.time);
 	}
 
-	private _setRowsToSeries(series: Series, seriesRows: (SeriesPlotRow | WhitespacePlotRow)[]): void {
+	private _setRowsToSeries(series: Series<SeriesType, HorzScaleItem>, seriesRows: (SeriesPlotRow<SeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>)[]): void {
 		if (seriesRows.length !== 0) {
 			this._seriesRowsBySeries.set(series, seriesRows.filter(isSeriesPlotRow));
 			this._seriesLastTimePoint.set(series, seriesRows[seriesRows.length - 1].time);
@@ -427,7 +353,7 @@ export class DataLayer {
 		// note that we can use _sortedTimePoints here since a point might be removed only it was here previously
 		for (const point of this._sortedTimePoints) {
 			if (point.pointData.mapping.size === 0) {
-				this._pointDataByTimePoint.delete(point.time.timestamp);
+				this._pointDataByTimePoint.delete(this._horzScaleBehavior.key(point.time));
 			}
 		}
 	}
@@ -437,14 +363,14 @@ export class DataLayer {
 	 *
 	 * @returns The index of the first changed point or `-1` if there is no change.
 	 */
-	private _replaceTimeScalePoints(newTimePoints: InternalTimeScalePoint[]): number {
+	private _replaceTimeScalePoints(newTimePoints: InternalTimeScalePoint<HorzScaleItem>[]): number {
 		let firstChangedPointIndex = -1;
 
 		// search the first different point and "syncing" time weight by the way
 		for (let index = 0; index < this._sortedTimePoints.length && index < newTimePoints.length; ++index) {
 			const oldPoint = this._sortedTimePoints[index];
 			const newPoint = newTimePoints[index];
-			if (oldPoint.time.timestamp !== newPoint.time.timestamp) {
+			if (this._horzScaleBehavior.key(oldPoint.time) !== this._horzScaleBehavior.key(newPoint.time)) {
 				firstChangedPointIndex = index;
 				break;
 			}
@@ -473,7 +399,7 @@ export class DataLayer {
 		}
 
 		// re-fill time weights for point after the first changed one
-		fillWeightsForPoints(newTimePoints, firstChangedPointIndex);
+		this._horzScaleBehavior.fillWeightsForPoints(newTimePoints, firstChangedPointIndex);
 
 		this._sortedTimePoints = newTimePoints;
 
@@ -488,7 +414,7 @@ export class DataLayer {
 
 		let baseIndex = 0 as TimePointIndex;
 
-		this._seriesRowsBySeries.forEach((data: SeriesPlotRow[]) => {
+		this._seriesRowsBySeries.forEach((data: SeriesPlotRow<SeriesType, HorzScaleItem>[]) => {
 			if (data.length !== 0) {
 				baseIndex = Math.max(baseIndex, data[data.length - 1].index) as TimePointIndex;
 			}
@@ -497,8 +423,8 @@ export class DataLayer {
 		return baseIndex;
 	}
 
-	private _getUpdateResponse(updatedSeries: Series, firstChangedPointIndex: number, info?: SeriesUpdateInfo): DataUpdateResponse {
-		const dataUpdateResponse: DataUpdateResponse = {
+	private _getUpdateResponse(updatedSeries: Series<SeriesType, HorzScaleItem>, firstChangedPointIndex: number, info?: SeriesUpdateInfo): DataUpdateResponse<HorzScaleItem> {
+		const dataUpdateResponse: DataUpdateResponse<HorzScaleItem> = {
 			series: new Map(),
 			timeScale: {
 				baseIndex: this._getBaseIndex(),
@@ -508,7 +434,7 @@ export class DataLayer {
 		if (firstChangedPointIndex !== -1) {
 			// TODO: it's possible to make perf improvements by checking what series has data after firstChangedPointIndex
 			// but let's skip for now
-			this._seriesRowsBySeries.forEach((data: SeriesPlotRow[], s: Series) => {
+			this._seriesRowsBySeries.forEach((data: SeriesPlotRow<SeriesType, HorzScaleItem>[], s: Series<SeriesType, HorzScaleItem>) => {
 				dataUpdateResponse.series.set(
 					s,
 					{
@@ -537,12 +463,12 @@ export class DataLayer {
 	}
 }
 
-function assignIndexToPointData(pointData: TimePointData, index: TimePointIndex): void {
+function assignIndexToPointData<HorzScaleItem>(pointData: TimePointData<HorzScaleItem>, index: TimePointIndex): void {
 	// first, nevertheless update index of point data ("make it valid")
 	pointData.index = index;
 
 	// and then we need to sync indexes for all series
-	pointData.mapping.forEach((seriesRow: Mutable<SeriesPlotRow | WhitespacePlotRow>) => {
+	pointData.mapping.forEach((seriesRow: Mutable<SeriesPlotRow<SeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>>) => {
 		seriesRow.index = index;
 	});
 }
diff --git a/src/api/data-validators.ts b/src/api/data-validators.ts
index 2dc2ef94aa..ddc18b48cd 100644
--- a/src/api/data-validators.ts
+++ b/src/api/data-validators.ts
@@ -1,12 +1,11 @@
 import { assert } from '../helpers/assertions';
 
+import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 import { CreatePriceLineOptions } from '../model/price-line-options';
 import { SeriesMarker } from '../model/series-markers';
 import { SeriesType } from '../model/series-options';
-import { Time } from '../model/time-data';
 
 import { isFulfilledData, SeriesDataItemTypeMap } from './data-consumer';
-import { convertTime } from './data-layer';
 
 export function checkPriceLineOptions(options: CreatePriceLineOptions): void {
 	if (process.env.NODE_ENV === 'production') {
@@ -17,7 +16,7 @@ export function checkPriceLineOptions(options: CreatePriceLineOptions): void {
 	assert(typeof options.price === 'number', `the type of 'price' price line's property must be a number, got '${typeof options.price}'`);
 }
 
-export function checkItemsAreOrdered(data: readonly (SeriesMarker<Time> | SeriesDataItemTypeMap[SeriesType])[], allowDuplicates: boolean = false): void {
+export function checkItemsAreOrdered<HorzScaleItem>(data: readonly (SeriesMarker<HorzScaleItem, HorzScaleItem> | SeriesDataItemTypeMap<HorzScaleItem>[SeriesType])[], bh: IHorzScaleBehavior<HorzScaleItem>, allowDuplicates: boolean = false): void {
 	if (process.env.NODE_ENV === 'production') {
 		return;
 	}
@@ -26,26 +25,26 @@ export function checkItemsAreOrdered(data: readonly (SeriesMarker<Time> | Series
 		return;
 	}
 
-	let prevTime = convertTime(data[0].time).timestamp;
+	let prevTime = bh.key(data[0].time);
 	for (let i = 1; i < data.length; ++i) {
-		const currentTime = convertTime(data[i].time).timestamp;
+		const currentTime = bh.key(data[i].time);
 		const checkResult = allowDuplicates ? prevTime <= currentTime : prevTime < currentTime;
 		assert(checkResult, `data must be asc ordered by time, index=${i}, time=${currentTime}, prev time=${prevTime}`);
 		prevTime = currentTime;
 	}
 }
 
-export function checkSeriesValuesType(type: SeriesType, data: readonly SeriesDataItemTypeMap[SeriesType][]): void {
+export function checkSeriesValuesType<HorzScaleItem>(type: SeriesType, data: readonly SeriesDataItemTypeMap<HorzScaleItem>[SeriesType][]): void {
 	if (process.env.NODE_ENV === 'production') {
 		return;
 	}
 
-	data.forEach(getChecker(type));
+	data.forEach(getChecker<HorzScaleItem>(type));
 }
 
-type Checker = (item: SeriesDataItemTypeMap[SeriesType]) => void;
+type Checker<HorzScaleItem> = (item: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType]) => void;
 
-function getChecker(type: SeriesType): Checker {
+function getChecker<HorzScaleItem>(type: SeriesType): Checker<HorzScaleItem> {
 	switch (type) {
 		case 'Bar':
 		case 'Candlestick':
@@ -59,9 +58,9 @@ function getChecker(type: SeriesType): Checker {
 	}
 }
 
-function checkBarItem(
+function checkBarItem<HorzScaleItem>(
 	type: 'Bar' | 'Candlestick',
-	barItem: SeriesDataItemTypeMap[typeof type]
+	barItem: SeriesDataItemTypeMap<HorzScaleItem>[typeof type]
 ): void {
 	if (!isFulfilledData(barItem)) {
 		return;
@@ -97,9 +96,9 @@ function checkBarItem(
 	);
 }
 
-function checkLineItem(
+function checkLineItem<HorzScaleItem>(
 	type: 'Area' | 'Baseline' | 'Line' | 'Histogram',
-	lineItem: SeriesDataItemTypeMap[typeof type]
+	lineItem: SeriesDataItemTypeMap<HorzScaleItem>[typeof type]
 ): void {
 	if (!isFulfilledData(lineItem)) {
 		return;
diff --git a/src/api/get-series-data-creator.ts b/src/api/get-series-data-creator.ts
index 26448936c7..3cf7381119 100644
--- a/src/api/get-series-data-creator.ts
+++ b/src/api/get-series-data-creator.ts
@@ -8,7 +8,6 @@ import {
 	SeriesPlotRow,
 } from '../model/series-data';
 import { SeriesType } from '../model/series-options';
-import { Time } from '../model/time-data';
 
 import {
 	AreaData,
@@ -21,19 +20,19 @@ import {
 	SingleValueData,
 } from './data-consumer';
 
-type SeriesPlotRowToDataMap = {
-	[T in keyof SeriesDataItemTypeMap]: (plotRow: SeriesPlotRow) => SeriesDataItemTypeMap[T];
+type SeriesPlotRowToDataMap<HorzScaleItem> = {
+	[T in keyof SeriesDataItemTypeMap<HorzScaleItem>]: (plotRow: SeriesPlotRow<T, HorzScaleItem>) => SeriesDataItemTypeMap<HorzScaleItem>[T];
 };
 
-function singleValueData(plotRow: PlotRow): SingleValueData {
+function singleValueData<HorzScaleItem>(plotRow: PlotRow<HorzScaleItem>): SingleValueData<HorzScaleItem> {
 	return {
 		value: plotRow.value[PlotRowValueIndex.Close],
-		time: plotRow.originalTime as unknown as Time,
+		time: plotRow.originalTime as unknown as HorzScaleItem,
 	};
 }
 
-function lineData(plotRow: LinePlotRow): LineData {
-	const result: LineData = singleValueData(plotRow);
+function lineData<HorzScaleItem>(plotRow: LinePlotRow<HorzScaleItem>): LineData<HorzScaleItem> {
+	const result: LineData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.color !== undefined) {
 		result.color = plotRow.color;
@@ -42,8 +41,8 @@ function lineData(plotRow: LinePlotRow): LineData {
 	return result;
 }
 
-function areaData(plotRow: AreaPlotRow): AreaData {
-	const result: AreaData = singleValueData(plotRow);
+function areaData<HorzScaleItem>(plotRow: AreaPlotRow<HorzScaleItem>): AreaData<HorzScaleItem> {
+	const result: AreaData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.lineColor !== undefined) {
 		result.lineColor = plotRow.lineColor;
@@ -60,8 +59,8 @@ function areaData(plotRow: AreaPlotRow): AreaData {
 	return result;
 }
 
-function baselineData(plotRow: BaselinePlotRow): BaselineData {
-	const result: BaselineData = singleValueData(plotRow);
+function baselineData<HorzScaleItem>(plotRow: BaselinePlotRow<HorzScaleItem>): BaselineData<HorzScaleItem> {
+	const result: BaselineData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.topLineColor !== undefined) {
 		result.topLineColor = plotRow.topLineColor;
@@ -90,18 +89,18 @@ function baselineData(plotRow: BaselinePlotRow): BaselineData {
 	return result;
 }
 
-function ohlcData(plotRow: PlotRow): OhlcData {
+function ohlcData<HorzScaleItem>(plotRow: PlotRow<HorzScaleItem>): OhlcData<HorzScaleItem> {
 	return {
 		open: plotRow.value[PlotRowValueIndex.Open],
 		high: plotRow.value[PlotRowValueIndex.High],
 		low: plotRow.value[PlotRowValueIndex.Low],
 		close: plotRow.value[PlotRowValueIndex.Close],
-		time: plotRow.originalTime as unknown as Time,
+		time: plotRow.originalTime as unknown as HorzScaleItem,
 	};
 }
 
-function barData(plotRow: BarPlotRow): BarData {
-	const result: BarData = ohlcData(plotRow);
+function barData<HorzScaleItem>(plotRow: BarPlotRow<HorzScaleItem>): BarData<HorzScaleItem> {
+	const result: BarData<HorzScaleItem> = ohlcData(plotRow);
 
 	if (plotRow.color !== undefined) {
 		result.color = plotRow.color;
@@ -110,8 +109,8 @@ function barData(plotRow: BarPlotRow): BarData {
 	return result;
 }
 
-function candlestickData(plotRow: CandlestickPlotRow): CandlestickData {
-	const result: CandlestickData = ohlcData(plotRow);
+function candlestickData<HorzScaleItem>(plotRow: CandlestickPlotRow<HorzScaleItem>): CandlestickData<HorzScaleItem> {
+	const result: CandlestickData<HorzScaleItem> = ohlcData(plotRow);
 	const { color, borderColor, wickColor } = plotRow;
 
 	if (color !== undefined) {
@@ -129,15 +128,15 @@ function candlestickData(plotRow: CandlestickPlotRow): CandlestickData {
 	return result;
 }
 
-const seriesPlotRowToDataMap: SeriesPlotRowToDataMap = {
-	Area: areaData,
-	Line: lineData,
-	Baseline: baselineData,
-	Histogram: lineData,
-	Bar: barData,
-	Candlestick: candlestickData,
-};
+export function getSeriesDataCreator<TSeriesType extends SeriesType, HorzScaleItem>(seriesType: TSeriesType): (plotRow: SeriesPlotRow<TSeriesType, HorzScaleItem>) => SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType] {
+	const seriesPlotRowToDataMap: SeriesPlotRowToDataMap<HorzScaleItem> = {
+		Area: areaData<HorzScaleItem>,
+		Line: lineData<HorzScaleItem>,
+		Baseline: baselineData<HorzScaleItem>,
+		Histogram: lineData<HorzScaleItem>,
+		Bar: barData,
+		Candlestick: candlestickData,
+	};
 
-export function getSeriesDataCreator<TSeriesType extends SeriesType>(seriesType: TSeriesType): (plotRow: SeriesPlotRow<TSeriesType>) => SeriesDataItemTypeMap[TSeriesType] {
 	return seriesPlotRowToDataMap[seriesType];
 }
diff --git a/src/api/get-series-plot-row-creator.ts b/src/api/get-series-plot-row-creator.ts
index accb37b002..4d8d200b86 100644
--- a/src/api/get-series-plot-row-creator.ts
+++ b/src/api/get-series-plot-row-creator.ts
@@ -1,14 +1,15 @@
+import { InternalHorzScaleItem } from '../model/ihorz-scale-behavior';
 import { PlotRow } from '../model/plot-data';
 import { SeriesPlotRow } from '../model/series-data';
 import { SeriesType } from '../model/series-options';
-import { OriginalTime, TimePoint, TimePointIndex } from '../model/time-data';
+import { TimePointIndex } from '../model/time-data';
 
 import { AreaData, BarData, BaselineData, CandlestickData, HistogramData, isWhitespaceData, LineData, SeriesDataItemTypeMap } from './data-consumer';
 
-function getColoredLineBasedSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: LineData | HistogramData, originalTime: OriginalTime): Mutable<SeriesPlotRow<'Line' | 'Histogram'>> {
+function getColoredLineBasedSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: LineData<HorzScaleItem> | HistogramData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Line' | 'Histogram', HorzScaleItem>> {
 	const val = item.value;
 
-	const res: Mutable<SeriesPlotRow<'Line' | 'Histogram'>> = { index, time, value: [val, val, val, val], originalTime };
+	const res: Mutable<SeriesPlotRow<'Line' | 'Histogram', HorzScaleItem>> = { index, time, value: [val, val, val, val], originalTime };
 
 	if (item.color !== undefined) {
 		res.color = item.color;
@@ -17,10 +18,10 @@ function getColoredLineBasedSeriesPlotRow(time: TimePoint, index: TimePointIndex
 	return res;
 }
 
-function getAreaSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: AreaData, originalTime: OriginalTime): Mutable<SeriesPlotRow<'Area'>> {
+function getAreaSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: AreaData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Area', HorzScaleItem>> {
 	const val = item.value;
 
-	const res: Mutable<SeriesPlotRow<'Area'>> = { index, time, value: [val, val, val, val], originalTime };
+	const res: Mutable<SeriesPlotRow<'Area', HorzScaleItem>> = { index, time, value: [val, val, val, val], originalTime };
 
 	if (item.lineColor !== undefined) {
 		res.lineColor = item.lineColor;
@@ -37,10 +38,10 @@ function getAreaSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: Area
 	return res;
 }
 
-function getBaselineSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: BaselineData, originalTime: OriginalTime): Mutable<SeriesPlotRow<'Baseline'>> {
+function getBaselineSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: BaselineData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Baseline', HorzScaleItem>> {
 	const val = item.value;
 
-	const res: Mutable<SeriesPlotRow<'Baseline'>> = { index, time, value: [val, val, val, val], originalTime };
+	const res: Mutable<SeriesPlotRow<'Baseline', HorzScaleItem>> = { index, time, value: [val, val, val, val], originalTime };
 
 	if (item.topLineColor !== undefined) {
 		res.topLineColor = item.topLineColor;
@@ -69,8 +70,8 @@ function getBaselineSeriesPlotRow(time: TimePoint, index: TimePointIndex, item:
 	return res;
 }
 
-function getBarSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: BarData, originalTime: OriginalTime): Mutable<SeriesPlotRow<'Bar'>> {
-	const res: Mutable<SeriesPlotRow<'Bar'>> = { index, time, value: [item.open, item.high, item.low, item.close], originalTime };
+function getBarSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: BarData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Bar', HorzScaleItem>> {
+	const res: Mutable<SeriesPlotRow<'Bar', HorzScaleItem>> = { index, time, value: [item.open, item.high, item.low, item.close], originalTime };
 
 	if (item.color !== undefined) {
 		res.color = item.color;
@@ -79,8 +80,8 @@ function getBarSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: BarDa
 	return res;
 }
 
-function getCandlestickSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: CandlestickData, originalTime: OriginalTime): Mutable<SeriesPlotRow<'Candlestick'>> {
-	const res: Mutable<SeriesPlotRow<'Candlestick'>> = { index, time, value: [item.open, item.high, item.low, item.close], originalTime };
+function getCandlestickSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: CandlestickData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Candlestick', HorzScaleItem>> {
+	const res: Mutable<SeriesPlotRow<'Candlestick', HorzScaleItem>> = { index, time, value: [item.open, item.high, item.low, item.close], originalTime };
 	if (item.color !== undefined) {
 		res.color = item.color;
 	}
@@ -96,18 +97,18 @@ function getCandlestickSeriesPlotRow(time: TimePoint, index: TimePointIndex, ite
 	return res;
 }
 
-export type WhitespacePlotRow = Omit<PlotRow, 'value'>;
+export type WhitespacePlotRow<HorzScaleItem> = Omit<PlotRow<HorzScaleItem>, 'value'>;
 
-export function isSeriesPlotRow(row: SeriesPlotRow | WhitespacePlotRow): row is SeriesPlotRow {
-	return (row as Partial<SeriesPlotRow>).value !== undefined;
+export function isSeriesPlotRow<TSeriesType extends SeriesType, HorzScaleItem>(row: SeriesPlotRow<TSeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>): row is SeriesPlotRow<TSeriesType, HorzScaleItem> {
+	return (row as Partial<SeriesPlotRow<TSeriesType, HorzScaleItem>>).value !== undefined;
 }
 
-type SeriesItemValueFnMap = {
-	[T in keyof SeriesDataItemTypeMap]: (time: TimePoint, index: TimePointIndex, item: SeriesDataItemTypeMap[T], originalTime: OriginalTime) => Mutable<SeriesPlotRow<T> | WhitespacePlotRow>;
+type SeriesItemValueFnMap<TSeriesType extends SeriesType, HorzScaleItem> = {
+	[T in keyof SeriesDataItemTypeMap<TSeriesType>]: (time: InternalHorzScaleItem, index: TimePointIndex, item: SeriesDataItemTypeMap<HorzScaleItem>[T], originalTime: HorzScaleItem) => Mutable<SeriesPlotRow<T, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>>;
 };
 
-function wrapWhitespaceData<TSeriesType extends SeriesType>(createPlotRowFn: (typeof getBaselineSeriesPlotRow) | (typeof getBarSeriesPlotRow) | (typeof getCandlestickSeriesPlotRow)): SeriesItemValueFnMap[TSeriesType] {
-	return (time: TimePoint, index: TimePointIndex, bar: SeriesDataItemTypeMap[SeriesType], originalTime: OriginalTime) => {
+function wrapWhitespaceData<TSeriesType extends SeriesType, HorzScaleItem>(createPlotRowFn: (typeof getBaselineSeriesPlotRow) | (typeof getBarSeriesPlotRow) | (typeof getCandlestickSeriesPlotRow)): SeriesItemValueFnMap<TSeriesType, HorzScaleItem>[TSeriesType] {
+	return (time: InternalHorzScaleItem, index: TimePointIndex, bar: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType], originalTime: HorzScaleItem) => {
 		if (isWhitespaceData(bar)) {
 			return { time, index, originalTime };
 		}
@@ -116,15 +117,15 @@ function wrapWhitespaceData<TSeriesType extends SeriesType>(createPlotRowFn: (ty
 	};
 }
 
-const seriesPlotRowFnMap: SeriesItemValueFnMap = {
-	Candlestick: wrapWhitespaceData(getCandlestickSeriesPlotRow),
-	Bar: wrapWhitespaceData(getBarSeriesPlotRow),
-	Area: wrapWhitespaceData(getAreaSeriesPlotRow),
-	Baseline: wrapWhitespaceData(getBaselineSeriesPlotRow),
-	Histogram: wrapWhitespaceData(getColoredLineBasedSeriesPlotRow),
-	Line: wrapWhitespaceData(getColoredLineBasedSeriesPlotRow),
-};
+export function getSeriesPlotRowCreator<TSeriesType extends SeriesType, HorzScaleItem>(seriesType: TSeriesType): SeriesItemValueFnMap<TSeriesType, HorzScaleItem>[TSeriesType] {
+	const seriesPlotRowFnMap: SeriesItemValueFnMap<TSeriesType, HorzScaleItem> = {
+		Candlestick: wrapWhitespaceData(getCandlestickSeriesPlotRow),
+		Bar: wrapWhitespaceData(getBarSeriesPlotRow),
+		Area: wrapWhitespaceData(getAreaSeriesPlotRow),
+		Baseline: wrapWhitespaceData(getBaselineSeriesPlotRow),
+		Histogram: wrapWhitespaceData(getColoredLineBasedSeriesPlotRow),
+		Line: wrapWhitespaceData(getColoredLineBasedSeriesPlotRow),
+	};
 
-export function getSeriesPlotRowCreator<TSeriesType extends SeriesType>(seriesType: TSeriesType): SeriesItemValueFnMap[TSeriesType] {
 	return seriesPlotRowFnMap[seriesType];
 }
diff --git a/src/api/ichart-api.ts b/src/api/ichart-api.ts
index 54562a9358..db43402fe5 100644
--- a/src/api/ichart-api.ts
+++ b/src/api/ichart-api.ts
@@ -1,6 +1,7 @@
 import { DeepPartial } from '../helpers/strict-type-checks';
 
 import { ChartOptions } from '../model/chart-model';
+import { Time } from '../model/horz-scale-behavior-time/types';
 import { Point } from '../model/point';
 import {
 	AreaSeriesPartialOptions,
@@ -11,7 +12,7 @@ import {
 	LineSeriesPartialOptions,
 	SeriesType,
 } from '../model/series-options';
-import { Logical, Time } from '../model/time-data';
+import { Logical } from '../model/time-data';
 import { TouchMouseEventData } from '../model/touch-mouse-event-data';
 
 import { BarData, HistogramData, LineData } from './data-consumer';
@@ -22,13 +23,13 @@ import { ITimeScaleApi } from './itime-scale-api';
 /**
  * Represents a mouse event.
  */
-export interface MouseEventParams {
+export interface MouseEventParams<HorzScaleItem = Time> {
 	/**
 	 * Time of the data at the location of the mouse event.
 	 *
 	 * The value will be `undefined` if the location of the event in the chart is outside the range of available data.
 	 */
-	time?: Time;
+	time?: HorzScaleItem;
 	/**
 	 * Logical index
 	 */
@@ -45,11 +46,11 @@ export interface MouseEventParams {
 	 * Keys of the map are {@link ISeriesApi} instances. Values are prices.
 	 * Values of the map are original data items
 	 */
-	seriesData: Map<ISeriesApi<SeriesType>, BarData | LineData | HistogramData>;
+	seriesData: Map<ISeriesApi<SeriesType, HorzScaleItem>, BarData<HorzScaleItem> | LineData<HorzScaleItem> | HistogramData<HorzScaleItem>>;
 	/**
 	 * The {@link ISeriesApi} for the series at the point of the mouse event.
 	 */
-	hoveredSeries?: ISeriesApi<SeriesType>;
+	hoveredSeries?: ISeriesApi<SeriesType, HorzScaleItem>;
 	/**
 	 * The ID of the object at the point of the mouse event.
 	 */
@@ -63,12 +64,12 @@ export interface MouseEventParams {
 /**
  * A custom function use to handle mouse events.
  */
-export type MouseEventHandler = (param: MouseEventParams) => void;
+export type MouseEventHandler<HorzScaleItem> = (param: MouseEventParams<HorzScaleItem>) => void;
 
 /**
  * The main interface of a single chart.
  */
-export interface IChartApi {
+export interface IChartApi<HorzScaleItem = Time> {
 	/**
 	 * Removes the chart object including all DOM elements. This is an irreversible operation, you cannot do anything with the chart after removing it.
 	 */
@@ -96,7 +97,7 @@ export interface IChartApi {
 	 * const series = chart.addAreaSeries();
 	 * ```
 	 */
-	addAreaSeries(areaOptions?: AreaSeriesPartialOptions): ISeriesApi<'Area'>;
+	addAreaSeries(areaOptions?: AreaSeriesPartialOptions): ISeriesApi<'Area', HorzScaleItem>;
 
 	/**
 	 * Creates a baseline series with specified parameters.
@@ -108,7 +109,7 @@ export interface IChartApi {
 	 * const series = chart.addBaselineSeries();
 	 * ```
 	 */
-	addBaselineSeries(baselineOptions?: BaselineSeriesPartialOptions): ISeriesApi<'Baseline'>;
+	addBaselineSeries(baselineOptions?: BaselineSeriesPartialOptions): ISeriesApi<'Baseline', HorzScaleItem>;
 
 	/**
 	 * Creates a bar series with specified parameters.
@@ -120,7 +121,7 @@ export interface IChartApi {
 	 * const series = chart.addBarSeries();
 	 * ```
 	 */
-	addBarSeries(barOptions?: BarSeriesPartialOptions): ISeriesApi<'Bar'>;
+	addBarSeries(barOptions?: BarSeriesPartialOptions): ISeriesApi<'Bar', HorzScaleItem>;
 
 	/**
 	 * Creates a candlestick series with specified parameters.
@@ -132,7 +133,7 @@ export interface IChartApi {
 	 * const series = chart.addCandlestickSeries();
 	 * ```
 	 */
-	addCandlestickSeries(candlestickOptions?: CandlestickSeriesPartialOptions): ISeriesApi<'Candlestick'>;
+	addCandlestickSeries(candlestickOptions?: CandlestickSeriesPartialOptions): ISeriesApi<'Candlestick', HorzScaleItem>;
 
 	/**
 	 * Creates a histogram series with specified parameters.
@@ -144,7 +145,7 @@ export interface IChartApi {
 	 * const series = chart.addHistogramSeries();
 	 * ```
 	 */
-	addHistogramSeries(histogramOptions?: HistogramSeriesPartialOptions): ISeriesApi<'Histogram'>;
+	addHistogramSeries(histogramOptions?: HistogramSeriesPartialOptions): ISeriesApi<'Histogram', HorzScaleItem>;
 
 	/**
 	 * Creates a line series with specified parameters.
@@ -156,7 +157,7 @@ export interface IChartApi {
 	 * const series = chart.addLineSeries();
 	 * ```
 	 */
-	addLineSeries(lineOptions?: LineSeriesPartialOptions): ISeriesApi<'Line'>;
+	addLineSeries(lineOptions?: LineSeriesPartialOptions): ISeriesApi<'Line', HorzScaleItem>;
 
 	/**
 	 * Removes a series of any type. This is an irreversible operation, you cannot do anything with the series after removing it.
@@ -166,7 +167,7 @@ export interface IChartApi {
 	 * chart.removeSeries(series);
 	 * ```
 	 */
-	removeSeries(seriesApi: ISeriesApi<SeriesType>): void;
+	removeSeries(seriesApi: ISeriesApi<SeriesType, HorzScaleItem>): void;
 
 	/**
 	 * Subscribe to the chart click event.
@@ -185,7 +186,7 @@ export interface IChartApi {
 	 * chart.subscribeClick(myClickHandler);
 	 * ```
 	 */
-	subscribeClick(handler: MouseEventHandler): void;
+	subscribeClick(handler: MouseEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Unsubscribe a handler that was previously subscribed using {@link subscribeClick}.
@@ -196,7 +197,7 @@ export interface IChartApi {
 	 * chart.unsubscribeClick(myClickHandler);
 	 * ```
 	 */
-	unsubscribeClick(handler: MouseEventHandler): void;
+	unsubscribeClick(handler: MouseEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Subscribe to the crosshair move event.
@@ -215,7 +216,7 @@ export interface IChartApi {
 	 * chart.subscribeCrosshairMove(myCrosshairMoveHandler);
 	 * ```
 	 */
-	subscribeCrosshairMove(handler: MouseEventHandler): void;
+	subscribeCrosshairMove(handler: MouseEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Unsubscribe a handler that was previously subscribed using {@link subscribeCrosshairMove}.
@@ -226,7 +227,7 @@ export interface IChartApi {
 	 * chart.unsubscribeCrosshairMove(myCrosshairMoveHandler);
 	 * ```
 	 */
-	unsubscribeCrosshairMove(handler: MouseEventHandler): void;
+	unsubscribeCrosshairMove(handler: MouseEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Returns API to manipulate a price scale.
@@ -241,21 +242,21 @@ export interface IChartApi {
 	 *
 	 * @returns Target API
 	 */
-	timeScale(): ITimeScaleApi;
+	timeScale(): ITimeScaleApi<HorzScaleItem>;
 
 	/**
 	 * Applies new options to the chart
 	 *
 	 * @param options - Any subset of options.
 	 */
-	applyOptions(options: DeepPartial<ChartOptions>): void;
+	applyOptions(options: DeepPartial<ChartOptions<HorzScaleItem>>): void;
 
 	/**
 	 * Returns currently applied options
 	 *
 	 * @returns Full set of currently applied options, including defaults
 	 */
-	options(): Readonly<ChartOptions>;
+	options(): Readonly<ChartOptions<HorzScaleItem>>;
 
 	/**
 	 * Make a screenshot of the chart with all the elements excluding crosshair.
diff --git a/src/api/iseries-api.ts b/src/api/iseries-api.ts
index 4708e2454a..fad2c5f5c6 100644
--- a/src/api/iseries-api.ts
+++ b/src/api/iseries-api.ts
@@ -10,7 +10,7 @@ import {
 	SeriesPartialOptionsMap,
 	SeriesType,
 } from '../model/series-options';
-import { Range, Time } from '../model/time-data';
+import { Range } from '../model/time-data';
 
 import { SeriesDataItemTypeMap } from './data-consumer';
 import { IPriceLine } from './iprice-line';
@@ -21,7 +21,7 @@ import { IPriceScaleApi } from './iprice-scale-api';
  */
 // actually range might be either exist or not
 // but to avoid hard-readable type let's say every part of range is optional
-export interface BarsInfo extends Partial<Range<Time>> {
+export interface BarsInfo<HorzScaleItem> extends Partial<Range<HorzScaleItem>> {
 	/**
 	 * The number of bars before the start of the range.
 	 * Positive value means that there are some bars before (out of logical range from the left) the {@link Range.from} logical index in the series.
@@ -40,7 +40,7 @@ export interface BarsInfo extends Partial<Range<Time>> {
 /**
  * Represents the interface for interacting with series.
  */
-export interface ISeriesApi<TSeriesType extends SeriesType> {
+export interface ISeriesApi<TSeriesType extends SeriesType, HorzScaleItem> {
 	/**
 	 * Returns current price formatter
 	 *
@@ -88,7 +88,7 @@ export interface ISeriesApi<TSeriesType extends SeriesType> {
 	 * chart.timeScale().subscribeVisibleLogicalRangeChange(onVisibleLogicalRangeChanged);
 	 * ```
 	 */
-	barsInLogicalRange(range: Range<number>): BarsInfo | null;
+	barsInLogicalRange(range: Range<number>): BarsInfo<HorzScaleItem> | null;
 
 	/**
 	 * Applies new options to the existing series
@@ -132,7 +132,7 @@ export interface ISeriesApi<TSeriesType extends SeriesType> {
 	 * ]);
 	 * ```
 	 */
-	setData(data: SeriesDataItemTypeMap[TSeriesType][]): void;
+	setData(data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void;
 
 	/**
 	 * Adds new data item to the existing set (or updates the latest item if times of the passed/latest items are equal).
@@ -157,7 +157,7 @@ export interface ISeriesApi<TSeriesType extends SeriesType> {
 	 * });
 	 * ```
 	 */
-	update(bar: SeriesDataItemTypeMap[TSeriesType]): void;
+	update(bar: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void;
 
 	/**
 	 * Returns a bar data by provided logical index.
@@ -170,7 +170,7 @@ export interface ISeriesApi<TSeriesType extends SeriesType> {
 	 * const originalData = series.dataByIndex(10, LightweightCharts.MismatchDirection.NearestLeft);
 	 * ```
 	 */
-	dataByIndex(logicalIndex: number, mismatchDirection?: MismatchDirection): SeriesDataItemTypeMap[TSeriesType] | null;
+	dataByIndex(logicalIndex: number, mismatchDirection?: MismatchDirection): SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType] | null;
 
 	/**
 	 * Allows to set/replace all existing series markers with new ones.
@@ -212,12 +212,12 @@ export interface ISeriesApi<TSeriesType extends SeriesType> {
 	 * });
 	 * ```
 	 */
-	setMarkers(data: SeriesMarker<Time>[]): void;
+	setMarkers(data: SeriesMarker<HorzScaleItem, HorzScaleItem>[]): void;
 
 	/**
 	 * Returns an array of series markers.
 	 */
-	markers(): SeriesMarker<Time>[];
+	markers(): SeriesMarker<HorzScaleItem, HorzScaleItem>[];
 
 	/**
 	 * Creates a new price line
diff --git a/src/api/itime-scale-api.ts b/src/api/itime-scale-api.ts
index 24e12901d6..4d754d0305 100644
--- a/src/api/itime-scale-api.ts
+++ b/src/api/itime-scale-api.ts
@@ -1,18 +1,13 @@
 import { DeepPartial } from '../helpers/strict-type-checks';
 
 import { Coordinate } from '../model/coordinate';
-import { Logical, LogicalRange, Range, Time } from '../model/time-data';
+import { Logical, LogicalRange, Range } from '../model/time-data';
 import { TimeScaleOptions } from '../model/time-scale';
 
-/**
- * Represents a {@link Time} range.
- */
-export type TimeRange = Range<Time>;
-
 /**
  * A custom function used to handle changes to the time scale's time range.
  */
-export type TimeRangeChangeEventHandler = (timeRange: TimeRange | null) => void;
+export type TimeRangeChangeEventHandler<HorzScaleItem> = (timeRange: Range<HorzScaleItem> | null) => void;
 /**
  * A custom function used to handle changes to the time scale's logical range.
  */
@@ -23,7 +18,7 @@ export type LogicalRangeChangeEventHandler = (logicalRange: LogicalRange | null)
 export type SizeChangeEventHandler = (width: number, height: number) => void;
 
 /** Interface to chart time scale */
-export interface ITimeScaleApi {
+export interface ITimeScaleApi<HorzScaleItem> {
 	/**
 	 * Return the distance from the right edge of the time scale to the lastest bar of the series measured in bars.
 	 */
@@ -50,7 +45,7 @@ export interface ITimeScaleApi {
 	 *
 	 * @returns Visible range or null if the chart has no data at all.
 	 */
-	getVisibleRange(): TimeRange | null;
+	getVisibleRange(): Range<HorzScaleItem> | null;
 
 	/**
 	 * Sets visible range of data.
@@ -69,7 +64,7 @@ export interface ITimeScaleApi {
 	 * });
 	 * ```
 	 */
-	setVisibleRange(range: TimeRange): void;
+	setVisibleRange(range: Range<HorzScaleItem>): void;
 
 	/**
 	 * Returns the current visible [logical range](/time-scale.md#logical-range) of the chart as an object with the first and last time points of the logical range, or returns `null` if the chart has no data.
@@ -121,7 +116,7 @@ export interface ITimeScaleApi {
 	 * @param time - Time needs to be converted
 	 * @returns X coordinate of that time or `null` if no time found on time scale
 	 */
-	timeToCoordinate(time: Time): Coordinate | null;
+	timeToCoordinate(time: HorzScaleItem): Coordinate | null;
 
 	/**
 	 * Converts a coordinate to time.
@@ -129,7 +124,7 @@ export interface ITimeScaleApi {
 	 * @param x - Coordinate needs to be converted.
 	 * @returns Time of a bar that is located on that coordinate or `null` if there are no bars found on that coordinate.
 	 */
-	coordinateToTime(x: number): Time | null;
+	coordinateToTime(x: number): HorzScaleItem | null;
 
 	/**
 	 * Returns a width of the time scale.
@@ -160,7 +155,7 @@ export interface ITimeScaleApi {
 	 * chart.timeScale().subscribeVisibleTimeRangeChange(myVisibleTimeRangeChangeHandler);
 	 * ```
 	 */
-	subscribeVisibleTimeRangeChange(handler: TimeRangeChangeEventHandler): void;
+	subscribeVisibleTimeRangeChange(handler: TimeRangeChangeEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Unsubscribe a handler that was previously subscribed using {@link subscribeVisibleTimeRangeChange}.
@@ -171,7 +166,7 @@ export interface ITimeScaleApi {
 	 * chart.timeScale().unsubscribeVisibleTimeRangeChange(myVisibleTimeRangeChangeHandler);
 	 * ```
 	 */
-	unsubscribeVisibleTimeRangeChange(handler: TimeRangeChangeEventHandler): void;
+	unsubscribeVisibleTimeRangeChange(handler: TimeRangeChangeEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Subscribe to the visible logical range change events.
diff --git a/src/api/options/chart-options-defaults.ts b/src/api/options/chart-options-defaults.ts
index 9abf077e56..50628e5c5d 100644
--- a/src/api/options/chart-options-defaults.ts
+++ b/src/api/options/chart-options-defaults.ts
@@ -9,53 +9,55 @@ import { priceScaleOptionsDefaults } from './price-scale-options-defaults';
 import { timeScaleOptionsDefaults } from './time-scale-options-defaults';
 import { watermarkOptionsDefaults } from './watermark-options-defaults';
 
-export const chartOptionsDefaults: ChartOptionsInternal = {
-	width: 0,
-	height: 0,
-	autoSize: false,
-	layout: layoutOptionsDefaults,
-	crosshair: crosshairOptionsDefaults,
-	grid: gridOptionsDefaults,
-	overlayPriceScales: {
-		...priceScaleOptionsDefaults,
-	},
-	leftPriceScale: {
-		...priceScaleOptionsDefaults,
-		visible: false,
-	},
-	rightPriceScale: {
-		...priceScaleOptionsDefaults,
-		visible: true,
-	},
-	timeScale: timeScaleOptionsDefaults,
-	watermark: watermarkOptionsDefaults,
-	localization: {
-		locale: isRunningOnClientSide ? navigator.language : '',
-		dateFormat: 'dd MMM \'yy',
-	},
-	handleScroll: {
-		mouseWheel: true,
-		pressedMouseMove: true,
-		horzTouchDrag: true,
-		vertTouchDrag: true,
-	},
-	handleScale: {
-		axisPressedMouseMove: {
-			time: true,
-			price: true,
-		},
-		axisDoubleClickReset: {
-			time: true,
-			price: true,
-		},
-		mouseWheel: true,
-		pinch: true,
-	},
-	kineticScroll: {
-		mouse: false,
-		touch: true,
-	},
-	trackingMode: {
-		exitMode: TrackingModeExitMode.OnNextTap,
-	},
-};
+export function chartOptionsDefaults<HorzScaleItem>() : ChartOptionsInternal<HorzScaleItem> {
+	return {
+		width: 0,
+		height: 0,
+		autoSize: false,
+		layout: layoutOptionsDefaults,
+		crosshair: crosshairOptionsDefaults,
+		grid: gridOptionsDefaults,
+		overlayPriceScales: {
+			...priceScaleOptionsDefaults,
+		},
+		leftPriceScale: {
+			...priceScaleOptionsDefaults,
+			visible: false,
+		},
+		rightPriceScale: {
+			...priceScaleOptionsDefaults,
+			visible: true,
+		},
+		timeScale: timeScaleOptionsDefaults,
+		watermark: watermarkOptionsDefaults,
+		localization: {
+			locale: isRunningOnClientSide ? navigator.language : '',
+			dateFormat: 'dd MMM \'yy',
+		},
+		handleScroll: {
+			mouseWheel: true,
+			pressedMouseMove: true,
+			horzTouchDrag: true,
+			vertTouchDrag: true,
+		},
+		handleScale: {
+			axisPressedMouseMove: {
+				time: true,
+				price: true,
+			},
+			axisDoubleClickReset: {
+				time: true,
+				price: true,
+			},
+			mouseWheel: true,
+			pinch: true,
+		},
+		kineticScroll: {
+			mouse: false,
+			touch: true,
+		},
+		trackingMode: {
+			exitMode: TrackingModeExitMode.OnNextTap,
+		},
+	};
+}
diff --git a/src/api/options/time-scale-options-defaults.ts b/src/api/options/time-scale-options-defaults.ts
index 3863d67298..2b3a6891e8 100644
--- a/src/api/options/time-scale-options-defaults.ts
+++ b/src/api/options/time-scale-options-defaults.ts
@@ -15,4 +15,5 @@ export const timeScaleOptionsDefaults: TimeScaleOptions = {
 	secondsVisible: true,
 	shiftVisibleRangeOnNewBar: true,
 	ticksVisible: false,
+	uniformDistribution: false,
 };
diff --git a/src/api/price-line-api.ts b/src/api/price-line-api.ts
index c531241379..d27fe8db4e 100644
--- a/src/api/price-line-api.ts
+++ b/src/api/price-line-api.ts
@@ -3,10 +3,10 @@ import { PriceLineOptions } from '../model/price-line-options';
 
 import { IPriceLine } from './iprice-line';
 
-export class PriceLine implements IPriceLine {
-	private readonly _priceLine: CustomPriceLine;
+export class PriceLine<HorzScaleItem> implements IPriceLine {
+	private readonly _priceLine: CustomPriceLine<HorzScaleItem>;
 
-	public constructor(priceLine: CustomPriceLine) {
+	public constructor(priceLine: CustomPriceLine<HorzScaleItem>) {
 		this._priceLine = priceLine;
 	}
 
@@ -17,7 +17,7 @@ export class PriceLine implements IPriceLine {
 		return this._priceLine.options();
 	}
 
-	public priceLine(): CustomPriceLine {
+	public priceLine(): CustomPriceLine<HorzScaleItem> {
 		return this._priceLine;
 	}
 }
diff --git a/src/api/price-scale-api.ts b/src/api/price-scale-api.ts
index 4b2d1fc485..2ab28ad86e 100644
--- a/src/api/price-scale-api.ts
+++ b/src/api/price-scale-api.ts
@@ -8,11 +8,11 @@ import { PriceScale, PriceScaleOptions } from '../model/price-scale';
 
 import { IPriceScaleApi } from './iprice-scale-api';
 
-export class PriceScaleApi implements IPriceScaleApi {
-	private _chartWidget: ChartWidget;
+export class PriceScaleApi<HorzScaleItem> implements IPriceScaleApi {
+	private _chartWidget: ChartWidget<HorzScaleItem>;
 	private readonly _priceScaleId: string;
 
-	public constructor(chartWidget: ChartWidget, priceScaleId: string) {
+	public constructor(chartWidget: ChartWidget<HorzScaleItem>, priceScaleId: string) {
 		this._chartWidget = chartWidget;
 		this._priceScaleId = priceScaleId;
 	}
@@ -33,7 +33,7 @@ export class PriceScaleApi implements IPriceScaleApi {
 		return this._chartWidget.getPriceAxisWidth(this._priceScaleId);
 	}
 
-	private _priceScale(): PriceScale {
+	private _priceScale(): PriceScale<HorzScaleItem> {
 		return ensureNotNull(this._chartWidget.model().findPriceScale(this._priceScaleId)).priceScale;
 	}
 }
diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index 3118106e63..bb0e7256fa 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -5,6 +5,7 @@ import { clone, merge } from '../helpers/strict-type-checks';
 
 import { BarPrice } from '../model/bar';
 import { Coordinate } from '../model/coordinate';
+import { IHorzScaleBehavior, InternalHorzScaleItem } from '../model/ihorz-scale-behavior';
 import { MismatchDirection } from '../model/plot-list';
 import { CreatePriceLineOptions, PriceLineOptions } from '../model/price-line-options';
 import { RangeImpl } from '../model/range-impl';
@@ -15,12 +16,11 @@ import {
 	SeriesPartialOptionsMap,
 	SeriesType,
 } from '../model/series-options';
-import { Logical, OriginalTime, Range, Time, TimePoint, TimePointIndex } from '../model/time-data';
+import { Logical, Range, TimePointIndex } from '../model/time-data';
 import { TimeScaleVisibleRange } from '../model/time-scale-visible-range';
 
 import { IPriceScaleApiProvider } from './chart-api';
 import { DataUpdatesConsumer, SeriesDataItemTypeMap } from './data-consumer';
-import { convertTime } from './data-layer';
 import { checkItemsAreOrdered, checkPriceLineOptions, checkSeriesValuesType } from './data-validators';
 import { getSeriesDataCreator } from './get-series-data-creator';
 import { IPriceLine } from './iprice-line';
@@ -29,16 +29,19 @@ import { BarsInfo, ISeriesApi } from './iseries-api';
 import { priceLineOptionsDefaults } from './options/price-line-options-defaults';
 import { PriceLine } from './price-line-api';
 
-export class SeriesApi<TSeriesType extends SeriesType> implements ISeriesApi<TSeriesType> {
-	protected _series: Series<TSeriesType>;
-	protected _dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType>;
+export class SeriesApi<TSeriesType extends SeriesType, HorzScaleItem> implements ISeriesApi<TSeriesType, HorzScaleItem> {
+	protected _series: Series<TSeriesType, HorzScaleItem>;
+	protected _dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType, HorzScaleItem>;
 
-	private readonly _priceScaleApiProvider: IPriceScaleApiProvider;
+	private readonly _priceScaleApiProvider: IPriceScaleApiProvider<HorzScaleItem>;
 
-	public constructor(series: Series<TSeriesType>, dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType>, priceScaleApiProvider: IPriceScaleApiProvider) {
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(series: Series<TSeriesType, HorzScaleItem>, dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType, HorzScaleItem>, priceScaleApiProvider: IPriceScaleApiProvider<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
 		this._series = series;
 		this._dataUpdatesConsumer = dataUpdatesConsumer;
 		this._priceScaleApiProvider = priceScaleApiProvider;
+		this._horzScaleBehavior = horzScaleBehavior;
 	}
 
 	public priceFormatter(): IPriceFormatter {
@@ -63,7 +66,7 @@ export class SeriesApi<TSeriesType extends SeriesType> implements ISeriesApi<TSe
 	}
 
 	// eslint-disable-next-line complexity
-	public barsInLogicalRange(range: Range<number> | null): BarsInfo | null {
+	public barsInLogicalRange(range: Range<number> | null): BarsInfo<HorzScaleItem> | null {
 		if (range === null) {
 			return null;
 		}
@@ -103,57 +106,59 @@ export class SeriesApi<TSeriesType extends SeriesType> implements ISeriesApi<TSe
 			? dataLastIndex - range.to
 			: dataLastIndex - dataLastBarInRange.index;
 
-		const result: BarsInfo = { barsBefore, barsAfter };
+		const result: BarsInfo<HorzScaleItem> = { barsBefore, barsAfter };
 
 		// actually they can't exist separately
 		if (dataFirstBarInRange !== null && dataLastBarInRange !== null) {
-			result.from = dataFirstBarInRange.time.businessDay || dataFirstBarInRange.time.timestamp;
-			result.to = dataLastBarInRange.time.businessDay || dataLastBarInRange.time.timestamp;
+			// result.from = dataFirstBarInRange.time.businessDay || dataFirstBarInRange.time.timestamp;
+			// result.to = dataLastBarInRange.time.businessDay || dataLastBarInRange.time.timestamp;
+			result.from = this._horzScaleBehavior.convertInternalToHorzItem(dataFirstBarInRange.time);
+			result.to = this._horzScaleBehavior.convertInternalToHorzItem(dataLastBarInRange.time);
 		}
 
 		return result;
 	}
 
-	public setData(data: SeriesDataItemTypeMap[TSeriesType][]): void {
-		checkItemsAreOrdered(data);
+	public setData(data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void {
+		checkItemsAreOrdered(data, this._horzScaleBehavior);
 		checkSeriesValuesType(this._series.seriesType(), data);
 
 		this._dataUpdatesConsumer.applyNewData(this._series, data);
 	}
 
-	public update(bar: SeriesDataItemTypeMap[TSeriesType]): void {
+	public update(bar: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void {
 		checkSeriesValuesType(this._series.seriesType(), [bar]);
 
 		this._dataUpdatesConsumer.updateData(this._series, bar);
 	}
 
-	public dataByIndex(logicalIndex: number, mismatchDirection?: MismatchDirection): SeriesDataItemTypeMap[TSeriesType] | null {
+	public dataByIndex(logicalIndex: number, mismatchDirection?: MismatchDirection): SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType] | null {
 		const data = this._series.bars().search(logicalIndex as unknown as TimePointIndex, mismatchDirection);
 		if (data === null) {
 			// actually it can be a whitespace
 			return null;
 		}
 
-		return getSeriesDataCreator(this.seriesType())(data);
+		return getSeriesDataCreator<TSeriesType, HorzScaleItem>(this.seriesType())(data);
 	}
 
-	public setMarkers(data: SeriesMarker<Time>[]): void {
-		checkItemsAreOrdered(data, true);
+	public setMarkers(data: SeriesMarker<HorzScaleItem, HorzScaleItem>[]): void {
+		checkItemsAreOrdered(data, this._horzScaleBehavior, true);
 
-		const convertedMarkers = data.map<SeriesMarker<TimePoint>>((marker: SeriesMarker<Time>) => ({
-			...marker,
-			originalTime: marker.time as unknown as OriginalTime,
-			time: convertTime(marker.time),
+		const convertedMarkers = data.map<SeriesMarker<InternalHorzScaleItem, HorzScaleItem>>((marker: SeriesMarker<HorzScaleItem, HorzScaleItem>) => ({
+			...marker as Omit<SeriesMarker<HorzScaleItem, HorzScaleItem>, 'time'>,
+			originalTime: marker.time,
+			time: this._horzScaleBehavior.convertHorzItemToInternal(marker.time),
 		}));
 		this._series.setMarkers(convertedMarkers);
 	}
 
-	public markers(): SeriesMarker<Time>[] {
-		return this._series.markers().map<SeriesMarker<Time>>((internalItem: SeriesMarker<TimePoint>) => {
-			const { originalTime, time, ...item } = internalItem;
+	public markers(): SeriesMarker<HorzScaleItem, HorzScaleItem>[] {
+		return this._series.markers().map<SeriesMarker<HorzScaleItem, HorzScaleItem>>((internalItem: SeriesMarker<InternalHorzScaleItem, HorzScaleItem>) => {
+			const { time, ...item } = internalItem;
 			return {
-				time: originalTime as unknown as Time,
-				...item as Omit<SeriesMarker<TimePoint>, 'time' | 'originalTIme'>,
+				time: item.originalTime,
+				...item as Omit<SeriesMarker<HorzScaleItem, HorzScaleItem>, 'time' | 'originalTIme'>,
 			};
 		});
 	}
@@ -179,7 +184,7 @@ export class SeriesApi<TSeriesType extends SeriesType> implements ISeriesApi<TSe
 	}
 
 	public removePriceLine(line: IPriceLine): void {
-		this._series.removePriceLine((line as PriceLine).priceLine());
+		this._series.removePriceLine((line as PriceLine<HorzScaleItem>).priceLine());
 	}
 
 	public seriesType(): TSeriesType {
diff --git a/src/api/time-scale-api.ts b/src/api/time-scale-api.ts
index 7482ccec58..a482181ac8 100644
--- a/src/api/time-scale-api.ts
+++ b/src/api/time-scale-api.ts
@@ -9,36 +9,39 @@ import { clone, DeepPartial } from '../helpers/strict-type-checks';
 
 import { ChartModel } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
-import { Logical, LogicalRange, Range, Time, TimePointIndex, TimePointsRange } from '../model/time-data';
+import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
+import { Logical, LogicalRange, Range, TimePointIndex, TimePointsRange } from '../model/time-data';
 import { TimeScale, TimeScaleOptions } from '../model/time-scale';
 
-import { convertTime } from './data-layer';
 import {
 	ITimeScaleApi,
 	LogicalRangeChangeEventHandler,
 	SizeChangeEventHandler,
-	TimeRange,
 	TimeRangeChangeEventHandler,
 } from './itime-scale-api';
 const enum Constants {
 	AnimationDurationMs = 1000,
 }
 
-export class TimeScaleApi implements ITimeScaleApi, IDestroyable {
-	private _model: ChartModel;
-	private _timeScale: TimeScale;
-	private readonly _timeAxisWidget: TimeAxisWidget;
-	private readonly _timeRangeChanged: Delegate<TimeRange | null> = new Delegate();
+export class TimeScaleApi<HorzScaleItem> implements ITimeScaleApi<HorzScaleItem>, IDestroyable {
+	private _model: ChartModel<HorzScaleItem>;
+	private _timeScale: TimeScale<HorzScaleItem>;
+	private readonly _timeAxisWidget: TimeAxisWidget<HorzScaleItem>;
+	private readonly _timeRangeChanged: Delegate<Range<HorzScaleItem> | null> = new Delegate();
 	private readonly _logicalRangeChanged: Delegate<LogicalRange | null> = new Delegate();
 	private readonly _sizeChanged: Delegate<number, number> = new Delegate();
 
-	public constructor(model: ChartModel, timeAxisWidget: TimeAxisWidget) {
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(model: ChartModel<HorzScaleItem>, timeAxisWidget: TimeAxisWidget<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
 		this._model = model;
 		this._timeScale = model.timeScale();
 		this._timeAxisWidget = timeAxisWidget;
 		this._timeScale.visibleBarsChanged().subscribe(this._onVisibleBarsChanged.bind(this));
 		this._timeScale.logicalRangeChanged().subscribe(this._onVisibleLogicalRangeChanged.bind(this));
 		this._timeAxisWidget.sizeChanged().subscribe(this._onSizeChanged.bind(this));
+
+		this._horzScaleBehavior = horzScaleBehavior;
 	}
 
 	public destroy(): void {
@@ -67,7 +70,7 @@ export class TimeScaleApi implements ITimeScaleApi, IDestroyable {
 		this._timeScale.scrollToRealTime();
 	}
 
-	public getVisibleRange(): TimeRange | null {
+	public getVisibleRange(): Range<HorzScaleItem> | null {
 		const timeRange = this._timeScale.visibleTimeRange();
 
 		if (timeRange === null) {
@@ -75,15 +78,15 @@ export class TimeScaleApi implements ITimeScaleApi, IDestroyable {
 		}
 
 		return {
-			from: timeRange.from.businessDay ?? timeRange.from.timestamp,
-			to: timeRange.to.businessDay ?? timeRange.to.timestamp,
+			from: this._horzScaleBehavior.convertInternalToHorzItem(timeRange.from),
+			to: this._horzScaleBehavior.convertInternalToHorzItem(timeRange.to),
 		};
 	}
 
-	public setVisibleRange(range: TimeRange): void {
+	public setVisibleRange(range: Range<HorzScaleItem>): void {
 		const convertedRange: TimePointsRange = {
-			from: convertTime(range.from),
-			to: convertTime(range.to),
+			from: this._horzScaleBehavior.convertHorzItemToInternal(range.from),
+			to: this._horzScaleBehavior.convertHorzItemToInternal(range.to),
 		};
 		const logicalRange = this._timeScale.logicalRangeForTimeRange(convertedRange);
 
@@ -133,8 +136,8 @@ export class TimeScaleApi implements ITimeScaleApi, IDestroyable {
 		}
 	}
 
-	public timeToCoordinate(time: Time): Coordinate | null {
-		const timePoint = convertTime(time);
+	public timeToCoordinate(time: HorzScaleItem): Coordinate | null {
+		const timePoint = this._horzScaleBehavior.convertHorzItemToInternal(time);
 		const timePointIndex = this._timeScale.timeToIndex(timePoint, false);
 		if (timePointIndex === null) {
 			return null;
@@ -143,7 +146,7 @@ export class TimeScaleApi implements ITimeScaleApi, IDestroyable {
 		return this._timeScale.indexToCoordinate(timePointIndex);
 	}
 
-	public coordinateToTime(x: number): Time | null {
+	public coordinateToTime(x: number): HorzScaleItem | null {
 		const timeScale = this._model.timeScale();
 		const timePointIndex = timeScale.coordinateToIndex(x as Coordinate);
 		const timePoint = timeScale.indexToTime(timePointIndex);
@@ -151,7 +154,7 @@ export class TimeScaleApi implements ITimeScaleApi, IDestroyable {
 			return null;
 		}
 
-		return timePoint.businessDay ?? timePoint.timestamp;
+		return this._horzScaleBehavior.convertInternalToHorzItem(timePoint);
 	}
 
 	public width(): number {
@@ -162,11 +165,11 @@ export class TimeScaleApi implements ITimeScaleApi, IDestroyable {
 		return this._timeAxisWidget.getSize().height;
 	}
 
-	public subscribeVisibleTimeRangeChange(handler: TimeRangeChangeEventHandler): void {
+	public subscribeVisibleTimeRangeChange(handler: TimeRangeChangeEventHandler<HorzScaleItem>): void {
 		this._timeRangeChanged.subscribe(handler);
 	}
 
-	public unsubscribeVisibleTimeRangeChange(handler: TimeRangeChangeEventHandler): void {
+	public unsubscribeVisibleTimeRangeChange(handler: TimeRangeChangeEventHandler<HorzScaleItem>): void {
 		this._timeRangeChanged.unsubscribe(handler);
 	}
 
diff --git a/src/gui/chart-widget.ts b/src/gui/chart-widget.ts
index e5eca3fa02..1e6e6b1932 100644
--- a/src/gui/chart-widget.ts
+++ b/src/gui/chart-widget.ts
@@ -11,6 +11,7 @@ import { DeepPartial } from '../helpers/strict-type-checks';
 import { ChartModel, ChartOptionsInternal } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { DefaultPriceScaleId } from '../model/default-price-scale';
+import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 import {
 	InvalidateMask,
 	InvalidationLevel,
@@ -20,34 +21,33 @@ import {
 import { Point } from '../model/point';
 import { Series } from '../model/series';
 import { SeriesPlotRow } from '../model/series-data';
-import { OriginalTime, TimePointIndex } from '../model/time-data';
+import { SeriesType } from '../model/series-options';
+import { TimePointIndex } from '../model/time-data';
 import { TouchMouseEventData } from '../model/touch-mouse-event-data';
 
 import { suggestChartSize, suggestPriceScaleWidth, suggestTimeScaleHeight } from './internal-layout-sizes-hints';
 import { PaneWidget } from './pane-widget';
 import { TimeAxisWidget } from './time-axis-widget';
 
-// import { PaneSeparator, SEPARATOR_HEIGHT } from './pane-separator';
-
-export interface MouseEventParamsImpl {
-	time?: OriginalTime;
+export interface MouseEventParamsImpl<HorzScaleItem> {
+	time?: HorzScaleItem;
 	index?: TimePointIndex;
 	point?: Point;
-	seriesData: Map<Series, SeriesPlotRow>;
-	hoveredSeries?: Series;
+	seriesData: Map<Series<SeriesType, HorzScaleItem>, SeriesPlotRow<SeriesType, HorzScaleItem>>;
+	hoveredSeries?: Series<SeriesType, HorzScaleItem>;
 	hoveredObject?: string;
 	touchMouseEventData?: TouchMouseEventData;
 }
 
-export type MouseEventParamsImplSupplier = () => MouseEventParamsImpl;
+export type MouseEventParamsImplSupplier<HorzScaleItem> = () => MouseEventParamsImpl<HorzScaleItem>;
 
 const windowsChrome = isChromiumBased() && isWindows();
 
-export class ChartWidget implements IDestroyable {
-	private readonly _options: ChartOptionsInternal;
-	private _paneWidgets: PaneWidget[] = [];
+export class ChartWidget<HorzScaleItem> implements IDestroyable {
+	private readonly _options: ChartOptionsInternal<HorzScaleItem>;
+	private _paneWidgets: PaneWidget<HorzScaleItem>[] = [];
 	// private _paneSeparators: PaneSeparator[] = [];
-	private readonly _model: ChartModel;
+	private readonly _model: ChartModel<HorzScaleItem>;
 	private _drawRafId: number = 0;
 	private _height: number = 0;
 	private _width: number = 0;
@@ -55,19 +55,22 @@ export class ChartWidget implements IDestroyable {
 	private _rightPriceAxisWidth: number = 0;
 	private _element: HTMLElement;
 	private readonly _tableElement: HTMLElement;
-	private _timeAxisWidget: TimeAxisWidget;
+	private _timeAxisWidget: TimeAxisWidget<HorzScaleItem>;
 	private _invalidateMask: InvalidateMask | null = null;
 	private _drawPlanned: boolean = false;
-	private _clicked: Delegate<MouseEventParamsImplSupplier> = new Delegate();
-	private _crosshairMoved: Delegate<MouseEventParamsImplSupplier> = new Delegate();
+	private _clicked: Delegate<MouseEventParamsImplSupplier<HorzScaleItem>> = new Delegate();
+	private _crosshairMoved: Delegate<MouseEventParamsImplSupplier<HorzScaleItem>> = new Delegate();
 	private _onWheelBound: (event: WheelEvent) => void;
 	private _observer: ResizeObserver | null = null;
 
 	private _container: HTMLElement;
 
-	public constructor(container: HTMLElement, options: ChartOptionsInternal) {
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(container: HTMLElement, options: ChartOptionsInternal<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
 		this._container = container;
 		this._options = options;
+		this._horzScaleBehavior = horzScaleBehavior;
 
 		this._element = document.createElement('div');
 		this._element.classList.add('tv-lightweight-charts');
@@ -86,11 +89,12 @@ export class ChartWidget implements IDestroyable {
 		}
 		this._model = new ChartModel(
 			this._invalidateHandler.bind(this),
-			this._options
+			this._options,
+			horzScaleBehavior
 		);
 		this.model().crosshairMoved().subscribe(this._onPaneWidgetCrosshairMoved.bind(this), this);
 
-		this._timeAxisWidget = new TimeAxisWidget(this);
+		this._timeAxisWidget = new TimeAxisWidget(this, this._horzScaleBehavior);
 		this._tableElement.appendChild(this._timeAxisWidget.getElement());
 
 		const usedObserver = options.autoSize && this._installObserver();
@@ -119,19 +123,19 @@ export class ChartWidget implements IDestroyable {
 		this._model.priceScalesOptionsChanged().subscribe(this._model.fullUpdate.bind(this._model), this);
 	}
 
-	public model(): ChartModel {
+	public model(): ChartModel<HorzScaleItem> {
 		return this._model;
 	}
 
-	public options(): Readonly<ChartOptionsInternal> {
+	public options(): Readonly<ChartOptionsInternal<HorzScaleItem>> {
 		return this._options;
 	}
 
-	public paneWidgets(): PaneWidget[] {
+	public paneWidgets(): PaneWidget<HorzScaleItem>[] {
 		return this._paneWidgets;
 	}
 
-	public timeAxisWidget(): TimeAxisWidget {
+	public timeAxisWidget(): TimeAxisWidget<HorzScaleItem> {
 		return this._timeAxisWidget;
 	}
 
@@ -210,7 +214,7 @@ export class ChartWidget implements IDestroyable {
 		}
 	}
 
-	public applyOptions(options: DeepPartial<ChartOptionsInternal>): void {
+	public applyOptions(options: DeepPartial<ChartOptionsInternal<HorzScaleItem>>): void {
 		const currentlyHasMouseWheelListener = shouldSubscribeMouseWheel(this._options);
 
 		// we don't need to merge options here because it's done in chart model
@@ -228,11 +232,11 @@ export class ChartWidget implements IDestroyable {
 		this._applyAutoSizeOptions(options);
 	}
 
-	public clicked(): ISubscription<MouseEventParamsImplSupplier> {
+	public clicked(): ISubscription<MouseEventParamsImplSupplier<HorzScaleItem>> {
 		return this._clicked;
 	}
 
-	public crosshairMoved(): ISubscription<MouseEventParamsImplSupplier> {
+	public crosshairMoved(): ISubscription<MouseEventParamsImplSupplier<HorzScaleItem>> {
 		return this._crosshairMoved;
 	}
 
@@ -280,7 +284,7 @@ export class ChartWidget implements IDestroyable {
 	}
 
 	// eslint-disable-next-line complexity
-	private _applyAutoSizeOptions(options: DeepPartial<ChartOptionsInternal>): void {
+	private _applyAutoSizeOptions(options: DeepPartial<ChartOptionsInternal<HorzScaleItem>>): void {
 		if (options.autoSize === undefined && this._observer && (options.width !== undefined || options.height !== undefined)) {
 			warn(`You should turn autoSize off explicitly before specifying sizes; try adding options.autoSize: false to new options`);
 			return;
@@ -552,7 +556,7 @@ export class ChartWidget implements IDestroyable {
 			this._applyTimeScaleInvalidations(invalidateMask, time);
 
 			this._timeAxisWidget.update();
-			this._paneWidgets.forEach((pane: PaneWidget) => {
+			this._paneWidgets.forEach((pane: PaneWidget<HorzScaleItem>) => {
 				pane.updatePriceAxisWidgets();
 			});
 
@@ -709,11 +713,11 @@ export class ChartWidget implements IDestroyable {
 		index: TimePointIndex | null,
 		point: Point | null,
 		event: TouchMouseEventData | null
-	): MouseEventParamsImpl {
-		const seriesData = new Map<Series, SeriesPlotRow>();
+	): MouseEventParamsImpl<HorzScaleItem> {
+		const seriesData = new Map<Series<SeriesType, HorzScaleItem>, SeriesPlotRow<SeriesType, HorzScaleItem>>();
 		if (index !== null) {
 			const serieses = this._model.serieses();
-			serieses.forEach((s: Series) => {
+			serieses.forEach((s: Series<SeriesType, HorzScaleItem>) => {
 				// TODO: replace with search left
 				const data = s.bars().search(index);
 				if (data !== null) {
@@ -721,7 +725,7 @@ export class ChartWidget implements IDestroyable {
 				}
 			});
 		}
-		let clientTime: OriginalTime | undefined;
+		let clientTime: HorzScaleItem | undefined;
 		if (index !== null) {
 			const timePoint = this._model.timeScale().indexToTimeScalePoint(index)?.originalTime;
 			if (timePoint !== undefined) {
@@ -817,6 +821,6 @@ function disableSelection(element: HTMLElement): void {
 	(element.style as any).webkitTapHighlightColor = 'transparent';
 }
 
-function shouldSubscribeMouseWheel(options: ChartOptionsInternal): boolean {
+function shouldSubscribeMouseWheel<HorzScaleItem>(options: ChartOptionsInternal<HorzScaleItem>): boolean {
 	return Boolean(options.handleScroll.mouseWheel || options.handleScale.mouseWheel);
 }
diff --git a/src/gui/pane-separator.ts b/src/gui/pane-separator.ts
index 5548991fdd..8818b9905e 100644
--- a/src/gui/pane-separator.ts
+++ b/src/gui/pane-separator.ts
@@ -7,14 +7,14 @@ import { PaneWidget } from './pane-widget';
 
 export const SEPARATOR_HEIGHT = 1;
 
-export class PaneSeparator implements IDestroyable {
-	private readonly _chartWidget: ChartWidget;
+export class PaneSeparator<HorzScaleItem> implements IDestroyable {
+	private readonly _chartWidget: ChartWidget<HorzScaleItem>;
 	private readonly _rowElement: HTMLTableRowElement;
 	private readonly _cell: HTMLTableCellElement;
 	private readonly _handle: HTMLDivElement | null;
 	private readonly _mouseEventHandler: MouseEventHandler | null;
-	private readonly _paneA: PaneWidget;
-	private readonly _paneB: PaneWidget;
+	private readonly _paneA: PaneWidget<HorzScaleItem>;
+	private readonly _paneB: PaneWidget<HorzScaleItem>;
 
 	private _startY: number = 0;
 	private _deltaY: number = 0;
@@ -24,7 +24,7 @@ export class PaneSeparator implements IDestroyable {
 	private _maxPaneHeight: number = 0;
 	private _pixelStretchFactor: number = 0;
 
-	public constructor(chartWidget: ChartWidget, topPaneIndex: number, bottomPaneIndex: number, disableResize: boolean) {
+	public constructor(chartWidget: ChartWidget<HorzScaleItem>, topPaneIndex: number, bottomPaneIndex: number, disableResize: boolean) {
 		this._chartWidget = chartWidget;
 		this._paneA = chartWidget.paneWidgets()[topPaneIndex];
 		this._paneB = chartWidget.paneWidgets()[bottomPaneIndex];
diff --git a/src/gui/pane-widget.ts b/src/gui/pane-widget.ts
index 9c63dadfe4..24c64bd8e2 100644
--- a/src/gui/pane-widget.ts
+++ b/src/gui/pane-widget.ts
@@ -51,28 +51,28 @@ function drawForeground(renderer: IPaneRenderer, target: CanvasRenderingTarget2D
 	renderer.draw(target, isHovered, hitTestData);
 }
 
-type PaneViewsGetter = (source: IDataSource, pane: Pane) => readonly IPaneView[];
+type PaneViewsGetter<HorzScaleItem> = (source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>) => readonly IPaneView<HorzScaleItem>[];
 
-function sourcePaneViews(source: IDataSource, pane: Pane): readonly IPaneView[] {
+function sourcePaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
 	return source.paneViews(pane);
 }
 
-function sourceLabelPaneViews(source: IDataSource, pane: Pane): readonly IPaneView[] {
+function sourceLabelPaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
 	return source.labelPaneViews(pane);
 }
 
-function sourceTopPaneViews(source: IDataSource, pane: Pane): readonly IPaneView[] {
+function sourceTopPaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
 	return source.topPaneViews !== undefined ? source.topPaneViews(pane) : [];
 }
 
-export interface HitTestResult {
-	source: IPriceDataSource;
+export interface HitTestResult<HorzScaleItem> {
+	source: IPriceDataSource<HorzScaleItem>;
 	object?: HoveredObject;
-	view: IPaneView;
+	view: IPaneView<HorzScaleItem>;
 }
 
-interface HitTestPaneViewResult {
-	view: IPaneView;
+interface HitTestPaneViewResult<HorzScaleItem> {
+	view: IPaneView<HorzScaleItem>;
 	object?: HoveredObject;
 }
 
@@ -82,12 +82,12 @@ interface StartScrollPosition extends Point {
 	localY: Coordinate;
 }
 
-export class PaneWidget implements IDestroyable, MouseEventHandlers {
-	private readonly _chart: ChartWidget;
-	private _state: Pane | null;
+export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandlers {
+	private readonly _chart: ChartWidget<HorzScaleItem>;
+	private _state: Pane<HorzScaleItem> | null;
 	private _size: Size = size({ width: 0, height: 0 });
-	private _leftPriceAxisWidget: PriceAxisWidget | null = null;
-	private _rightPriceAxisWidget: PriceAxisWidget | null = null;
+	private _leftPriceAxisWidget: PriceAxisWidget<HorzScaleItem> | null = null;
+	private _rightPriceAxisWidget: PriceAxisWidget<HorzScaleItem> | null = null;
 	private readonly _paneCell: HTMLElement;
 	private readonly _leftAxisCell: HTMLElement;
 	private readonly _rightAxisCell: HTMLElement;
@@ -108,7 +108,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 
 	private _isSettingSize: boolean = false;
 
-	public constructor(chart: ChartWidget, state: Pane) {
+	public constructor(chart: ChartWidget<HorzScaleItem>, state: Pane<HorzScaleItem>) {
 		this._chart = chart;
 
 		this._state = state;
@@ -185,11 +185,11 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		this._mouseEventHandler.destroy();
 	}
 
-	public state(): Pane {
+	public state(): Pane<HorzScaleItem> {
 		return ensureNotNull(this._state);
 	}
 
-	public setState(pane: Pane | null): void {
+	public setState(pane: Pane<HorzScaleItem> | null): void {
 		if (this._state !== null) {
 			this._state.onDestroyed().unsubscribeAll(this);
 		}
@@ -203,7 +203,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		this.updatePriceAxisWidgetsStates();
 	}
 
-	public chart(): ChartWidget {
+	public chart(): ChartWidget<HorzScaleItem> {
 		return this._chart;
 	}
 
@@ -391,7 +391,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		this._endScroll(event);
 	}
 
-	public hitTest(x: Coordinate, y: Coordinate): HitTestResult | null {
+	public hitTest(x: Coordinate, y: Coordinate): HitTestResult<HorzScaleItem> | null {
 		const state = this._state;
 		if (state === null) {
 			return null;
@@ -512,11 +512,11 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		}
 	}
 
-	public leftPriceAxisWidget(): PriceAxisWidget | null {
+	public leftPriceAxisWidget(): PriceAxisWidget<HorzScaleItem> | null {
 		return this._leftPriceAxisWidget;
 	}
 
-	public rightPriceAxisWidget(): PriceAxisWidget | null {
+	public rightPriceAxisWidget(): PriceAxisWidget<HorzScaleItem> | null {
 		return this._rightPriceAxisWidget;
 	}
 
@@ -569,7 +569,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		this._drawSourceImpl(target, sourcePaneViews, drawForeground, this._model().crosshairSource());
 	}
 
-	private _drawSources(target: CanvasRenderingTarget2D, paneViewsGetter: PaneViewsGetter): void {
+	private _drawSources(target: CanvasRenderingTarget2D, paneViewsGetter: PaneViewsGetter<HorzScaleItem>): void {
 		const state = ensureNotNull(this._state);
 		const sources = state.orderedSources();
 
@@ -584,9 +584,9 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 
 	private _drawSourceImpl(
 		target: CanvasRenderingTarget2D,
-		paneViewsGetter: PaneViewsGetter,
+		paneViewsGetter: PaneViewsGetter<HorzScaleItem>,
 		drawFn: DrawFunction,
-		source: IDataSource
+		source: IDataSource<HorzScaleItem>
 	): void {
 		const state = ensureNotNull(this._state);
 		const paneViews = paneViewsGetter(source, state);
@@ -604,7 +604,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		}
 	}
 
-	private _hitTestPaneView(paneViews: readonly IPaneView[], x: Coordinate, y: Coordinate): HitTestPaneViewResult | null {
+	private _hitTestPaneView(paneViews: readonly IPaneView<HorzScaleItem>[], x: Coordinate, y: Coordinate): HitTestPaneViewResult<HorzScaleItem> | null {
 		for (const paneView of paneViews) {
 			const renderer = paneView.renderer();
 			if (renderer !== null && renderer.hitTest) {
@@ -684,7 +684,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		this._initCrosshairPosition = { x: crosshair.appliedX(), y: crosshair.appliedY() };
 	}
 
-	private _model(): ChartModel {
+	private _model(): ChartModel<HorzScaleItem> {
 		return this._chart.model();
 	}
 
diff --git a/src/gui/price-axis-stub.ts b/src/gui/price-axis-stub.ts
index c141639fe2..b1535fd821 100644
--- a/src/gui/price-axis-stub.ts
+++ b/src/gui/price-axis-stub.ts
@@ -17,20 +17,20 @@ import { PriceAxisRendererOptionsProvider } from '../renderers/price-axis-render
 import { createBoundCanvas } from './canvas-utils';
 import { PriceAxisWidgetSide } from './price-axis-widget';
 
-export interface PriceAxisStubParams {
-	rendererOptionsProvider: PriceAxisRendererOptionsProvider;
+export interface PriceAxisStubParams<HorzScaleItem> {
+	rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
 }
 
 export type BorderVisibleGetter = () => boolean;
 export type ColorGetter = () => string;
 
-export class PriceAxisStub implements IDestroyable {
+export class PriceAxisStub<HorzScaleItem> implements IDestroyable {
 	private readonly _cell: HTMLDivElement;
 	private readonly _canvasBinding: CanvasElementBitmapSizeBinding;
 
-	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider;
+	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
 
-	private _options: ChartOptionsInternal;
+	private _options: ChartOptionsInternal<HorzScaleItem>;
 
 	private _invalidated: boolean = true;
 
@@ -41,8 +41,8 @@ export class PriceAxisStub implements IDestroyable {
 
 	public constructor(
 		side: PriceAxisWidgetSide,
-		options: ChartOptionsInternal,
-		params: PriceAxisStubParams,
+		options: ChartOptionsInternal<HorzScaleItem>,
+		params: PriceAxisStubParams<HorzScaleItem>,
 		borderVisible: BorderVisibleGetter,
 		bottomColor: ColorGetter
 	) {
diff --git a/src/gui/price-axis-widget.ts b/src/gui/price-axis-widget.ts
index 4fb247386c..e8068633fa 100644
--- a/src/gui/price-axis-widget.ts
+++ b/src/gui/price-axis-widget.ts
@@ -43,20 +43,20 @@ const enum Constants {
 	DefaultOptimalWidth = 34,
 }
 
-type IPriceAxisViewArray = readonly IPriceAxisView[];
+type IPriceAxisViewArray<HorzScaleItem> = readonly IPriceAxisView<HorzScaleItem>[];
 
 const enum Constants {
 	LabelOffset = 5,
 }
 
-export class PriceAxisWidget implements IDestroyable {
-	private readonly _pane: PaneWidget;
-	private readonly _options: Readonly<ChartOptionsInternal>;
+export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
+	private readonly _pane: PaneWidget<HorzScaleItem>;
+	private readonly _options: Readonly<ChartOptionsInternal<HorzScaleItem>>;
 	private readonly _layoutOptions: Readonly<LayoutOptions>;
-	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider;
+	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
 	private readonly _isLeft: boolean;
 
-	private _priceScale: PriceScale | null = null;
+	private _priceScale: PriceScale<HorzScaleItem> | null = null;
 
 	private _size: Size | null = null;
 
@@ -73,7 +73,7 @@ export class PriceAxisWidget implements IDestroyable {
 	private _prevOptimalWidth: number = 0;
 	private _isSettingSize: boolean = false;
 
-	public constructor(pane: PaneWidget, options: Readonly<ChartOptionsInternal>, rendererOptionsProvider: PriceAxisRendererOptionsProvider, side: PriceAxisWidgetSide) {
+	public constructor(pane: PaneWidget<HorzScaleItem>, options: Readonly<ChartOptionsInternal<HorzScaleItem>>, rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>, side: PriceAxisWidgetSide) {
 		this._pane = pane;
 		this._options = options;
 		this._layoutOptions = options.layout;
@@ -238,7 +238,7 @@ export class PriceAxisWidget implements IDestroyable {
 		return ensureNotNull(this._size).width;
 	}
 
-	public setPriceScale(priceScale: PriceScale): void {
+	public setPriceScale(priceScale: PriceScale<HorzScaleItem>): void {
 		if (this._priceScale === priceScale) {
 			return;
 		}
@@ -251,7 +251,7 @@ export class PriceAxisWidget implements IDestroyable {
 		priceScale.onMarksChanged().subscribe(this._onMarksChanged.bind(this), this);
 	}
 
-	public priceScale(): PriceScale | null {
+	public priceScale(): PriceScale<HorzScaleItem> | null {
 		return this._priceScale;
 	}
 
@@ -374,12 +374,12 @@ export class PriceAxisWidget implements IDestroyable {
 		this._setCursor(CursorType.Default);
 	}
 
-	private _backLabels(): IPriceAxisView[] {
-		const res: IPriceAxisView[] = [];
+	private _backLabels(): IPriceAxisView<HorzScaleItem>[] {
+		const res: IPriceAxisView<HorzScaleItem>[] = [];
 
 		const priceScale = (this._priceScale === null) ? undefined : this._priceScale;
 
-		const addViewsForSources = (sources: readonly IDataSource[]) => {
+		const addViewsForSources = (sources: readonly IDataSource<HorzScaleItem>[]) => {
 			for (let i = 0; i < sources.length; ++i) {
 				const source = sources[i];
 				const views = source.priceAxisViews(this._pane.state(), priceScale);
@@ -486,7 +486,7 @@ export class PriceAxisWidget implements IDestroyable {
 		}
 		let center = this._size.height / 2;
 
-		const views: IPriceAxisView[] = [];
+		const views: IPriceAxisView<HorzScaleItem>[] = [];
 		const orderedSources = this._priceScale.orderedSources().slice(); // Copy of array
 		const pane = this._pane;
 		const paneState = pane.state();
@@ -496,7 +496,7 @@ export class PriceAxisWidget implements IDestroyable {
 		const isDefault = this._priceScale === paneState.defaultVisiblePriceScale();
 
 		if (isDefault) {
-			this._pane.state().orderedSources().forEach((source: IPriceDataSource) => {
+			this._pane.state().orderedSources().forEach((source: IPriceDataSource<HorzScaleItem>) => {
 				if (paneState.isOverlay(source)) {
 					orderedSources.push(source);
 				}
@@ -507,11 +507,11 @@ export class PriceAxisWidget implements IDestroyable {
 		const centerSource = this._priceScale.dataSources()[0];
 		const priceScale = this._priceScale;
 
-		const updateForSources = (sources: IDataSource[]) => {
-			sources.forEach((source: IDataSource) => {
+		const updateForSources = (sources: IDataSource<HorzScaleItem>[]) => {
+			sources.forEach((source: IDataSource<HorzScaleItem>) => {
 				const sourceViews = source.priceAxisViews(paneState, priceScale);
 				// never align selected sources
-				sourceViews.forEach((view: IPriceAxisView) => {
+				sourceViews.forEach((view: IPriceAxisView<HorzScaleItem>) => {
 					view.setFixedCoordinate(null);
 					if (view.isVisible()) {
 						views.push(view);
@@ -526,7 +526,7 @@ export class PriceAxisWidget implements IDestroyable {
 		// crosshair individually
 		updateForSources(orderedSources);
 
-		views.forEach((view: IPriceAxisView) => view.setFixedCoordinate(view.coordinate()));
+		views.forEach((view: IPriceAxisView<HorzScaleItem>) => view.setFixedCoordinate(view.coordinate()));
 
 		const options = this._priceScale.options();
 		if (!options.alignLabels) {
@@ -536,24 +536,24 @@ export class PriceAxisWidget implements IDestroyable {
 		this._fixLabelOverlap(views, rendererOptions, center);
 	}
 
-	private _fixLabelOverlap(views: IPriceAxisView[], rendererOptions: Readonly<PriceAxisViewRendererOptions>, center: number): void {
+	private _fixLabelOverlap(views: IPriceAxisView<HorzScaleItem>[], rendererOptions: Readonly<PriceAxisViewRendererOptions>, center: number): void {
 		if (this._size === null) {
 			return;
 		}
 
 		// split into two parts
-		const top = views.filter((view: IPriceAxisView) => view.coordinate() <= center);
-		const bottom = views.filter((view: IPriceAxisView) => view.coordinate() > center);
+		const top = views.filter((view: IPriceAxisView<HorzScaleItem>) => view.coordinate() <= center);
+		const bottom = views.filter((view: IPriceAxisView<HorzScaleItem>) => view.coordinate() > center);
 
 		// sort top from center to top
-		top.sort((l: IPriceAxisView, r: IPriceAxisView) => r.coordinate() - l.coordinate());
+		top.sort((l: IPriceAxisView<HorzScaleItem>, r: IPriceAxisView<HorzScaleItem>) => r.coordinate() - l.coordinate());
 
 		// share center label
 		if (top.length && bottom.length) {
 			bottom.push(top[0]);
 		}
 
-		bottom.sort((l: IPriceAxisView, r: IPriceAxisView) => l.coordinate() - r.coordinate());
+		bottom.sort((l: IPriceAxisView<HorzScaleItem>, r: IPriceAxisView<HorzScaleItem>) => l.coordinate() - r.coordinate());
 
 		for (const view of views) {
 			const halfHeight = Math.floor(view.height(rendererOptions) / 2);
@@ -602,7 +602,7 @@ export class PriceAxisWidget implements IDestroyable {
 		const rendererOptions = this.rendererOptions();
 		const align = this._isLeft ? 'right' : 'left';
 
-		views.forEach((view: IPriceAxisView) => {
+		views.forEach((view: IPriceAxisView<HorzScaleItem>) => {
 			if (view.isAxisLabelVisible()) {
 				const renderer = view.renderer(ensureNotNull(this._priceScale));
 				renderer.draw(target, rendererOptions, this._widthCache, align);
@@ -617,7 +617,7 @@ export class PriceAxisWidget implements IDestroyable {
 
 		const model = this._pane.chart().model();
 
-		const views: IPriceAxisViewArray[] = []; // array of arrays
+		const views: IPriceAxisViewArray<HorzScaleItem>[] = []; // array of arrays
 		const pane = this._pane.state();
 
 		const v = model.crosshairSource().priceAxisViews(pane, this._priceScale);
@@ -628,8 +628,8 @@ export class PriceAxisWidget implements IDestroyable {
 		const ro = this.rendererOptions();
 		const align = this._isLeft ? 'right' : 'left';
 
-		views.forEach((arr: IPriceAxisViewArray) => {
-			arr.forEach((view: IPriceAxisView) => {
+		views.forEach((arr: IPriceAxisViewArray<HorzScaleItem>) => {
+			arr.forEach((view: IPriceAxisView<HorzScaleItem>) => {
 				view.renderer(ensureNotNull(this._priceScale)).draw(target, ro, this._widthCache, align);
 			});
 		});
diff --git a/src/gui/time-axis-widget.ts b/src/gui/time-axis-widget.ts
index a29e3a2131..89f1d3c884 100644
--- a/src/gui/time-axis-widget.ts
+++ b/src/gui/time-axis-widget.ts
@@ -16,11 +16,10 @@ import { ISubscription } from '../helpers/isubscription';
 import { makeFont } from '../helpers/make-font';
 
 import { IDataSource } from '../model/idata-source';
+import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 import { InvalidationLevel } from '../model/invalidate-mask';
 import { LayoutOptions } from '../model/layout-options';
 import { TextWidthCache } from '../model/text-width-cache';
-import { TickMarkWeight } from '../model/time-data';
-import { TimeMark } from '../model/time-scale';
 import { TimeAxisViewRendererOptions } from '../renderers/itime-axis-view-renderer';
 
 import { createBoundCanvas } from './canvas-utils';
@@ -38,12 +37,8 @@ const enum CursorType {
 	EwResize,
 }
 
-function markWithGreaterWeight(a: TimeMark, b: TimeMark): TimeMark {
-	return a.weight > b.weight ? a : b;
-}
-
-export class TimeAxisWidget implements MouseEventHandlers, IDestroyable {
-	private readonly _chart: ChartWidget;
+export class TimeAxisWidget<HorzScaleItem> implements MouseEventHandlers, IDestroyable {
+	private readonly _chart: ChartWidget<HorzScaleItem>;
 	private readonly _options: LayoutOptions;
 	private readonly _element: HTMLElement;
 	private readonly _leftStubCell: HTMLElement;
@@ -52,8 +47,8 @@ export class TimeAxisWidget implements MouseEventHandlers, IDestroyable {
 	private readonly _dv: HTMLElement;
 	private readonly _canvasBinding: CanvasElementBitmapSizeBinding;
 	private readonly _topCanvasBinding: CanvasElementBitmapSizeBinding;
-	private _leftStub: PriceAxisStub | null = null;
-	private _rightStub: PriceAxisStub | null = null;
+	private _leftStub: PriceAxisStub<HorzScaleItem> | null = null;
+	private _rightStub: PriceAxisStub<HorzScaleItem> | null = null;
 	private readonly _mouseEventHandler: MouseEventHandler;
 	private _rendererOptions: TimeAxisViewRendererOptions | null = null;
 	private _mouseDown: boolean = false;
@@ -62,8 +57,11 @@ export class TimeAxisWidget implements MouseEventHandlers, IDestroyable {
 	private readonly _widthCache: TextWidthCache = new TextWidthCache(5);
 	private _isSettingSize: boolean = false;
 
-	public constructor(chartWidget: ChartWidget) {
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(chartWidget: ChartWidget<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
 		this._chart = chartWidget;
+		this._horzScaleBehavior = horzScaleBehavior;
 		this._options = chartWidget.options().layout;
 
 		this._element = document.createElement('tr');
@@ -138,11 +136,11 @@ export class TimeAxisWidget implements MouseEventHandlers, IDestroyable {
 		return this._element;
 	}
 
-	public leftStub(): PriceAxisStub | null {
+	public leftStub(): PriceAxisStub<HorzScaleItem> | null {
 		return this._leftStub;
 	}
 
-	public rightStub(): PriceAxisStub | null {
+	public rightStub(): PriceAxisStub<HorzScaleItem> | null {
 		return this._rightStub;
 	}
 
@@ -340,13 +338,7 @@ export class TimeAxisWidget implements MouseEventHandlers, IDestroyable {
 			return;
 		}
 
-		let maxWeight = tickMarks.reduce(markWithGreaterWeight, tickMarks[0]).weight;
-
-		// special case: it looks strange if 15:00 is bold but 14:00 is not
-		// so if maxWeight > TickMarkWeight.Hour1 and < TickMarkWeight.Day reduce it to TickMarkWeight.Hour1
-		if (maxWeight > TickMarkWeight.Hour1 && maxWeight < TickMarkWeight.Day) {
-			maxWeight = TickMarkWeight.Hour1;
-		}
+		const maxWeight = this._horzScaleBehavior.maxTickMarkWeight(tickMarks);
 
 		const rendererOptions = this._getRendererOptions();
 
@@ -414,7 +406,7 @@ export class TimeAxisWidget implements MouseEventHandlers, IDestroyable {
 		return coordinate;
 	}
 
-	private _drawLabels(sources: readonly IDataSource[], target: CanvasRenderingTarget2D): void {
+	private _drawLabels(sources: readonly IDataSource<HorzScaleItem>[], target: CanvasRenderingTarget2D): void {
 		const rendererOptions = this._getRendererOptions();
 		for (const source of sources) {
 			for (const view of source.timeAxisViews()) {
@@ -495,7 +487,7 @@ export class TimeAxisWidget implements MouseEventHandlers, IDestroyable {
 			this._rightStub = null;
 		}
 		const rendererOptionsProvider = this._chart.model().rendererOptionsProvider();
-		const params: PriceAxisStubParams = {
+		const params: PriceAxisStubParams<HorzScaleItem> = {
 			rendererOptionsProvider: rendererOptionsProvider,
 		};
 
diff --git a/src/index.ts b/src/index.ts
index a8c90b8646..7711bd15a0 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -7,15 +7,9 @@ export { CrosshairMode } from './model/crosshair';
 export { MismatchDirection } from './model/plot-list';
 export { PriceScaleMode } from './model/price-scale';
 export { PriceLineSource, LastPriceAnimationMode } from './model/series-options';
-export { TickMarkType } from './model/time-scale';
 export { ColorType } from './model/layout-options';
 
-export {
-	isBusinessDay,
-	isUTCTimestamp,
-} from './api/data-consumer';
-
-export { createChart } from './api/create-chart';
+export { createChart, createOptionsChart } from './api/create-chart';
 
 /**
  * Returns the current version as a string. For example `'3.3.0'`.
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index 1ff8344ab0..50f7c2b4a8 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -14,6 +14,7 @@ import { Coordinate } from './coordinate';
 import { Crosshair, CrosshairOptions } from './crosshair';
 import { DefaultPriceScaleId, isDefaultPriceScale } from './default-price-scale';
 import { GridOptions } from './grid';
+import { IHorzScaleBehavior } from './ihorz-scale-behavior';
 import { InvalidateMask, InvalidationLevel, ITimeScaleAnimation } from './invalidate-mask';
 import { IPriceDataSource } from './iprice-data-source';
 import { ColorType, LayoutOptions } from './layout-options';
@@ -167,14 +168,14 @@ export interface HoveredObject {
 	externalId?: string;
 }
 
-export interface HoveredSource {
-	source: IPriceDataSource;
+export interface HoveredSource<HorzScaleItem> {
+	source: IPriceDataSource<HorzScaleItem>;
 	object?: HoveredObject;
 }
 
-export interface PriceScaleOnPane {
-	priceScale: PriceScale;
-	pane: Pane;
+export interface PriceScaleOnPane<HorzScaleItem> {
+	priceScale: PriceScale<HorzScaleItem>;
+	pane: Pane<HorzScaleItem>;
 }
 
 const enum BackgroundColorSide {
@@ -232,7 +233,7 @@ export interface TrackingModeOptions {
 /**
  * Structure describing options of the chart. Series options are to be set separately
  */
-export interface ChartOptions {
+export interface ChartOptions<HorzScaleItem> {
 	/**
 	 * Width of the chart in pixels
 	 *
@@ -312,7 +313,7 @@ export interface ChartOptions {
 	/**
 	 * Localization options.
 	 */
-	localization: LocalizationOptions;
+	localization: LocalizationOptions<HorzScaleItem>;
 
 	/**
 	 * Scroll options, or a boolean flag that enables/disables scrolling
@@ -336,8 +337,8 @@ export interface ChartOptions {
 
 }
 
-export type ChartOptionsInternal =
-	Omit<ChartOptions, 'handleScroll' | 'handleScale' | 'layout'>
+export type ChartOptionsInternal<HorzScaleItem> =
+	Omit<ChartOptions<HorzScaleItem>, 'handleScroll' | 'handleScale' | 'layout'>
 	& {
 		/** @public */
 		handleScroll: HandleScrollOptions;
@@ -353,22 +354,22 @@ interface GradientColorsCache {
 	colors: Map<number, string>;
 }
 
-export class ChartModel implements IDestroyable {
-	private readonly _options: ChartOptionsInternal;
+export class ChartModel<HorzScaleItem> implements IDestroyable {
+	private readonly _options: ChartOptionsInternal<HorzScaleItem>;
 	private readonly _invalidateHandler: InvalidateHandler;
 
-	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider;
+	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
 
-	private readonly _timeScale: TimeScale;
-	private readonly _panes: Pane[] = [];
-	private readonly _crosshair: Crosshair;
-	private readonly _magnet: Magnet;
-	private readonly _watermark: Watermark;
+	private readonly _timeScale: TimeScale<HorzScaleItem>;
+	private readonly _panes: Pane<HorzScaleItem>[] = [];
+	private readonly _crosshair: Crosshair<HorzScaleItem>;
+	private readonly _magnet: Magnet<HorzScaleItem>;
+	private readonly _watermark: Watermark<HorzScaleItem>;
 
-	private _serieses: Series[] = [];
+	private _serieses: Series<SeriesType, HorzScaleItem>[] = [];
 
 	private _width: number = 0;
-	private _hoveredSource: HoveredSource | null = null;
+	private _hoveredSource: HoveredSource<HorzScaleItem> | null = null;
 	private readonly _priceScalesOptionsChanged: Delegate = new Delegate();
 	private _crosshairMoved: Delegate<TimePointIndex | null, Point | null, TouchMouseEventData | null> = new Delegate();
 
@@ -376,13 +377,16 @@ export class ChartModel implements IDestroyable {
 	private _backgroundBottomColor: string;
 	private _gradientColorsCache: GradientColorsCache | null = null;
 
-	public constructor(invalidateHandler: InvalidateHandler, options: ChartOptionsInternal) {
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(invalidateHandler: InvalidateHandler, options: ChartOptionsInternal<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
 		this._invalidateHandler = invalidateHandler;
 		this._options = options;
+		this._horzScaleBehavior = horzScaleBehavior;
 
 		this._rendererOptionsProvider = new PriceAxisRendererOptionsProvider(this);
 
-		this._timeScale = new TimeScale(this, options.timeScale, this._options.localization);
+		this._timeScale = new TimeScale(this, options.timeScale, this._options.localization, horzScaleBehavior);
 		this._crosshair = new Crosshair(this, options.crosshair);
 		this._magnet = new Magnet(options.crosshair);
 		this._watermark = new Watermark(this, options.watermark);
@@ -406,16 +410,16 @@ export class ChartModel implements IDestroyable {
 		this._invalidate(new InvalidateMask(InvalidationLevel.Cursor));
 	}
 
-	public updateSource(source: IPriceDataSource): void {
+	public updateSource(source: IPriceDataSource<HorzScaleItem>): void {
 		const inv = this._invalidationMaskForSource(source);
 		this._invalidate(inv);
 	}
 
-	public hoveredSource(): HoveredSource | null {
+	public hoveredSource(): HoveredSource<HorzScaleItem> | null {
 		return this._hoveredSource;
 	}
 
-	public setHoveredSource(source: HoveredSource | null): void {
+	public setHoveredSource(source: HoveredSource<HorzScaleItem> | null): void {
 		const prevSource = this._hoveredSource;
 		this._hoveredSource = source;
 		if (prevSource !== null) {
@@ -426,14 +430,14 @@ export class ChartModel implements IDestroyable {
 		}
 	}
 
-	public options(): Readonly<ChartOptionsInternal> {
+	public options(): Readonly<ChartOptionsInternal<HorzScaleItem>> {
 		return this._options;
 	}
 
-	public applyOptions(options: DeepPartial<ChartOptionsInternal>): void {
+	public applyOptions(options: DeepPartial<ChartOptionsInternal<HorzScaleItem>>): void {
 		merge(this._options, options);
 
-		this._panes.forEach((p: Pane) => p.applyScaleOptions(options));
+		this._panes.forEach((p: Pane<HorzScaleItem>) => p.applyScaleOptions(options));
 
 		if (options.timeScale !== undefined) {
 			this._timeScale.applyOptions(options.timeScale);
@@ -480,7 +484,7 @@ export class ChartModel implements IDestroyable {
 		this._priceScalesOptionsChanged.fire();
 	}
 
-	public findPriceScale(priceScaleId: string): PriceScaleOnPane | null {
+	public findPriceScale(priceScaleId: string): PriceScaleOnPane<HorzScaleItem> | null {
 		for (const pane of this._panes) {
 			const priceScale = pane.priceScaleById(priceScaleId);
 			if (priceScale !== null) {
@@ -493,19 +497,19 @@ export class ChartModel implements IDestroyable {
 		return null;
 	}
 
-	public timeScale(): TimeScale {
+	public timeScale(): TimeScale<HorzScaleItem> {
 		return this._timeScale;
 	}
 
-	public panes(): readonly Pane[] {
+	public panes(): readonly Pane<HorzScaleItem>[] {
 		return this._panes;
 	}
 
-	public watermarkSource(): Watermark {
+	public watermarkSource(): Watermark<HorzScaleItem> {
 		return this._watermark;
 	}
 
-	public crosshairSource(): Crosshair {
+	public crosshairSource(): Crosshair<HorzScaleItem> {
 		return this._crosshair;
 	}
 
@@ -513,7 +517,7 @@ export class ChartModel implements IDestroyable {
 		return this._crosshairMoved;
 	}
 
-	public setPaneHeight(pane: Pane, height: number): void {
+	public setPaneHeight(pane: Pane<HorzScaleItem>, height: number): void {
 		pane.setHeight(height);
 		this.recalculateAllPanes();
 	}
@@ -521,11 +525,11 @@ export class ChartModel implements IDestroyable {
 	public setWidth(width: number): void {
 		this._width = width;
 		this._timeScale.setWidth(this._width);
-		this._panes.forEach((pane: Pane) => pane.setWidth(width));
+		this._panes.forEach((pane: Pane<HorzScaleItem>) => pane.setWidth(width));
 		this.recalculateAllPanes();
 	}
 
-	public createPane(index?: number): Pane {
+	public createPane(index?: number): Pane<HorzScaleItem> {
 		const pane = new Pane(this._timeScale, this);
 
 		if (index !== undefined) {
@@ -551,29 +555,29 @@ export class ChartModel implements IDestroyable {
 		return pane;
 	}
 
-	public startScalePrice(pane: Pane, priceScale: PriceScale, x: number): void {
+	public startScalePrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, x: number): void {
 		pane.startScalePrice(priceScale, x);
 	}
 
-	public scalePriceTo(pane: Pane, priceScale: PriceScale, x: number): void {
+	public scalePriceTo(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, x: number): void {
 		pane.scalePriceTo(priceScale, x);
 		this.updateCrosshair();
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public endScalePrice(pane: Pane, priceScale: PriceScale): void {
+	public endScalePrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): void {
 		pane.endScalePrice(priceScale);
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public startScrollPrice(pane: Pane, priceScale: PriceScale, x: number): void {
+	public startScrollPrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, x: number): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
 		pane.startScrollPrice(priceScale, x);
 	}
 
-	public scrollPriceTo(pane: Pane, priceScale: PriceScale, x: number): void {
+	public scrollPriceTo(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, x: number): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
@@ -582,7 +586,7 @@ export class ChartModel implements IDestroyable {
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public endScrollPrice(pane: Pane, priceScale: PriceScale): void {
+	public endScrollPrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
@@ -590,7 +594,7 @@ export class ChartModel implements IDestroyable {
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public resetPriceScale(pane: Pane, priceScale: PriceScale): void {
+	public resetPriceScale(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): void {
 		pane.resetPriceScale(priceScale);
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
@@ -649,11 +653,11 @@ export class ChartModel implements IDestroyable {
 		this.lightUpdate();
 	}
 
-	public serieses(): readonly Series[] {
+	public serieses(): readonly Series<SeriesType, HorzScaleItem>[] {
 		return this._serieses;
 	}
 
-	public setAndSaveCurrentPosition(x: Coordinate, y: Coordinate, event: TouchMouseEventData | null, pane: Pane): void {
+	public setAndSaveCurrentPosition(x: Coordinate, y: Coordinate, event: TouchMouseEventData | null, pane: Pane<HorzScaleItem>): void {
 		this._crosshair.saveOriginCoord(x, y);
 		let price = NaN;
 		let index = this._timeScale.coordinateToIndex(x);
@@ -695,7 +699,7 @@ export class ChartModel implements IDestroyable {
 		this._crosshair.updateAllViews();
 	}
 
-	public updateTimeScale(newBaseIndex: TimePointIndex | null, newPoints?: readonly TimeScalePoint[], firstChangedPointIndex?: number): void {
+	public updateTimeScale(newBaseIndex: TimePointIndex | null, newPoints?: readonly TimeScalePoint<HorzScaleItem>[], firstChangedPointIndex?: number): void {
 		const oldFirstTime = this._timeScale.indexToTime(0 as TimePointIndex);
 
 		if (newPoints !== undefined && firstChangedPointIndex !== undefined) {
@@ -712,7 +716,7 @@ export class ChartModel implements IDestroyable {
 		// (and actually we cannot)
 		if (visibleBars !== null && oldFirstTime !== null && newFirstTime !== null) {
 			const isLastSeriesBarVisible = visibleBars.contains(currentBaseIndex);
-			const isLeftBarShiftToLeft = oldFirstTime.timestamp > newFirstTime.timestamp;
+			const isLeftBarShiftToLeft = this._horzScaleBehavior.key(oldFirstTime) > this._horzScaleBehavior.key(newFirstTime);
 			const isSeriesPointsAdded = newBaseIndex !== null && newBaseIndex > currentBaseIndex;
 			const isSeriesPointsAddedToRight = isSeriesPointsAdded && !isLeftBarShiftToLeft;
 
@@ -726,25 +730,25 @@ export class ChartModel implements IDestroyable {
 		this._timeScale.setBaseIndex(newBaseIndex);
 	}
 
-	public recalculatePane(pane: Pane | null): void {
+	public recalculatePane(pane: Pane<HorzScaleItem> | null): void {
 		if (pane !== null) {
 			pane.recalculate();
 		}
 	}
 
-	public paneForSource(source: IPriceDataSource): Pane | null {
-		const pane = this._panes.find((p: Pane) => p.orderedSources().includes(source));
+	public paneForSource(source: IPriceDataSource<HorzScaleItem>): Pane<HorzScaleItem> | null {
+		const pane = this._panes.find((p: Pane<HorzScaleItem>) => p.orderedSources().includes(source));
 		return pane === undefined ? null : pane;
 	}
 
 	public recalculateAllPanes(): void {
 		this._watermark.updateAllViews();
-		this._panes.forEach((p: Pane) => p.recalculate());
+		this._panes.forEach((p: Pane<HorzScaleItem>) => p.recalculate());
 		this.updateCrosshair();
 	}
 
 	public destroy(): void {
-		this._panes.forEach((p: Pane) => p.destroy());
+		this._panes.forEach((p: Pane<HorzScaleItem>) => p.destroy());
 		this._panes.length = 0;
 
 		// to avoid memleaks
@@ -752,7 +756,7 @@ export class ChartModel implements IDestroyable {
 		this._options.localization.timeFormatter = undefined;
 	}
 
-	public rendererOptionsProvider(): PriceAxisRendererOptionsProvider {
+	public rendererOptionsProvider(): PriceAxisRendererOptionsProvider<HorzScaleItem> {
 		return this._rendererOptionsProvider;
 	}
 
@@ -764,7 +768,7 @@ export class ChartModel implements IDestroyable {
 		return this._priceScalesOptionsChanged;
 	}
 
-	public createSeries<T extends SeriesType>(seriesType: T, options: SeriesOptionsMap[T]): Series<T> {
+	public createSeries<T extends SeriesType>(seriesType: T, options: SeriesOptionsMap[T]): Series<T, HorzScaleItem> {
 		const pane = this._panes[0];
 		const series = this._createSeries(options, seriesType, pane);
 		this._serieses.push(series);
@@ -779,7 +783,7 @@ export class ChartModel implements IDestroyable {
 		return series;
 	}
 
-	public removeSeries(series: Series): void {
+	public removeSeries(series: Series<SeriesType, HorzScaleItem>): void {
 		const pane = this.paneForSource(series);
 
 		const seriesIndex = this._serieses.indexOf(series);
@@ -792,7 +796,7 @@ export class ChartModel implements IDestroyable {
 		}
 	}
 
-	public moveSeriesToScale(series: Series, targetScaleId: string): void {
+	public moveSeriesToScale(series: Series<SeriesType, HorzScaleItem>, targetScaleId: string): void {
 		const pane = ensureNotNull(this.paneForSource(series));
 		pane.removeDataSource(series);
 
@@ -897,7 +901,7 @@ export class ChartModel implements IDestroyable {
 		return result;
 	}
 
-	private _paneInvalidationMask(pane: Pane | null, level: InvalidationLevel): InvalidateMask {
+	private _paneInvalidationMask(pane: Pane<HorzScaleItem> | null, level: InvalidationLevel): InvalidateMask {
 		const inv = new InvalidateMask(level);
 		if (pane !== null) {
 			const index = this._panes.indexOf(pane);
@@ -908,7 +912,7 @@ export class ChartModel implements IDestroyable {
 		return inv;
 	}
 
-	private _invalidationMaskForSource(source: IPriceDataSource, invalidateType?: InvalidationLevel): InvalidateMask {
+	private _invalidationMaskForSource(source: IPriceDataSource<HorzScaleItem>, invalidateType?: InvalidationLevel): InvalidateMask {
 		if (invalidateType === undefined) {
 			invalidateType = InvalidationLevel.Light;
 		}
@@ -921,11 +925,11 @@ export class ChartModel implements IDestroyable {
 			this._invalidateHandler(mask);
 		}
 
-		this._panes.forEach((pane: Pane) => pane.grid().paneView().update());
+		this._panes.forEach((pane: Pane<HorzScaleItem>) => pane.grid().paneView().update());
 	}
 
-	private _createSeries<T extends SeriesType>(options: SeriesOptionsInternal<T>, seriesType: T, pane: Pane): Series<T> {
-		const series = new Series<T>(this, options, seriesType);
+	private _createSeries<T extends SeriesType>(options: SeriesOptionsInternal<T>, seriesType: T, pane: Pane<HorzScaleItem>): Series<T, HorzScaleItem> {
+		const series = new Series<T, HorzScaleItem>(this, options, seriesType);
 
 		const targetScaleId = options.priceScaleId !== undefined ? options.priceScaleId : this.defaultVisiblePriceScaleId();
 		pane.addDataSource(series, targetScaleId);
diff --git a/src/model/crosshair.ts b/src/model/crosshair.ts
index 09d3b300f3..5c02b7cd7b 100644
--- a/src/model/crosshair.ts
+++ b/src/model/crosshair.ts
@@ -15,10 +15,12 @@ import { BarPrice } from './bar';
 import { ChartModel } from './chart-model';
 import { Coordinate } from './coordinate';
 import { DataSource } from './data-source';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { Pane } from './pane';
 import { PriceScale } from './price-scale';
 import { Series } from './series';
-import { TimePoint, TimePointIndex } from './time-data';
+import { SeriesType } from './series-options';
+import { TimePointIndex } from './time-data';
 
 export interface CrosshairPriceAndCoordinate {
 	price: number;
@@ -26,11 +28,11 @@ export interface CrosshairPriceAndCoordinate {
 }
 
 export interface CrosshairTimeAndCoordinate {
-	time: TimePoint;
+	time: InternalHorzScaleItem;
 	coordinate: number;
 }
 
-export type PriceAndCoordinateProvider = (priceScale: PriceScale) => CrosshairPriceAndCoordinate;
+export type PriceAndCoordinateProvider<HorzScaleItem> = (priceScale: PriceScale<HorzScaleItem>) => CrosshairPriceAndCoordinate;
 export type TimeAndCoordinateProvider = () => CrosshairTimeAndCoordinate | null;
 
 /**
@@ -122,19 +124,19 @@ type RawPriceProvider = () => BarPrice;
 type RawCoordinateProvider = () => Coordinate;
 type RawIndexProvider = () => TimePointIndex;
 
-export class Crosshair extends DataSource {
-	private _pane: Pane | null = null;
+export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
+	private _pane: Pane<HorzScaleItem> | null = null;
 	private _price: number = NaN;
 	private _index: TimePointIndex = 0 as TimePointIndex;
 	private _visible: boolean = true;
-	private readonly _model: ChartModel;
-	private _priceAxisViews: Map<PriceScale, CrosshairPriceAxisView> = new Map();
-	private readonly _timeAxisView: CrosshairTimeAxisView;
-	private readonly _markersPaneView: CrosshairMarksPaneView;
+	private readonly _model: ChartModel<HorzScaleItem>;
+	private _priceAxisViews: Map<PriceScale<HorzScaleItem>, CrosshairPriceAxisView<HorzScaleItem>> = new Map();
+	private readonly _timeAxisView: CrosshairTimeAxisView<HorzScaleItem>;
+	private readonly _markersPaneView: CrosshairMarksPaneView<HorzScaleItem>;
 	private _subscribed: boolean = false;
-	private readonly _currentPosPriceProvider: PriceAndCoordinateProvider;
+	private readonly _currentPosPriceProvider: PriceAndCoordinateProvider<HorzScaleItem>;
 	private readonly _options: CrosshairOptions;
-	private readonly _paneView: CrosshairPaneView;
+	private readonly _paneView: CrosshairPaneView<HorzScaleItem>;
 
 	private _x: Coordinate = NaN as Coordinate;
 	private _y: Coordinate = NaN as Coordinate;
@@ -142,14 +144,14 @@ export class Crosshair extends DataSource {
 	private _originX: Coordinate = NaN as Coordinate;
 	private _originY: Coordinate = NaN as Coordinate;
 
-	public constructor(model: ChartModel, options: CrosshairOptions) {
+	public constructor(model: ChartModel<HorzScaleItem>, options: CrosshairOptions) {
 		super();
 		this._model = model;
 		this._options = options;
 		this._markersPaneView = new CrosshairMarksPaneView(model, this);
 
 		const valuePriceProvider = (rawPriceProvider: RawPriceProvider, rawCoordinateProvider: RawCoordinateProvider) => {
-			return (priceScale: PriceScale) => {
+			return (priceScale: PriceScale<HorzScaleItem>) => {
 				const coordinate = rawCoordinateProvider();
 				const rawPrice = rawPriceProvider();
 				if (priceScale === ensureNotNull(this._pane).defaultPriceScale()) {
@@ -215,7 +217,7 @@ export class Crosshair extends DataSource {
 		return this._originY;
 	}
 
-	public setPosition(index: TimePointIndex, price: number, pane: Pane): void {
+	public setPosition(index: TimePointIndex, price: number, pane: Pane<HorzScaleItem>): void {
 		if (!this._subscribed) {
 			this._subscribed = true;
 		}
@@ -253,11 +255,11 @@ export class Crosshair extends DataSource {
 		this.clearOriginCoord();
 	}
 
-	public paneViews(pane: Pane): readonly IPaneView[] {
+	public paneViews(pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
 		return this._pane !== null ? [this._paneView, this._markersPaneView] : [];
 	}
 
-	public horzLineVisible(pane: Pane): boolean {
+	public horzLineVisible(pane: Pane<HorzScaleItem>): boolean {
 		return pane === this._pane && this._options.horzLine.visible;
 	}
 
@@ -265,12 +267,12 @@ export class Crosshair extends DataSource {
 		return this._options.vertLine.visible;
 	}
 
-	public override priceAxisViews(pane: Pane, priceScale: PriceScale): IPriceAxisView[] {
+	public override priceAxisViews(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): IPriceAxisView<HorzScaleItem>[] {
 		if (!this._visible || this._pane !== pane) {
 			this._priceAxisViews.clear();
 		}
 
-		const views: IPriceAxisView[] = [];
+		const views: IPriceAxisView<HorzScaleItem>[] = [];
 		if (this._pane === pane) {
 			views.push(this._createPriceAxisViewOnDemand(this._priceAxisViews, priceScale, this._currentPosPriceProvider));
 		}
@@ -278,22 +280,22 @@ export class Crosshair extends DataSource {
 		return views;
 	}
 
-	public override timeAxisViews(): readonly ITimeAxisView[] {
+	public override timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[] {
 		return this._visible ? [this._timeAxisView] : [];
 	}
 
-	public pane(): Pane | null {
+	public pane(): Pane<HorzScaleItem> | null {
 		return this._pane;
 	}
 
 	public updateAllViews(): void {
 		this._paneView.update();
-		this._priceAxisViews.forEach((value: PriceAxisView) => value.update());
+		this._priceAxisViews.forEach((value: PriceAxisView<HorzScaleItem>) => value.update());
 		this._timeAxisView.update();
 		this._markersPaneView.update();
 	}
 
-	private _priceScaleByPane(pane: Pane): PriceScale | null {
+	private _priceScaleByPane(pane: Pane<HorzScaleItem>): PriceScale<HorzScaleItem> | null {
 		if (pane && !pane.defaultPriceScale().isEmpty()) {
 			return pane.defaultPriceScale();
 		}
@@ -301,13 +303,13 @@ export class Crosshair extends DataSource {
 		return null;
 	}
 
-	private _tryToUpdateViews(index: TimePointIndex, price: number, pane: Pane): void {
+	private _tryToUpdateViews(index: TimePointIndex, price: number, pane: Pane<HorzScaleItem>): void {
 		if (this._tryToUpdateData(index, price, pane)) {
 			this.updateAllViews();
 		}
 	}
 
-	private _tryToUpdateData(newIndex: TimePointIndex, newPrice: number, newPane: Pane): boolean {
+	private _tryToUpdateData(newIndex: TimePointIndex, newPrice: number, newPane: Pane<HorzScaleItem>): boolean {
 		const oldX = this._x;
 		const oldY = this._y;
 		const oldPrice = this._price;
@@ -334,13 +336,13 @@ export class Crosshair extends DataSource {
 
 	private _setIndexToLastSeriesBarIndex(): void {
 		const lastIndexes = this._model.serieses()
-			.map((s: Series) => s.bars().lastIndex())
+			.map((s: Series<SeriesType, HorzScaleItem>) => s.bars().lastIndex())
 			.filter(notNull);
 		const lastBarIndex = (lastIndexes.length === 0) ? null : (Math.max(...lastIndexes) as TimePointIndex);
 		this._index = lastBarIndex !== null ? lastBarIndex : NaN as TimePointIndex;
 	}
 
-	private _createPriceAxisViewOnDemand(map: Map<PriceScale, CrosshairPriceAxisView>, priceScale: PriceScale, valueProvider: PriceAndCoordinateProvider): IPriceAxisView {
+	private _createPriceAxisViewOnDemand(map: Map<PriceScale<HorzScaleItem>, CrosshairPriceAxisView<HorzScaleItem>>, priceScale: PriceScale<HorzScaleItem>, valueProvider: PriceAndCoordinateProvider<HorzScaleItem>): IPriceAxisView<HorzScaleItem> {
 		let view = map.get(priceScale);
 
 		if (view === undefined) {
diff --git a/src/model/custom-price-line.ts b/src/model/custom-price-line.ts
index 3b75419c9f..334bfc81af 100644
--- a/src/model/custom-price-line.ts
+++ b/src/model/custom-price-line.ts
@@ -9,15 +9,16 @@ import { IPriceAxisView } from '../views/price-axis/iprice-axis-view';
 import { Coordinate } from './coordinate';
 import { PriceLineOptions } from './price-line-options';
 import { Series } from './series';
+import { SeriesType } from './series-options';
 
-export class CustomPriceLine {
-	private readonly _series: Series;
-	private readonly _priceLineView: CustomPriceLinePaneView;
-	private readonly _priceAxisView: CustomPriceLinePriceAxisView;
-	private readonly _panePriceAxisView: PanePriceAxisView;
+export class CustomPriceLine<HorzScaleItem> {
+	private readonly _series: Series<SeriesType, HorzScaleItem>;
+	private readonly _priceLineView: CustomPriceLinePaneView<HorzScaleItem>;
+	private readonly _priceAxisView: CustomPriceLinePriceAxisView<HorzScaleItem>;
+	private readonly _panePriceAxisView: PanePriceAxisView<HorzScaleItem>;
 	private readonly _options: PriceLineOptions;
 
-	public constructor(series: Series, options: PriceLineOptions) {
+	public constructor(series: Series<SeriesType, HorzScaleItem>, options: PriceLineOptions) {
 		this._series = series;
 		this._options = options;
 		this._priceLineView = new CustomPriceLinePaneView(series, this);
@@ -35,15 +36,15 @@ export class CustomPriceLine {
 		return this._options;
 	}
 
-	public paneView(): IPaneView {
+	public paneView(): IPaneView<HorzScaleItem> {
 		return this._priceLineView;
 	}
 
-	public labelPaneView(): IPaneView {
+	public labelPaneView(): IPaneView<HorzScaleItem> {
 		return this._panePriceAxisView;
 	}
 
-	public priceAxisView(): IPriceAxisView {
+	public priceAxisView(): IPriceAxisView<HorzScaleItem> {
 		return this._priceAxisView;
 	}
 
diff --git a/src/model/data-source.ts b/src/model/data-source.ts
index 322e9b2051..4fbf9660da 100644
--- a/src/model/data-source.ts
+++ b/src/model/data-source.ts
@@ -6,8 +6,8 @@ import { IDataSource } from './idata-source';
 import { Pane } from './pane';
 import { PriceScale } from './price-scale';
 
-export abstract class DataSource implements IDataSource {
-	protected _priceScale: PriceScale | null = null;
+export abstract class DataSource<HorzScaleItem> implements IDataSource<HorzScaleItem> {
+	protected _priceScale: PriceScale<HorzScaleItem> | null = null;
 
 	private _zorder: number = 0;
 
@@ -19,22 +19,22 @@ export abstract class DataSource implements IDataSource {
 		this._zorder = zorder;
 	}
 
-	public priceScale(): PriceScale | null {
+	public priceScale(): PriceScale<HorzScaleItem> | null {
 		return this._priceScale;
 	}
 
-	public setPriceScale(priceScale: PriceScale | null): void {
+	public setPriceScale(priceScale: PriceScale<HorzScaleItem> | null): void {
 		this._priceScale = priceScale;
 	}
 
-	public abstract priceAxisViews(pane?: Pane, priceScale?: PriceScale): readonly IPriceAxisView[];
-	public abstract paneViews(pane?: Pane): readonly IPaneView[];
+	public abstract priceAxisViews(pane?: Pane<HorzScaleItem>, priceScale?: PriceScale<HorzScaleItem>): readonly IPriceAxisView<HorzScaleItem>[];
+	public abstract paneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[];
 
-	public labelPaneViews(pane?: Pane): readonly IPaneView[] {
+	public labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
 		return [];
 	}
 
-	public timeAxisViews(): readonly ITimeAxisView[] {
+	public timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[] {
 		return [];
 	}
 
diff --git a/src/model/formatted-labels-cache.ts b/src/model/formatted-labels-cache.ts
index 0e831c3b7f..c79c53cb86 100644
--- a/src/model/formatted-labels-cache.ts
+++ b/src/model/formatted-labels-cache.ts
@@ -1,5 +1,6 @@
 import { ensureDefined } from '../helpers/assertions';
 
+import { IHorzScaleBehavior } from './ihorz-scale-behavior';
 import { TickMark } from './tick-marks';
 
 interface CachedTick {
@@ -7,10 +8,10 @@ interface CachedTick {
 	tick: number;
 }
 
-export type FormatFunction = (tickMark: TickMark) => string;
+export type FormatFunction<HorzScaleItem> = (tickMark: TickMark<HorzScaleItem>) => string;
 
-export class FormattedLabelsCache {
-	private readonly _format: FormatFunction;
+export class FormattedLabelsCache<HorzScaleItem> {
+	private readonly _format: FormatFunction<HorzScaleItem>;
 	private readonly _maxSize: number;
 	private _actualSize: number = 0;
 	private _usageTick: number = 1;
@@ -18,16 +19,18 @@ export class FormattedLabelsCache {
 	private _cache: Map<number, CachedTick> = new Map();
 	private _tick2Labels: Map<number, number> = new Map();
 
-	public constructor(format: FormatFunction, size: number = 50) {
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(format: FormatFunction<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, size: number = 50) {
 		this._format = format;
+		this._horzScaleBehavior = horzScaleBehavior;
 		this._maxSize = size;
 	}
 
-	public format(tickMark: TickMark): string {
+	public format(tickMark: TickMark<HorzScaleItem>): string {
 		const time = tickMark.time;
-		const cacheKey = time.businessDay === undefined
-			? new Date(time.timestamp * 1000).getTime()
-			: new Date(Date.UTC(time.businessDay.year, time.businessDay.month - 1, time.businessDay.day)).getTime();
+
+		const cacheKey = this._horzScaleBehavior.cacheKey(time);
 
 		const tick = this._cache.get(cacheKey);
 		if (tick !== undefined) {
diff --git a/src/model/grid.ts b/src/model/grid.ts
index 92b5a3a367..d8870cf6d1 100644
--- a/src/model/grid.ts
+++ b/src/model/grid.ts
@@ -41,14 +41,14 @@ export interface GridOptions {
 	horzLines: GridLineOptions;
 }
 
-export class Grid {
-	private _paneView: GridPaneView;
+export class Grid<HorzScaleItem> {
+	private _paneView: GridPaneView<HorzScaleItem>;
 
-	public constructor(pane: Pane) {
+	public constructor(pane: Pane<HorzScaleItem>) {
 		this._paneView = new GridPaneView(pane);
 	}
 
-	public paneView(): IUpdatablePaneView {
+	public paneView(): IUpdatablePaneView<HorzScaleItem> {
 		return this._paneView;
 	}
 }
diff --git a/src/model/default-tick-mark-formatter.ts b/src/model/horz-scale-behavior-time/default-tick-mark-formatter.ts
similarity index 91%
rename from src/model/default-tick-mark-formatter.ts
rename to src/model/horz-scale-behavior-time/default-tick-mark-formatter.ts
index f85e21dcd9..2ddc860565 100644
--- a/src/model/default-tick-mark-formatter.ts
+++ b/src/model/horz-scale-behavior-time/default-tick-mark-formatter.ts
@@ -1,7 +1,6 @@
-import { ensureNever } from '../helpers/assertions';
+import { ensureNever } from '../../helpers/assertions';
 
-import { TimePoint } from './time-data';
-import { TickMarkType } from './time-scale';
+import { TickMarkType, TimePoint } from './types';
 
 export function defaultTickMarkFormatter(timePoint: TimePoint, tickMarkType: TickMarkType, locale: string): string {
 	const formatOptions: Intl.DateTimeFormatOptions = {};
diff --git a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
new file mode 100644
index 0000000000..ecefed57ed
--- /dev/null
+++ b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
@@ -0,0 +1,266 @@
+import { SeriesDataItemTypeMap } from '../../api/data-consumer';
+import { TimedData } from '../../api/data-layer';
+import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../ihorz-scale-behavior';
+import { DateFormatter } from '../../formatters/date-formatter';
+import { DateTimeFormatter } from '../../formatters/date-time-formatter';
+import { ensureNotNull } from '../../helpers/assertions';
+import { isString } from '../../helpers/strict-type-checks';
+import { ChartOptions } from '../chart-model';
+import { LocalizationOptions } from '../localization-options';
+import { SeriesType } from '../series-options';
+import { TickMark } from '../tick-marks';
+import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
+import { markWithGreaterWeight, TimeMark, TimeScaleOptions } from '../time-scale';
+
+import { defaultTickMarkFormatter } from './default-tick-mark-formatter';
+import { fillWeightsForPoints } from './time-scale-point-weight-generator';
+import { BusinessDay, isBusinessDay, isUTCTimestamp, TickMarkType, TickMarkWeight, Time, TimePoint, UTCTimestamp } from './types';
+
+type TimeConverter = (time: Time) => InternalHorzScaleItem;
+
+function businessDayConverter(time: Time): InternalHorzScaleItem {
+	if (!isBusinessDay(time)) {
+		throw new Error('time must be of type BusinessDay');
+	}
+
+	const date = new Date(Date.UTC(time.year, time.month - 1, time.day, 0, 0, 0, 0));
+
+	return {
+		timestamp: Math.round(date.getTime() / 1000) as UTCTimestamp,
+		businessDay: time,
+	} as unknown as InternalHorzScaleItem;
+}
+
+function timestampConverter(time: Time): InternalHorzScaleItem {
+	if (!isUTCTimestamp(time)) {
+		throw new Error('time must be of type isUTCTimestamp');
+	}
+	return {
+		timestamp: time,
+	} as unknown as InternalHorzScaleItem;
+}
+
+function selectTimeConverter(data: TimedData<Time>[]): TimeConverter | null {
+	if (data.length === 0) {
+		return null;
+	}
+	if (isBusinessDay(data[0].time)) {
+		return businessDayConverter;
+	}
+	return timestampConverter;
+}
+
+const validDateRegex = /^\d\d\d\d-\d\d-\d\d$/;
+
+export function convertTime(time: Time): InternalHorzScaleItem {
+	if (isUTCTimestamp(time)) {
+		return timestampConverter(time);
+	}
+
+	if (!isBusinessDay(time)) {
+		return businessDayConverter(stringToBusinessDay(time));
+	}
+
+	return businessDayConverter(time);
+}
+
+export function stringToBusinessDay(value: string): BusinessDay {
+	if (process.env.NODE_ENV === 'development') {
+		// in some browsers (I look at your Chrome) the Date constructor may accept invalid date string
+		// but parses them in 'implementation specific' way
+		// for example 2019-1-1 isn't the same as 2019-01-01 (for Chrome both are 'valid' date strings)
+		// see https://bugs.chromium.org/p/chromium/issues/detail?id=968939
+		// so, we need to be sure that date has valid format to avoid strange behavior and hours of debugging
+		// but let's do this in development build only because of perf
+		if (!validDateRegex.test(value)) {
+			throw new Error(`Invalid date string=${value}, expected format=yyyy-mm-dd`);
+		}
+	}
+
+	const d = new Date(value);
+	if (isNaN(d.getTime())) {
+		throw new Error(`Invalid date string=${value}, expected format=yyyy-mm-dd`);
+	}
+
+	return {
+		day: d.getUTCDate(),
+		month: d.getUTCMonth() + 1,
+		year: d.getUTCFullYear(),
+	};
+}
+
+function convertStringToBusinessDay(value: TimedData<Time>): void {
+	if (isString(value.time)) {
+		value.time = stringToBusinessDay(value.time);
+	}
+}
+
+function convertStringsToBusinessDays(data: TimedData<Time>[]): void {
+	return data.forEach(convertStringToBusinessDay);
+}
+
+interface TimeLocalizationOptions extends LocalizationOptions<Time> {
+	dateFormat: string;
+}
+
+/**
+ * The `TickMarkFormatter` is used to customize tick mark labels on the time scale.
+ *
+ * This function should return `time` as a string formatted according to `tickMarkType` type (year, month, etc) and `locale`.
+ *
+ * Note that the returned string should be the shortest possible value and should have no more than 8 characters.
+ * Otherwise, the tick marks will overlap each other.
+ *
+ * If the formatter function returns `null` then the default tick mark formatter will be used as a fallback.
+ *
+ * @example
+ * ```js
+ * const customFormatter = (time, tickMarkType, locale) => {
+ *     // your code here
+ * };
+ * ```
+ */
+export type TickMarkFormatter = (time: Time, tickMarkType: TickMarkType, locale: string) => string | null;
+
+interface TimeTimeScaleOptions extends TimeScaleOptions {
+	/**
+	 * Tick marks formatter can be used to customize tick marks labels on the time axis.
+	 *
+	 * @defaultValue `undefined`
+	 */
+	tickMarkFormatter?: TickMarkFormatter;
+}
+
+// eslint-disable-next-line complexity
+function weightToTickMarkType(weight: TickMarkWeight, timeVisible: boolean, secondsVisible: boolean): TickMarkType {
+	switch (weight) {
+		case TickMarkWeight.LessThanSecond:
+		case TickMarkWeight.Second:
+			return timeVisible
+				? (secondsVisible ? TickMarkType.TimeWithSeconds : TickMarkType.Time)
+				: TickMarkType.DayOfMonth;
+
+		case TickMarkWeight.Minute1:
+		case TickMarkWeight.Minute5:
+		case TickMarkWeight.Minute30:
+		case TickMarkWeight.Hour1:
+		case TickMarkWeight.Hour3:
+		case TickMarkWeight.Hour6:
+		case TickMarkWeight.Hour12:
+			return timeVisible ? TickMarkType.Time : TickMarkType.DayOfMonth;
+
+		case TickMarkWeight.Day:
+			return TickMarkType.DayOfMonth;
+
+		case TickMarkWeight.Month:
+			return TickMarkType.Month;
+
+		case TickMarkWeight.Year:
+			return TickMarkType.Year;
+	}
+}
+
+export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
+	private _dateTimeFormatter!: DateFormatter | DateTimeFormatter;
+	private _options!: ChartOptions<Time>;
+
+	public setOptions(options: ChartOptions<Time>) {
+		this._options = options;
+		this.updateFormatter(options.localization as TimeLocalizationOptions);
+	}
+
+	public preprocessData(data: DataItem<Time> | DataItem<Time>[]): void {
+		if (Array.isArray(data)) {
+			convertStringsToBusinessDays(data);
+		} else {
+			convertStringToBusinessDay(data);
+		}
+	}
+
+	public createConverterToInternalObj(data: SeriesDataItemTypeMap<Time>[SeriesType][]): HorzScaleItemConverterToInternalObj<Time> {
+		return ensureNotNull(selectTimeConverter(data));
+	}
+
+	public convertInternalToHorzItem(item: InternalHorzScaleItem): Time {
+		const tp = item as unknown as TimePoint;
+		return tp.businessDay ?? tp.timestamp;
+	}
+
+	public key(item: InternalHorzScaleItem | Time): InternalHorzScaleItemKey {
+		if ((typeof item === 'object') && 'timestamp' in item) {
+			return (item as unknown as TimePoint).timestamp as unknown as InternalHorzScaleItemKey;
+		} else {
+			return this.key(this.convertHorzItemToInternal(item as Time));
+		}
+	}
+
+	public cacheKey(item: InternalHorzScaleItem): number {
+		const time = item as unknown as TimePoint;
+		return time.businessDay === undefined
+			? new Date(time.timestamp * 1000).getTime()
+			: new Date(Date.UTC(time.businessDay.year, time.businessDay.month - 1, time.businessDay.day)).getTime();
+	}
+
+
+	public convertHorzItemToInternal(item: Time): InternalHorzScaleItem {
+		return convertTime(item);
+	}
+
+	public updateFormatter(options: TimeLocalizationOptions): void {
+		if (!this._options) {
+			return;
+		}
+		const dateFormat = options.dateFormat;
+
+		if (this._options.timeScale.timeVisible) {
+			this._dateTimeFormatter = new DateTimeFormatter({
+				dateFormat: dateFormat,
+				timeFormat: this._options.timeScale.secondsVisible ? '%h:%m:%s' : '%h:%m',
+				dateTimeSeparator: '   ',
+				locale: options.locale,
+			});
+		} else {
+			this._dateTimeFormatter = new DateFormatter(dateFormat, options.locale);
+		}
+	}
+
+	public formatHorzItem(item: InternalHorzScaleItem): string {
+		const tp = item as unknown as TimePoint;
+		return this._dateTimeFormatter.format(new Date(tp.timestamp * 1000));
+	}
+
+	public formatTickmark(tickMark: TickMark<Time>, localizationOptions: LocalizationOptions<Time>): string {
+		const tickMarkType = weightToTickMarkType(tickMark.weight, this._options.timeScale.timeVisible, this._options.timeScale.secondsVisible);
+
+		const options = this._options.timeScale as TimeTimeScaleOptions;
+
+		if (options.tickMarkFormatter !== undefined) {
+			const tickMarkString = options.tickMarkFormatter(
+				tickMark.originalTime as unknown as Time,
+				tickMarkType,
+				localizationOptions.locale
+			);
+			if (tickMarkString !== null) {
+				return tickMarkString;
+			}
+		}
+
+		return defaultTickMarkFormatter(tickMark.time as unknown as TimePoint, tickMarkType, localizationOptions.locale);
+	}
+
+	public maxTickMarkWeight(tickMarks: TimeMark[]): TickMarkWeightValue {
+		let maxWeight = tickMarks.reduce(markWithGreaterWeight, tickMarks[0]).weight;
+
+		// special case: it looks strange if 15:00 is bold but 14:00 is not
+		// so if maxWeight > TickMarkWeight.Hour1 and < TickMarkWeight.Day reduce it to TickMarkWeight.Hour1
+		if (maxWeight > TickMarkWeight.Hour1 && maxWeight < TickMarkWeight.Day) {
+			maxWeight = TickMarkWeight.Hour1 as TickMarkWeightValue;
+		}
+		return maxWeight;
+	}
+
+	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Time>>[], startIndex: number): void {
+		fillWeightsForPoints(sortedTimePoints, startIndex);
+	}
+
+}
diff --git a/src/api/time-scale-point-weight-generator.ts b/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
similarity index 69%
rename from src/api/time-scale-point-weight-generator.ts
rename to src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
index 4824dd7d7a..3943a3b13a 100644
--- a/src/api/time-scale-point-weight-generator.ts
+++ b/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
@@ -1,4 +1,6 @@
-import { TickMarkWeight, TimeScalePoint } from '../model/time-data';
+import { InternalHorzScaleItem } from '../ihorz-scale-behavior';
+import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
+import { TickMarkWeight, Time, TimePoint } from './types';
 
 function hours(count: number): number {
 	return count * 60 * 60 * 1000;
@@ -46,27 +48,31 @@ function weightByTime(currentDate: Date, prevDate: Date): TickMarkWeight {
 	return TickMarkWeight.LessThanSecond;
 }
 
-export function fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint>[], startIndex: number = 0): void {
+function cast(t: InternalHorzScaleItem): TimePoint {
+	return t as unknown as TimePoint;
+}
+
+export function fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Time>>[], startIndex: number = 0): void {
 	if (sortedTimePoints.length === 0) {
 		return;
 	}
 
-	let prevTime = startIndex === 0 ? null : sortedTimePoints[startIndex - 1].time.timestamp;
+	let prevTime = startIndex === 0 ? null : cast(sortedTimePoints[startIndex - 1].time).timestamp;
 	let prevDate = prevTime !== null ? new Date(prevTime * 1000) : null;
 
 	let totalTimeDiff = 0;
 
 	for (let index = startIndex; index < sortedTimePoints.length; ++index) {
 		const currentPoint = sortedTimePoints[index];
-		const currentDate = new Date(currentPoint.time.timestamp * 1000);
+		const currentDate = new Date(cast(currentPoint.time).timestamp * 1000);
 
 		if (prevDate !== null) {
-			currentPoint.timeWeight = weightByTime(currentDate, prevDate);
+			currentPoint.timeWeight = weightByTime(currentDate, prevDate) as TickMarkWeightValue;
 		}
 
-		totalTimeDiff += currentPoint.time.timestamp - (prevTime || currentPoint.time.timestamp);
+		totalTimeDiff += cast(currentPoint.time).timestamp - (prevTime || cast(currentPoint.time).timestamp);
 
-		prevTime = currentPoint.time.timestamp;
+		prevTime = cast(currentPoint.time).timestamp;
 		prevDate = currentDate;
 	}
 
@@ -74,7 +80,7 @@ export function fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScal
 		// let's guess a weight for the first point
 		// let's say the previous point was average time back in the history
 		const averageTimeDiff = Math.ceil(totalTimeDiff / (sortedTimePoints.length - 1));
-		const approxPrevDate = new Date((sortedTimePoints[0].time.timestamp - averageTimeDiff) * 1000);
-		sortedTimePoints[0].timeWeight = weightByTime(new Date(sortedTimePoints[0].time.timestamp * 1000), approxPrevDate);
+		const approxPrevDate = new Date((cast(sortedTimePoints[0].time).timestamp - averageTimeDiff) * 1000);
+		sortedTimePoints[0].timeWeight = weightByTime(new Date(cast(sortedTimePoints[0].time).timestamp * 1000), approxPrevDate) as TickMarkWeightValue;
 	}
 }
diff --git a/src/model/horz-scale-behavior-time/types.ts b/src/model/horz-scale-behavior-time/types.ts
new file mode 100644
index 0000000000..5ec826c7e0
--- /dev/null
+++ b/src/model/horz-scale-behavior-time/types.ts
@@ -0,0 +1,130 @@
+import { Nominal } from "../../helpers/nominal";
+import { isNumber, isString } from "../../helpers/strict-type-checks";
+
+/**
+ * Represents a time as a UNIX timestamp.
+ *
+ * If your chart displays an intraday interval you should use a UNIX Timestamp.
+ *
+ * Note that JavaScript Date APIs like `Date.now` return a number of milliseconds but UTCTimestamp expects a number of seconds.
+ *
+ * Note that to prevent errors, you should cast the numeric type of the time to `UTCTimestamp` type from the package (`value as UTCTimestamp`) in TypeScript code.
+ *
+ * @example
+ * ```ts
+ * const timestamp = 1529899200 as UTCTimestamp; // Literal timestamp representing 2018-06-25T04:00:00.000Z
+ * const timestamp2 = (Date.now() / 1000) as UTCTimestamp;
+ * ```
+ */
+export type UTCTimestamp = Nominal<number, 'UTCTimestamp'>;
+
+/**
+ * Represents a time as a day/month/year.
+ *
+ * @example
+ * ```js
+ * const day = { year: 2019, month: 6, day: 1 }; // June 1, 2019
+ * ```
+ */
+export interface BusinessDay {
+	/**
+	 * The year.
+	 */
+	year: number;
+	/**
+	 * The month.
+	 */
+	month: number;
+	/**
+	 * The day.
+	 */
+	day: number;
+}
+
+/**
+ * The Time type is used to represent the time of data items.
+ *
+ * Values can be a {@link UTCTimestamp}, a {@link BusinessDay}, or a business day string in ISO format.
+ *
+ * @example
+ * ```js
+ * const timestamp = 1529899200; // Literal timestamp representing 2018-06-25T04:00:00.000Z
+ * const businessDay = { year: 2019, month: 6, day: 1 }; // June 1, 2019
+ * const businessDayString = '2021-02-03'; // Business day string literal
+ * ```
+ */
+export type Time = UTCTimestamp | BusinessDay | string;
+
+export interface TimePoint {
+	timestamp: UTCTimestamp;
+	businessDay?: BusinessDay;
+}
+
+/**
+ * Check if a time value is a business day object.
+ *
+ * @param time - The time to check.
+ * @returns `true` if `time` is a {@link BusinessDay} object, false otherwise.
+ */
+export function isBusinessDay(time: Time): time is BusinessDay {
+	return !isNumber(time) && !isString(time);
+}
+
+/**
+ * Check if a time value is a UTC timestamp number.
+ *
+ * @param time - The time to check.
+ * @returns `true` if `time` is a {@link UTCTimestamp} number, false otherwise.
+ */
+export function isUTCTimestamp(time: Time): time is UTCTimestamp {
+	return isNumber(time);
+}
+
+/**
+ * Represents the type of a tick mark on the time axis.
+ */
+export const enum TickMarkType {
+	/**
+	 * The start of the year (e.g. it's the first tick mark in a year).
+	 */
+	Year,
+	/**
+	 * The start of the month (e.g. it's the first tick mark in a month).
+	 */
+	Month,
+	/**
+	 * A day of the month.
+	 */
+	DayOfMonth,
+	/**
+	 * A time without seconds.
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-shadow
+	Time,
+	/**
+	 * A time with seconds.
+	 */
+	TimeWithSeconds,
+}
+
+/**
+ * Describes a weight of tick mark, i.e. a part of a time that changed since previous time.
+ * Note that you can use any timezone to calculate this value, it is unnecessary to use UTC.
+ *
+ * @example Between 2020-01-01 and 2020-01-02 there is a day of difference, i.e. for 2020-01-02 weight would be a day.
+ * @example Between 2020-01-01 and 2020-02-02 there is a month of difference, i.e. for 2020-02-02 weight would be a month.
+ */
+export const enum TickMarkWeight {
+	LessThanSecond = 0,
+	Second = 10,
+	Minute1 = 20,
+	Minute5 = 21,
+	Minute30 = 22,
+	Hour1 = 30,
+	Hour3 = 31,
+	Hour6 = 32,
+	Hour12 = 33,
+	Day = 50,
+	Month = 60,
+	Year = 70,
+}
diff --git a/src/model/idata-source.ts b/src/model/idata-source.ts
index 9a90336703..ac9a4500c3 100644
--- a/src/model/idata-source.ts
+++ b/src/model/idata-source.ts
@@ -5,23 +5,23 @@ import { ITimeAxisView } from '../views/time-axis/itime-axis-view';
 import { Pane } from './pane';
 import { PriceScale } from './price-scale';
 
-export interface IDataSource {
+export interface IDataSource<HorzScaleItem> {
 	zorder(): number | null;
 	setZorder(value: number): void;
-	priceScale(): PriceScale | null;
-	setPriceScale(scale: PriceScale | null): void;
+	priceScale(): PriceScale<HorzScaleItem> | null;
+	setPriceScale(scale: PriceScale<HorzScaleItem> | null): void;
 
 	updateAllViews(): void;
 
-	priceAxisViews(pane?: Pane, priceScale?: PriceScale): readonly IPriceAxisView[];
-	timeAxisViews(): readonly ITimeAxisView[];
-	paneViews(pane: Pane): readonly IPaneView[];
-	labelPaneViews(pane?: Pane): readonly IPaneView[];
+	priceAxisViews(pane?: Pane<HorzScaleItem>, priceScale?: PriceScale<HorzScaleItem>): readonly IPriceAxisView<HorzScaleItem>[];
+	timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[];
+	paneViews(pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[];
+	labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[];
 
 	/**
 	 * Pane views that are painted on the most top layer
 	 */
-	topPaneViews?(pane: Pane): readonly IPaneView[];
+	topPaneViews?(pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[];
 
 	visible(): boolean;
 
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
new file mode 100644
index 0000000000..4cdc4c0d10
--- /dev/null
+++ b/src/model/ihorz-scale-behavior.ts
@@ -0,0 +1,32 @@
+import { Nominal } from '../helpers/nominal';
+import { ChartOptions } from './chart-model';
+import { LocalizationOptions } from './localization-options';
+import { SeriesType } from './series-options';
+import { TickMark } from './tick-marks';
+import { TickMarkWeightValue, TimeScalePoint } from './time-data';
+import { TimeMark } from './time-scale';
+
+import { SeriesDataItemTypeMap } from '../api/data-consumer';
+
+export type InternalHorzScaleItem = Nominal<unknown, 'InternalHorzScaleItem'>;
+
+export type HorzScaleItemConverterToInternalObj<HorzScaleItem> = (time: HorzScaleItem) => InternalHorzScaleItem;
+
+export type DataItem<HorzScaleItem> = SeriesDataItemTypeMap<HorzScaleItem>[SeriesType];
+
+export type InternalHorzScaleItemKey = Nominal<number, 'InternalHorzScaleItemKey'>;
+
+export interface IHorzScaleBehavior<HorzScaleItem> {
+	setOptions(options: ChartOptions<HorzScaleItem>): void;
+    preprocessData(data: DataItem<HorzScaleItem> | DataItem<HorzScaleItem>[]): void;
+    convertHorzItemToInternal(item: HorzScaleItem): InternalHorzScaleItem;
+    convertInternalToHorzItem(item: InternalHorzScaleItem): HorzScaleItem;
+    createConverterToInternalObj(data: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType][]): HorzScaleItemConverterToInternalObj<HorzScaleItem>;
+    key(internalItem: InternalHorzScaleItem | HorzScaleItem): InternalHorzScaleItemKey;
+    cacheKey(internalItem: InternalHorzScaleItem): number;
+    updateFormatter(options: LocalizationOptions<HorzScaleItem>): void;
+    formatHorzItem(item: InternalHorzScaleItem): string;
+    formatTickmark(item: TickMark<HorzScaleItem>, localizationOptions: LocalizationOptions<HorzScaleItem>): string;
+    maxTickMarkWeight(marks: TimeMark[]): TickMarkWeightValue;
+    fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<HorzScaleItem>>[], startIndex: number): void;
+}
diff --git a/src/model/iprice-data-source.ts b/src/model/iprice-data-source.ts
index 5407afbf0a..a24edb0c1c 100644
--- a/src/model/iprice-data-source.ts
+++ b/src/model/iprice-data-source.ts
@@ -3,18 +3,19 @@ import { IPriceFormatter } from '../formatters/iprice-formatter';
 import { AutoscaleInfoImpl } from './autoscale-info-impl';
 import { ChartModel } from './chart-model';
 import { IDataSource } from './idata-source';
-import { TimePoint, TimePointIndex } from './time-data';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
+import { TimePointIndex } from './time-data';
 
 export interface FirstValue {
 	value: number;
-	timePoint: TimePoint;
+	timePoint: InternalHorzScaleItem;
 }
 
-export interface IPriceDataSource extends IDataSource {
+export interface IPriceDataSource<HorzScaleItem> extends IDataSource<HorzScaleItem> {
 	firstValue(): FirstValue | null;
 	formatter(): IPriceFormatter;
 	priceLineColor(lastBarColor: string): string;
-	model(): ChartModel;
+	model(): ChartModel<HorzScaleItem>;
 	minMove(): number;
 	autoscaleInfo(startTimePoint: TimePointIndex, endTimePoint: TimePointIndex): AutoscaleInfoImpl | null;
 }
diff --git a/src/model/localization-options.ts b/src/model/localization-options.ts
index 72e1209a0b..a8afa35e5a 100644
--- a/src/model/localization-options.ts
+++ b/src/model/localization-options.ts
@@ -1,15 +1,14 @@
 import { PriceFormatterFn } from './price-formatter-fn';
-import { Time } from './time-data';
 
 /**
  * A custom function used to override formatting of a time to a string.
  */
-export type TimeFormatterFn = (time: Time) => string;
+export type TimeFormatterFn<HorzScaleItem> = (time: HorzScaleItem) => string;
 
 /**
  * Represents options for formatting dates, times, and prices according to a locale.
  */
-export interface LocalizationOptions {
+export interface LocalizationOptions<HorzScaleItem> {
 	/**
 	 * Current locale used to format dates. Uses the browser's language settings by default.
 	 *
@@ -31,7 +30,7 @@ export interface LocalizationOptions {
 	 *
 	 * @defaultValue `undefined`
 	 */
-	timeFormatter?: TimeFormatterFn;
+	timeFormatter?: TimeFormatterFn<HorzScaleItem>;
 
 	/**
 	 * Date formatting string.
diff --git a/src/model/magnet.ts b/src/model/magnet.ts
index 85b267a5f0..88b85773fd 100644
--- a/src/model/magnet.ts
+++ b/src/model/magnet.ts
@@ -6,16 +6,17 @@ import { IPriceDataSource } from './iprice-data-source';
 import { Pane } from './pane';
 import { PlotRowValueIndex } from './plot-data';
 import { Series } from './series';
+import { SeriesType } from './series-options';
 import { TimePointIndex } from './time-data';
 
-export class Magnet {
+export class Magnet<HorzScaleItem> {
 	private readonly _options: CrosshairOptions;
 
 	public constructor(options: CrosshairOptions) {
 		this._options = options;
 	}
 
-	public align(price: number, index: TimePointIndex, pane: Pane): number {
+	public align(price: number, index: TimePointIndex, pane: Pane<HorzScaleItem>): number {
 		let res = price;
 		if (this._options.mode === CrosshairMode.Normal) {
 			return res;
@@ -31,11 +32,11 @@ export class Magnet {
 		const y = defaultPriceScale.priceToCoordinate(price, firstValue);
 
 		// get all serieses from the pane
-		const serieses: readonly Series[] = pane.dataSources().filter(
-			((ds: IPriceDataSource) => (ds instanceof Series)) as (ds: IPriceDataSource) => ds is Series);
+		const serieses: readonly Series<SeriesType, HorzScaleItem>[] = pane.dataSources().filter(
+			((ds: IPriceDataSource<HorzScaleItem>) => (ds instanceof Series<SeriesType, HorzScaleItem>)) as (ds: IPriceDataSource<HorzScaleItem>) => ds is Series<SeriesType, HorzScaleItem>);
 
 		const candidates = serieses.reduce(
-			(acc: Coordinate[], series: Series) => {
+			(acc: Coordinate[], series: Series<SeriesType, HorzScaleItem>) => {
 				if (pane.isOverlay(series) || !series.visible()) {
 					return acc;
 				}
diff --git a/src/model/pane.ts b/src/model/pane.ts
index 7e591a28bf..2a254bae4a 100644
--- a/src/model/pane.ts
+++ b/src/model/pane.ts
@@ -21,25 +21,25 @@ interface MinMaxOrderInfo {
 	maxZOrder: number;
 }
 
-export class Pane implements IDestroyable {
-	private readonly _timeScale: TimeScale;
-	private readonly _model: ChartModel;
-	private readonly _grid: Grid;
+export class Pane<HorzScaleItem> implements IDestroyable {
+	private readonly _timeScale: TimeScale<HorzScaleItem>;
+	private readonly _model: ChartModel<HorzScaleItem>;
+	private readonly _grid: Grid<HorzScaleItem>;
 
-	private _dataSources: IPriceDataSource[] = [];
-	private _overlaySourcesByScaleId: Map<string, IPriceDataSource[]> = new Map();
+	private _dataSources: IPriceDataSource<HorzScaleItem>[] = [];
+	private _overlaySourcesByScaleId: Map<string, IPriceDataSource<HorzScaleItem>[]> = new Map();
 
 	private _height: number = 0;
 	private _width: number = 0;
 	private _stretchFactor: number = DEFAULT_STRETCH_FACTOR;
-	private _cachedOrderedSources: readonly IPriceDataSource[] | null = null;
+	private _cachedOrderedSources: readonly IPriceDataSource<HorzScaleItem>[] | null = null;
 
 	private _destroyed: Delegate = new Delegate();
 
-	private _leftPriceScale: PriceScale;
-	private _rightPriceScale: PriceScale;
+	private _leftPriceScale: PriceScale<HorzScaleItem>;
+	private _rightPriceScale: PriceScale<HorzScaleItem>;
 
-	public constructor(timeScale: TimeScale, model: ChartModel) {
+	public constructor(timeScale: TimeScale<HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
 		this._timeScale = timeScale;
 		this._model = model;
 		this._grid = new Grid(this);
@@ -55,7 +55,7 @@ export class Pane implements IDestroyable {
 		this.applyScaleOptions(options);
 	}
 
-	public applyScaleOptions(options: DeepPartial<ChartOptions>): void {
+	public applyScaleOptions(options: DeepPartial<ChartOptions<HorzScaleItem>>): void {
 		if (options.leftPriceScale) {
 			this._leftPriceScale.applyOptions(options.leftPriceScale);
 		}
@@ -78,7 +78,7 @@ export class Pane implements IDestroyable {
 		}
 	}
 
-	public priceScaleById(id: string): PriceScale | null {
+	public priceScaleById(id: string): PriceScale<HorzScaleItem> | null {
 		switch (id) {
 			case DefaultPriceScaleId.Left: {
 				return this._leftPriceScale;
@@ -99,7 +99,7 @@ export class Pane implements IDestroyable {
 		this._leftPriceScale.modeChanged().unsubscribeAll(this);
 		this._rightPriceScale.modeChanged().unsubscribeAll(this);
 
-		this._dataSources.forEach((source: IPriceDataSource) => {
+		this._dataSources.forEach((source: IPriceDataSource<HorzScaleItem>) => {
 			if (source.destroy) {
 				source.destroy();
 			}
@@ -115,7 +115,7 @@ export class Pane implements IDestroyable {
 		this._stretchFactor = factor;
 	}
 
-	public model(): ChartModel {
+	public model(): ChartModel<HorzScaleItem> {
 		return this._model;
 	}
 
@@ -139,7 +139,7 @@ export class Pane implements IDestroyable {
 		this._rightPriceScale.setHeight(height);
 
 		// process overlays
-		this._dataSources.forEach((ds: IPriceDataSource) => {
+		this._dataSources.forEach((ds: IPriceDataSource<HorzScaleItem>) => {
 			if (this.isOverlay(ds)) {
 				const priceScale = ds.priceScale();
 				if (priceScale !== null) {
@@ -151,11 +151,11 @@ export class Pane implements IDestroyable {
 		this.updateAllSources();
 	}
 
-	public dataSources(): readonly IPriceDataSource[] {
+	public dataSources(): readonly IPriceDataSource<HorzScaleItem>[] {
 		return this._dataSources;
 	}
 
-	public isOverlay(source: IPriceDataSource): boolean {
+	public isOverlay(source: IPriceDataSource<HorzScaleItem>): boolean {
 		const priceScale = source.priceScale();
 		if (priceScale === null) {
 			return true;
@@ -163,12 +163,12 @@ export class Pane implements IDestroyable {
 		return this._leftPriceScale !== priceScale && this._rightPriceScale !== priceScale;
 	}
 
-	public addDataSource(source: IPriceDataSource, targetScaleId: string, zOrder?: number): void {
+	public addDataSource(source: IPriceDataSource<HorzScaleItem>, targetScaleId: string, zOrder?: number): void {
 		const targetZOrder = (zOrder !== undefined) ? zOrder : this._getZOrderMinMax().maxZOrder + 1;
 		this._insertDataSource(source, targetScaleId, targetZOrder);
 	}
 
-	public removeDataSource(source: IPriceDataSource): void {
+	public removeDataSource(source: IPriceDataSource<HorzScaleItem>): void {
 		const index = this._dataSources.indexOf(source);
 		assert(index !== -1, 'removeDataSource: invalid data source');
 
@@ -201,7 +201,7 @@ export class Pane implements IDestroyable {
 		this._cachedOrderedSources = null;
 	}
 
-	public priceScalePosition(priceScale: PriceScale): PriceScalePosition {
+	public priceScalePosition(priceScale: PriceScale<HorzScaleItem>): PriceScalePosition {
 		if (priceScale === this._leftPriceScale) {
 			return 'left';
 		}
@@ -212,50 +212,50 @@ export class Pane implements IDestroyable {
 		return 'overlay';
 	}
 
-	public leftPriceScale(): PriceScale {
+	public leftPriceScale(): PriceScale<HorzScaleItem> {
 		return this._leftPriceScale;
 	}
 
-	public rightPriceScale(): PriceScale {
+	public rightPriceScale(): PriceScale<HorzScaleItem> {
 		return this._rightPriceScale;
 	}
 
-	public startScalePrice(priceScale: PriceScale, x: number): void {
+	public startScalePrice(priceScale: PriceScale<HorzScaleItem>, x: number): void {
 		priceScale.startScale(x);
 	}
 
-	public scalePriceTo(priceScale: PriceScale, x: number): void {
+	public scalePriceTo(priceScale: PriceScale<HorzScaleItem>, x: number): void {
 		priceScale.scaleTo(x);
 
 		// TODO: be more smart and update only affected views
 		this.updateAllSources();
 	}
 
-	public endScalePrice(priceScale: PriceScale): void {
+	public endScalePrice(priceScale: PriceScale<HorzScaleItem>): void {
 		priceScale.endScale();
 	}
 
-	public startScrollPrice(priceScale: PriceScale, x: number): void {
+	public startScrollPrice(priceScale: PriceScale<HorzScaleItem>, x: number): void {
 		priceScale.startScroll(x);
 	}
 
-	public scrollPriceTo(priceScale: PriceScale, x: number): void {
+	public scrollPriceTo(priceScale: PriceScale<HorzScaleItem>, x: number): void {
 		priceScale.scrollTo(x);
 		this.updateAllSources();
 	}
 
-	public endScrollPrice(priceScale: PriceScale): void {
+	public endScrollPrice(priceScale: PriceScale<HorzScaleItem>): void {
 		priceScale.endScroll();
 	}
 
 	public updateAllSources(): void {
-		this._dataSources.forEach((source: IPriceDataSource) => {
+		this._dataSources.forEach((source: IPriceDataSource<HorzScaleItem>) => {
 			source.updateAllViews();
 		});
 	}
 
-	public defaultPriceScale(): PriceScale {
-		let priceScale: PriceScale | null = null;
+	public defaultPriceScale(): PriceScale<HorzScaleItem> {
+		let priceScale: PriceScale<HorzScaleItem> | null = null;
 
 		if (this._model.options().rightPriceScale.visible && this._rightPriceScale.dataSources().length !== 0) {
 			priceScale = this._rightPriceScale;
@@ -272,8 +272,8 @@ export class Pane implements IDestroyable {
 		return priceScale;
 	}
 
-	public defaultVisiblePriceScale(): PriceScale | null {
-		let priceScale: PriceScale | null = null;
+	public defaultVisiblePriceScale(): PriceScale<HorzScaleItem> | null {
+		let priceScale: PriceScale<HorzScaleItem> | null = null;
 
 		if (this._model.options().rightPriceScale.visible) {
 			priceScale = this._rightPriceScale;
@@ -283,7 +283,7 @@ export class Pane implements IDestroyable {
 		return priceScale;
 	}
 
-	public recalculatePriceScale(priceScale: PriceScale | null): void {
+	public recalculatePriceScale(priceScale: PriceScale<HorzScaleItem> | null): void {
 		if (priceScale === null || !priceScale.isAutoScale()) {
 			return;
 		}
@@ -291,7 +291,7 @@ export class Pane implements IDestroyable {
 		this._recalculatePriceScaleImpl(priceScale);
 	}
 
-	public resetPriceScale(priceScale: PriceScale): void {
+	public resetPriceScale(priceScale: PriceScale<HorzScaleItem>): void {
 		const visibleBars = this._timeScale.visibleStrictRange();
 		priceScale.setMode({ autoScale: true });
 		if (visibleBars !== null) {
@@ -309,7 +309,7 @@ export class Pane implements IDestroyable {
 		this.recalculatePriceScale(this._leftPriceScale);
 		this.recalculatePriceScale(this._rightPriceScale);
 
-		this._dataSources.forEach((ds: IPriceDataSource) => {
+		this._dataSources.forEach((ds: IPriceDataSource<HorzScaleItem>) => {
 			if (this.isOverlay(ds)) {
 				this.recalculatePriceScale(ds.priceScale());
 			}
@@ -319,9 +319,9 @@ export class Pane implements IDestroyable {
 		this._model.lightUpdate();
 	}
 
-	public orderedSources(): readonly IPriceDataSource[] {
+	public orderedSources(): readonly IPriceDataSource<HorzScaleItem>[] {
 		if (this._cachedOrderedSources === null) {
-			this._cachedOrderedSources = sortSources(this._dataSources);
+			this._cachedOrderedSources = sortSources<HorzScaleItem, IPriceDataSource<HorzScaleItem>>(this._dataSources);
 		}
 
 		return this._cachedOrderedSources;
@@ -331,11 +331,11 @@ export class Pane implements IDestroyable {
 		return this._destroyed;
 	}
 
-	public grid(): Grid {
+	public grid(): Grid<HorzScaleItem> {
 		return this._grid;
 	}
 
-	private _recalculatePriceScaleImpl(priceScale: PriceScale): void {
+	private _recalculatePriceScaleImpl(priceScale: PriceScale<HorzScaleItem>): void {
 		// TODO: can use this checks
 		const sourceForAutoScale = priceScale.sourcesForAutoScale();
 
@@ -374,7 +374,7 @@ export class Pane implements IDestroyable {
 		return { minZOrder: minZOrder, maxZOrder: maxZOrder };
 	}
 
-	private _insertDataSource(source: IPriceDataSource, priceScaleId: string, zOrder: number): void {
+	private _insertDataSource(source: IPriceDataSource<HorzScaleItem>, priceScaleId: string, zOrder: number): void {
 		let priceScale = this.priceScaleById(priceScaleId);
 
 		if (priceScale === null) {
@@ -398,7 +398,7 @@ export class Pane implements IDestroyable {
 		this._cachedOrderedSources = null;
 	}
 
-	private _onPriceScaleModeChanged(priceScale: PriceScale, oldMode: PriceScaleState, newMode: PriceScaleState): void {
+	private _onPriceScaleModeChanged(priceScale: PriceScale<HorzScaleItem>, oldMode: PriceScaleState, newMode: PriceScaleState): void {
 		if (oldMode.mode === newMode.mode) {
 			return;
 		}
@@ -407,9 +407,9 @@ export class Pane implements IDestroyable {
 		this._recalculatePriceScaleImpl(priceScale);
 	}
 
-	private _createPriceScale(id: string, options: OverlayPriceScaleOptions | VisiblePriceScaleOptions): PriceScale {
+	private _createPriceScale(id: string, options: OverlayPriceScaleOptions | VisiblePriceScaleOptions): PriceScale<HorzScaleItem> {
 		const actualOptions: PriceScaleOptions = { visible: true, autoScale: true, ...clone(options) };
-		const priceScale = new PriceScale(
+		const priceScale = new PriceScale<HorzScaleItem>(
 			id,
 			actualOptions,
 			this._model.options().layout,
diff --git a/src/model/plot-data.ts b/src/model/plot-data.ts
index aad5a19dfe..f4ea428d7c 100644
--- a/src/model/plot-data.ts
+++ b/src/model/plot-data.ts
@@ -1,4 +1,5 @@
-import { OriginalTime, TimePoint, TimePointIndex } from './time-data';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
+import { TimePointIndex } from './time-data';
 
 /**
  * Plot's index in plot list tuple for series
@@ -17,9 +18,9 @@ export type PlotRowValue = [
 	number, // close
 ];
 
-export interface PlotRow {
+export interface PlotRow<HorzPlotItem> {
 	readonly index: TimePointIndex;
-	readonly time: TimePoint;
+	readonly time: InternalHorzScaleItem;
 	readonly value: PlotRowValue;
-	readonly originalTime: OriginalTime;
+	readonly originalTime: HorzPlotItem;
 }
diff --git a/src/model/plot-list.ts b/src/model/plot-list.ts
index 3e4029dcad..7a7027f3b8 100644
--- a/src/model/plot-list.ts
+++ b/src/model/plot-list.ts
@@ -37,7 +37,7 @@ const CHUNK_SIZE = 30;
  * PlotList is an array of plot rows
  * each plot row consists of key (index in timescale) and plot value map
  */
-export class PlotList<PlotRowType extends PlotRow = PlotRow> {
+export class PlotList<HorzScaleItem, PlotRowType extends PlotRow<HorzScaleItem> = PlotRow<HorzScaleItem>> {
 	private _items: readonly PlotRowType[] = [];
 	private _minMaxCache: Map<PlotRowValueIndex, Map<number, MinMax | null>> = new Map();
 	private _rowSearchCache: Map<TimePointIndex, Map<MismatchDirection, PlotRowType>> = new Map();
diff --git a/src/model/price-data-source.ts b/src/model/price-data-source.ts
index befae6768a..5cb5107b55 100644
--- a/src/model/price-data-source.ts
+++ b/src/model/price-data-source.ts
@@ -6,15 +6,15 @@ import { DataSource } from './data-source';
 import { FirstValue, IPriceDataSource } from './iprice-data-source';
 import { TimePointIndex } from './time-data';
 
-export abstract class PriceDataSource extends DataSource implements IPriceDataSource {
-	private readonly _model: ChartModel;
+export abstract class PriceDataSource<HorzScaleItem> extends DataSource<HorzScaleItem> implements IPriceDataSource<HorzScaleItem> {
+	private readonly _model: ChartModel<HorzScaleItem>;
 
-	public constructor(model: ChartModel) {
+	public constructor(model: ChartModel<HorzScaleItem>) {
 		super();
 		this._model = model;
 	}
 
-	public model(): ChartModel {
+	public model(): ChartModel<HorzScaleItem> {
 		return this._model;
 	}
 
diff --git a/src/model/price-scale.ts b/src/model/price-scale.ts
index 14a5324b8b..bb483215ce 100644
--- a/src/model/price-scale.ts
+++ b/src/model/price-scale.ts
@@ -193,11 +193,11 @@ interface MarksCache {
 	firstValueIsNull: boolean;
 }
 
-export class PriceScale {
+export class PriceScale<HorzScaleItem> {
 	private readonly _id: string;
 
 	private readonly _layoutOptions: LayoutOptions;
-	private readonly _localizationOptions: LocalizationOptions;
+	private readonly _localizationOptions: LocalizationOptions<HorzScaleItem>;
 	private readonly _options: PriceScaleOptions;
 
 	private _height: number = 0;
@@ -210,13 +210,13 @@ export class PriceScale {
 	private _marginAbove: number = 0;
 	private _marginBelow: number = 0;
 
-	private _markBuilder: PriceTickMarkBuilder;
+	private _markBuilder: PriceTickMarkBuilder<HorzScaleItem>;
 	private _onMarksChanged: Delegate = new Delegate();
 
 	private _modeChanged: Delegate<PriceScaleState, PriceScaleState> = new Delegate();
 
-	private _dataSources: IPriceDataSource[] = [];
-	private _cachedOrderedSources: IPriceDataSource[] | null = null;
+	private _dataSources: IPriceDataSource<HorzScaleItem>[] = [];
+	private _cachedOrderedSources: IPriceDataSource<HorzScaleItem>[] | null = null;
 
 	private _marksCache: MarksCache | null = null;
 
@@ -226,7 +226,7 @@ export class PriceScale {
 
 	private _logFormula: LogFormula = logFormulaForPriceRange(null);
 
-	public constructor(id: string, options: PriceScaleOptions, layoutOptions: LayoutOptions, localizationOptions: LocalizationOptions) {
+	public constructor(id: string, options: PriceScaleOptions, layoutOptions: LayoutOptions, localizationOptions: LocalizationOptions<HorzScaleItem>) {
 		this._id = id;
 		this._options = options;
 		this._layoutOptions = layoutOptions;
@@ -518,16 +518,16 @@ export class PriceScale {
 		return value as BarPrice;
 	}
 
-	public dataSources(): readonly IPriceDataSource[] {
+	public dataSources(): readonly IPriceDataSource<HorzScaleItem>[] {
 		return this._dataSources;
 	}
 
-	public orderedSources(): readonly IPriceDataSource[] {
+	public orderedSources(): readonly IPriceDataSource<HorzScaleItem>[] {
 		if (this._cachedOrderedSources) {
 			return this._cachedOrderedSources;
 		}
 
-		let sources: IPriceDataSource[] = [];
+		let sources: IPriceDataSource<HorzScaleItem>[] = [];
 		for (let i = 0; i < this._dataSources.length; i++) {
 			const ds = this._dataSources[i];
 			if (ds.zorder() === null) {
@@ -537,12 +537,12 @@ export class PriceScale {
 			sources.push(ds);
 		}
 
-		sources = sortSources(sources);
+		sources = sortSources<HorzScaleItem, IPriceDataSource<HorzScaleItem>>(sources);
 		this._cachedOrderedSources = sources;
 		return this._cachedOrderedSources;
 	}
 
-	public addDataSource(source: IPriceDataSource): void {
+	public addDataSource(source: IPriceDataSource<HorzScaleItem>): void {
 		if (this._dataSources.indexOf(source) !== -1) {
 			return;
 		}
@@ -552,7 +552,7 @@ export class PriceScale {
 		this.invalidateSourcesCache();
 	}
 
-	public removeDataSource(source: IPriceDataSource): void {
+	public removeDataSource(source: IPriceDataSource<HorzScaleItem>): void {
 		const index = this._dataSources.indexOf(source);
 		if (index === -1) {
 			throw new Error('source is not attached to scale');
@@ -768,7 +768,7 @@ export class PriceScale {
 		return percentageFormatter.format(price);
 	}
 
-	public sourcesForAutoScale(): readonly IPriceDataSource[] {
+	public sourcesForAutoScale(): readonly IPriceDataSource<HorzScaleItem>[] {
 		return this._dataSources;
 	}
 
@@ -780,7 +780,7 @@ export class PriceScale {
 	}
 
 	public updateAllViews(): void {
-		this._dataSources.forEach((s: IPriceDataSource) => s.updateAllViews());
+		this._dataSources.forEach((s: IPriceDataSource<HorzScaleItem>) => s.updateAllViews());
 	}
 
 	public updateFormatter(): void {
@@ -822,7 +822,7 @@ export class PriceScale {
 	/**
 	 * @returns The {@link IPriceDataSource} that will be used as the "formatter source" (take minMove for formatter).
 	 */
-	private _formatterSource(): IPriceDataSource | null {
+	private _formatterSource(): IPriceDataSource<HorzScaleItem> | null {
 		return this._dataSources[0] || null;
 	}
 
diff --git a/src/model/price-tick-mark-builder.ts b/src/model/price-tick-mark-builder.ts
index cf7c19f74f..4ba78e9be0 100644
--- a/src/model/price-tick-mark-builder.ts
+++ b/src/model/price-tick-mark-builder.ts
@@ -9,15 +9,15 @@ export type LogicalToCoordinateConverter = (x: number, firstValue: number, keepI
 
 const TICK_DENSITY = 2.5;
 
-export class PriceTickMarkBuilder {
+export class PriceTickMarkBuilder<HorzScaleItem> {
 	private _marks: PriceMark[] = [];
 	private _base: number;
-	private readonly _priceScale: PriceScale;
+	private readonly _priceScale: PriceScale<HorzScaleItem>;
 	private readonly _coordinateToLogicalFunc: CoordinateToLogicalConverter;
 	private readonly _logicalToCoordinateFunc: LogicalToCoordinateConverter;
 
 	public constructor(
-		priceScale: PriceScale,
+		priceScale: PriceScale<HorzScaleItem>,
 		base: number,
 		coordinateToLogicalFunc: CoordinateToLogicalConverter,
 		logicalToCoordinateFunc: LogicalToCoordinateConverter
diff --git a/src/model/series-bar-colorer.ts b/src/model/series-bar-colorer.ts
index e9310a850e..df9e70ca30 100644
--- a/src/model/series-bar-colorer.ts
+++ b/src/model/series-bar-colorer.ts
@@ -15,9 +15,9 @@ import {
 } from './series-options';
 import { TimePointIndex } from './time-data';
 
-export interface PrecomputedBars {
-	value: SeriesPlotRow;
-	previousValue?: SeriesPlotRow;
+export interface PrecomputedBars<HorzScaleItem> {
+	value: SeriesPlotRow<SeriesType, HorzScaleItem>;
+	previousValue?: SeriesPlotRow<SeriesType, HorzScaleItem>;
 }
 
 export interface CommonBarColorerStyle {
@@ -72,110 +72,113 @@ export interface BarStylesMap {
 	Histogram: HistogramBarColorerStyle;
 }
 
-type FindBarFn = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars) => SeriesPlotRow | null;
+type FindBarFn<HorzScaleItem> = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>) => SeriesPlotRow<SeriesType, HorzScaleItem> | null;
 
-type StyleGetterFn<T extends SeriesType> = (
-	findBar: FindBarFn,
-	barStyle: ReturnType<Series<T>['options']>,
+type StyleGetterFn<T extends SeriesType, HorzScaleItem> = (
+	findBar: FindBarFn<HorzScaleItem>,
+	barStyle: ReturnType<Series<T, HorzScaleItem>['options']>,
 	barIndex: TimePointIndex,
-	precomputedBars?: PrecomputedBars
+	precomputedBars?: PrecomputedBars<HorzScaleItem>
 ) => BarStylesMap[T];
 
-type BarStylesFnMap = {
-	[T in keyof SeriesOptionsMap]: StyleGetterFn<T>;
+type BarStylesFnMap<T extends SeriesType, HorzScaleItem> = {
+	[T in keyof SeriesOptionsMap]: StyleGetterFn<T, HorzScaleItem>;
 };
 
-const barStyleFnMap: BarStylesFnMap = {
-	// eslint-disable-next-line @typescript-eslint/naming-convention
-	Bar: (findBar: FindBarFn, barStyle: BarStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BarColorerStyle => {
-		const upColor = barStyle.upColor;
-		const downColor = barStyle.downColor;
+export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> {
+	private _series: Series<T, HorzScaleItem>;
+	private readonly _styleGetter: BarStylesFnMap<T, HorzScaleItem>[T];
+	private readonly _barStyleFnMap: BarStylesFnMap<T, HorzScaleItem>;
 
-		const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Bar'>;
-		const isUp = ensure(currentBar.value[PlotRowValueIndex.Open]) <= ensure(currentBar.value[PlotRowValueIndex.Close]);
+	public constructor(series: Series<T, HorzScaleItem>) {
+		this._series = series;
 
-		return {
-			barColor: currentBar.color ?? (isUp ? upColor : downColor),
-		};
-	},
-	// eslint-disable-next-line @typescript-eslint/naming-convention
-	Candlestick: (findBar: FindBarFn, candlestickStyle: CandlestickStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): CandlesticksColorerStyle => {
-		const upColor = candlestickStyle.upColor;
-		const downColor = candlestickStyle.downColor;
-		const borderUpColor = candlestickStyle.borderUpColor;
-		const borderDownColor = candlestickStyle.borderDownColor;
-
-		const wickUpColor = candlestickStyle.wickUpColor;
-		const wickDownColor = candlestickStyle.wickDownColor;
-
-		const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Candlestick'>;
-		const isUp = ensure(currentBar.value[PlotRowValueIndex.Open]) <= ensure(currentBar.value[PlotRowValueIndex.Close]);
-
-		return {
-			barColor: currentBar.color ?? (isUp ? upColor : downColor),
-			barBorderColor: currentBar.borderColor ?? (isUp ? borderUpColor : borderDownColor),
-			barWickColor: currentBar.wickColor ?? (isUp ? wickUpColor : wickDownColor),
-		};
-	},
-	// eslint-disable-next-line @typescript-eslint/naming-convention
-	Area: (findBar: FindBarFn, areaStyle: AreaStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): AreaBarColorerStyle => {
-		const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Area'>;
-		return {
-			barColor: currentBar.lineColor ?? areaStyle.lineColor,
-			lineColor: currentBar.lineColor ?? areaStyle.lineColor,
-			topColor: currentBar.topColor ?? areaStyle.topColor,
-			bottomColor: currentBar.bottomColor ?? areaStyle.bottomColor,
-		};
-	},
-	// eslint-disable-next-line @typescript-eslint/naming-convention
-	Baseline: (findBar: FindBarFn, baselineStyle: BaselineStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BaselineBarColorerStyle => {
-		const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Baseline'>;
-		const isAboveBaseline = currentBar.value[PlotRowValueIndex.Close] >= baselineStyle.baseValue.price;
-
-		return {
-			barColor: isAboveBaseline ? baselineStyle.topLineColor : baselineStyle.bottomLineColor,
-			topLineColor: currentBar.topLineColor ?? baselineStyle.topLineColor,
-			bottomLineColor: currentBar.bottomLineColor ?? baselineStyle.bottomLineColor,
-			topFillColor1: currentBar.topFillColor1 ?? baselineStyle.topFillColor1,
-			topFillColor2: currentBar.topFillColor2 ?? baselineStyle.topFillColor2,
-			bottomFillColor1: currentBar.bottomFillColor1 ?? baselineStyle.bottomFillColor1,
-			bottomFillColor2: currentBar.bottomFillColor2 ?? baselineStyle.bottomFillColor2,
+		this._barStyleFnMap = {
+			// eslint-disable-next-line @typescript-eslint/naming-convention
+			Bar: (findBar: FindBarFn<HorzScaleItem>, barStyle: BarStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): BarColorerStyle => {
+				const upColor = barStyle.upColor;
+				const downColor = barStyle.downColor;
+
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Bar', HorzScaleItem>;
+				const isUp = ensure(currentBar.value[PlotRowValueIndex.Open]) <= ensure(currentBar.value[PlotRowValueIndex.Close]);
+
+				return {
+					barColor: currentBar.color ?? (isUp ? upColor : downColor),
+				};
+			},
+			// eslint-disable-next-line @typescript-eslint/naming-convention
+			Candlestick: (findBar: FindBarFn<HorzScaleItem>, candlestickStyle: CandlestickStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): CandlesticksColorerStyle => {
+				const upColor = candlestickStyle.upColor;
+				const downColor = candlestickStyle.downColor;
+				const borderUpColor = candlestickStyle.borderUpColor;
+				const borderDownColor = candlestickStyle.borderDownColor;
+
+				const wickUpColor = candlestickStyle.wickUpColor;
+				const wickDownColor = candlestickStyle.wickDownColor;
+
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Candlestick', HorzScaleItem>;
+				const isUp = ensure(currentBar.value[PlotRowValueIndex.Open]) <= ensure(currentBar.value[PlotRowValueIndex.Close]);
+
+				return {
+					barColor: currentBar.color ?? (isUp ? upColor : downColor),
+					barBorderColor: currentBar.borderColor ?? (isUp ? borderUpColor : borderDownColor),
+					barWickColor: currentBar.wickColor ?? (isUp ? wickUpColor : wickDownColor),
+				};
+			},
+			// eslint-disable-next-line @typescript-eslint/naming-convention
+			Area: (findBar: FindBarFn<HorzScaleItem>, areaStyle: AreaStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): AreaBarColorerStyle => {
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Area', HorzScaleItem>;
+				return {
+					barColor: currentBar.lineColor ?? areaStyle.lineColor,
+					lineColor: currentBar.lineColor ?? areaStyle.lineColor,
+					topColor: currentBar.topColor ?? areaStyle.topColor,
+					bottomColor: currentBar.bottomColor ?? areaStyle.bottomColor,
+				};
+			},
+			// eslint-disable-next-line @typescript-eslint/naming-convention
+			Baseline: (findBar: FindBarFn<HorzScaleItem>, baselineStyle: BaselineStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): BaselineBarColorerStyle => {
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Baseline', HorzScaleItem>;
+				const isAboveBaseline = currentBar.value[PlotRowValueIndex.Close] >= baselineStyle.baseValue.price;
+
+				return {
+					barColor: isAboveBaseline ? baselineStyle.topLineColor : baselineStyle.bottomLineColor,
+					topLineColor: currentBar.topLineColor ?? baselineStyle.topLineColor,
+					bottomLineColor: currentBar.bottomLineColor ?? baselineStyle.bottomLineColor,
+					topFillColor1: currentBar.topFillColor1 ?? baselineStyle.topFillColor1,
+					topFillColor2: currentBar.topFillColor2 ?? baselineStyle.topFillColor2,
+					bottomFillColor1: currentBar.bottomFillColor1 ?? baselineStyle.bottomFillColor1,
+					bottomFillColor2: currentBar.bottomFillColor2 ?? baselineStyle.bottomFillColor2,
+				};
+			},
+			// eslint-disable-next-line @typescript-eslint/naming-convention
+			Line: (findBar: FindBarFn<HorzScaleItem>, lineStyle: LineStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): LineBarColorerStyle => {
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Line', HorzScaleItem>;
+
+				return {
+					barColor: currentBar.color ?? lineStyle.color,
+					lineColor: currentBar.color ?? lineStyle.color,
+				};
+			},
+			// eslint-disable-next-line @typescript-eslint/naming-convention
+			Histogram: (findBar: FindBarFn<HorzScaleItem>, histogramStyle: HistogramStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): HistogramBarColorerStyle => {
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Histogram', HorzScaleItem>;
+				return {
+					barColor: currentBar.color ?? histogramStyle.color,
+				};
+			},
 		};
-	},
-	// eslint-disable-next-line @typescript-eslint/naming-convention
-	Line: (findBar: FindBarFn, lineStyle: LineStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): LineBarColorerStyle => {
-		const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Line'>;
-
-		return {
-			barColor: currentBar.color ?? lineStyle.color,
-			lineColor: currentBar.color ?? lineStyle.color,
-		};
-	},
-	// eslint-disable-next-line @typescript-eslint/naming-convention
-	Histogram: (findBar: FindBarFn, histogramStyle: HistogramStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): HistogramBarColorerStyle => {
-		const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Histogram'>;
-		return {
-			barColor: currentBar.color ?? histogramStyle.color,
-		};
-	},
-};
 
-export class SeriesBarColorer<T extends SeriesType> {
-	private _series: Series<T>;
-	private readonly _styleGetter: typeof barStyleFnMap[T];
+		this._styleGetter = this._barStyleFnMap[series.seriesType()];
 
-	public constructor(series: Series<T>) {
-		this._series = series;
-		this._styleGetter = barStyleFnMap[series.seriesType()];
 	}
 
-	public barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BarStylesMap[T] {
+	public barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): BarStylesMap[T] {
 		// precomputedBars: {value: [Array BarValues], previousValue: [Array BarValues] | undefined}
 		// Used to avoid binary search if bars are already known
 		return this._styleGetter(this._findBar, this._series.options(), barIndex, precomputedBars);
 	}
 
-	private _findBar = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): SeriesPlotRow | null => {
+	private _findBar = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): SeriesPlotRow<T, HorzScaleItem> | null => {
 		if (precomputedBars !== undefined) {
 			return precomputedBars.value;
 		}
diff --git a/src/model/series-data.ts b/src/model/series-data.ts
index d9d1f06f37..d8a8991b6d 100644
--- a/src/model/series-data.ts
+++ b/src/model/series-data.ts
@@ -2,17 +2,17 @@ import { PlotRow } from './plot-data';
 import { PlotList } from './plot-list';
 import { SeriesType } from './series-options';
 
-export interface LinePlotRow extends PlotRow {
+export interface LinePlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
 	readonly color?: string;
 }
 
-export interface AreaPlotRow extends PlotRow {
+export interface AreaPlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
 	lineColor?: string;
 	topColor?: string;
 	bottomColor?: string;
 }
 
-export interface BaselinePlotRow extends PlotRow {
+export interface BaselinePlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
 	topFillColor1?: string;
 	topFillColor2?: string;
 	topLineColor?: string;
@@ -21,32 +21,32 @@ export interface BaselinePlotRow extends PlotRow {
 	bottomLineColor?: string;
 }
 
-export interface HistogramPlotRow extends PlotRow {
+export interface HistogramPlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
 	readonly color?: string;
 }
 
-export interface BarPlotRow extends PlotRow {
+export interface BarPlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
 	readonly color?: string;
 }
 
-export interface CandlestickPlotRow extends PlotRow {
+export interface CandlestickPlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
 	readonly color?: string;
 	readonly borderColor?: string;
 	readonly wickColor?: string;
 }
 
-export interface SeriesPlotRowTypeAtTypeMap {
-	Bar: BarPlotRow;
-	Candlestick: CandlestickPlotRow;
-	Area: AreaPlotRow;
-	Baseline: BaselinePlotRow;
-	Line: LinePlotRow;
-	Histogram: HistogramPlotRow;
+export interface SeriesPlotRowTypeAtTypeMap<HorzScaleItem> {
+	Bar: BarPlotRow<HorzScaleItem>;
+	Candlestick: CandlestickPlotRow<HorzScaleItem>;
+	Area: AreaPlotRow<HorzScaleItem>;
+	Baseline: BaselinePlotRow<HorzScaleItem>;
+	Line: LinePlotRow<HorzScaleItem>;
+	Histogram: HistogramPlotRow<HorzScaleItem>;
 }
 
-export type SeriesPlotRow<T extends SeriesType = SeriesType> = SeriesPlotRowTypeAtTypeMap[T];
-export type SeriesPlotList<T extends SeriesType = SeriesType> = PlotList<SeriesPlotRow<T>>;
+export type SeriesPlotRow<T extends SeriesType, HorzScaleItem> = SeriesPlotRowTypeAtTypeMap<HorzScaleItem>[T];
+export type SeriesPlotList<T extends SeriesType, HorzScaleItem> = PlotList<HorzScaleItem, SeriesPlotRow<T, HorzScaleItem>>;
 
-export function createSeriesPlotList<T extends SeriesType = SeriesType>(): SeriesPlotList<T> {
-	return new PlotList<SeriesPlotRow<T>>();
+export function createSeriesPlotList<T extends SeriesType, HorzScaleItem>(): SeriesPlotList<T, HorzScaleItem> {
+	return new PlotList<HorzScaleItem, SeriesPlotRow<T, HorzScaleItem>>();
 }
diff --git a/src/model/series-markers.ts b/src/model/series-markers.ts
index 9b3b7d073f..01151279a8 100644
--- a/src/model/series-markers.ts
+++ b/src/model/series-markers.ts
@@ -1,5 +1,3 @@
-import { OriginalTime } from './time-data';
-
 /**
  * Represents the position of a series marker relative to a bar.
  */
@@ -13,7 +11,7 @@ export type SeriesMarkerShape = 'circle' | 'square' | 'arrowUp' | 'arrowDown';
 /**
  * Represents a series marker.
  */
-export interface SeriesMarker<TimeType> {
+export interface SeriesMarker<TimeType, HorzScaleItem> {
 	/**
 	 * The time of the marker.
 	 */
@@ -45,12 +43,9 @@ export interface SeriesMarker<TimeType> {
 	 */
 	size?: number;
 
-	/**
-	 * @internal
-	 */
-	originalTime: OriginalTime;
+	originalTime: HorzScaleItem;
 }
 
-export interface InternalSeriesMarker<TimeType> extends Omit<SeriesMarker<TimeType>, 'originalTime'> {
+export interface InternalSeriesMarker<TimeType, HorzScaleItem> extends SeriesMarker<TimeType, HorzScaleItem> {
 	internalId: number;
 }
diff --git a/src/model/series.ts b/src/model/series.ts
index ab2c6e97eb..c23d8aed13 100644
--- a/src/model/series.ts
+++ b/src/model/series.ts
@@ -29,6 +29,7 @@ import { ChartModel } from './chart-model';
 import { Coordinate } from './coordinate';
 import { CustomPriceLine } from './custom-price-line';
 import { isDefaultPriceScale } from './default-price-scale';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { FirstValue } from './iprice-data-source';
 import { Pane } from './pane';
 import { PlotRowValueIndex } from './plot-data';
@@ -49,7 +50,7 @@ import {
 	SeriesPartialOptionsMap,
 	SeriesType,
 } from './series-options';
-import { TimePoint, TimePointIndex } from './time-data';
+import { TimePointIndex } from './time-data';
 
 export interface LastValueDataResultWithoutData {
 	noData: true;
@@ -94,25 +95,25 @@ export interface SeriesUpdateInfo {
 export type SeriesOptionsInternal<T extends SeriesType = SeriesType> = SeriesOptionsMap[T];
 export type SeriesPartialOptionsInternal<T extends SeriesType = SeriesType> = SeriesPartialOptionsMap[T];
 
-export class Series<T extends SeriesType = SeriesType> extends PriceDataSource implements IDestroyable {
+export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource<HorzScaleItem> implements IDestroyable {
 	private readonly _seriesType: T;
-	private _data: SeriesPlotList<T> = createSeriesPlotList();
-	private readonly _priceAxisViews: IPriceAxisView[];
-	private readonly _panePriceAxisView: PanePriceAxisView;
+	private _data: SeriesPlotList<T, HorzScaleItem> = createSeriesPlotList<T, HorzScaleItem>();
+	private readonly _priceAxisViews: IPriceAxisView<HorzScaleItem>[];
+	private readonly _panePriceAxisView: PanePriceAxisView<HorzScaleItem>;
 	private _formatter!: IPriceFormatter;
-	private readonly _priceLineView: SeriesPriceLinePaneView = new SeriesPriceLinePaneView(this);
-	private readonly _customPriceLines: CustomPriceLine[] = [];
-	private readonly _baseHorizontalLineView: SeriesHorizontalBaseLinePaneView = new SeriesHorizontalBaseLinePaneView(this);
-	private _paneView!: IUpdatablePaneView;
-	private readonly _lastPriceAnimationPaneView: SeriesLastPriceAnimationPaneView | null = null;
-	private _barColorerCache: SeriesBarColorer<T> | null = null;
+	private readonly _priceLineView: SeriesPriceLinePaneView<HorzScaleItem> = new SeriesPriceLinePaneView(this);
+	private readonly _customPriceLines: CustomPriceLine<HorzScaleItem>[] = [];
+	private readonly _baseHorizontalLineView: SeriesHorizontalBaseLinePaneView<HorzScaleItem> = new SeriesHorizontalBaseLinePaneView(this);
+	private _paneView!: IUpdatablePaneView<HorzScaleItem>;
+	private readonly _lastPriceAnimationPaneView: SeriesLastPriceAnimationPaneView<HorzScaleItem> | null = null;
+	private _barColorerCache: SeriesBarColorer<T, HorzScaleItem> | null = null;
 	private readonly _options: SeriesOptionsInternal<T>;
-	private _markers: readonly SeriesMarker<TimePoint>[] = [];
-	private _indexedMarkers: InternalSeriesMarker<TimePointIndex>[] = [];
-	private _markersPaneView!: SeriesMarkersPaneView;
+	private _markers: readonly SeriesMarker<InternalHorzScaleItem, HorzScaleItem>[] = [];
+	private _indexedMarkers: InternalSeriesMarker<TimePointIndex, HorzScaleItem>[] = [];
+	private _markersPaneView!: SeriesMarkersPaneView<HorzScaleItem>;
 	private _animationTimeoutId: TimerId | null = null;
 
-	public constructor(model: ChartModel, options: SeriesOptionsInternal<T>, seriesType: T) {
+	public constructor(model: ChartModel<HorzScaleItem>, options: SeriesOptionsInternal<T>, seriesType: T) {
 		super(model);
 		this._options = options;
 		this._seriesType = seriesType;
@@ -123,7 +124,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		this._panePriceAxisView = new PanePriceAxisView(priceAxisView, this, model);
 
 		if (seriesType === 'Area' || seriesType === 'Line' || seriesType === 'Baseline') {
-			this._lastPriceAnimationPaneView = new SeriesLastPriceAnimationPaneView(this as Series<'Area'> | Series<'Line'> | Series<'Baseline'>);
+			this._lastPriceAnimationPaneView = new SeriesLastPriceAnimationPaneView(this as Series<'Area', HorzScaleItem> | Series<'Line', HorzScaleItem> | Series<'Baseline', HorzScaleItem>);
 		}
 
 		this._recreateFormatter();
@@ -158,7 +159,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 
 		// find range of bars inside range
 		// TODO: make it more optimal
-		let bar: SeriesPlotRow<T> | null;
+		let bar: SeriesPlotRow<T, HorzScaleItem> | null;
 		let lastIndex: TimePointIndex;
 		if (globalLast) {
 			const lastBar = this._data.last();
@@ -198,7 +199,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		};
 	}
 
-	public barColorer(): SeriesBarColorer<T> {
+	public barColorer(): SeriesBarColorer<T, HorzScaleItem> {
 		if (this._barColorerCache !== null) {
 			return this._barColorerCache;
 		}
@@ -238,7 +239,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		this._paneView.update('options');
 	}
 
-	public setData(data: readonly SeriesPlotRow<T>[], updateInfo?: SeriesUpdateInfo): void {
+	public setData(data: readonly SeriesPlotRow<T, HorzScaleItem>[], updateInfo?: SeriesUpdateInfo): void {
 		this._data.setData(data);
 
 		this._recalculateMarkers();
@@ -261,7 +262,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		this.model().lightUpdate();
 	}
 
-	public setMarkers(data: readonly SeriesMarker<TimePoint>[]): void {
+	public setMarkers(data: readonly SeriesMarker<InternalHorzScaleItem, HorzScaleItem>[]): void {
 		this._markers = data;
 		this._recalculateMarkers();
 		const sourcePane = this.model().paneForSource(this);
@@ -272,22 +273,22 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		this.model().lightUpdate();
 	}
 
-	public markers(): readonly SeriesMarker<TimePoint>[] {
+	public markers(): readonly SeriesMarker<InternalHorzScaleItem, HorzScaleItem>[] {
 		return this._markers;
 	}
 
-	public indexedMarkers(): InternalSeriesMarker<TimePointIndex>[] {
+	public indexedMarkers(): InternalSeriesMarker<TimePointIndex, HorzScaleItem>[] {
 		return this._indexedMarkers;
 	}
 
-	public createPriceLine(options: PriceLineOptions): CustomPriceLine {
-		const result = new CustomPriceLine(this, options);
+	public createPriceLine(options: PriceLineOptions): CustomPriceLine<HorzScaleItem> {
+		const result = new CustomPriceLine<HorzScaleItem>(this, options);
 		this._customPriceLines.push(result);
 		this.model().updateSource(this);
 		return result;
 	}
 
-	public removePriceLine(line: CustomPriceLine): void {
+	public removePriceLine(line: CustomPriceLine<HorzScaleItem>): void {
 		const index = this._customPriceLines.indexOf(line);
 		if (index !== -1) {
 			this._customPriceLines.splice(index, 1);
@@ -311,7 +312,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		};
 	}
 
-	public firstBar(): SeriesPlotRow<T> | null {
+	public firstBar(): SeriesPlotRow<T, HorzScaleItem> | null {
 		const visibleBars = this.model().timeScale().visibleStrictRange();
 		if (visibleBars === null) {
 			return null;
@@ -321,7 +322,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		return this._data.search(startTimePoint, MismatchDirection.NearestRight);
 	}
 
-	public bars(): SeriesPlotList<T> {
+	public bars(): SeriesPlotList<T, HorzScaleItem> {
 		return this._data;
 	}
 
@@ -342,7 +343,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		}
 	}
 
-	public topPaneViews(pane: Pane): readonly IPaneView[] {
+	public topPaneViews(pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
 		const animationPaneView = this._lastPriceAnimationPaneView;
 		if (animationPaneView === null || !animationPaneView.visible()) {
 			return [];
@@ -362,8 +363,8 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		return [animationPaneView];
 	}
 
-	public paneViews(): readonly IPaneView[] {
-		const res: IPaneView[] = [];
+	public paneViews(): readonly IPaneView<HorzScaleItem>[] {
+		const res: IPaneView<HorzScaleItem>[] = [];
 
 		if (!this._isOverlay()) {
 			res.push(this._baseHorizontalLineView);
@@ -375,20 +376,20 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 			this._markersPaneView
 		);
 
-		const priceLineViews = this._customPriceLines.map((line: CustomPriceLine) => line.paneView());
+		const priceLineViews = this._customPriceLines.map((line: CustomPriceLine<HorzScaleItem>) => line.paneView());
 		res.push(...priceLineViews);
 
 		return res;
 	}
 
-	public override labelPaneViews(pane?: Pane): readonly IPaneView[] {
+	public override labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
 		return [
 			this._panePriceAxisView,
-			...this._customPriceLines.map((line: CustomPriceLine) => line.labelPaneView()),
+			...this._customPriceLines.map((line: CustomPriceLine<HorzScaleItem>) => line.labelPaneView()),
 		];
 	}
 
-	public override priceAxisViews(pane: Pane, priceScale: PriceScale): readonly IPriceAxisView[] {
+	public override priceAxisViews(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): readonly IPriceAxisView<HorzScaleItem>[] {
 		if (priceScale !== this._priceScale && !this._isOverlay()) {
 			return [];
 		}
@@ -436,7 +437,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		this._lastPriceAnimationPaneView?.update();
 	}
 
-	public override priceScale(): PriceScale {
+	public override priceScale(): PriceScale<HorzScaleItem> {
 		return ensureNotNull(super.priceScale());
 	}
 
@@ -585,7 +586,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 
 		const firstDataIndex = ensureNotNull(this._data.firstIndex());
 
-		this._indexedMarkers = this._markers.map<InternalSeriesMarker<TimePointIndex>>((marker: SeriesMarker<TimePoint>, index: number) => {
+		this._indexedMarkers = this._markers.map<InternalSeriesMarker<TimePointIndex, HorzScaleItem>>((marker: SeriesMarker<InternalHorzScaleItem, HorzScaleItem>, index: number) => {
 			// the first find index on the time scale (across all series)
 			const timePointIndex = ensureNotNull(timeScale.timeToIndex(marker.time, true));
 
@@ -601,6 +602,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 				internalId: index,
 				text: marker.text,
 				size: marker.size,
+				originalTime: marker.originalTime,
 			};
 		});
 	}
@@ -610,32 +612,32 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 
 		switch (this._seriesType) {
 			case 'Bar': {
-				this._paneView = new SeriesBarsPaneView(this as Series<'Bar'>, this.model());
+				this._paneView = new SeriesBarsPaneView(this as Series<'Bar', HorzScaleItem>, this.model());
 				break;
 			}
 
 			case 'Candlestick': {
-				this._paneView = new SeriesCandlesticksPaneView(this as Series<'Candlestick'>, this.model());
+				this._paneView = new SeriesCandlesticksPaneView(this as Series<'Candlestick', HorzScaleItem>, this.model());
 				break;
 			}
 
 			case 'Line': {
-				this._paneView = new SeriesLinePaneView(this as Series<'Line'>, this.model());
+				this._paneView = new SeriesLinePaneView(this as Series<'Line', HorzScaleItem>, this.model());
 				break;
 			}
 
 			case 'Area': {
-				this._paneView = new SeriesAreaPaneView(this as Series<'Area'>, this.model());
+				this._paneView = new SeriesAreaPaneView(this as Series<'Area', HorzScaleItem>, this.model());
 				break;
 			}
 
 			case 'Baseline': {
-				this._paneView = new SeriesBaselinePaneView(this as Series<'Baseline'>, this.model());
+				this._paneView = new SeriesBaselinePaneView(this as Series<'Baseline', HorzScaleItem>, this.model());
 				break;
 			}
 
 			case 'Histogram': {
-				this._paneView = new SeriesHistogramPaneView(this as Series<'Histogram'>, this.model());
+				this._paneView = new SeriesHistogramPaneView(this as Series<'Histogram', HorzScaleItem>, this.model());
 				break;
 			}
 
diff --git a/src/model/sort-sources.ts b/src/model/sort-sources.ts
index 28bf853e2b..aebd918b62 100644
--- a/src/model/sort-sources.ts
+++ b/src/model/sort-sources.ts
@@ -2,8 +2,8 @@ import { ensureNotNull } from '../helpers/assertions';
 
 import { IDataSource } from './idata-source';
 
-export function sortSources<T extends IDataSource>(sources: readonly T[]): T[] {
-	return sources.slice().sort((s1: IDataSource, s2: IDataSource) => {
+export function sortSources<HorzScaleItem, T extends IDataSource<HorzScaleItem>>(sources: readonly T[]): T[] {
+	return sources.slice().sort((s1: IDataSource<HorzScaleItem>, s2: IDataSource<HorzScaleItem>) => {
 		return (ensureNotNull(s1.zorder()) - ensureNotNull(s2.zorder()));
 	});
 }
diff --git a/src/model/tick-marks.ts b/src/model/tick-marks.ts
index 2549d849b0..5fa7d0c62a 100644
--- a/src/model/tick-marks.ts
+++ b/src/model/tick-marks.ts
@@ -1,25 +1,32 @@
 import { lowerbound } from '../helpers/algorithms';
 import { ensureDefined } from '../helpers/assertions';
 
-import { OriginalTime, TickMarkWeight, TimePoint, TimePointIndex, TimeScalePoint } from './time-data';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
+import { TickMarkWeightValue, TimePointIndex, TimeScalePoint } from './time-data';
 
-export interface TickMark {
+export interface TickMark<HorzScaleItem> {
 	index: TimePointIndex;
-	time: TimePoint;
-	weight: TickMarkWeight;
-	originalTime: OriginalTime;
+	time: InternalHorzScaleItem;
+	weight: TickMarkWeightValue;
+	originalTime: HorzScaleItem;
 }
 
-interface MarksCache {
+interface MarksCache<HorzScaleItem> {
 	maxIndexesPerMark: number;
-	marks: readonly TickMark[];
+	marks: readonly TickMark<HorzScaleItem>[];
 }
 
-export class TickMarks {
-	private _marksByWeight: Map<TickMarkWeight, TickMark[]> = new Map();
-	private _cache: MarksCache | null = null;
+export class TickMarks<HorzScaleItem> {
+	private _marksByWeight: Map<TickMarkWeightValue, TickMark<HorzScaleItem>[]> = new Map();
+	private _cache: MarksCache<HorzScaleItem> | null = null;
+	private _uniformDistribution: boolean = false;
 
-	public setTimeScalePoints(newPoints: readonly TimeScalePoint[], firstChangedPointIndex: number): void {
+	public setUniformDistribution(val: boolean): void {
+		this._uniformDistribution = val;
+		this._cache = null;
+	}
+
+	public setTimeScalePoints(newPoints: readonly TimeScalePoint<HorzScaleItem>[], firstChangedPointIndex: number): void {
 		this._removeMarksSinceIndex(firstChangedPointIndex);
 
 		this._cache = null;
@@ -41,7 +48,7 @@ export class TickMarks {
 		}
 	}
 
-	public build(spacing: number, maxWidth: number): readonly TickMark[] {
+	public build(spacing: number, maxWidth: number): readonly TickMark<HorzScaleItem>[] {
 		const maxIndexesPerMark = Math.ceil(maxWidth / spacing);
 		if (this._cache === null || this._cache.maxIndexesPerMark !== maxIndexesPerMark) {
 			this._cache = {
@@ -59,14 +66,14 @@ export class TickMarks {
 			return;
 		}
 
-		const weightsToClear: TickMarkWeight[] = [];
+		const weightsToClear: TickMarkWeightValue[] = [];
 
-		this._marksByWeight.forEach((marks: TickMark[], timeWeight: number) => {
+		this._marksByWeight.forEach((marks: TickMark<HorzScaleItem>[], timeWeight: TickMarkWeightValue) => {
 			if (sinceIndex <= marks[0].index) {
 				weightsToClear.push(timeWeight);
 			} else {
 				marks.splice(
-					lowerbound(marks, sinceIndex, (tm: TickMark) => tm.index < sinceIndex),
+					lowerbound(marks, sinceIndex, (tm: TickMark<HorzScaleItem>) => tm.index < sinceIndex),
 					Infinity
 				);
 			}
@@ -77,8 +84,8 @@ export class TickMarks {
 		}
 	}
 
-	private _buildMarksImpl(maxIndexesPerMark: number): readonly TickMark[] {
-		let marks: TickMark[] = [];
+	private _buildMarksImpl(maxIndexesPerMark: number): readonly TickMark<HorzScaleItem>[] {
+		let marks: TickMark<HorzScaleItem>[] = [];
 
 		for (const weight of Array.from(this._marksByWeight.keys()).sort((a: number, b: number) => b - a)) {
 			if (!this._marksByWeight.get(weight)) {
@@ -120,6 +127,10 @@ export class TickMarks {
 					// TickMark fits. Place it into new array
 					marks.push(mark);
 					leftIndex = currentIndex;
+				} else {
+					if (this._uniformDistribution) {
+						return prevMarks;
+					}
 				}
 			}
 
diff --git a/src/model/time-data.ts b/src/model/time-data.ts
index 17a7753af5..bb7c75f013 100644
--- a/src/model/time-data.ts
+++ b/src/model/time-data.ts
@@ -2,95 +2,15 @@ import { lowerbound, upperbound } from '../helpers/algorithms';
 import { Nominal } from '../helpers/nominal';
 
 import { Coordinate } from './coordinate';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { RangeImpl } from './range-impl';
 
-/**
- * Represents a time as a UNIX timestamp.
- *
- * If your chart displays an intraday interval you should use a UNIX Timestamp.
- *
- * Note that JavaScript Date APIs like `Date.now` return a number of milliseconds but UTCTimestamp expects a number of seconds.
- *
- * Note that to prevent errors, you should cast the numeric type of the time to `UTCTimestamp` type from the package (`value as UTCTimestamp`) in TypeScript code.
- *
- * @example
- * ```ts
- * const timestamp = 1529899200 as UTCTimestamp; // Literal timestamp representing 2018-06-25T04:00:00.000Z
- * const timestamp2 = (Date.now() / 1000) as UTCTimestamp;
- * ```
- */
-export type UTCTimestamp = Nominal<number, 'UTCTimestamp'>;
-
-/**
- * Represents a time as a day/month/year.
- *
- * @example
- * ```js
- * const day = { year: 2019, month: 6, day: 1 }; // June 1, 2019
- * ```
- */
-export interface BusinessDay {
-	/**
-	 * The year.
-	 */
-	year: number;
-	/**
-	 * The month.
-	 */
-	month: number;
-	/**
-	 * The day.
-	 */
-	day: number;
-}
-
-/**
- * The Time type is used to represent the time of data items.
- *
- * Values can be a {@link UTCTimestamp}, a {@link BusinessDay}, or a business day string in ISO format.
- *
- * @example
- * ```js
- * const timestamp = 1529899200; // Literal timestamp representing 2018-06-25T04:00:00.000Z
- * const businessDay = { year: 2019, month: 6, day: 1 }; // June 1, 2019
- * const businessDayString = '2021-02-03'; // Business day string literal
- * ```
- */
-export type Time = UTCTimestamp | BusinessDay | string;
-
-export type OriginalTime = Nominal<unknown, 'OriginalTime'>;
-
-export interface TimePoint {
-	timestamp: UTCTimestamp;
-	businessDay?: BusinessDay;
-}
-
-/**
- * Describes a weight of tick mark, i.e. a part of a time that changed since previous time.
- * Note that you can use any timezone to calculate this value, it is unnecessary to use UTC.
- *
- * @example Between 2020-01-01 and 2020-01-02 there is a day of difference, i.e. for 2020-01-02 weight would be a day.
- * @example Between 2020-01-01 and 2020-02-02 there is a month of difference, i.e. for 2020-02-02 weight would be a month.
- */
-export const enum TickMarkWeight {
-	LessThanSecond = 0,
-	Second = 10,
-	Minute1 = 20,
-	Minute5 = 21,
-	Minute30 = 22,
-	Hour1 = 30,
-	Hour3 = 31,
-	Hour6 = 32,
-	Hour12 = 33,
-	Day = 50,
-	Month = 60,
-	Year = 70,
-}
+export type TickMarkWeightValue = Nominal<number, 'TickMarkWeightValue'>;
 
-export interface TimeScalePoint {
-	readonly timeWeight: TickMarkWeight;
-	readonly time: TimePoint;
-	readonly originalTime: OriginalTime;
+export interface TimeScalePoint<HorzScaleItem> {
+	readonly timeWeight: TickMarkWeightValue;
+	readonly time: InternalHorzScaleItem;
+	readonly originalTime: HorzScaleItem;
 }
 
 /**
@@ -107,7 +27,7 @@ export interface Range<T> {
 	to: T;
 }
 
-export type TimePointsRange = Range<TimePoint>;
+export type TimePointsRange = Range<InternalHorzScaleItem>;
 
 export type TimePointIndex = Nominal<number, 'TimePointIndex'>;
 
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index d40e7f9a5f..9ca7ebf230 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -1,6 +1,3 @@
-import { DateFormatter } from '../formatters/date-formatter';
-import { DateTimeFormatter } from '../formatters/date-time-formatter';
-
 import { lowerbound } from '../helpers/algorithms';
 import { ensureNotNull } from '../helpers/assertions';
 import { Delegate } from '../helpers/delegate';
@@ -10,8 +7,9 @@ import { DeepPartial, isInteger, merge } from '../helpers/strict-type-checks';
 
 import { ChartModel } from './chart-model';
 import { Coordinate } from './coordinate';
-import { defaultTickMarkFormatter } from './default-tick-mark-formatter';
+// import { defaultTickMarkFormatter } from './default-tick-mark-formatter';
 import { FormattedLabelsCache } from './formatted-labels-cache';
+import { IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from './ihorz-scale-behavior';
 import { LocalizationOptions } from './localization-options';
 import { areRangesEqual, RangeImpl } from './range-impl';
 import { TickMark, TickMarks } from './tick-marks';
@@ -19,14 +17,11 @@ import {
 	Logical,
 	LogicalRange,
 	SeriesItemsIndexesRange,
-	TickMarkWeight,
-	Time,
+	TickMarkWeightValue,
 	TimedValue,
-	TimePoint,
 	TimePointIndex,
 	TimePointsRange,
 	TimeScalePoint,
-	UTCTimestamp,
 } from './time-data';
 import { TimeScaleVisibleRange } from './time-scale-visible-range';
 
@@ -45,55 +40,13 @@ export interface TimeMark {
 	needAlignCoordinate: boolean;
 	coord: number;
 	label: string;
-	weight: TickMarkWeight;
+	weight: TickMarkWeightValue;
 }
 
-/**
- * Represents the type of a tick mark on the time axis.
- */
-export const enum TickMarkType {
-	/**
-	 * The start of the year (e.g. it's the first tick mark in a year).
-	 */
-	Year,
-	/**
-	 * The start of the month (e.g. it's the first tick mark in a month).
-	 */
-	Month,
-	/**
-	 * A day of the month.
-	 */
-	DayOfMonth,
-	/**
-	 * A time without seconds.
-	 */
-	// eslint-disable-next-line @typescript-eslint/no-shadow
-	Time,
-	/**
-	 * A time with seconds.
-	 */
-	TimeWithSeconds,
+export function markWithGreaterWeight(a: TimeMark, b: TimeMark): TimeMark {
+	return a.weight > b.weight ? a : b;
 }
 
-/**
- * The `TickMarkFormatter` is used to customize tick mark labels on the time scale.
- *
- * This function should return `time` as a string formatted according to `tickMarkType` type (year, month, etc) and `locale`.
- *
- * Note that the returned string should be the shortest possible value and should have no more than 8 characters.
- * Otherwise, the tick marks will overlap each other.
- *
- * If the formatter function returns `null` then the default tick mark formatter will be used as a fallback.
- *
- * @example
- * ```js
- * const customFormatter = (time, tickMarkType, locale) => {
- *     // your code here
- * };
- * ```
- */
-export type TickMarkFormatter = (time: Time, tickMarkType: TickMarkType, locale: string) => string | null;
-
 /**
  * Options for the time scale; the horizontal scale at the bottom of the chart that displays the time of data.
  */
@@ -191,37 +144,30 @@ export interface TimeScaleOptions {
 	 */
 	shiftVisibleRangeOnNewBar: boolean;
 
-	/**
-	 * Tick marks formatter can be used to customize tick marks labels on the time axis.
-	 *
-	 * @defaultValue `undefined`
-	 */
-	tickMarkFormatter?: TickMarkFormatter;
-
 	/**
 	 * Draw small vertical line on time axis labels.
 	 *
 	 * @defaultValue `false`
 	 */
 	ticksVisible: boolean;
+
+	uniformDistribution: boolean;
 }
 
-export class TimeScale {
+export class TimeScale<HorzScaleItem> {
 	private readonly _options: TimeScaleOptions;
-	private readonly _model: ChartModel;
-	private readonly _localizationOptions: LocalizationOptions;
-
-	private _dateTimeFormatter!: DateFormatter | DateTimeFormatter;
+	private readonly _model: ChartModel<HorzScaleItem>;
+	private readonly _localizationOptions: LocalizationOptions<HorzScaleItem>;
 
 	private _width: number = 0;
 	private _baseIndexOrNull: TimePointIndex | null = null;
 	private _rightOffset: number;
-	private _points: readonly TimeScalePoint[] = [];
+	private _points: readonly TimeScalePoint<HorzScaleItem>[] = [];
 	private _barSpacing: number;
 	private _scrollStartPoint: Coordinate | null = null;
 	private _scaleStartPoint: Coordinate | null = null;
-	private readonly _tickMarks: TickMarks = new TickMarks();
-	private _formattedByWeight: Map<number, FormattedLabelsCache> = new Map();
+	private readonly _tickMarks: TickMarks<HorzScaleItem> = new TickMarks();
+	private _formattedByWeight: Map<number, FormattedLabelsCache<HorzScaleItem>> = new Map();
 
 	private _visibleRange: TimeScaleVisibleRange = TimeScaleVisibleRange.invalid();
 	private _visibleRangeInvalidated: boolean = true;
@@ -235,28 +181,34 @@ export class TimeScale {
 
 	private _labels: TimeMark[] = [];
 
-	public constructor(model: ChartModel, options: TimeScaleOptions, localizationOptions: LocalizationOptions) {
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(model: ChartModel<HorzScaleItem>, options: TimeScaleOptions, localizationOptions: LocalizationOptions<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
 		this._options = options;
 		this._localizationOptions = localizationOptions;
 		this._rightOffset = options.rightOffset;
 		this._barSpacing = options.barSpacing;
 		this._model = model;
 
+		this._horzScaleBehavior = horzScaleBehavior;
+
 		this._updateDateTimeFormatter();
+
+		this._tickMarks.setUniformDistribution(options.uniformDistribution);
 	}
 
 	public options(): Readonly<TimeScaleOptions> {
 		return this._options;
 	}
 
-	public applyLocalizationOptions(localizationOptions: DeepPartial<LocalizationOptions>): void {
+	public applyLocalizationOptions(localizationOptions: DeepPartial<LocalizationOptions<HorzScaleItem>>): void {
 		merge(this._localizationOptions, localizationOptions);
 
 		this._invalidateTickMarks();
 		this._updateDateTimeFormatter();
 	}
 
-	public applyOptions(options: DeepPartial<TimeScaleOptions>, localizationOptions?: DeepPartial<LocalizationOptions>): void {
+	public applyOptions(options: DeepPartial<TimeScaleOptions>, localizationOptions?: DeepPartial<LocalizationOptions<HorzScaleItem>>): void {
 		merge(this._options, options);
 
 		if (this._options.fixLeftEdge) {
@@ -289,28 +241,28 @@ export class TimeScale {
 		this._optionsApplied.fire();
 	}
 
-	public indexToTime(index: TimePointIndex): TimePoint | null {
+	public indexToTime(index: TimePointIndex): InternalHorzScaleItem | null {
 		return this._points[index]?.time ?? null;
 	}
 
-	public indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint | null {
+	public indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint<HorzScaleItem> | null {
 		return this._points[index] ?? null;
 	}
 
-	public timeToIndex(time: TimePoint, findNearest: boolean): TimePointIndex | null {
+	public timeToIndex(time: InternalHorzScaleItem, findNearest: boolean): TimePointIndex | null {
 		if (this._points.length < 1) {
 			// no time points available
 			return null;
 		}
 
-		if (time.timestamp > this._points[this._points.length - 1].time.timestamp) {
+		if (this._horzScaleBehavior.key(time) > this._horzScaleBehavior.key(this._points[this._points.length - 1].time)) {
 			// special case
 			return findNearest ? this._points.length - 1 as TimePointIndex : null;
 		}
 
-		const index = lowerbound(this._points, time.timestamp, (a: TimeScalePoint, b: UTCTimestamp) => a.time.timestamp < b);
+		const index = lowerbound(this._points, this._horzScaleBehavior.key(time), (a: TimeScalePoint<HorzScaleItem>, b: InternalHorzScaleItemKey) => this._horzScaleBehavior.key(a.time) < b);
 
-		if (time.timestamp < this._points[index].time.timestamp) {
+		if (this._horzScaleBehavior.key(time) < this._horzScaleBehavior.key(this._points[index].time)) {
 			return findNearest ? index as TimePointIndex : null;
 		}
 
@@ -358,8 +310,8 @@ export class TimeScale {
 		const lastIndex = ensureNotNull(this._lastIndex());
 
 		return {
-			from: ensureNotNull(this.indexToTime(Math.max(firstIndex, from) as TimePointIndex) as TimePoint),
-			to: ensureNotNull(this.indexToTime(Math.min(lastIndex, to) as TimePointIndex) as TimePoint),
+			from: ensureNotNull(this.indexToTime(Math.max(firstIndex, from) as TimePointIndex)),
+			to: ensureNotNull(this.indexToTime(Math.min(lastIndex, to) as TimePointIndex)),
 		};
 	}
 
@@ -687,7 +639,7 @@ export class TimeScale {
 		});
 	}
 
-	public update(newPoints: readonly TimeScalePoint[], firstChangedPointIndex: number): void {
+	public update(newPoints: readonly TimeScalePoint<HorzScaleItem>[], firstChangedPointIndex: number): void {
 		this._visibleRangeInvalidated = true;
 
 		this._points = newPoints;
@@ -743,12 +695,12 @@ export class TimeScale {
 		this.setVisibleRange(barRange);
 	}
 
-	public formatDateTime(timeScalePoint: TimeScalePoint): string {
+	public formatDateTime(timeScalePoint: TimeScalePoint<HorzScaleItem>): string {
 		if (this._localizationOptions.timeFormatter !== undefined) {
-			return this._localizationOptions.timeFormatter(timeScalePoint.originalTime as unknown as Time);
+			return this._localizationOptions.timeFormatter(timeScalePoint.originalTime as unknown as HorzScaleItem);
 		}
 
-		return this._dateTimeFormatter.format(new Date(timeScalePoint.time.timestamp * 1000));
+		return this._horzScaleBehavior.formatHorzItem(timeScalePoint.time);
 	}
 
 	private _isAllScalingAndScrollingDisabled(): boolean {
@@ -894,12 +846,14 @@ export class TimeScale {
 		this._commonTransitionStartState = null;
 	}
 
-	private _formatLabel(tickMark: TickMark): string {
+	private _formatLabel(tickMark: TickMark<HorzScaleItem>): string {
 		let formatter = this._formattedByWeight.get(tickMark.weight);
 		if (formatter === undefined) {
-			formatter = new FormattedLabelsCache((mark: TickMark) => {
-				return this._formatLabelImpl(mark);
-			});
+			formatter = new FormattedLabelsCache(
+				(mark: TickMark<HorzScaleItem>) => {
+					return this._formatLabelImpl(mark);
+				},
+				this._horzScaleBehavior);
 
 			this._formattedByWeight.set(tickMark.weight, formatter);
 		}
@@ -907,21 +861,8 @@ export class TimeScale {
 		return formatter.format(tickMark);
 	}
 
-	private _formatLabelImpl(tickMark: TickMark): string {
-		const tickMarkType = weightToTickMarkType(tickMark.weight, this._options.timeVisible, this._options.secondsVisible);
-
-		if (this._options.tickMarkFormatter !== undefined) {
-			const tickMarkString = this._options.tickMarkFormatter(
-				tickMark.originalTime as unknown as Time,
-				tickMarkType,
-				this._localizationOptions.locale
-			);
-			if (tickMarkString !== null) {
-				return tickMarkString;
-			}
-		}
-
-		return defaultTickMarkFormatter(tickMark.time, tickMarkType, this._localizationOptions.locale);
+	private _formatLabelImpl(tickMark: TickMark<HorzScaleItem>): string {
+		return this._horzScaleBehavior.formatTickmark(tickMark, this._localizationOptions);
 	}
 
 	private _setVisibleRange(newVisibleRange: TimeScaleVisibleRange): void {
@@ -950,18 +891,7 @@ export class TimeScale {
 	}
 
 	private _updateDateTimeFormatter(): void {
-		const dateFormat = this._localizationOptions.dateFormat;
-
-		if (this._options.timeVisible) {
-			this._dateTimeFormatter = new DateTimeFormatter({
-				dateFormat: dateFormat,
-				timeFormat: this._options.secondsVisible ? '%h:%m:%s' : '%h:%m',
-				dateTimeSeparator: '   ',
-				locale: this._localizationOptions.locale,
-			});
-		} else {
-			this._dateTimeFormatter = new DateFormatter(dateFormat, this._localizationOptions.locale);
-		}
+		this._horzScaleBehavior.updateFormatter(this._localizationOptions);
 	}
 
 	private _doFixLeftEdge(): void {
@@ -994,32 +924,3 @@ export class TimeScale {
 		this._correctBarSpacing();
 	}
 }
-
-// eslint-disable-next-line complexity
-function weightToTickMarkType(weight: TickMarkWeight, timeVisible: boolean, secondsVisible: boolean): TickMarkType {
-	switch (weight) {
-		case TickMarkWeight.LessThanSecond:
-		case TickMarkWeight.Second:
-			return timeVisible
-				? (secondsVisible ? TickMarkType.TimeWithSeconds : TickMarkType.Time)
-				: TickMarkType.DayOfMonth;
-
-		case TickMarkWeight.Minute1:
-		case TickMarkWeight.Minute5:
-		case TickMarkWeight.Minute30:
-		case TickMarkWeight.Hour1:
-		case TickMarkWeight.Hour3:
-		case TickMarkWeight.Hour6:
-		case TickMarkWeight.Hour12:
-			return timeVisible ? TickMarkType.Time : TickMarkType.DayOfMonth;
-
-		case TickMarkWeight.Day:
-			return TickMarkType.DayOfMonth;
-
-		case TickMarkWeight.Month:
-			return TickMarkType.Month;
-
-		case TickMarkWeight.Year:
-			return TickMarkType.Year;
-	}
-}
diff --git a/src/model/watermark.ts b/src/model/watermark.ts
index 1146379386..848dc688b2 100644
--- a/src/model/watermark.ts
+++ b/src/model/watermark.ts
@@ -65,21 +65,21 @@ export interface WatermarkOptions {
 	vertAlign: VertAlign;
 }
 
-export class Watermark extends DataSource {
-	private readonly _paneView: WatermarkPaneView;
+export class Watermark<HorzScaleItem> extends DataSource<HorzScaleItem> {
+	private readonly _paneView: WatermarkPaneView<HorzScaleItem>;
 	private readonly _options: WatermarkOptions;
 
-	public constructor(model: ChartModel, options: WatermarkOptions) {
+	public constructor(model: ChartModel<HorzScaleItem>, options: WatermarkOptions) {
 		super();
 		this._options = options;
 		this._paneView = new WatermarkPaneView(this);
 	}
 
-	public override priceAxisViews(): readonly IPriceAxisView[] {
+	public override priceAxisViews(): readonly IPriceAxisView<HorzScaleItem>[] {
 		return [];
 	}
 
-	public paneViews(): readonly IPaneView[] {
+	public paneViews(): readonly IPaneView<HorzScaleItem>[] {
 		return [this._paneView];
 	}
 
diff --git a/src/renderers/itime-axis-view-renderer.ts b/src/renderers/itime-axis-view-renderer.ts
index ee71da0417..80b3521346 100644
--- a/src/renderers/itime-axis-view-renderer.ts
+++ b/src/renderers/itime-axis-view-renderer.ts
@@ -15,6 +15,6 @@ export interface TimeAxisViewRendererOptions {
 	labelBottomOffset: number;
 }
 
-export interface ITimeAxisViewRenderer {
+export interface ITimeAxisViewRenderer<HorzScaleItem> {
 	draw(target: CanvasRenderingTarget2D, rendererOptions: TimeAxisViewRendererOptions): void;
 }
diff --git a/src/renderers/price-axis-renderer-options-provider.ts b/src/renderers/price-axis-renderer-options-provider.ts
index cd8aeb4117..43daf22357 100644
--- a/src/renderers/price-axis-renderer-options-provider.ts
+++ b/src/renderers/price-axis-renderer-options-provider.ts
@@ -9,8 +9,8 @@ const enum RendererConstants {
 	TickLength = 5,
 }
 
-export class PriceAxisRendererOptionsProvider {
-	private readonly _chartModel: ChartModel;
+export class PriceAxisRendererOptionsProvider<HorzScaleItem> {
+	private readonly _chartModel: ChartModel<HorzScaleItem>;
 
 	private readonly _rendererOptions: PriceAxisViewRendererOptions = {
 		borderSize: RendererConstants.BorderSize,
@@ -27,7 +27,7 @@ export class PriceAxisRendererOptionsProvider {
 		baselineOffset: 0,
 	};
 
-	public constructor(chartModel: ChartModel) {
+	public constructor(chartModel: ChartModel<HorzScaleItem>) {
 		this._chartModel = chartModel;
 	}
 
diff --git a/src/renderers/time-axis-view-renderer.ts b/src/renderers/time-axis-view-renderer.ts
index 788835cc0e..f196574a84 100644
--- a/src/renderers/time-axis-view-renderer.ts
+++ b/src/renderers/time-axis-view-renderer.ts
@@ -18,7 +18,7 @@ const optimizationReplacementRe = /[1-9]/g;
 
 const radius = 2;
 
-export class TimeAxisViewRenderer implements ITimeAxisViewRenderer {
+export class TimeAxisViewRenderer<HorzScaleItem> implements ITimeAxisViewRenderer<HorzScaleItem> {
 	private _data: TimeAxisViewRendererData | null;
 
 	public constructor() {
diff --git a/src/views/pane/area-pane-view.ts b/src/views/pane/area-pane-view.ts
index 6593abb213..11ef7fdff2 100644
--- a/src/views/pane/area-pane-view.ts
+++ b/src/views/pane/area-pane-view.ts
@@ -9,17 +9,17 @@ import { LineStrokeItem, PaneRendererLine } from '../../renderers/line-renderer'
 
 import { LinePaneViewBase } from './line-pane-view-base';
 
-export class SeriesAreaPaneView extends LinePaneViewBase<'Area', AreaFillItem & LineStrokeItem, CompositeRenderer> {
+export class SeriesAreaPaneView<HorzScaleItem> extends LinePaneViewBase<'Area', AreaFillItem & LineStrokeItem, CompositeRenderer, HorzScaleItem> {
 	protected readonly _renderer: CompositeRenderer = new CompositeRenderer();
 	private readonly _areaRenderer: PaneRendererArea = new PaneRendererArea();
 	private readonly _lineRenderer: PaneRendererLine = new PaneRendererLine();
 
-	public constructor(series: Series<'Area'>, model: ChartModel) {
+	public constructor(series: Series<'Area', HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
 		super(series, model);
 		this._renderer.setRenderers([this._areaRenderer, this._lineRenderer]);
 	}
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Area'>): AreaFillItem & LineStrokeItem {
+	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Area', HorzScaleItem>): AreaFillItem & LineStrokeItem {
 		return {
 			...this._createRawItemBase(time, price),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/bars-pane-view-base.ts b/src/views/pane/bars-pane-view-base.ts
index 07a8fc317a..9a2abae5d9 100644
--- a/src/views/pane/bars-pane-view-base.ts
+++ b/src/views/pane/bars-pane-view-base.ts
@@ -15,19 +15,19 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { SeriesPaneViewBase } from './series-pane-view-base';
 
-export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick', ItemType extends BarCandlestickItemBase, TRenderer extends IPaneRenderer> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer> {
-	public constructor(series: Series<TSeriesType>, model: ChartModel) {
+export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick', ItemType extends BarCandlestickItemBase, TRenderer extends IPaneRenderer, HorzScaleItem> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer, HorzScaleItem> {
+	public constructor(series: Series<TSeriesType, HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
 		super(series, model, false);
 	}
 
-	protected _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale, firstValue: number): void {
+	protected _convertToCoordinates(priceScale: PriceScale<HorzScaleItem>, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void {
 		timeScale.indexesToCoordinates(this._items, undefinedIfNull(this._itemsVisibleRange));
 		priceScale.barPricesToCoordinates(this._items, firstValue, undefinedIfNull(this._itemsVisibleRange));
 	}
 
-	protected abstract _createRawItem(time: TimePointIndex, bar: SeriesPlotRow, colorer: SeriesBarColorer<TSeriesType>): ItemType;
+	protected abstract _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType, HorzScaleItem>, colorer: SeriesBarColorer<TSeriesType, HorzScaleItem>): ItemType;
 
-	protected _createDefaultItem(time: TimePointIndex, bar: SeriesPlotRow, colorer: SeriesBarColorer<TSeriesType>): BarCandlestickItemBase {
+	protected _createDefaultItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType, HorzScaleItem>, colorer: SeriesBarColorer<TSeriesType, HorzScaleItem>): BarCandlestickItemBase {
 		return {
 			time: time,
 			open: bar.value[PlotRowValueIndex.Open] as BarPrice,
@@ -45,6 +45,6 @@ export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick'
 	protected _fillRawPoints(): void {
 		const colorer = this._series.barColorer();
 
-		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType>) => this._createRawItem(row.index, row, colorer));
+		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType, HorzScaleItem>) => this._createRawItem(row.index, row, colorer));
 	}
 }
diff --git a/src/views/pane/bars-pane-view.ts b/src/views/pane/bars-pane-view.ts
index 9938415186..31b4793aba 100644
--- a/src/views/pane/bars-pane-view.ts
+++ b/src/views/pane/bars-pane-view.ts
@@ -1,5 +1,6 @@
 import { SeriesBarColorer } from '../../model/series-bar-colorer';
 import { SeriesPlotRow } from '../../model/series-data';
+import { SeriesType } from '../../model/series-options';
 import { TimePointIndex } from '../../model/time-data';
 import {
 	BarItem,
@@ -8,10 +9,10 @@ import {
 
 import { BarsPaneViewBase } from './bars-pane-view-base';
 
-export class SeriesBarsPaneView extends BarsPaneViewBase<'Bar', BarItem, PaneRendererBars> {
+export class SeriesBarsPaneView<HorzScaleItem> extends BarsPaneViewBase<'Bar', BarItem, PaneRendererBars, HorzScaleItem> {
 	protected readonly _renderer: PaneRendererBars = new PaneRendererBars();
 
-	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow, colorer: SeriesBarColorer<'Bar'>): BarItem {
+	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<SeriesType, HorzScaleItem>, colorer: SeriesBarColorer<'Bar', HorzScaleItem>): BarItem {
 		return {
 			...this._createDefaultItem(time, bar, colorer),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/baseline-pane-view.ts b/src/views/pane/baseline-pane-view.ts
index f14fb7d16f..03aaaa286e 100644
--- a/src/views/pane/baseline-pane-view.ts
+++ b/src/views/pane/baseline-pane-view.ts
@@ -9,17 +9,17 @@ import { CompositeRenderer } from '../../renderers/composite-renderer';
 
 import { LinePaneViewBase } from './line-pane-view-base';
 
-export class SeriesBaselinePaneView extends LinePaneViewBase<'Baseline', BaselineFillItem & BaselineStrokeItem, CompositeRenderer> {
+export class SeriesBaselinePaneView<HorzScaleItem> extends LinePaneViewBase<'Baseline', BaselineFillItem & BaselineStrokeItem, CompositeRenderer, HorzScaleItem> {
 	protected readonly _renderer: CompositeRenderer = new CompositeRenderer();
 	private readonly _baselineAreaRenderer: PaneRendererBaselineArea = new PaneRendererBaselineArea();
 	private readonly _baselineLineRenderer: PaneRendererBaselineLine = new PaneRendererBaselineLine();
 
-	public constructor(series: Series<'Baseline'>, model: ChartModel) {
+	public constructor(series: Series<'Baseline', HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
 		super(series, model);
 		this._renderer.setRenderers([this._baselineAreaRenderer, this._baselineLineRenderer]);
 	}
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Baseline'>): BaselineFillItem & BaselineStrokeItem {
+	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Baseline', HorzScaleItem>): BaselineFillItem & BaselineStrokeItem {
 		return {
 			...this._createRawItemBase(time, price),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/candlesticks-pane-view.ts b/src/views/pane/candlesticks-pane-view.ts
index 6b4c2ce3e4..d606ac3f98 100644
--- a/src/views/pane/candlesticks-pane-view.ts
+++ b/src/views/pane/candlesticks-pane-view.ts
@@ -8,10 +8,10 @@ import {
 
 import { BarsPaneViewBase } from './bars-pane-view-base';
 
-export class SeriesCandlesticksPaneView extends BarsPaneViewBase<'Candlestick', CandlestickItem, PaneRendererCandlesticks> {
+export class SeriesCandlesticksPaneView<HorzScaleItem> extends BarsPaneViewBase<'Candlestick', CandlestickItem, PaneRendererCandlesticks, HorzScaleItem> {
 	protected readonly _renderer: PaneRendererCandlesticks = new PaneRendererCandlesticks();
 
-	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow, colorer: SeriesBarColorer<'Candlestick'>): CandlestickItem {
+	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<'Candlestick', HorzScaleItem>, colorer: SeriesBarColorer<'Candlestick', HorzScaleItem>): CandlestickItem {
 		return {
 			...this._createDefaultItem(time, bar, colorer),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/crosshair-marks-pane-view.ts b/src/views/pane/crosshair-marks-pane-view.ts
index 8a307d9027..7ee1525770 100644
--- a/src/views/pane/crosshair-marks-pane-view.ts
+++ b/src/views/pane/crosshair-marks-pane-view.ts
@@ -5,6 +5,7 @@ import { ChartModel } from '../../model/chart-model';
 import { Coordinate } from '../../model/coordinate';
 import { Crosshair } from '../../model/crosshair';
 import { Series } from '../../model/series';
+import { SeriesType } from '../../model/series-options';
 import { SeriesItemsIndexesRange, TimePointIndex } from '../../model/time-data';
 import { CompositeRenderer } from '../../renderers/composite-renderer';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
@@ -30,15 +31,15 @@ function createEmptyMarkerData(): MarksRendererData {
 
 const rangeForSinglePoint: SeriesItemsIndexesRange = { from: 0, to: 1 };
 
-export class CrosshairMarksPaneView implements IUpdatablePaneView {
-	private readonly _chartModel: ChartModel;
-	private readonly _crosshair: Crosshair;
+export class CrosshairMarksPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+	private readonly _chartModel: ChartModel<HorzScaleItem>;
+	private readonly _crosshair: Crosshair<HorzScaleItem>;
 	private readonly _compositeRenderer: CompositeRenderer = new CompositeRenderer();
 	private _markersRenderers: PaneRendererMarks[] = [];
 	private _markersData: MarksRendererData[] = [];
 	private _invalidated: boolean = true;
 
-	public constructor(chartModel: ChartModel, crosshair: Crosshair) {
+	public constructor(chartModel: ChartModel<HorzScaleItem>, crosshair: Crosshair<HorzScaleItem>) {
 		this._chartModel = chartModel;
 		this._crosshair = crosshair;
 		this._compositeRenderer.setRenderers(this._markersRenderers);
@@ -73,7 +74,7 @@ export class CrosshairMarksPaneView implements IUpdatablePaneView {
 		const timePointIndex = this._crosshair.appliedIndex();
 		const timeScale = this._chartModel.timeScale();
 
-		serieses.forEach((s: Series, index: number) => {
+		serieses.forEach((s: Series<SeriesType, HorzScaleItem>, index: number) => {
 			const data = this._markersData[index];
 			const seriesData = s.markerDataAtIndex(timePointIndex);
 
diff --git a/src/views/pane/crosshair-pane-view.ts b/src/views/pane/crosshair-pane-view.ts
index bb96748fe4..0448ac162c 100644
--- a/src/views/pane/crosshair-pane-view.ts
+++ b/src/views/pane/crosshair-pane-view.ts
@@ -6,9 +6,9 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IPaneView } from './ipane-view';
 
-export class CrosshairPaneView implements IPaneView {
+export class CrosshairPaneView<HorzScaleItem> implements IPaneView<HorzScaleItem> {
 	private _invalidated: boolean = true;
-	private readonly _source: Crosshair;
+	private readonly _source: Crosshair<HorzScaleItem>;
 	private readonly _rendererData: CrosshairRendererData = {
 		vertLine: {
 			lineWidth: 1,
@@ -27,7 +27,7 @@ export class CrosshairPaneView implements IPaneView {
 	};
 	private _renderer: CrosshairRenderer = new CrosshairRenderer(this._rendererData);
 
-	public constructor(source: Crosshair) {
+	public constructor(source: Crosshair<HorzScaleItem>) {
 		this._source = source;
 	}
 
diff --git a/src/views/pane/custom-price-line-pane-view.ts b/src/views/pane/custom-price-line-pane-view.ts
index 81423d6faa..cab387fa5e 100644
--- a/src/views/pane/custom-price-line-pane-view.ts
+++ b/src/views/pane/custom-price-line-pane-view.ts
@@ -1,12 +1,13 @@
 import { CustomPriceLine } from '../../model/custom-price-line';
 import { Series } from '../../model/series';
+import { SeriesType } from '../../model/series-options';
 
 import { SeriesHorizontalLinePaneView } from './series-horizontal-line-pane-view';
 
-export class CustomPriceLinePaneView extends SeriesHorizontalLinePaneView {
-	private readonly _priceLine: CustomPriceLine;
+export class CustomPriceLinePaneView<HorzScaleItem> extends SeriesHorizontalLinePaneView<HorzScaleItem> {
+	private readonly _priceLine: CustomPriceLine<HorzScaleItem>;
 
-	public constructor(series: Series, priceLine: CustomPriceLine) {
+	public constructor(series: Series<SeriesType, HorzScaleItem>, priceLine: CustomPriceLine<HorzScaleItem>) {
 		super(series);
 		this._priceLine = priceLine;
 	}
diff --git a/src/views/pane/grid-pane-view.ts b/src/views/pane/grid-pane-view.ts
index 5d567a9137..bed7dc0193 100644
--- a/src/views/pane/grid-pane-view.ts
+++ b/src/views/pane/grid-pane-view.ts
@@ -4,12 +4,12 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IUpdatablePaneView } from './iupdatable-pane-view';
 
-export class GridPaneView implements IUpdatablePaneView {
-	private readonly _pane: Pane;
+export class GridPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+	private readonly _pane: Pane<HorzScaleItem>;
 	private readonly _renderer: GridRenderer = new GridRenderer();
 	private _invalidated: boolean = true;
 
-	public constructor(pane: Pane) {
+	public constructor(pane: Pane<HorzScaleItem>) {
 		this._pane = pane;
 	}
 
diff --git a/src/views/pane/histogram-pane-view.ts b/src/views/pane/histogram-pane-view.ts
index 54d11417b5..605fc5d925 100644
--- a/src/views/pane/histogram-pane-view.ts
+++ b/src/views/pane/histogram-pane-view.ts
@@ -7,10 +7,10 @@ import { HistogramItem, PaneRendererHistogram, PaneRendererHistogramData } from
 
 import { LinePaneViewBase } from './line-pane-view-base';
 
-export class SeriesHistogramPaneView extends LinePaneViewBase<'Histogram', HistogramItem, PaneRendererHistogram> {
+export class SeriesHistogramPaneView<HorzScaleItem> extends LinePaneViewBase<'Histogram', HistogramItem, PaneRendererHistogram, HorzScaleItem> {
 	protected readonly _renderer: PaneRendererHistogram = new PaneRendererHistogram();
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Histogram'>): HistogramItem {
+	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Histogram', HorzScaleItem>): HistogramItem {
 		return {
 			...this._createRawItemBase(time, price),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/ipane-view.ts b/src/views/pane/ipane-view.ts
index 87324a9511..de344cbbf9 100644
--- a/src/views/pane/ipane-view.ts
+++ b/src/views/pane/ipane-view.ts
@@ -1,5 +1,5 @@
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
-export interface IPaneView {
+export interface IPaneView<HorzScaleItem> {
 	renderer(addAnchors?: boolean): IPaneRenderer | null;
 }
diff --git a/src/views/pane/iupdatable-pane-view.ts b/src/views/pane/iupdatable-pane-view.ts
index 10b070a164..1f0c49ce14 100644
--- a/src/views/pane/iupdatable-pane-view.ts
+++ b/src/views/pane/iupdatable-pane-view.ts
@@ -2,6 +2,6 @@ import { IPaneView } from './ipane-view';
 
 export type UpdateType = 'data' | 'other' | 'options';
 
-export interface IUpdatablePaneView extends IPaneView {
+export interface IUpdatablePaneView<HorzScaleItem> extends IPaneView<HorzScaleItem> {
 	update(updateType?: UpdateType): void;
 }
diff --git a/src/views/pane/line-pane-view-base.ts b/src/views/pane/line-pane-view-base.ts
index f5d1312f51..3e9dd2c6db 100644
--- a/src/views/pane/line-pane-view-base.ts
+++ b/src/views/pane/line-pane-view-base.ts
@@ -17,18 +17,19 @@ import { SeriesPaneViewBase } from './series-pane-view-base';
 export abstract class LinePaneViewBase<
 	TSeriesType extends 'Line' | 'Area' | 'Baseline' | 'Histogram',
 	ItemType extends PricedValue & TimedValue,
-	TRenderer extends IPaneRenderer
-> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer> {
-	public constructor(series: Series<TSeriesType>, model: ChartModel) {
+	TRenderer extends IPaneRenderer,
+	HorzScaleItem
+> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer, HorzScaleItem> {
+	public constructor(series: Series<TSeriesType, HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
 		super(series, model, true);
 	}
 
-	protected _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale, firstValue: number): void {
+	protected _convertToCoordinates(priceScale: PriceScale<HorzScaleItem>, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void {
 		timeScale.indexesToCoordinates(this._items, undefinedIfNull(this._itemsVisibleRange));
 		priceScale.pointsArrayToCoordinates(this._items, firstValue, undefinedIfNull(this._itemsVisibleRange));
 	}
 
-	protected abstract _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<TSeriesType>): ItemType;
+	protected abstract _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<TSeriesType, HorzScaleItem>): ItemType;
 
 	protected _createRawItemBase(time: TimePointIndex, price: BarPrice): PricedValue & TimedValue {
 		return {
@@ -41,7 +42,7 @@ export abstract class LinePaneViewBase<
 
 	protected _fillRawPoints(): void {
 		const colorer = this._series.barColorer();
-		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType>) => {
+		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType, HorzScaleItem>) => {
 			const value = row.value[PlotRowValueIndex.Close] as BarPrice;
 			return this._createRawItem(row.index, value, colorer);
 		});
diff --git a/src/views/pane/line-pane-view.ts b/src/views/pane/line-pane-view.ts
index 6a1d730025..d4941dad7f 100644
--- a/src/views/pane/line-pane-view.ts
+++ b/src/views/pane/line-pane-view.ts
@@ -5,10 +5,10 @@ import { LineStrokeItem, PaneRendererLine, PaneRendererLineData } from '../../re
 
 import { LinePaneViewBase } from './line-pane-view-base';
 
-export class SeriesLinePaneView extends LinePaneViewBase<'Line', LineStrokeItem, PaneRendererLine> {
+export class SeriesLinePaneView<HorzScaleItem> extends LinePaneViewBase<'Line', LineStrokeItem, PaneRendererLine, HorzScaleItem> {
 	protected readonly _renderer: PaneRendererLine = new PaneRendererLine();
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Line'>): LineStrokeItem {
+	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Line', HorzScaleItem>): LineStrokeItem {
 		return {
 			...this._createRawItemBase(time, price),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/pane-price-axis-view.ts b/src/views/pane/pane-price-axis-view.ts
index bf262d508b..d0b2a39cf8 100644
--- a/src/views/pane/pane-price-axis-view.ts
+++ b/src/views/pane/pane-price-axis-view.ts
@@ -38,15 +38,15 @@ class PanePriceAxisViewRenderer implements IPaneRenderer {
 	}
 }
 
-export class PanePriceAxisView implements IPaneView {
-	private _priceAxisView: IPriceAxisView;
+export class PanePriceAxisView<HorzScaleItem> implements IPaneView<HorzScaleItem> {
+	private _priceAxisView: IPriceAxisView<HorzScaleItem>;
 	private readonly _textWidthCache: TextWidthCache;
-	private readonly _dataSource: IPriceDataSource;
-	private readonly _chartModel: ChartModel;
+	private readonly _dataSource: IPriceDataSource<HorzScaleItem>;
+	private readonly _chartModel: ChartModel<HorzScaleItem>;
 	private readonly _renderer: PanePriceAxisViewRenderer;
 	private _fontSize: number;
 
-	public constructor(priceAxisView: IPriceAxisView, dataSource: IPriceDataSource, chartModel: ChartModel) {
+	public constructor(priceAxisView: IPriceAxisView<HorzScaleItem>, dataSource: IPriceDataSource<HorzScaleItem>, chartModel: ChartModel<HorzScaleItem>) {
 		this._priceAxisView = priceAxisView;
 		this._textWidthCache = new TextWidthCache(50); // when should we clear cache?
 		this._dataSource = dataSource;
diff --git a/src/views/pane/series-horizontal-base-line-pane-view.ts b/src/views/pane/series-horizontal-base-line-pane-view.ts
index b544baea0e..e5a1f78a9c 100644
--- a/src/views/pane/series-horizontal-base-line-pane-view.ts
+++ b/src/views/pane/series-horizontal-base-line-pane-view.ts
@@ -1,11 +1,12 @@
 import { PriceScaleMode } from '../../model/price-scale';
 import { Series } from '../../model/series';
+import { SeriesType } from '../../model/series-options';
 
 import { SeriesHorizontalLinePaneView } from './series-horizontal-line-pane-view';
 
-export class SeriesHorizontalBaseLinePaneView extends SeriesHorizontalLinePaneView {
+export class SeriesHorizontalBaseLinePaneView<HorzScaleItem> extends SeriesHorizontalLinePaneView<HorzScaleItem> {
 	// eslint-disable-next-line no-useless-constructor
-	public constructor(series: Series) {
+	public constructor(series: Series<SeriesType, HorzScaleItem>) {
 		super(series);
 	}
 
diff --git a/src/views/pane/series-horizontal-line-pane-view.ts b/src/views/pane/series-horizontal-line-pane-view.ts
index 7f4cbb5890..1114cfdfb8 100644
--- a/src/views/pane/series-horizontal-line-pane-view.ts
+++ b/src/views/pane/series-horizontal-line-pane-view.ts
@@ -1,13 +1,14 @@
 import { ChartModel } from '../../model/chart-model';
 import { Coordinate } from '../../model/coordinate';
 import { Series } from '../../model/series';
+import { SeriesType } from '../../model/series-options';
 import { LineStyle } from '../../renderers/draw-line';
 import { HorizontalLineRenderer, HorizontalLineRendererData } from '../../renderers/horizontal-line-renderer';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IPaneView } from './ipane-view';
 
-export abstract class SeriesHorizontalLinePaneView implements IPaneView {
+export abstract class SeriesHorizontalLinePaneView<HorzScaleItem> implements IPaneView<HorzScaleItem> {
 	protected readonly _lineRendererData: HorizontalLineRendererData = {
 		y: 0 as Coordinate,
 		color: 'rgba(0, 0, 0, 0)',
@@ -16,12 +17,12 @@ export abstract class SeriesHorizontalLinePaneView implements IPaneView {
 		visible: false,
 	};
 
-	protected readonly _series: Series;
-	protected readonly _model: ChartModel;
+	protected readonly _series: Series<SeriesType, HorzScaleItem>;
+	protected readonly _model: ChartModel<HorzScaleItem>;
 	protected readonly _lineRenderer: HorizontalLineRenderer = new HorizontalLineRenderer();
 	private _invalidated: boolean = true;
 
-	protected constructor(series: Series) {
+	protected constructor(series: Series<SeriesType, HorzScaleItem>) {
 		this._series = series;
 		this._model = series.model();
 		this._lineRenderer.setData(this._lineRendererData);
diff --git a/src/views/pane/series-last-price-animation-pane-view.ts b/src/views/pane/series-last-price-animation-pane-view.ts
index 1bb7367c69..6fccaa01cf 100644
--- a/src/views/pane/series-last-price-animation-pane-view.ts
+++ b/src/views/pane/series-last-price-animation-pane-view.ts
@@ -119,8 +119,8 @@ function animationData(durationSinceStart: number, lineColor: string): Animation
 	};
 }
 
-export class SeriesLastPriceAnimationPaneView implements IUpdatablePaneView {
-	private readonly _series: Series<'Area'> | Series<'Line'> | Series<'Baseline'>;
+export class SeriesLastPriceAnimationPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+	private readonly _series: Series<'Area', HorzScaleItem> | Series<'Line', HorzScaleItem> | Series<'Baseline', HorzScaleItem>;
 	private readonly _renderer: SeriesLastPriceAnimationRenderer = new SeriesLastPriceAnimationRenderer();
 	private _invalidated: boolean = true;
 	private _stageInvalidated: boolean = true;
@@ -128,7 +128,7 @@ export class SeriesLastPriceAnimationPaneView implements IUpdatablePaneView {
 	private _startTime: number = performance.now();
 	private _endTime: number = this._startTime - 1;
 
-	public constructor(series: Series<'Area'> | Series<'Line'> | Series<'Baseline'>) {
+	public constructor(series: Series<'Area', HorzScaleItem> | Series<'Line', HorzScaleItem> | Series<'Baseline', HorzScaleItem>) {
 		this._series = series;
 	}
 
diff --git a/src/views/pane/series-markers-pane-view.ts b/src/views/pane/series-markers-pane-view.ts
index 13017d75e6..49599281cc 100644
--- a/src/views/pane/series-markers-pane-view.ts
+++ b/src/views/pane/series-markers-pane-view.ts
@@ -8,6 +8,7 @@ import { Coordinate } from '../../model/coordinate';
 import { PriceScale } from '../../model/price-scale';
 import { Series } from '../../model/series';
 import { InternalSeriesMarker } from '../../model/series-markers';
+import { SeriesType } from '../../model/series-options';
 import { TimePointIndex, visibleTimedValues } from '../../model/time-data';
 import { TimeScale } from '../../model/time-scale';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
@@ -33,15 +34,15 @@ interface Offsets {
 }
 
 // eslint-disable-next-line max-params
-function fillSizeAndY(
+function fillSizeAndY<HorzScaleItem>(
 	rendererItem: SeriesMarkerRendererDataItem,
-	marker: InternalSeriesMarker<TimePointIndex>,
+	marker: InternalSeriesMarker<TimePointIndex, HorzScaleItem>,
 	seriesData: BarPrices | BarPrice,
 	offsets: Offsets,
 	textHeight: number,
 	shapeMargin: number,
-	priceScale: PriceScale,
-	timeScale: TimeScale,
+	priceScale: PriceScale<HorzScaleItem>,
+	timeScale: TimeScale<HorzScaleItem>,
 	firstValue: number
 ): void {
 	const inBarPrice = isNumber(seriesData) ? seriesData : seriesData.close;
@@ -83,9 +84,9 @@ function fillSizeAndY(
 	ensureNever(marker.position);
 }
 
-export class SeriesMarkersPaneView implements IUpdatablePaneView {
-	private readonly _series: Series;
-	private readonly _model: ChartModel;
+export class SeriesMarkersPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+	private readonly _series: Series<SeriesType, HorzScaleItem>;
+	private readonly _model: ChartModel<HorzScaleItem>;
 	private _data: SeriesMarkerRendererData;
 
 	private _invalidated: boolean = true;
@@ -96,7 +97,7 @@ export class SeriesMarkersPaneView implements IUpdatablePaneView {
 
 	private _renderer: SeriesMarkersRenderer = new SeriesMarkersRenderer();
 
-	public constructor(series: Series, model: ChartModel) {
+	public constructor(series: Series<SeriesType, HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
 		this._series = series;
 		this._model = model;
 		this._data = {
@@ -154,7 +155,7 @@ export class SeriesMarkersPaneView implements IUpdatablePaneView {
 		const timeScale = this._model.timeScale();
 		const seriesMarkers = this._series.indexedMarkers();
 		if (this._dataInvalidated) {
-			this._data.items = seriesMarkers.map<SeriesMarkerRendererDataItem>((marker: InternalSeriesMarker<TimePointIndex>) => ({
+			this._data.items = seriesMarkers.map<SeriesMarkerRendererDataItem>((marker: InternalSeriesMarker<TimePointIndex, HorzScaleItem>) => ({
 				time: marker.time,
 				x: 0 as Coordinate,
 				y: 0 as Coordinate,
diff --git a/src/views/pane/series-pane-view-base.ts b/src/views/pane/series-pane-view-base.ts
index e944858c7a..faacf450d6 100644
--- a/src/views/pane/series-pane-view-base.ts
+++ b/src/views/pane/series-pane-view-base.ts
@@ -8,9 +8,9 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IUpdatablePaneView, UpdateType } from './iupdatable-pane-view';
 
-export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemType extends TimedValue, TRenderer extends IPaneRenderer> implements IUpdatablePaneView {
-	protected readonly _series: Series<TSeriesType>;
-	protected readonly _model: ChartModel;
+export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemType extends TimedValue, TRenderer extends IPaneRenderer, HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+	protected readonly _series: Series<TSeriesType, HorzScaleItem>;
+	protected readonly _model: ChartModel<HorzScaleItem>;
 	protected _invalidated: boolean = true;
 	protected _dataInvalidated: boolean = true;
 	protected _optionsInvalidated: boolean = true;
@@ -19,7 +19,7 @@ export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemTyp
 	protected readonly abstract _renderer: TRenderer;
 	private readonly _extendedVisibleRange: boolean;
 
-	public constructor(series: Series<TSeriesType>, model: ChartModel, extendedVisibleRange: boolean) {
+	public constructor(series: Series<TSeriesType, HorzScaleItem>, model: ChartModel<HorzScaleItem>, extendedVisibleRange: boolean) {
 		this._series = series;
 		this._model = model;
 		this._extendedVisibleRange = extendedVisibleRange;
@@ -54,7 +54,7 @@ export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemTyp
 		}));
 	}
 
-	protected abstract _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale, firstValue: number): void;
+	protected abstract _convertToCoordinates(priceScale: PriceScale<HorzScaleItem>, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void;
 
 	protected _clearVisibleRange(): void {
 		this._itemsVisibleRange = null;
diff --git a/src/views/pane/series-price-line-pane-view.ts b/src/views/pane/series-price-line-pane-view.ts
index 302aa4b484..4e0d71fc47 100644
--- a/src/views/pane/series-price-line-pane-view.ts
+++ b/src/views/pane/series-price-line-pane-view.ts
@@ -1,11 +1,11 @@
 import { Series } from '../../model/series';
-import { PriceLineSource } from '../../model/series-options';
+import { PriceLineSource, SeriesType } from '../../model/series-options';
 
 import { SeriesHorizontalLinePaneView } from './series-horizontal-line-pane-view';
 
-export class SeriesPriceLinePaneView extends SeriesHorizontalLinePaneView {
+export class SeriesPriceLinePaneView<HorzScaleItem> extends SeriesHorizontalLinePaneView<HorzScaleItem> {
 	// eslint-disable-next-line no-useless-constructor
-	public constructor(series: Series) {
+	public constructor(series: Series<SeriesType, HorzScaleItem>) {
 		super(series);
 	}
 
diff --git a/src/views/pane/watermark-pane-view.ts b/src/views/pane/watermark-pane-view.ts
index d3d94d1ddd..9c22749eb6 100644
--- a/src/views/pane/watermark-pane-view.ts
+++ b/src/views/pane/watermark-pane-view.ts
@@ -6,8 +6,8 @@ import { WatermarkRenderer, WatermarkRendererData } from '../../renderers/waterm
 
 import { IUpdatablePaneView } from './iupdatable-pane-view';
 
-export class WatermarkPaneView implements IUpdatablePaneView {
-	private _source: Watermark;
+export class WatermarkPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+	private _source: Watermark<HorzScaleItem>;
 	private _invalidated: boolean = true;
 
 	private readonly _rendererData: WatermarkRendererData = {
@@ -19,7 +19,7 @@ export class WatermarkPaneView implements IUpdatablePaneView {
 	};
 	private readonly _renderer: WatermarkRenderer = new WatermarkRenderer(this._rendererData);
 
-	public constructor(source: Watermark) {
+	public constructor(source: Watermark<HorzScaleItem>) {
 		this._source = source;
 	}
 
diff --git a/src/views/price-axis/crosshair-price-axis-view.ts b/src/views/price-axis/crosshair-price-axis-view.ts
index 4b40811362..21c1c85f26 100644
--- a/src/views/price-axis/crosshair-price-axis-view.ts
+++ b/src/views/price-axis/crosshair-price-axis-view.ts
@@ -6,14 +6,14 @@ import { PriceAxisViewRendererCommonData, PriceAxisViewRendererData } from '../.
 
 import { PriceAxisView } from './price-axis-view';
 
-export type CrosshairPriceAxisViewValueProvider = (priceScale: PriceScale) => CrosshairPriceAndCoordinate;
+export type CrosshairPriceAxisViewValueProvider<HorzScaleItem> = (priceScale: PriceScale<HorzScaleItem>) => CrosshairPriceAndCoordinate;
 
-export class CrosshairPriceAxisView extends PriceAxisView {
-	private _source: Crosshair;
-	private readonly _priceScale: PriceScale;
-	private readonly _valueProvider: CrosshairPriceAxisViewValueProvider;
+export class CrosshairPriceAxisView<HorzScaleItem> extends PriceAxisView<HorzScaleItem> {
+	private _source: Crosshair<HorzScaleItem>;
+	private readonly _priceScale: PriceScale<HorzScaleItem>;
+	private readonly _valueProvider: CrosshairPriceAxisViewValueProvider<HorzScaleItem>;
 
-	public constructor(source: Crosshair, priceScale: PriceScale, valueProvider: CrosshairPriceAxisViewValueProvider) {
+	public constructor(source: Crosshair<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, valueProvider: CrosshairPriceAxisViewValueProvider<HorzScaleItem>) {
 		super();
 		this._source = source;
 		this._priceScale = priceScale;
diff --git a/src/views/price-axis/custom-price-line-price-axis-view.ts b/src/views/price-axis/custom-price-line-price-axis-view.ts
index 6cd9dfd18e..f8c77b40f3 100644
--- a/src/views/price-axis/custom-price-line-price-axis-view.ts
+++ b/src/views/price-axis/custom-price-line-price-axis-view.ts
@@ -2,6 +2,7 @@ import { generateContrastColors } from '../../helpers/color';
 
 import { CustomPriceLine } from '../../model/custom-price-line';
 import { Series } from '../../model/series';
+import { SeriesType } from '../../model/series-options';
 import {
 	PriceAxisViewRendererCommonData,
 	PriceAxisViewRendererData,
@@ -9,11 +10,11 @@ import {
 
 import { PriceAxisView } from './price-axis-view';
 
-export class CustomPriceLinePriceAxisView extends PriceAxisView {
-	private readonly _series: Series;
-	private readonly _priceLine: CustomPriceLine;
+export class CustomPriceLinePriceAxisView<HorzScaleItem> extends PriceAxisView<HorzScaleItem> {
+	private readonly _series: Series<SeriesType, HorzScaleItem>;
+	private readonly _priceLine: CustomPriceLine<HorzScaleItem>;
 
-	public constructor(series: Series, priceLine: CustomPriceLine) {
+	public constructor(series: Series<SeriesType, HorzScaleItem>, priceLine: CustomPriceLine<HorzScaleItem>) {
 		super();
 		this._series = series;
 		this._priceLine = priceLine;
diff --git a/src/views/price-axis/iprice-axis-view.ts b/src/views/price-axis/iprice-axis-view.ts
index 93b7b74cad..9c1bc10449 100644
--- a/src/views/price-axis/iprice-axis-view.ts
+++ b/src/views/price-axis/iprice-axis-view.ts
@@ -4,13 +4,13 @@ import {
 	PriceAxisViewRendererOptions,
 } from '../../renderers/iprice-axis-view-renderer';
 
-export interface IPriceAxisView {
+export interface IPriceAxisView<HorzScaleItem> {
 	coordinate(): number;
 	getFixedCoordinate(): number;
 	height(rendererOptions: PriceAxisViewRendererOptions, useSecondLine?: boolean): number;
 	isVisible(): boolean;
 	isAxisLabelVisible(): boolean;
-	renderer(priceScale: PriceScale): IPriceAxisViewRenderer;
+	renderer(priceScale: PriceScale<HorzScaleItem>): IPriceAxisViewRenderer;
 	paneRenderer(): IPriceAxisViewRenderer;
 	setFixedCoordinate(value: number | null): void;
 	text(): string;
diff --git a/src/views/price-axis/price-axis-view.ts b/src/views/price-axis/price-axis-view.ts
index 4223b467b2..fc6fc66254 100644
--- a/src/views/price-axis/price-axis-view.ts
+++ b/src/views/price-axis/price-axis-view.ts
@@ -10,7 +10,7 @@ import { PriceAxisViewRenderer } from '../../renderers/price-axis-view-renderer'
 
 import { IPriceAxisView } from './iprice-axis-view';
 
-export abstract class PriceAxisView implements IPriceAxisView {
+export abstract class PriceAxisView<HorzScaleItem> implements IPriceAxisView<HorzScaleItem> {
 	private readonly _commonRendererData: PriceAxisViewRendererCommonData = {
 		coordinate: 0,
 		background: '#000',
@@ -88,7 +88,7 @@ export abstract class PriceAxisView implements IPriceAxisView {
 		return this._axisRendererData.visible;
 	}
 
-	public renderer(priceScale: PriceScale): IPriceAxisViewRenderer {
+	public renderer(priceScale: PriceScale<HorzScaleItem>): IPriceAxisViewRenderer {
 		this._updateRendererDataIfNeeded();
 
 		// force update tickVisible state from price scale options
diff --git a/src/views/price-axis/series-price-axis-view.ts b/src/views/price-axis/series-price-axis-view.ts
index c8a3474275..ea58e6835c 100644
--- a/src/views/price-axis/series-price-axis-view.ts
+++ b/src/views/price-axis/series-price-axis-view.ts
@@ -1,15 +1,15 @@
 import { generateContrastColors } from '../../helpers/color';
 
 import { LastValueDataResultWithData, Series } from '../../model/series';
-import { PriceAxisLastValueMode } from '../../model/series-options';
+import { PriceAxisLastValueMode, SeriesType } from '../../model/series-options';
 import { PriceAxisViewRendererCommonData, PriceAxisViewRendererData } from '../../renderers/iprice-axis-view-renderer';
 
 import { PriceAxisView } from './price-axis-view';
 
-export class SeriesPriceAxisView extends PriceAxisView {
-	private readonly _source: Series;
+export class SeriesPriceAxisView<HorzScaleItem> extends PriceAxisView<HorzScaleItem> {
+	private readonly _source: Series<SeriesType, HorzScaleItem>;
 
-	public constructor(source: Series) {
+	public constructor(source: Series<SeriesType, HorzScaleItem>) {
 		super();
 		this._source = source;
 	}
diff --git a/src/views/time-axis/crosshair-time-axis-view.ts b/src/views/time-axis/crosshair-time-axis-view.ts
index 7ba1b23745..f940630b5e 100644
--- a/src/views/time-axis/crosshair-time-axis-view.ts
+++ b/src/views/time-axis/crosshair-time-axis-view.ts
@@ -7,12 +7,12 @@ import { TimeAxisViewRenderer, TimeAxisViewRendererData } from '../../renderers/
 
 import { ITimeAxisView } from './itime-axis-view';
 
-export class CrosshairTimeAxisView implements ITimeAxisView {
+export class CrosshairTimeAxisView<HorzScaleItem> implements ITimeAxisView<HorzScaleItem> {
 	private _invalidated: boolean = true;
-	private readonly _crosshair: Crosshair;
-	private readonly _model: ChartModel;
+	private readonly _crosshair: Crosshair<HorzScaleItem>;
+	private readonly _model: ChartModel<HorzScaleItem>;
 	private readonly _valueProvider: TimeAndCoordinateProvider;
-	private readonly _renderer: TimeAxisViewRenderer = new TimeAxisViewRenderer();
+	private readonly _renderer: TimeAxisViewRenderer<HorzScaleItem> = new TimeAxisViewRenderer();
 	private readonly _rendererData: TimeAxisViewRendererData = {
 		visible: false,
 		background: '#4c525e',
@@ -23,7 +23,7 @@ export class CrosshairTimeAxisView implements ITimeAxisView {
 		tickVisible: true,
 	};
 
-	public constructor(crosshair: Crosshair, model: ChartModel, valueProvider: TimeAndCoordinateProvider) {
+	public constructor(crosshair: Crosshair<HorzScaleItem>, model: ChartModel<HorzScaleItem>, valueProvider: TimeAndCoordinateProvider) {
 		this._crosshair = crosshair;
 		this._model = model;
 		this._valueProvider = valueProvider;
@@ -33,7 +33,7 @@ export class CrosshairTimeAxisView implements ITimeAxisView {
 		this._invalidated = true;
 	}
 
-	public renderer(): TimeAxisViewRenderer {
+	public renderer(): TimeAxisViewRenderer<HorzScaleItem> {
 		if (this._invalidated) {
 			this._updateImpl();
 			this._invalidated = false;
diff --git a/src/views/time-axis/itime-axis-view.ts b/src/views/time-axis/itime-axis-view.ts
index cda658e993..23e7040a93 100644
--- a/src/views/time-axis/itime-axis-view.ts
+++ b/src/views/time-axis/itime-axis-view.ts
@@ -1,5 +1,5 @@
 import { TimeAxisViewRenderer } from '../../renderers/time-axis-view-renderer';
 
-export interface ITimeAxisView {
-	renderer(): TimeAxisViewRenderer;
+export interface ITimeAxisView<HorzScaleItem> {
+	renderer(): TimeAxisViewRenderer<HorzScaleItem>;
 }
diff --git a/tests/unittests/default-tick-mark-formatter.spec.ts b/tests/unittests/default-tick-mark-formatter.spec.ts
index 1bfce878bc..7e6f86a29a 100644
--- a/tests/unittests/default-tick-mark-formatter.spec.ts
+++ b/tests/unittests/default-tick-mark-formatter.spec.ts
@@ -1,9 +1,8 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
-import { defaultTickMarkFormatter } from '../../src/model/default-tick-mark-formatter';
-import { TimePoint, UTCTimestamp } from '../../src/model/time-data';
-import { TickMarkType } from '../../src/model/time-scale';
+import { defaultTickMarkFormatter } from '../../src/model/horz-scale-behavior-time/default-tick-mark-formatter';
+import { TickMarkType, TimePoint, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
 
 function time(dateTimeStr: string): TimePoint {
 	return {

From c911cb3f14b7b9cf1d3e875d22a0f8df9d5156c4 Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Fri, 24 Mar 2023 10:33:01 +0300
Subject: [PATCH 02/23] Added example

---
 debug-price.html | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 debug-price.html

diff --git a/debug-price.html b/debug-price.html
new file mode 100644
index 0000000000..3ddc65eef7
--- /dev/null
+++ b/debug-price.html
@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,minimum-scale=1.0">
+	<title>Debug page</title>
+
+	<script type="text/javascript" src="./dist/lightweight-charts.standalone.development.js"></script>
+
+	<script language="javascript">
+		function init() {
+			const chart = LightweightCharts.createOptionsChart(document.getElementById('container'), 
+			{
+				width: 900,
+				height: 600, 
+			});
+			const s1 = chart.addLineSeries({
+				color: 'red'
+			});
+			const arr = []
+			for (let i = 0; i < 5000; i++) {
+				arr.push({time: i * 0.25, value: Math.round(Math.random() * 10000) / 100 });
+			}
+			s1.setData(arr);
+		}
+	</script>
+		
+</head>
+
+<body style="padding: 0; margin: 0; background-color: #505050" onload="init()">
+	<div id="container" style="position: absolute; width: 600px; height: 600px"></div>
+</body>
+
+</html>

From 54de1e692e1a60cb68b1058ff5eba99b3b5dec3c Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 4 Apr 2023 10:33:45 +0300
Subject: [PATCH 03/23] Move files to satisfy CI

---
 src/api/chart-api.ts                                   |  4 ++--
 src/api/create-chart.ts                                |  2 +-
 src/api/data-validators.ts                             |  2 +-
 src/api/get-series-data-creator.ts                     |  2 +-
 src/api/ichart-api.ts                                  |  2 +-
 src/api/iseries-api.ts                                 |  2 +-
 src/api/series-api.ts                                  |  2 +-
 src/{api => model}/data-consumer.ts                    |  4 ++--
 src/{api => model}/data-layer.ts                       | 10 +++++-----
 src/{api => model}/get-series-plot-row-creator.ts      | 10 +++++-----
 .../horz-scale-behavior-time.ts                        |  4 ++--
 src/model/ihorz-scale-behavior.ts                      |  2 +-
 tests/unittests/data-layer.spec.ts                     |  4 ++--
 tests/unittests/get-series-plot-row-creator.spec.ts    |  2 +-
 14 files changed, 26 insertions(+), 26 deletions(-)
 rename src/{api => model}/data-consumer.ts (98%)
 rename src/{api => model}/data-layer.ts (98%)
 rename src/{api => model}/get-series-plot-row-creator.ts (94%)

diff --git a/src/api/chart-api.ts b/src/api/chart-api.ts
index 653e451d4c..f167768e92 100644
--- a/src/api/chart-api.ts
+++ b/src/api/chart-api.ts
@@ -27,8 +27,8 @@ import {
 } from '../model/series-options';
 import { Logical } from '../model/time-data';
 
-import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap } from './data-consumer';
-import { DataLayer, DataUpdateResponse, SeriesChanges } from './data-layer';
+import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap } from '../model/data-consumer';
+import { DataLayer, DataUpdateResponse, SeriesChanges } from '../model/data-layer';
 import { getSeriesDataCreator } from './get-series-data-creator';
 import { IChartApi, MouseEventHandler, MouseEventParams } from './ichart-api';
 import { IPriceScaleApi } from './iprice-scale-api';
diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index c6722f1f4e..176b7bc2fd 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -13,7 +13,7 @@ import { TickMarkWeightValue, TimeScalePoint } from '../model/time-data';
 import { markWithGreaterWeight, TimeMark } from '../model/time-scale';
 
 import { ChartApi } from './chart-api';
-import { SeriesDataItemTypeMap } from './data-consumer';
+import { SeriesDataItemTypeMap } from '../model/data-consumer';
 import { IChartApi } from './ichart-api';
 
 /**
diff --git a/src/api/data-validators.ts b/src/api/data-validators.ts
index ddc18b48cd..dac66dc87b 100644
--- a/src/api/data-validators.ts
+++ b/src/api/data-validators.ts
@@ -5,7 +5,7 @@ import { CreatePriceLineOptions } from '../model/price-line-options';
 import { SeriesMarker } from '../model/series-markers';
 import { SeriesType } from '../model/series-options';
 
-import { isFulfilledData, SeriesDataItemTypeMap } from './data-consumer';
+import { isFulfilledData, SeriesDataItemTypeMap } from '../model/data-consumer';
 
 export function checkPriceLineOptions(options: CreatePriceLineOptions): void {
 	if (process.env.NODE_ENV === 'production') {
diff --git a/src/api/get-series-data-creator.ts b/src/api/get-series-data-creator.ts
index 3cf7381119..216519feb1 100644
--- a/src/api/get-series-data-creator.ts
+++ b/src/api/get-series-data-creator.ts
@@ -18,7 +18,7 @@ import {
 	OhlcData,
 	SeriesDataItemTypeMap,
 	SingleValueData,
-} from './data-consumer';
+} from '../model/data-consumer';
 
 type SeriesPlotRowToDataMap<HorzScaleItem> = {
 	[T in keyof SeriesDataItemTypeMap<HorzScaleItem>]: (plotRow: SeriesPlotRow<T, HorzScaleItem>) => SeriesDataItemTypeMap<HorzScaleItem>[T];
diff --git a/src/api/ichart-api.ts b/src/api/ichart-api.ts
index db43402fe5..da1e8c511b 100644
--- a/src/api/ichart-api.ts
+++ b/src/api/ichart-api.ts
@@ -15,7 +15,7 @@ import {
 import { Logical } from '../model/time-data';
 import { TouchMouseEventData } from '../model/touch-mouse-event-data';
 
-import { BarData, HistogramData, LineData } from './data-consumer';
+import { BarData, HistogramData, LineData } from '../model/data-consumer';
 import { IPriceScaleApi } from './iprice-scale-api';
 import { ISeriesApi } from './iseries-api';
 import { ITimeScaleApi } from './itime-scale-api';
diff --git a/src/api/iseries-api.ts b/src/api/iseries-api.ts
index fad2c5f5c6..f2c8c30f64 100644
--- a/src/api/iseries-api.ts
+++ b/src/api/iseries-api.ts
@@ -12,7 +12,7 @@ import {
 } from '../model/series-options';
 import { Range } from '../model/time-data';
 
-import { SeriesDataItemTypeMap } from './data-consumer';
+import { SeriesDataItemTypeMap } from '../model/data-consumer';
 import { IPriceLine } from './iprice-line';
 import { IPriceScaleApi } from './iprice-scale-api';
 
diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index bb0e7256fa..1d0ac96946 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -20,7 +20,7 @@ import { Logical, Range, TimePointIndex } from '../model/time-data';
 import { TimeScaleVisibleRange } from '../model/time-scale-visible-range';
 
 import { IPriceScaleApiProvider } from './chart-api';
-import { DataUpdatesConsumer, SeriesDataItemTypeMap } from './data-consumer';
+import { DataUpdatesConsumer, SeriesDataItemTypeMap } from '../model/data-consumer';
 import { checkItemsAreOrdered, checkPriceLineOptions, checkSeriesValuesType } from './data-validators';
 import { getSeriesDataCreator } from './get-series-data-creator';
 import { IPriceLine } from './iprice-line';
diff --git a/src/api/data-consumer.ts b/src/model/data-consumer.ts
similarity index 98%
rename from src/api/data-consumer.ts
rename to src/model/data-consumer.ts
index 4c93ae222e..0f5da4485c 100644
--- a/src/api/data-consumer.ts
+++ b/src/model/data-consumer.ts
@@ -1,5 +1,5 @@
-import { Series } from '../model/series';
-import { SeriesType } from '../model/series-options';
+import { Series } from './series';
+import { SeriesType } from './series-options';
 
 /**
  * Represents a whitespace data item, which is a data point without a value.
diff --git a/src/api/data-layer.ts b/src/model/data-layer.ts
similarity index 98%
rename from src/api/data-layer.ts
rename to src/model/data-layer.ts
index d2fc577f9c..2e32803c6d 100644
--- a/src/api/data-layer.ts
+++ b/src/model/data-layer.ts
@@ -3,15 +3,15 @@
 import { lowerbound } from '../helpers/algorithms';
 import { ensureDefined } from '../helpers/assertions';
 
-import { IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../model/ihorz-scale-behavior';
-import { Series, SeriesUpdateInfo } from '../model/series';
-import { SeriesPlotRow } from '../model/series-data';
-import { SeriesType } from '../model/series-options';
+import { IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from './ihorz-scale-behavior';
+import { Series, SeriesUpdateInfo } from './series';
+import { SeriesPlotRow } from './series-data';
+import { SeriesType } from './series-options';
 import {
 	TickMarkWeightValue,
 	TimePointIndex,
 	TimeScalePoint,
-} from '../model/time-data';
+} from './time-data';
 
 import {
 	SeriesDataItemTypeMap,
diff --git a/src/api/get-series-plot-row-creator.ts b/src/model/get-series-plot-row-creator.ts
similarity index 94%
rename from src/api/get-series-plot-row-creator.ts
rename to src/model/get-series-plot-row-creator.ts
index 4d8d200b86..e972341aa3 100644
--- a/src/api/get-series-plot-row-creator.ts
+++ b/src/model/get-series-plot-row-creator.ts
@@ -1,8 +1,8 @@
-import { InternalHorzScaleItem } from '../model/ihorz-scale-behavior';
-import { PlotRow } from '../model/plot-data';
-import { SeriesPlotRow } from '../model/series-data';
-import { SeriesType } from '../model/series-options';
-import { TimePointIndex } from '../model/time-data';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
+import { PlotRow } from './plot-data';
+import { SeriesPlotRow } from './series-data';
+import { SeriesType } from './series-options';
+import { TimePointIndex } from './time-data';
 
 import { AreaData, BarData, BaselineData, CandlestickData, HistogramData, isWhitespaceData, LineData, SeriesDataItemTypeMap } from './data-consumer';
 
diff --git a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
index ecefed57ed..74e9d0b974 100644
--- a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
+++ b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
@@ -1,5 +1,5 @@
-import { SeriesDataItemTypeMap } from '../../api/data-consumer';
-import { TimedData } from '../../api/data-layer';
+import { SeriesDataItemTypeMap } from '../data-consumer';
+import { TimedData } from '../data-layer';
 import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../ihorz-scale-behavior';
 import { DateFormatter } from '../../formatters/date-formatter';
 import { DateTimeFormatter } from '../../formatters/date-time-formatter';
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
index 4cdc4c0d10..e2bf3e7daf 100644
--- a/src/model/ihorz-scale-behavior.ts
+++ b/src/model/ihorz-scale-behavior.ts
@@ -6,7 +6,7 @@ import { TickMark } from './tick-marks';
 import { TickMarkWeightValue, TimeScalePoint } from './time-data';
 import { TimeMark } from './time-scale';
 
-import { SeriesDataItemTypeMap } from '../api/data-consumer';
+import { SeriesDataItemTypeMap } from './data-consumer';
 
 export type InternalHorzScaleItem = Nominal<unknown, 'InternalHorzScaleItem'>;
 
diff --git a/tests/unittests/data-layer.spec.ts b/tests/unittests/data-layer.spec.ts
index 251dcf7d05..c29fbd3742 100644
--- a/tests/unittests/data-layer.spec.ts
+++ b/tests/unittests/data-layer.spec.ts
@@ -3,8 +3,8 @@ import { expect } from 'chai';
 import chaiExclude from 'chai-exclude';
 import { describe, it } from 'mocha';
 
-import { BarData, HistogramData, LineData, WhitespaceData } from '../../src/api/data-consumer';
-import { convertTime, DataLayer, SeriesChanges, stringToBusinessDay } from '../../src/api/data-layer';
+import { BarData, HistogramData, LineData, WhitespaceData } from '../../src/model/data-consumer';
+import { convertTime, DataLayer, SeriesChanges, stringToBusinessDay } from '../../src/model/data-layer';
 import { ensureDefined } from '../../src/helpers/assertions';
 import { PlotRowValueIndex } from '../../src/model/plot-data';
 import { PlotList } from '../../src/model/plot-list';
diff --git a/tests/unittests/get-series-plot-row-creator.spec.ts b/tests/unittests/get-series-plot-row-creator.spec.ts
index 18d55fd935..5603ae33cc 100644
--- a/tests/unittests/get-series-plot-row-creator.spec.ts
+++ b/tests/unittests/get-series-plot-row-creator.spec.ts
@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
-import { getSeriesPlotRowCreator } from '../../src/api/get-series-plot-row-creator';
+import { getSeriesPlotRowCreator } from '../../src/model/get-series-plot-row-creator';
 import { OriginalTime, TimePointIndex, UTCTimestamp } from '../../src/model/time-data';
 
 describe('getSeriesPlotRowCreator', () => {

From 780f768e02cab0b7b8414e183671ada42a82302c Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 4 Apr 2023 12:32:33 +0300
Subject: [PATCH 04/23] Fixed tests

---
 src/api/series-api.ts                         |   2 +-
 src/{api => model}/data-validators.ts         |  10 +-
 tests/unittests/data-layer.spec.ts            | 130 +++++++++---------
 .../unittests/get-series-data-creator.spec.ts |  22 +--
 .../get-series-plot-row-creator.spec.ts       |  44 +++---
 tests/unittests/plot-list.spec.ts             |  12 +-
 tests/unittests/time-scale.spec.ts            |  62 ++++-----
 7 files changed, 146 insertions(+), 136 deletions(-)
 rename src/{api => model}/data-validators.ts (90%)

diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index 1d0ac96946..f6fc004f9a 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -21,7 +21,7 @@ import { TimeScaleVisibleRange } from '../model/time-scale-visible-range';
 
 import { IPriceScaleApiProvider } from './chart-api';
 import { DataUpdatesConsumer, SeriesDataItemTypeMap } from '../model/data-consumer';
-import { checkItemsAreOrdered, checkPriceLineOptions, checkSeriesValuesType } from './data-validators';
+import { checkItemsAreOrdered, checkPriceLineOptions, checkSeriesValuesType } from '../model/data-validators';
 import { getSeriesDataCreator } from './get-series-data-creator';
 import { IPriceLine } from './iprice-line';
 import { IPriceScaleApi } from './iprice-scale-api';
diff --git a/src/api/data-validators.ts b/src/model/data-validators.ts
similarity index 90%
rename from src/api/data-validators.ts
rename to src/model/data-validators.ts
index dac66dc87b..cd6a37dc8d 100644
--- a/src/api/data-validators.ts
+++ b/src/model/data-validators.ts
@@ -1,11 +1,11 @@
 import { assert } from '../helpers/assertions';
 
-import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
-import { CreatePriceLineOptions } from '../model/price-line-options';
-import { SeriesMarker } from '../model/series-markers';
-import { SeriesType } from '../model/series-options';
+import { IHorzScaleBehavior } from './ihorz-scale-behavior';
+import { CreatePriceLineOptions } from './price-line-options';
+import { SeriesMarker } from './series-markers';
+import { SeriesType } from './series-options';
 
-import { isFulfilledData, SeriesDataItemTypeMap } from '../model/data-consumer';
+import { isFulfilledData, SeriesDataItemTypeMap } from './data-consumer';
 
 export function checkPriceLineOptions(options: CreatePriceLineOptions): void {
 	if (process.env.NODE_ENV === 'production') {
diff --git a/tests/unittests/data-layer.spec.ts b/tests/unittests/data-layer.spec.ts
index c29fbd3742..168885976f 100644
--- a/tests/unittests/data-layer.spec.ts
+++ b/tests/unittests/data-layer.spec.ts
@@ -4,38 +4,42 @@ import chaiExclude from 'chai-exclude';
 import { describe, it } from 'mocha';
 
 import { BarData, HistogramData, LineData, WhitespaceData } from '../../src/model/data-consumer';
-import { convertTime, DataLayer, SeriesChanges, stringToBusinessDay } from '../../src/model/data-layer';
+import { DataLayer, SeriesChanges } from '../../src/model/data-layer';
 import { ensureDefined } from '../../src/helpers/assertions';
 import { PlotRowValueIndex } from '../../src/model/plot-data';
 import { PlotList } from '../../src/model/plot-list';
 import { Series } from '../../src/model/series';
 import { SeriesType } from '../../src/model/series-options';
-import { BusinessDay, Time, TimePoint, TimePointIndex, UTCTimestamp } from '../../src/model/time-data';
+import { TimePointIndex } from '../../src/model/time-data';
+import { BusinessDay, Time, TimePoint, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
+import { convertTime, HorzScaleBehaviorTime, stringToBusinessDay } from '../../src/model/horz-scale-behavior-time/horz-scale-behavior-time';
 
 chai.use(chaiExclude);
 
-function createSeriesMock<T extends SeriesType = SeriesType>(seriesType?: T): Series<T> {
+function createSeriesMock<T extends SeriesType = SeriesType>(seriesType?: T): Series<T, Time> {
 	const data = new PlotList();
 
 	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 	return {
 		bars: () => data,
 		seriesType: () => seriesType || 'Line',
-	} as Series<T>;
+	} as Series<T, Time>;
 }
 
 // just for tests
-function dataItemAt(time: Time): BarData & LineData & HistogramData {
+function dataItemAt(time: Time): BarData<Time> & LineData<Time> & HistogramData<Time> {
 	return { time, value: 0, open: 0, high: 0, low: 0, close: 0 };
 }
 
-function whitespaceItemAt(time: Time): WhitespaceData {
+function whitespaceItemAt(time: Time): WhitespaceData<Time> {
 	return { time };
 }
 
+const behavior = new HorzScaleBehaviorTime();
+
 describe('DataLayer', () => {
 	it('should be able to append new series with updating time scale', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 
 		// actually we don't need to use Series, so we just use new Object()
 		const series1 = createSeriesMock();
@@ -49,14 +53,14 @@ describe('DataLayer', () => {
 		]);
 		expect(updateResult1.timeScale.firstChangedPointIndex).to.be.equal(0);
 		expect(updateResult1.series.size).to.be.equal(1);
-		updateResult1.series.forEach((updatePacket: SeriesChanges, series: Series) => {
+		updateResult1.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
 			expect(series).to.be.equal(series1);
 			expect(updatePacket.data.length).to.be.equal(2);
 
 			expect(updatePacket.data[0].index).to.be.equal(0 as TimePointIndex);
-			expect(updatePacket.data[0].time.timestamp).to.be.equal(1000 as UTCTimestamp);
+			expect((updatePacket.data[0].time as unknown as TimePoint).timestamp).to.be.equal(1000 as UTCTimestamp);
 			expect(updatePacket.data[1].index).to.be.equal(1 as TimePointIndex);
-			expect(updatePacket.data[1].time.timestamp).to.be.equal(3000 as UTCTimestamp);
+			expect((updatePacket.data[1].time as unknown as TimePoint).timestamp).to.be.equal(3000 as UTCTimestamp);
 		});
 
 		const updateResult2 = dataLayer.setSeriesData(series2, [dataItemAt(2000 as UTCTimestamp), dataItemAt(4000 as UTCTimestamp)]);
@@ -69,7 +73,7 @@ describe('DataLayer', () => {
 		]);
 		expect(updateResult2.timeScale.firstChangedPointIndex).to.be.equal(1);
 		expect(updateResult2.series.size).to.be.equal(2);
-		updateResult2.series.forEach((updatePacket: SeriesChanges, series: Series) => {
+		updateResult2.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
 			if (series === series1) {
 				expect(updatePacket.data.length).to.be.equal(2);
 
@@ -87,7 +91,7 @@ describe('DataLayer', () => {
 	});
 
 	it('should be able to append new series WITHOUT updating time scale', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 
 		// actually we don't need to use Series, so we just use new Object()
 		const series1 = createSeriesMock();
@@ -112,7 +116,7 @@ describe('DataLayer', () => {
 	});
 
 	it('should be able to remove series if time scale is changed', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 
 		// actually we don't need to use Series, so we just use new Object()
 		const series1 = createSeriesMock();
@@ -157,7 +161,7 @@ describe('DataLayer', () => {
 	});
 
 	it('should be able to remove series if time scale is NOT changed', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 
 		// actually we don't need to use Series, so we just use new Object()
 		const series1 = createSeriesMock();
@@ -181,7 +185,7 @@ describe('DataLayer', () => {
 	});
 
 	it('should be able to add new point in the end', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 
 		// actually we don't need to use Series, so we just use new Object()
 		const series1 = createSeriesMock();
@@ -237,7 +241,7 @@ describe('DataLayer', () => {
 	});
 
 	it('should be able to change last existing point', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 
 		// actually we don't need to use Series, so we just use new Object()
 		const series1 = createSeriesMock();
@@ -252,7 +256,7 @@ describe('DataLayer', () => {
 		expect(updateResult1.timeScale.points).to.be.equal(undefined);
 		expect(updateResult1.timeScale.firstChangedPointIndex).to.be.equal(undefined);
 		expect(updateResult1.series.size).to.be.equal(1);
-		updateResult1.series.forEach((updatePacket: SeriesChanges, series: Series) => {
+		updateResult1.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
 			expect(series).to.be.equal(series1);
 			expect(updatePacket.data).excludingEvery(['value', 'originalTime']).to.have.deep.members([
 				{ index: 0, time: { timestamp: 1000 } },
@@ -266,7 +270,7 @@ describe('DataLayer', () => {
 		expect(updateResult2.timeScale.points).to.be.equal(undefined);
 		expect(updateResult2.timeScale.firstChangedPointIndex).to.be.equal(undefined);
 		expect(updateResult2.series.size).to.be.equal(1);
-		updateResult2.series.forEach((updatePacket: SeriesChanges, series: Series) => {
+		updateResult2.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
 			expect(series).to.be.equal(series2);
 			expect(updatePacket.data).excludingEvery(['value', 'originalTime']).to.have.deep.members([
 				{ index: 1, time: { timestamp: 2000 } },
@@ -276,7 +280,7 @@ describe('DataLayer', () => {
 	});
 
 	it('should be able to add new point in the middle', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 
 		// actually we don't need to use Series, so we just use new Object()
 		const series1 = createSeriesMock();
@@ -297,7 +301,7 @@ describe('DataLayer', () => {
 		]);
 		expect(updateResult.timeScale.firstChangedPointIndex).to.be.equal(2);
 		expect(updateResult.series.size).to.be.equal(2);
-		updateResult.series.forEach((updatePacket: SeriesChanges, series: Series) => {
+		updateResult.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
 			if (series === series1) {
 				expect(updatePacket.data.length).to.be.equal(2);
 
@@ -322,7 +326,7 @@ describe('DataLayer', () => {
 	});
 
 	it('allow business days', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 		const series1 = createSeriesMock();
 		const date1: BusinessDay = { day: 1, month: 10, year: 2019 };
 		const date2: BusinessDay = { day: 2, month: 10, year: 2019 };
@@ -352,26 +356,26 @@ describe('DataLayer', () => {
 			{ time: timePoint2, timeWeight: 50, originalTime: { day: 2, month: 10, year: 2019 } },
 		]);
 		expect(updateResult1.series.size).to.be.equal(1);
-		updateResult1.series.forEach((updatePacket: SeriesChanges, series: Series) => {
+		updateResult1.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
 			expect(series).to.be.equal(series);
 			expect(updatePacket.data.length).to.be.equal(2);
 
 			expect(updatePacket.data[0].index).to.be.equal(0 as TimePointIndex);
-			expect(updatePacket.data[0].time.timestamp).to.be.equal(1569888000 as UTCTimestamp);
+			expect((updatePacket.data[0].time as unknown as TimePoint).timestamp).to.be.equal(1569888000 as UTCTimestamp);
 			expect(updatePacket.data[1].index).to.be.equal(1 as TimePointIndex);
-			expect(updatePacket.data[1].time.timestamp).to.be.equal(1569974400 as UTCTimestamp);
+			expect((updatePacket.data[1].time as unknown as TimePoint).timestamp).to.be.equal(1569974400 as UTCTimestamp);
 		});
 	});
 
 	it('all points should have same time type', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 		const series = createSeriesMock();
 		expect(() => dataLayer.setSeriesData(series, [dataItemAt(5000 as UTCTimestamp), dataItemAt({ day: 1, month: 10, year: 2019 })]))
 			.to.throw();
 	});
 
 	it('all points should have same time type on updating', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 		const series = createSeriesMock();
 		dataLayer.setSeriesData(series, [dataItemAt({ day: 1, month: 10, year: 2019 })]);
 		expect(() => dataLayer.updateSeriesData(series, dataItemAt(5000 as UTCTimestamp)))
@@ -398,10 +402,10 @@ describe('DataLayer', () => {
 		const ohlcBasedTypes: SeriesType[] = ['Bar', 'Candlestick'];
 
 		for (const seriesType of ohlcBasedTypes) {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 			const series = createSeriesMock(seriesType);
 
-			const item: BarData & LineData = {
+			const item: BarData<Time> & LineData<Time> = {
 				time: '2017-01-01',
 				open: 10,
 				high: 15,
@@ -421,7 +425,7 @@ describe('DataLayer', () => {
 	});
 
 	it('should update removed series data gh#752', () => {
-		function generateData(): LineData[] {
+		function generateData(): LineData<Time>[] {
 			const res = [];
 			const time = new Date(Date.UTC(2018, 0, 1, 0, 0, 0, 0));
 
@@ -434,7 +438,7 @@ describe('DataLayer', () => {
 			return res;
 		}
 
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 		const series1 = createSeriesMock();
 		const series2 = createSeriesMock();
 		const data1 = generateData();
@@ -476,7 +480,7 @@ describe('DataLayer', () => {
 	});
 
 	it('should correctly update indexes of series data if times are not changed', () => {
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 
 		const series = createSeriesMock();
 
@@ -498,7 +502,7 @@ describe('DataLayer', () => {
 	});
 
 	describe('should update base index to null when all series data is cleared gh#757', () => {
-		const data: LineData[] = [
+		const data: LineData<Time>[] = [
 			{
 				time: 1609459200 as UTCTimestamp,
 				value: 31.533026412262345,
@@ -542,7 +546,7 @@ describe('DataLayer', () => {
 		];
 
 		it('single series', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 			const series = createSeriesMock();
 
 			dataLayer.setSeriesData(series, data);
@@ -554,7 +558,7 @@ describe('DataLayer', () => {
 
 		it('multiple series', () => {
 			const seriesCount = 5;
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 			const series = [];
 
 			for (let i = 0; i < seriesCount; i++) {
@@ -578,7 +582,7 @@ describe('DataLayer', () => {
 
 	describe('should be able to remove series and generate full update to other series if time scale is changed gh#355', () => {
 		const barsCount = 10;
-		function generateData(startTime: number, step: number): LineData[] {
+		function generateData(startTime: number, step: number): LineData<Time>[] {
 			const res = [];
 			let time = startTime;
 			for (let i = 0; i < barsCount; ++i) {
@@ -590,7 +594,7 @@ describe('DataLayer', () => {
 		}
 
 		it('remove first series', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series1 = createSeriesMock();
 			const series2 = createSeriesMock();
@@ -615,7 +619,7 @@ describe('DataLayer', () => {
 		});
 
 		it('remove second series', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series1 = createSeriesMock();
 			const series2 = createSeriesMock();
@@ -642,7 +646,7 @@ describe('DataLayer', () => {
 
 	describe('whitespaces', () => {
 		it('should allow to set whitespaces to series', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series = createSeriesMock();
 
@@ -664,19 +668,19 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(1);
 
-			const seriesUpdate = updateResult.series.get(series) as SeriesChanges;
+			const seriesUpdate = updateResult.series.get(series) as SeriesChanges<Time>;
 			expect(seriesUpdate).not.to.be.equal(undefined);
 			expect(seriesUpdate.data.length).to.be.equal(2);
 
 			expect(seriesUpdate.data[0].index).to.be.equal(0 as TimePointIndex);
-			expect(seriesUpdate.data[0].time.timestamp).to.be.equal(1000 as UTCTimestamp);
+			expect((seriesUpdate.data[0].time as unknown as TimePoint).timestamp).to.be.equal(1000 as UTCTimestamp);
 
 			expect(seriesUpdate.data[1].index).to.be.equal(3 as TimePointIndex);
-			expect(seriesUpdate.data[1].time.timestamp).to.be.equal(4000 as UTCTimestamp);
+			expect((seriesUpdate.data[1].time as unknown as TimePoint).timestamp).to.be.equal(4000 as UTCTimestamp);
 		});
 
 		it('should allow to append whitespace via update', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series = createSeriesMock();
 
@@ -697,19 +701,19 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(1);
 
-			const seriesUpdate = updateResult.series.get(series) as SeriesChanges;
+			const seriesUpdate = updateResult.series.get(series) as SeriesChanges<Time>;
 			expect(seriesUpdate).not.to.be.equal(undefined);
 			expect(seriesUpdate.data.length).to.be.equal(2);
 
 			expect(seriesUpdate.data[0].index).to.be.equal(0 as TimePointIndex);
-			expect(seriesUpdate.data[0].time.timestamp).to.be.equal(1000 as UTCTimestamp);
+			expect((seriesUpdate.data[0].time as unknown as TimePoint).timestamp).to.be.equal(1000 as UTCTimestamp);
 
 			expect(seriesUpdate.data[1].index).to.be.equal(1 as TimePointIndex);
-			expect(seriesUpdate.data[1].time.timestamp).to.be.equal(4000 as UTCTimestamp);
+			expect((seriesUpdate.data[1].time as unknown as TimePoint).timestamp).to.be.equal(4000 as UTCTimestamp);
 		});
 
 		it('should allow to replace whitespace with bar', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series = createSeriesMock();
 
@@ -727,7 +731,7 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(1);
 
-			const seriesUpdate = updateResult.series.get(series) as SeriesChanges;
+			const seriesUpdate = updateResult.series.get(series) as SeriesChanges<Time>;
 			expect(seriesUpdate).not.to.be.equal(undefined);
 
 			expect(seriesUpdate.data).excludingEvery(['value', 'originalTime']).to.have.deep.members([
@@ -738,7 +742,7 @@ describe('DataLayer', () => {
 		});
 
 		it('should allow to replace bar with whitespace', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series = createSeriesMock();
 
@@ -756,19 +760,19 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(1);
 
-			const seriesUpdate = updateResult.series.get(series) as SeriesChanges;
+			const seriesUpdate = updateResult.series.get(series) as SeriesChanges<Time>;
 			expect(seriesUpdate).not.to.be.equal(undefined);
 			expect(seriesUpdate.data.length).to.be.equal(2);
 
 			expect(seriesUpdate.data[0].index).to.be.equal(0 as TimePointIndex);
-			expect(seriesUpdate.data[0].time.timestamp).to.be.equal(1000 as UTCTimestamp);
+			expect((seriesUpdate.data[0].time as unknown as TimePoint).timestamp).to.be.equal(1000 as UTCTimestamp);
 
 			expect(seriesUpdate.data[1].index).to.be.equal(1 as TimePointIndex);
-			expect(seriesUpdate.data[1].time.timestamp).to.be.equal(4000 as UTCTimestamp);
+			expect((seriesUpdate.data[1].time as unknown as TimePoint).timestamp).to.be.equal(4000 as UTCTimestamp);
 		});
 
 		it('should generate full update if whitespace extends timescale', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series1 = createSeriesMock();
 			const series2 = createSeriesMock();
@@ -797,27 +801,27 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(2);
 
-			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series) => {
+			updateResult.series.forEach((seriesUpdate: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
 				expect(seriesUpdate.data.length).to.be.equal(2);
 
 				if (series === series1) {
 					expect(seriesUpdate.data[0].index).to.be.equal(0 as TimePointIndex);
-					expect(seriesUpdate.data[0].time.timestamp).to.be.equal(1000 as UTCTimestamp);
+					expect((seriesUpdate.data[0].time as unknown as TimePoint).timestamp).to.be.equal(1000 as UTCTimestamp);
 
 					expect(seriesUpdate.data[1].index).to.be.equal(4 as TimePointIndex);
-					expect(seriesUpdate.data[1].time.timestamp).to.be.equal(5000 as UTCTimestamp);
+					expect((seriesUpdate.data[1].time as unknown as TimePoint).timestamp).to.be.equal(5000 as UTCTimestamp);
 				} else {
 					expect(seriesUpdate.data[0].index).to.be.equal(1 as TimePointIndex);
-					expect(seriesUpdate.data[0].time.timestamp).to.be.equal(2000 as UTCTimestamp);
+					expect((seriesUpdate.data[0].time as unknown as TimePoint).timestamp).to.be.equal(2000 as UTCTimestamp);
 
 					expect(seriesUpdate.data[1].index).to.be.equal(2 as TimePointIndex);
-					expect(seriesUpdate.data[1].time.timestamp).to.be.equal(3000 as UTCTimestamp);
+					expect((seriesUpdate.data[1].time as unknown as TimePoint).timestamp).to.be.equal(3000 as UTCTimestamp);
 				}
 			});
 		});
 
 		it('should remove old whitespaces while setting new data', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series1 = createSeriesMock();
 			const series2 = createSeriesMock();
@@ -851,21 +855,21 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(2);
 
-			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series) => {
+			updateResult.series.forEach((seriesUpdate: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
 				expect(seriesUpdate.data.length).to.be.equal(2);
 
 				if (series === series1) {
 					expect(seriesUpdate.data[0].index).to.be.equal(0 as TimePointIndex);
-					expect(seriesUpdate.data[0].time.timestamp).to.be.equal(1000 as UTCTimestamp);
+					expect((seriesUpdate.data[0].time as unknown as TimePoint).timestamp).to.be.equal(1000 as UTCTimestamp);
 
 					expect(seriesUpdate.data[1].index).to.be.equal(3 as TimePointIndex);
-					expect(seriesUpdate.data[1].time.timestamp).to.be.equal(5000 as UTCTimestamp);
+					expect((seriesUpdate.data[1].time as unknown as TimePoint).timestamp).to.be.equal(5000 as UTCTimestamp);
 				} else {
 					expect(seriesUpdate.data[0].index).to.be.equal(1 as TimePointIndex);
-					expect(seriesUpdate.data[0].time.timestamp).to.be.equal(2000 as UTCTimestamp);
+					expect((seriesUpdate.data[0].time as unknown as TimePoint).timestamp).to.be.equal(2000 as UTCTimestamp);
 
 					expect(seriesUpdate.data[1].index).to.be.equal(2 as TimePointIndex);
-					expect(seriesUpdate.data[1].time.timestamp).to.be.equal(3000 as UTCTimestamp);
+					expect((seriesUpdate.data[1].time as unknown as TimePoint).timestamp).to.be.equal(3000 as UTCTimestamp);
 				}
 			});
 		});
diff --git a/tests/unittests/get-series-data-creator.spec.ts b/tests/unittests/get-series-data-creator.spec.ts
index db0c975b2d..26272f995b 100644
--- a/tests/unittests/get-series-data-creator.spec.ts
+++ b/tests/unittests/get-series-data-creator.spec.ts
@@ -2,25 +2,27 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { getSeriesDataCreator } from '../../src/api/get-series-data-creator';
+import { Time, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
+import { InternalHorzScaleItem } from '../../src/model/ihorz-scale-behavior';
 import { PlotRow } from '../../src/model/plot-data';
 import { AreaPlotRow, BarPlotRow, BaselinePlotRow, CandlestickPlotRow, HistogramPlotRow, LinePlotRow } from '../../src/model/series-data';
-import { OriginalTime, TimePointIndex, UTCTimestamp } from '../../src/model/time-data';
+import { TimePointIndex } from '../../src/model/time-data';
 
-const plotRow: PlotRow = {
+const plotRow: PlotRow<Time> = {
 	index: 0 as TimePointIndex,
-	time: { timestamp: 1649931070 as UTCTimestamp },
+	time: { timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 	value: [1, 2, 3, 4],
-	originalTime: 1649931070 as unknown as OriginalTime,
+	originalTime: 1649931070 as UTCTimestamp,
 };
 
-const linePlotRows: LinePlotRow[] = [
+const linePlotRows: LinePlotRow<Time>[] = [
 	{
 		...plotRow,
 		color: '#FF0000',
 	},
 	plotRow,
 ];
-const areaPlotRows: AreaPlotRow[] = [
+const areaPlotRows: AreaPlotRow<Time>[] = [
 	{
 		...plotRow,
 		lineColor: '#FF0000',
@@ -29,7 +31,7 @@ const areaPlotRows: AreaPlotRow[] = [
 	},
 	plotRow,
 ];
-const baselinePlotRows: BaselinePlotRow[] = [
+const baselinePlotRows: BaselinePlotRow<Time>[] = [
 	{
 		...plotRow,
 		topFillColor1: '#000001',
@@ -41,21 +43,21 @@ const baselinePlotRows: BaselinePlotRow[] = [
 	},
 	plotRow,
 ];
-const histogramPlotRow: HistogramPlotRow[] = [
+const histogramPlotRow: HistogramPlotRow<Time>[] = [
 	{
 		...plotRow,
 		color: '#00FF00',
 	},
 	plotRow,
 ];
-const barPlotRow: BarPlotRow[] = [
+const barPlotRow: BarPlotRow<Time>[] = [
 	{
 		...plotRow,
 		color: '#0000FF',
 	},
 	plotRow,
 ];
-const candlestickPlotRows: CandlestickPlotRow[] = [
+const candlestickPlotRows: CandlestickPlotRow<Time>[] = [
 	{
 		...plotRow,
 		color: '#0000FF',
diff --git a/tests/unittests/get-series-plot-row-creator.spec.ts b/tests/unittests/get-series-plot-row-creator.spec.ts
index 5603ae33cc..379b1db5f0 100644
--- a/tests/unittests/get-series-plot-row-creator.spec.ts
+++ b/tests/unittests/get-series-plot-row-creator.spec.ts
@@ -2,31 +2,33 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { getSeriesPlotRowCreator } from '../../src/model/get-series-plot-row-creator';
-import { OriginalTime, TimePointIndex, UTCTimestamp } from '../../src/model/time-data';
+import { Time, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
+import { InternalHorzScaleItem } from '../../src/model/ihorz-scale-behavior';
+import { TimePointIndex } from '../../src/model/time-data';
 
 describe('getSeriesPlotRowCreator', () => {
 	it('Line', () => {
-		expect(getSeriesPlotRowCreator('Line')(
-			{ timestamp: 1649931070 as UTCTimestamp },
+		expect(getSeriesPlotRowCreator<'Line', Time>('Line')(
+			{ timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 			0 as TimePointIndex,
 			{
 				value: 4,
 				time: 1649931070 as UTCTimestamp,
 				color: '#FF0000',
 			},
-			1649931070 as unknown as OriginalTime
+			1649931070 as UTCTimestamp
 		)).to.deep.equal({
 			index: 0 as TimePointIndex,
 			time: { timestamp: 1649931070 as UTCTimestamp },
 			value: [4, 4, 4, 4],
-			originalTime: 1649931070 as unknown as OriginalTime,
+			originalTime: 1649931070 as UTCTimestamp,
 			color: '#FF0000',
 		});
 	});
 
 	it('Area', () => {
 		expect(getSeriesPlotRowCreator('Area')(
-			{ timestamp: 1649931070 as UTCTimestamp },
+			{ timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 			0 as TimePointIndex,
 			{
 				value: 4,
@@ -35,12 +37,12 @@ describe('getSeriesPlotRowCreator', () => {
 				topColor: '#00FF00',
 				bottomColor: '#0000FF',
 			},
-			1649931070 as unknown as OriginalTime
+			1649931070 as unknown as UTCTimestamp
 		)).to.deep.equal({
 			index: 0 as TimePointIndex,
 			time: { timestamp: 1649931070 as UTCTimestamp },
 			value: [4, 4, 4, 4],
-			originalTime: 1649931070 as unknown as OriginalTime,
+			originalTime: 1649931070 as UTCTimestamp,
 			lineColor: '#FF0000',
 			topColor: '#00FF00',
 			bottomColor: '#0000FF',
@@ -49,7 +51,7 @@ describe('getSeriesPlotRowCreator', () => {
 
 	it('Baseline', () => {
 		expect(getSeriesPlotRowCreator('Baseline')(
-			{ timestamp: 1649931070 as UTCTimestamp },
+			{ timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 			0 as TimePointIndex,
 			{
 				value: 4,
@@ -61,12 +63,12 @@ describe('getSeriesPlotRowCreator', () => {
 				bottomFillColor2: '#000005',
 				bottomLineColor: '#000006',
 			},
-			1649931070 as unknown as OriginalTime
+			1649931070 as UTCTimestamp
 		)).to.deep.equal({
 			index: 0 as TimePointIndex,
-			time: { timestamp: 1649931070 as UTCTimestamp },
+			time: { timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 			value: [4, 4, 4, 4],
-			originalTime: 1649931070 as unknown as OriginalTime,
+			originalTime: 1649931070 as UTCTimestamp,
 			topFillColor1: '#000001',
 			topFillColor2: '#000002',
 			topLineColor: '#000003',
@@ -78,26 +80,26 @@ describe('getSeriesPlotRowCreator', () => {
 
 	it('Histogram', () => {
 		expect(getSeriesPlotRowCreator('Histogram')(
-			{ timestamp: 1649931070 as UTCTimestamp },
+			{ timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 			0 as TimePointIndex,
 			{
 				value: 4,
 				time: 1649931070 as UTCTimestamp,
 				color: '#FF0000',
 			},
-			1649931070 as unknown as OriginalTime
+			1649931070 as UTCTimestamp
 		)).to.deep.equal({
 			index: 0 as TimePointIndex,
 			time: { timestamp: 1649931070 as UTCTimestamp },
 			value: [4, 4, 4, 4],
-			originalTime: 1649931070 as unknown as OriginalTime,
+			originalTime: 1649931070 as UTCTimestamp,
 			color: '#FF0000',
 		});
 	});
 
 	it('Bar', () => {
 		expect(getSeriesPlotRowCreator('Bar')(
-			{ timestamp: 1649931070 as UTCTimestamp },
+			{ timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 			0 as TimePointIndex,
 			{
 				open: 1,
@@ -107,19 +109,19 @@ describe('getSeriesPlotRowCreator', () => {
 				time: 1649931070 as UTCTimestamp,
 				color: '#FF0000',
 			},
-			1649931070 as unknown as OriginalTime
+			1649931070 as UTCTimestamp
 		)).to.deep.equal({
 			index: 0 as TimePointIndex,
 			time: { timestamp: 1649931070 as UTCTimestamp },
 			value: [1, 3, 0, 2],
-			originalTime: 1649931070 as unknown as OriginalTime,
+			originalTime: 1649931070 as UTCTimestamp,
 			color: '#FF0000',
 		});
 	});
 
 	it('Candlestick', () => {
 		expect(getSeriesPlotRowCreator('Candlestick')(
-			{ timestamp: 1649931070 as UTCTimestamp },
+			{ timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 			0 as TimePointIndex,
 			{
 				open: 1,
@@ -131,12 +133,12 @@ describe('getSeriesPlotRowCreator', () => {
 				borderColor: '#00FF00',
 				wickColor: '#0000FF',
 			},
-			1649931070 as unknown as OriginalTime
+			1649931070 as UTCTimestamp
 		)).to.deep.equal({
 			index: 0 as TimePointIndex,
 			time: { timestamp: 1649931070 as UTCTimestamp },
 			value: [1, 3, 0, 2],
-			originalTime: 1649931070 as unknown as OriginalTime,
+			originalTime: 1649931070 as UTCTimestamp,
 			color: '#FF0000',
 			borderColor: '#00FF00',
 			wickColor: '#0000FF',
diff --git a/tests/unittests/plot-list.spec.ts b/tests/unittests/plot-list.spec.ts
index 3456deff08..6686637d63 100644
--- a/tests/unittests/plot-list.spec.ts
+++ b/tests/unittests/plot-list.spec.ts
@@ -2,20 +2,22 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { ensureNotNull } from '../../src/helpers/assertions';
+import { TimePoint, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
+import { InternalHorzScaleItem } from '../../src/model/ihorz-scale-behavior';
 import { PlotRow, PlotRowValue, PlotRowValueIndex } from '../../src/model/plot-data';
 import { MismatchDirection, PlotList } from '../../src/model/plot-list';
-import { OriginalTime, TimePoint, TimePointIndex, UTCTimestamp } from '../../src/model/time-data';
+import { TimePointIndex } from '../../src/model/time-data';
 
 function timePoint(val: number): TimePoint {
 	return { timestamp: val as UTCTimestamp };
 }
 
-function plotRow(index: TimePointIndex, time: TimePoint, value: PlotRowValue): PlotRow {
-	return { index, time, value, originalTime: time as unknown as OriginalTime };
+function plotRow(index: TimePointIndex, time: TimePoint, value: PlotRowValue): PlotRow<TimePoint> {
+	return { index, time: time as unknown as InternalHorzScaleItem, value, originalTime: time };
 }
 
 describe('PlotList', () => {
-	let p: PlotList;
+	let p: PlotList<TimePoint>;
 
 	beforeEach(() => {
 		p = new PlotList();
@@ -130,7 +132,7 @@ describe('PlotList', () => {
 	});
 
 	describe('minMaxOnRangeByPlotFunction and minMaxOnRangeByPlotFunctionCached', () => {
-		let pl: PlotList;
+		let pl: PlotList<TimePoint>;
 
 		beforeEach(() => {
 			pl = new PlotList();
diff --git a/tests/unittests/time-scale.spec.ts b/tests/unittests/time-scale.spec.ts
index 6004a58aeb..e715e4927b 100644
--- a/tests/unittests/time-scale.spec.ts
+++ b/tests/unittests/time-scale.spec.ts
@@ -4,42 +4,42 @@ import { describe, it } from 'mocha';
 import { timeScaleOptionsDefaults } from '../../src/api/options/time-scale-options-defaults';
 import { ChartModel } from '../../src/model/chart-model';
 import { Coordinate } from '../../src/model/coordinate';
+import { HorzScaleBehaviorTime } from '../../src/model/horz-scale-behavior-time/horz-scale-behavior-time';
+import { Time, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
+import { InternalHorzScaleItem } from '../../src/model/ihorz-scale-behavior';
 import { LocalizationOptions } from '../../src/model/localization-options';
-import {
-	OriginalTime,
-	TimePointIndex,
-	TimeScalePoint,
-	UTCTimestamp,
-} from '../../src/model/time-data';
+import { TickMarkWeightValue, TimePointIndex, TimeScalePoint } from '../../src/model/time-data';
 import { TimeScale } from '../../src/model/time-scale';
 
-function chartModelMock(): ChartModel {
+function chartModelMock(): ChartModel<Time> {
 	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 	return {
 		recalculateAllPanes: () => {},
 		lightUpdate: () => {},
-	} as ChartModel;
+	} as ChartModel<Time>;
 }
 
-function tsUpdate(to: number): Parameters<TimeScale['update']> {
-	const points: TimeScalePoint[] = [];
+function tsUpdate(to: number): Parameters<TimeScale<Time>['update']> {
+	const points: TimeScalePoint<Time>[] = [];
 
 	const startIndex = 0;
 	for (let i = startIndex; i <= to; ++i) {
-		points.push({ time: { timestamp: i as UTCTimestamp }, timeWeight: 20, originalTime: i as unknown as OriginalTime });
+		points.push({ time: { timestamp: i as UTCTimestamp } as unknown as InternalHorzScaleItem, timeWeight: 20 as TickMarkWeightValue, originalTime: i as UTCTimestamp });
 	}
 
 	return [points, 0];
 }
 
+const behavior = new HorzScaleBehaviorTime();
+
 describe('TimeScale', () => {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	const fakeLocalizationOptions: LocalizationOptions = {} as any;
+	const fakeLocalizationOptions: LocalizationOptions<Time> = {} as any;
 
 	it('indexToCoordinate and coordinateToIndex inverse', () => {
 		const lastIndex = 499 as TimePointIndex;
 
-		const ts = new TimeScale(chartModelMock(), { ...timeScaleOptionsDefaults, barSpacing: 1, rightOffset: 0 }, fakeLocalizationOptions);
+		const ts = new TimeScale<Time>(chartModelMock(), { ...timeScaleOptionsDefaults, barSpacing: 1, rightOffset: 0 }, fakeLocalizationOptions, behavior);
 		ts.setWidth(500);
 		ts.update(...tsUpdate(lastIndex));
 		ts.setBaseIndex(lastIndex);
@@ -50,7 +50,7 @@ describe('TimeScale', () => {
 	it('all *ToCoordinate functions should return same coordinate for the same index', () => {
 		const lastIndex = 499 as TimePointIndex;
 
-		const ts = new TimeScale(chartModelMock(), { ...timeScaleOptionsDefaults, barSpacing: 1, rightOffset: 0 }, fakeLocalizationOptions);
+		const ts = new TimeScale<Time>(chartModelMock(), { ...timeScaleOptionsDefaults, barSpacing: 1, rightOffset: 0 }, fakeLocalizationOptions, behavior);
 		ts.setWidth(500);
 		ts.update(...tsUpdate(lastIndex));
 		ts.setBaseIndex(lastIndex);
@@ -69,60 +69,60 @@ describe('TimeScale', () => {
 
 	describe('timeToIndex', () => {
 		it('should return index for time on scale', () => {
-			const ts = new TimeScale(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions);
+			const ts = new TimeScale<Time>(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions, behavior);
 
 			ts.update(...tsUpdate(2));
 
-			expect(ts.timeToIndex({ timestamp: 0 as UTCTimestamp }, false)).to.be.equal(0);
-			expect(ts.timeToIndex({ timestamp: 1 as UTCTimestamp }, false)).to.be.equal(1);
-			expect(ts.timeToIndex({ timestamp: 2 as UTCTimestamp }, false)).to.be.equal(2);
+			expect(ts.timeToIndex({ timestamp: 0 as UTCTimestamp } as unknown as InternalHorzScaleItem, false)).to.be.equal(0);
+			expect(ts.timeToIndex({ timestamp: 1 as UTCTimestamp } as unknown as InternalHorzScaleItem, false)).to.be.equal(1);
+			expect(ts.timeToIndex({ timestamp: 2 as UTCTimestamp } as unknown as InternalHorzScaleItem, false)).to.be.equal(2);
 		});
 
 		it('should return null for time not on scale', () => {
-			const ts = new TimeScale(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions);
+			const ts = new TimeScale<Time>(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions, behavior);
 
 			ts.update(...tsUpdate(2));
 
-			expect(ts.timeToIndex({ timestamp: -1 as UTCTimestamp }, false)).to.be.equal(null);
-			expect(ts.timeToIndex({ timestamp: 3 as UTCTimestamp }, false)).to.be.equal(null);
+			expect(ts.timeToIndex({ timestamp: -1 as UTCTimestamp } as unknown as InternalHorzScaleItem, false)).to.be.equal(null);
+			expect(ts.timeToIndex({ timestamp: 3 as UTCTimestamp } as unknown as InternalHorzScaleItem, false)).to.be.equal(null);
 		});
 
 		it('should return null if time scale is empty', () => {
-			const ts = new TimeScale(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions);
+			const ts = new TimeScale<Time>(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions, behavior);
 
-			expect(ts.timeToIndex({ timestamp: 123 as UTCTimestamp }, false)).to.be.equal(null);
+			expect(ts.timeToIndex({ timestamp: 123 as UTCTimestamp } as unknown as InternalHorzScaleItem, false)).to.be.equal(null);
 		});
 
 		it('should return null if timestamp is between two values on the scale', () => {
-			const ts = new TimeScale(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions);
+			const ts = new TimeScale<Time>(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions, behavior);
 
 			ts.update(...tsUpdate(1));
 
-			expect(ts.timeToIndex({ timestamp: 0.5 as UTCTimestamp }, false)).to.be.equal(null);
+			expect(ts.timeToIndex({ timestamp: 0.5 as UTCTimestamp } as unknown as InternalHorzScaleItem, false)).to.be.equal(null);
 		});
 
 		it('should return last index if timestamp is greater than last timestamp and findNearest is parameter is true', () => {
-			const ts = new TimeScale(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions);
+			const ts = new TimeScale<Time>(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions, behavior);
 
 			ts.update(...tsUpdate(2));
 
-			expect(ts.timeToIndex({ timestamp: 3 as UTCTimestamp }, true)).to.be.equal(2);
+			expect(ts.timeToIndex({ timestamp: 3 as UTCTimestamp } as unknown as InternalHorzScaleItem, true)).to.be.equal(2);
 		});
 
 		it('should return first index if timestamp is less than first timestamp and findNearest is parameter is true', () => {
-			const ts = new TimeScale(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions);
+			const ts = new TimeScale<Time>(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions, behavior);
 
 			ts.update(...tsUpdate(2));
 
-			expect(ts.timeToIndex({ timestamp: -1 as UTCTimestamp }, true)).to.be.equal(0);
+			expect(ts.timeToIndex({ timestamp: -1 as UTCTimestamp } as unknown as InternalHorzScaleItem, true)).to.be.equal(0);
 		});
 
 		it('should return next index if timestamp is between two values on the scale and findNearest parameter is true', () => {
-			const ts = new TimeScale(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions);
+			const ts = new TimeScale<Time>(chartModelMock(), timeScaleOptionsDefaults, fakeLocalizationOptions, behavior);
 
 			ts.update(...tsUpdate(1));
 
-			expect(ts.timeToIndex({ timestamp: 0.5 as UTCTimestamp }, true)).to.be.equal(1);
+			expect(ts.timeToIndex({ timestamp: 0.5 as UTCTimestamp } as unknown as InternalHorzScaleItem, true)).to.be.equal(1);
 		});
 	});
 });

From fb99f4824e715b59182fc30fc939361e7cfe7d4c Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 4 Apr 2023 13:26:21 +0300
Subject: [PATCH 05/23] Fixed linters

---
 src/api/chart-api.ts                          |  4 +--
 src/api/create-chart.ts                       |  5 +++-
 src/api/get-series-data-creator.ts            | 21 +++++++--------
 src/api/ichart-api.ts                         |  2 +-
 src/api/iseries-api.ts                        |  2 +-
 src/api/options/chart-options-defaults.ts     |  2 +-
 src/api/series-api.ts                         |  5 ++--
 src/index.ts                                  |  2 ++
 src/model/data-layer.ts                       |  8 ++----
 src/model/data-validators.ts                  |  5 ++--
 src/model/get-series-plot-row-creator.ts      |  3 +--
 .../horz-scale-behavior-time.ts               | 15 +++++------
 src/model/horz-scale-behavior-time/types.ts   |  5 ++--
 src/model/ihorz-scale-behavior.ts             | 26 +++++++++----------
 src/model/series-bar-colorer.ts               |  7 +++--
 src/model/series-markers.ts                   |  3 +++
 src/model/time-scale.ts                       |  4 +++
 tests/unittests/data-layer.spec.ts            |  6 ++---
 18 files changed, 64 insertions(+), 61 deletions(-)

diff --git a/src/api/chart-api.ts b/src/api/chart-api.ts
index f167768e92..e6f8fe9f06 100644
--- a/src/api/chart-api.ts
+++ b/src/api/chart-api.ts
@@ -6,6 +6,8 @@ import { warn } from '../helpers/logger';
 import { clone, DeepPartial, isBoolean, merge } from '../helpers/strict-type-checks';
 
 import { ChartOptions, ChartOptionsInternal } from '../model/chart-model';
+import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap } from '../model/data-consumer';
+import { DataLayer, DataUpdateResponse, SeriesChanges } from '../model/data-layer';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 import { Series } from '../model/series';
 import { SeriesPlotRow } from '../model/series-data';
@@ -27,8 +29,6 @@ import {
 } from '../model/series-options';
 import { Logical } from '../model/time-data';
 
-import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap } from '../model/data-consumer';
-import { DataLayer, DataUpdateResponse, SeriesChanges } from '../model/data-layer';
 import { getSeriesDataCreator } from './get-series-data-creator';
 import { IChartApi, MouseEventHandler, MouseEventParams } from './ichart-api';
 import { IPriceScaleApi } from './iprice-scale-api';
diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index 176b7bc2fd..63c55a877e 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -3,6 +3,7 @@ import { Nominal } from '../helpers/nominal';
 import { DeepPartial, isString, merge } from '../helpers/strict-type-checks';
 
 import { ChartOptions } from '../model/chart-model';
+import { SeriesDataItemTypeMap } from '../model/data-consumer';
 import { HorzScaleBehaviorTime } from '../model/horz-scale-behavior-time/horz-scale-behavior-time';
 import { Time } from '../model/horz-scale-behavior-time/types';
 import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../model/ihorz-scale-behavior';
@@ -13,7 +14,6 @@ import { TickMarkWeightValue, TimeScalePoint } from '../model/time-data';
 import { markWithGreaterWeight, TimeMark } from '../model/time-scale';
 
 import { ChartApi } from './chart-api';
-import { SeriesDataItemTypeMap } from '../model/data-consumer';
 import { IChartApi } from './ichart-api';
 
 /**
@@ -42,6 +42,9 @@ export function createChart(container: string | HTMLElement, options?: DeepParti
 	return createChartEx<Time>(container, new HorzScaleBehaviorTime(), merge({ localization: { dateFormat: 'dd MMM \'yy' } }, options ?? {}));
 }
 
+/**
+ * Nominal for numbers used as values in the horizontal scale
+ */
 type Price = Nominal<number, 'Price'>;
 
 class HorzScaleBehaviorPrice implements IHorzScaleBehavior<Price> {
diff --git a/src/api/get-series-data-creator.ts b/src/api/get-series-data-creator.ts
index 216519feb1..0796d19670 100644
--- a/src/api/get-series-data-creator.ts
+++ b/src/api/get-series-data-creator.ts
@@ -1,14 +1,3 @@
-import { PlotRow, PlotRowValueIndex } from '../model/plot-data';
-import {
-	AreaPlotRow,
-	BarPlotRow,
-	BaselinePlotRow,
-	CandlestickPlotRow,
-	LinePlotRow,
-	SeriesPlotRow,
-} from '../model/series-data';
-import { SeriesType } from '../model/series-options';
-
 import {
 	AreaData,
 	BarData,
@@ -19,6 +8,16 @@ import {
 	SeriesDataItemTypeMap,
 	SingleValueData,
 } from '../model/data-consumer';
+import { PlotRow, PlotRowValueIndex } from '../model/plot-data';
+import {
+	AreaPlotRow,
+	BarPlotRow,
+	BaselinePlotRow,
+	CandlestickPlotRow,
+	LinePlotRow,
+	SeriesPlotRow,
+} from '../model/series-data';
+import { SeriesType } from '../model/series-options';
 
 type SeriesPlotRowToDataMap<HorzScaleItem> = {
 	[T in keyof SeriesDataItemTypeMap<HorzScaleItem>]: (plotRow: SeriesPlotRow<T, HorzScaleItem>) => SeriesDataItemTypeMap<HorzScaleItem>[T];
diff --git a/src/api/ichart-api.ts b/src/api/ichart-api.ts
index da1e8c511b..378ae32c7b 100644
--- a/src/api/ichart-api.ts
+++ b/src/api/ichart-api.ts
@@ -1,6 +1,7 @@
 import { DeepPartial } from '../helpers/strict-type-checks';
 
 import { ChartOptions } from '../model/chart-model';
+import { BarData, HistogramData, LineData } from '../model/data-consumer';
 import { Time } from '../model/horz-scale-behavior-time/types';
 import { Point } from '../model/point';
 import {
@@ -15,7 +16,6 @@ import {
 import { Logical } from '../model/time-data';
 import { TouchMouseEventData } from '../model/touch-mouse-event-data';
 
-import { BarData, HistogramData, LineData } from '../model/data-consumer';
 import { IPriceScaleApi } from './iprice-scale-api';
 import { ISeriesApi } from './iseries-api';
 import { ITimeScaleApi } from './itime-scale-api';
diff --git a/src/api/iseries-api.ts b/src/api/iseries-api.ts
index f2c8c30f64..b7847fae2d 100644
--- a/src/api/iseries-api.ts
+++ b/src/api/iseries-api.ts
@@ -2,6 +2,7 @@ import { IPriceFormatter } from '../formatters/iprice-formatter';
 
 import { BarPrice } from '../model/bar';
 import { Coordinate } from '../model/coordinate';
+import { SeriesDataItemTypeMap } from '../model/data-consumer';
 import { MismatchDirection } from '../model/plot-list';
 import { CreatePriceLineOptions } from '../model/price-line-options';
 import { SeriesMarker } from '../model/series-markers';
@@ -12,7 +13,6 @@ import {
 } from '../model/series-options';
 import { Range } from '../model/time-data';
 
-import { SeriesDataItemTypeMap } from '../model/data-consumer';
 import { IPriceLine } from './iprice-line';
 import { IPriceScaleApi } from './iprice-scale-api';
 
diff --git a/src/api/options/chart-options-defaults.ts b/src/api/options/chart-options-defaults.ts
index 50628e5c5d..10c003e58f 100644
--- a/src/api/options/chart-options-defaults.ts
+++ b/src/api/options/chart-options-defaults.ts
@@ -9,7 +9,7 @@ import { priceScaleOptionsDefaults } from './price-scale-options-defaults';
 import { timeScaleOptionsDefaults } from './time-scale-options-defaults';
 import { watermarkOptionsDefaults } from './watermark-options-defaults';
 
-export function chartOptionsDefaults<HorzScaleItem>() : ChartOptionsInternal<HorzScaleItem> {
+export function chartOptionsDefaults<HorzScaleItem>(): ChartOptionsInternal<HorzScaleItem> {
 	return {
 		width: 0,
 		height: 0,
diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index f6fc004f9a..99a2faa2d0 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -5,6 +5,8 @@ import { clone, merge } from '../helpers/strict-type-checks';
 
 import { BarPrice } from '../model/bar';
 import { Coordinate } from '../model/coordinate';
+import { DataUpdatesConsumer, SeriesDataItemTypeMap } from '../model/data-consumer';
+import { checkItemsAreOrdered, checkPriceLineOptions, checkSeriesValuesType } from '../model/data-validators';
 import { IHorzScaleBehavior, InternalHorzScaleItem } from '../model/ihorz-scale-behavior';
 import { MismatchDirection } from '../model/plot-list';
 import { CreatePriceLineOptions, PriceLineOptions } from '../model/price-line-options';
@@ -20,8 +22,6 @@ import { Logical, Range, TimePointIndex } from '../model/time-data';
 import { TimeScaleVisibleRange } from '../model/time-scale-visible-range';
 
 import { IPriceScaleApiProvider } from './chart-api';
-import { DataUpdatesConsumer, SeriesDataItemTypeMap } from '../model/data-consumer';
-import { checkItemsAreOrdered, checkPriceLineOptions, checkSeriesValuesType } from '../model/data-validators';
 import { getSeriesDataCreator } from './get-series-data-creator';
 import { IPriceLine } from './iprice-line';
 import { IPriceScaleApi } from './iprice-scale-api';
@@ -65,7 +65,6 @@ export class SeriesApi<TSeriesType extends SeriesType, HorzScaleItem> implements
 		return this._series.priceScale().coordinateToPrice(coordinate as Coordinate, firstValue.value);
 	}
 
-	// eslint-disable-next-line complexity
 	public barsInLogicalRange(range: Range<number> | null): BarsInfo<HorzScaleItem> | null {
 		if (range === null) {
 			return null;
diff --git a/src/index.ts b/src/index.ts
index 7711bd15a0..dda54e61c2 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -11,6 +11,8 @@ export { ColorType } from './model/layout-options';
 
 export { createChart, createOptionsChart } from './api/create-chart';
 
+export { isBusinessDay } from './model/horz-scale-behavior-time/types';
+
 /**
  * Returns the current version as a string. For example `'3.3.0'`.
  */
diff --git a/src/model/data-layer.ts b/src/model/data-layer.ts
index 2e32803c6d..66d5539e1d 100644
--- a/src/model/data-layer.ts
+++ b/src/model/data-layer.ts
@@ -3,6 +3,8 @@
 import { lowerbound } from '../helpers/algorithms';
 import { ensureDefined } from '../helpers/assertions';
 
+import { SeriesDataItemTypeMap } from './data-consumer';
+import { getSeriesPlotRowCreator, isSeriesPlotRow, WhitespacePlotRow } from './get-series-plot-row-creator';
 import { IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from './ihorz-scale-behavior';
 import { Series, SeriesUpdateInfo } from './series';
 import { SeriesPlotRow } from './series-data';
@@ -13,11 +15,6 @@ import {
 	TimeScalePoint,
 } from './time-data';
 
-import {
-	SeriesDataItemTypeMap,
-} from './data-consumer';
-import { getSeriesPlotRowCreator, isSeriesPlotRow, WhitespacePlotRow } from './get-series-plot-row-creator';
-
 export type TimedData<HorzScaleItem> = Pick<SeriesDataItemTypeMap<HorzScaleItem>[SeriesType], 'time'>;
 
 export interface TimeScaleChanges<HorzScaleItem> {
@@ -119,7 +116,6 @@ function timeScalePointTime<TSeriesType extends SeriesType, HorzScaleItem>(merge
 }
 
 function saveOriginalTime<TSeriesType extends SeriesType, HorzScaleItem>(data: SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>): void {
-	// eslint-disable-next-line @typescript-eslint/tslint/config
 	if (data.originalTime === undefined) {
 		data.originalTime = data.time;
 	}
diff --git a/src/model/data-validators.ts b/src/model/data-validators.ts
index cd6a37dc8d..0956ccb584 100644
--- a/src/model/data-validators.ts
+++ b/src/model/data-validators.ts
@@ -1,12 +1,13 @@
+/// <reference types="_build-time-constants" />
+
 import { assert } from '../helpers/assertions';
 
+import { isFulfilledData, SeriesDataItemTypeMap } from './data-consumer';
 import { IHorzScaleBehavior } from './ihorz-scale-behavior';
 import { CreatePriceLineOptions } from './price-line-options';
 import { SeriesMarker } from './series-markers';
 import { SeriesType } from './series-options';
 
-import { isFulfilledData, SeriesDataItemTypeMap } from './data-consumer';
-
 export function checkPriceLineOptions(options: CreatePriceLineOptions): void {
 	if (process.env.NODE_ENV === 'production') {
 		return;
diff --git a/src/model/get-series-plot-row-creator.ts b/src/model/get-series-plot-row-creator.ts
index e972341aa3..cd8b929fb6 100644
--- a/src/model/get-series-plot-row-creator.ts
+++ b/src/model/get-series-plot-row-creator.ts
@@ -1,11 +1,10 @@
+import { AreaData, BarData, BaselineData, CandlestickData, HistogramData, isWhitespaceData, LineData, SeriesDataItemTypeMap } from './data-consumer';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { PlotRow } from './plot-data';
 import { SeriesPlotRow } from './series-data';
 import { SeriesType } from './series-options';
 import { TimePointIndex } from './time-data';
 
-import { AreaData, BarData, BaselineData, CandlestickData, HistogramData, isWhitespaceData, LineData, SeriesDataItemTypeMap } from './data-consumer';
-
 function getColoredLineBasedSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: LineData<HorzScaleItem> | HistogramData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Line' | 'Histogram', HorzScaleItem>> {
 	const val = item.value;
 
diff --git a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
index 74e9d0b974..ad96ba1019 100644
--- a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
+++ b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
@@ -1,17 +1,18 @@
-import { SeriesDataItemTypeMap } from '../data-consumer';
-import { TimedData } from '../data-layer';
-import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../ihorz-scale-behavior';
 import { DateFormatter } from '../../formatters/date-formatter';
 import { DateTimeFormatter } from '../../formatters/date-time-formatter';
+
 import { ensureNotNull } from '../../helpers/assertions';
 import { isString } from '../../helpers/strict-type-checks';
+
 import { ChartOptions } from '../chart-model';
+import { SeriesDataItemTypeMap } from '../data-consumer';
+import { TimedData } from '../data-layer';
+import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../ihorz-scale-behavior';
 import { LocalizationOptions } from '../localization-options';
 import { SeriesType } from '../series-options';
 import { TickMark } from '../tick-marks';
 import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
 import { markWithGreaterWeight, TimeMark, TimeScaleOptions } from '../time-scale';
-
 import { defaultTickMarkFormatter } from './default-tick-mark-formatter';
 import { fillWeightsForPoints } from './time-scale-point-weight-generator';
 import { BusinessDay, isBusinessDay, isUTCTimestamp, TickMarkType, TickMarkWeight, Time, TimePoint, UTCTimestamp } from './types';
@@ -164,7 +165,7 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 	private _dateTimeFormatter!: DateFormatter | DateTimeFormatter;
 	private _options!: ChartOptions<Time>;
 
-	public setOptions(options: ChartOptions<Time>) {
+	public setOptions(options: ChartOptions<Time>): void {
 		this._options = options;
 		this.updateFormatter(options.localization as TimeLocalizationOptions);
 	}
@@ -187,7 +188,7 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 	}
 
 	public key(item: InternalHorzScaleItem | Time): InternalHorzScaleItemKey {
-		if ((typeof item === 'object') && 'timestamp' in item) {
+		if (typeof item === 'object') {
 			return (item as unknown as TimePoint).timestamp as unknown as InternalHorzScaleItemKey;
 		} else {
 			return this.key(this.convertHorzItemToInternal(item as Time));
@@ -201,7 +202,6 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 			: new Date(Date.UTC(time.businessDay.year, time.businessDay.month - 1, time.businessDay.day)).getTime();
 	}
 
-
 	public convertHorzItemToInternal(item: Time): InternalHorzScaleItem {
 		return convertTime(item);
 	}
@@ -262,5 +262,4 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Time>>[], startIndex: number): void {
 		fillWeightsForPoints(sortedTimePoints, startIndex);
 	}
-
 }
diff --git a/src/model/horz-scale-behavior-time/types.ts b/src/model/horz-scale-behavior-time/types.ts
index 5ec826c7e0..feba41343b 100644
--- a/src/model/horz-scale-behavior-time/types.ts
+++ b/src/model/horz-scale-behavior-time/types.ts
@@ -1,5 +1,5 @@
-import { Nominal } from "../../helpers/nominal";
-import { isNumber, isString } from "../../helpers/strict-type-checks";
+import { Nominal } from '../../helpers/nominal';
+import { isNumber, isString } from '../../helpers/strict-type-checks';
 
 /**
  * Represents a time as a UNIX timestamp.
@@ -99,7 +99,6 @@ export const enum TickMarkType {
 	/**
 	 * A time without seconds.
 	 */
-	// eslint-disable-next-line @typescript-eslint/no-shadow
 	Time,
 	/**
 	 * A time with seconds.
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
index e2bf3e7daf..98d8bbf89e 100644
--- a/src/model/ihorz-scale-behavior.ts
+++ b/src/model/ihorz-scale-behavior.ts
@@ -1,13 +1,13 @@
 import { Nominal } from '../helpers/nominal';
+
 import { ChartOptions } from './chart-model';
+import { SeriesDataItemTypeMap } from './data-consumer';
 import { LocalizationOptions } from './localization-options';
 import { SeriesType } from './series-options';
 import { TickMark } from './tick-marks';
 import { TickMarkWeightValue, TimeScalePoint } from './time-data';
 import { TimeMark } from './time-scale';
 
-import { SeriesDataItemTypeMap } from './data-consumer';
-
 export type InternalHorzScaleItem = Nominal<unknown, 'InternalHorzScaleItem'>;
 
 export type HorzScaleItemConverterToInternalObj<HorzScaleItem> = (time: HorzScaleItem) => InternalHorzScaleItem;
@@ -18,15 +18,15 @@ export type InternalHorzScaleItemKey = Nominal<number, 'InternalHorzScaleItemKey
 
 export interface IHorzScaleBehavior<HorzScaleItem> {
 	setOptions(options: ChartOptions<HorzScaleItem>): void;
-    preprocessData(data: DataItem<HorzScaleItem> | DataItem<HorzScaleItem>[]): void;
-    convertHorzItemToInternal(item: HorzScaleItem): InternalHorzScaleItem;
-    convertInternalToHorzItem(item: InternalHorzScaleItem): HorzScaleItem;
-    createConverterToInternalObj(data: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType][]): HorzScaleItemConverterToInternalObj<HorzScaleItem>;
-    key(internalItem: InternalHorzScaleItem | HorzScaleItem): InternalHorzScaleItemKey;
-    cacheKey(internalItem: InternalHorzScaleItem): number;
-    updateFormatter(options: LocalizationOptions<HorzScaleItem>): void;
-    formatHorzItem(item: InternalHorzScaleItem): string;
-    formatTickmark(item: TickMark<HorzScaleItem>, localizationOptions: LocalizationOptions<HorzScaleItem>): string;
-    maxTickMarkWeight(marks: TimeMark[]): TickMarkWeightValue;
-    fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<HorzScaleItem>>[], startIndex: number): void;
+	preprocessData(data: DataItem<HorzScaleItem> | DataItem<HorzScaleItem>[]): void;
+	convertHorzItemToInternal(item: HorzScaleItem): InternalHorzScaleItem;
+	convertInternalToHorzItem(item: InternalHorzScaleItem): HorzScaleItem;
+	createConverterToInternalObj(data: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType][]): HorzScaleItemConverterToInternalObj<HorzScaleItem>;
+	key(internalItem: InternalHorzScaleItem | HorzScaleItem): InternalHorzScaleItemKey;
+	cacheKey(internalItem: InternalHorzScaleItem): number;
+	updateFormatter(options: LocalizationOptions<HorzScaleItem>): void;
+	formatHorzItem(item: InternalHorzScaleItem): string;
+	formatTickmark(item: TickMark<HorzScaleItem>, localizationOptions: LocalizationOptions<HorzScaleItem>): string;
+	maxTickMarkWeight(marks: TimeMark[]): TickMarkWeightValue;
+	fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<HorzScaleItem>>[], startIndex: number): void;
 }
diff --git a/src/model/series-bar-colorer.ts b/src/model/series-bar-colorer.ts
index df9e70ca30..e2ae8c4d14 100644
--- a/src/model/series-bar-colorer.ts
+++ b/src/model/series-bar-colorer.ts
@@ -81,14 +81,14 @@ type StyleGetterFn<T extends SeriesType, HorzScaleItem> = (
 	precomputedBars?: PrecomputedBars<HorzScaleItem>
 ) => BarStylesMap[T];
 
-type BarStylesFnMap<T extends SeriesType, HorzScaleItem> = {
+type BarStylesFnMap<HorzScaleItem> = {
 	[T in keyof SeriesOptionsMap]: StyleGetterFn<T, HorzScaleItem>;
 };
 
 export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> {
 	private _series: Series<T, HorzScaleItem>;
-	private readonly _styleGetter: BarStylesFnMap<T, HorzScaleItem>[T];
-	private readonly _barStyleFnMap: BarStylesFnMap<T, HorzScaleItem>;
+	private readonly _styleGetter: BarStylesFnMap<HorzScaleItem>[T];
+	private readonly _barStyleFnMap: BarStylesFnMap<HorzScaleItem>;
 
 	public constructor(series: Series<T, HorzScaleItem>) {
 		this._series = series;
@@ -169,7 +169,6 @@ export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> {
 		};
 
 		this._styleGetter = this._barStyleFnMap[series.seriesType()];
-
 	}
 
 	public barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): BarStylesMap[T] {
diff --git a/src/model/series-markers.ts b/src/model/series-markers.ts
index 01151279a8..a172527783 100644
--- a/src/model/series-markers.ts
+++ b/src/model/series-markers.ts
@@ -43,6 +43,9 @@ export interface SeriesMarker<TimeType, HorzScaleItem> {
 	 */
 	size?: number;
 
+	/**
+	 * @internal
+	 */
 	originalTime: HorzScaleItem;
 }
 
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index 9ca7ebf230..60e605467f 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -151,6 +151,10 @@ export interface TimeScaleOptions {
 	 */
 	ticksVisible: boolean;
 
+	/**
+	 * Chanes horizontal scale makes generation
+	 * With this flag equal to true, marks of the wame weight are drawn all or not drawn at all
+	 */
 	uniformDistribution: boolean;
 }
 
diff --git a/tests/unittests/data-layer.spec.ts b/tests/unittests/data-layer.spec.ts
index 168885976f..274bd6c19f 100644
--- a/tests/unittests/data-layer.spec.ts
+++ b/tests/unittests/data-layer.spec.ts
@@ -3,16 +3,16 @@ import { expect } from 'chai';
 import chaiExclude from 'chai-exclude';
 import { describe, it } from 'mocha';
 
+import { ensureDefined } from '../../src/helpers/assertions';
 import { BarData, HistogramData, LineData, WhitespaceData } from '../../src/model/data-consumer';
 import { DataLayer, SeriesChanges } from '../../src/model/data-layer';
-import { ensureDefined } from '../../src/helpers/assertions';
+import { convertTime, HorzScaleBehaviorTime, stringToBusinessDay } from '../../src/model/horz-scale-behavior-time/horz-scale-behavior-time';
+import { BusinessDay, Time, TimePoint, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
 import { PlotRowValueIndex } from '../../src/model/plot-data';
 import { PlotList } from '../../src/model/plot-list';
 import { Series } from '../../src/model/series';
 import { SeriesType } from '../../src/model/series-options';
 import { TimePointIndex } from '../../src/model/time-data';
-import { BusinessDay, Time, TimePoint, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
-import { convertTime, HorzScaleBehaviorTime, stringToBusinessDay } from '../../src/model/horz-scale-behavior-time/horz-scale-behavior-time';
 
 chai.use(chaiExclude);
 

From c5bf22e4fe0334a66c803e719d937437c61e214f Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Wed, 5 Apr 2023 18:47:08 +0300
Subject: [PATCH 06/23] Fixed small issues, fixed tests and linters

---
 src/api/create-chart.ts                       | 107 +++---------------
 src/api/series-api.ts                         |   4 +-
 src/index.ts                                  |   3 +-
 .../horz-scale-behavior-price.ts              |  99 ++++++++++++++++
 .../horz-scale-behavior-time.ts               |  32 +++---
 .../time-based-chart-options.ts               |  26 +++++
 src/model/ihorz-scale-behavior.ts             |   1 +
 src/views/pane/grid-pane-view.ts              |   7 +-
 8 files changed, 169 insertions(+), 110 deletions(-)
 create mode 100644 src/model/horz-scale-behavior-price/horz-scale-behavior-price.ts
 create mode 100644 src/model/horz-scale-behavior-time/time-based-chart-options.ts

diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index 63c55a877e..36bac6f86e 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -1,17 +1,12 @@
 import { assert } from '../helpers/assertions';
-import { Nominal } from '../helpers/nominal';
-import { DeepPartial, isString, merge } from '../helpers/strict-type-checks';
+import { DeepPartial, isString } from '../helpers/strict-type-checks';
 
 import { ChartOptions } from '../model/chart-model';
-import { SeriesDataItemTypeMap } from '../model/data-consumer';
+import { HorzScaleBehaviorPrice, Price } from '../model/horz-scale-behavior-price/horz-scale-behavior-price';
 import { HorzScaleBehaviorTime } from '../model/horz-scale-behavior-time/horz-scale-behavior-time';
+import { TimeChartOptions } from '../model/horz-scale-behavior-time/time-based-chart-options';
 import { Time } from '../model/horz-scale-behavior-time/types';
-import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../model/ihorz-scale-behavior';
-import { LocalizationOptions } from '../model/localization-options';
-import { SeriesType } from '../model/series-options';
-import { TickMark } from '../model/tick-marks';
-import { TickMarkWeightValue, TimeScalePoint } from '../model/time-data';
-import { markWithGreaterWeight, TimeMark } from '../model/time-scale';
+import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 
 import { ChartApi } from './chart-api';
 import { IChartApi } from './ichart-api';
@@ -23,7 +18,11 @@ import { IChartApi } from './ichart-api';
  * @param options - Any subset of options to be applied at start.
  * @returns An interface to the created chart
  */
-export function createChartEx<HorzScaleItem = Time>(container: string | HTMLElement, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, options?: DeepPartial<ChartOptions<HorzScaleItem>>): IChartApi<HorzScaleItem> {
+export function createChartEx<HorzScaleItem, THorzScaleBehavior extends IHorzScaleBehavior<HorzScaleItem>>(
+	container: string | HTMLElement,
+	horzScaleBehavior: THorzScaleBehavior,
+	options?: DeepPartial<ReturnType<THorzScaleBehavior['options']>>
+): IChartApi<HorzScaleItem> {
 	let htmlElement: HTMLElement;
 	if (isString(container)) {
 		const element = document.getElementById(container);
@@ -38,86 +37,14 @@ export function createChartEx<HorzScaleItem = Time>(container: string | HTMLElem
 	return res;
 }
 
-export function createChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions<Time>>): IChartApi<Time> {
-	return createChartEx<Time>(container, new HorzScaleBehaviorTime(), merge({ localization: { dateFormat: 'dd MMM \'yy' } }, options ?? {}));
+export function createChart(container: string | HTMLElement, options?: DeepPartial<TimeChartOptions>): IChartApi<Time> {
+	return createChartEx<Time, HorzScaleBehaviorTime>(
+		container,
+		new HorzScaleBehaviorTime(),
+		HorzScaleBehaviorTime.applyDefaults(options)
+	);
 }
 
-/**
- * Nominal for numbers used as values in the horizontal scale
- */
-type Price = Nominal<number, 'Price'>;
-
-class HorzScaleBehaviorPrice implements IHorzScaleBehavior<Price> {
-	public setOptions(options: ChartOptions<Price>): void {}
-
-	public preprocessData(data: DataItem<Price> | DataItem<Price>[]): void {}
-
-	public createConverterToInternalObj(data: SeriesDataItemTypeMap<Price>[SeriesType][]): HorzScaleItemConverterToInternalObj<Price> {
-		return (price: Price) => price as unknown as InternalHorzScaleItem;
-	}
-
-	public convertInternalToHorzItem(item: InternalHorzScaleItem): Price {
-		return item as unknown as Price;
-	}
-
-	public key(item: InternalHorzScaleItem | Price): InternalHorzScaleItemKey {
-		return item as unknown as InternalHorzScaleItemKey;
-	}
-
-	public cacheKey(item: InternalHorzScaleItem): number {
-		return item as unknown as number;
-	}
-
-	public convertHorzItemToInternal(item: Price): InternalHorzScaleItem {
-		return item as unknown as InternalHorzScaleItem;
-	}
-
-	public updateFormatter(options: LocalizationOptions<Price>): void {}
-
-	public formatHorzItem(item: InternalHorzScaleItem): string {
-		const tp = item as unknown as Price;
-		return tp.toFixed(2);
-	}
-
-	public formatTickmark(tickMark: TickMark<Price>, localizationOptions: LocalizationOptions<Price>): string {
-		return (tickMark.time as unknown as Price).toFixed(2);
-	}
-
-	public maxTickMarkWeight(tickMarks: TimeMark[]): TickMarkWeightValue {
-		return tickMarks.reduce(markWithGreaterWeight, tickMarks[0]).weight;
-	}
-
-	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Price>>[], startIndex: number): void {
-		const priceWeight = (price: Price) => {
-			if (price === Math.ceil(price / 100) * 100) {
-				return 8;
-			}
-			if (price === Math.ceil(price / 50) * 50) {
-				return 7;
-			}
-			if (price === Math.ceil(price / 25) * 25) {
-				return 6;
-			}
-			if (price === Math.ceil(price / 10) * 10) {
-				return 5;
-			}
-			if (price === Math.ceil(price / 5) * 5) {
-				return 4;
-			}
-			if (price === Math.ceil(price)) {
-				return 3;
-			}
-			if (price * 2 === Math.ceil(price * 2)) {
-				return 1;
-			}
-			return 0;
-		};
-		for (let index = startIndex; index < sortedTimePoints.length; ++index) {
-			sortedTimePoints[index].timeWeight = priceWeight(sortedTimePoints[index].time as unknown as Price) as TickMarkWeightValue;
-		}
-	}
-}
-
-export function createOptionsChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions<Price>>): IChartApi<Price> {
-	return createChartEx<Price>(container, new HorzScaleBehaviorPrice(), merge({ timeScale: { uniformDistribution: true } }, options ?? {}));
+export function createChartWithPricesAtHorzScale(container: string | HTMLElement, options?: DeepPartial<ChartOptions<Price>>): IChartApi<Price> {
+	return createChartEx<Price, HorzScaleBehaviorPrice>(container, new HorzScaleBehaviorPrice(), HorzScaleBehaviorPrice.applyDefaults(options));
 }
diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index 99a2faa2d0..7c043da4d5 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -154,9 +154,9 @@ export class SeriesApi<TSeriesType extends SeriesType, HorzScaleItem> implements
 
 	public markers(): SeriesMarker<HorzScaleItem, HorzScaleItem>[] {
 		return this._series.markers().map<SeriesMarker<HorzScaleItem, HorzScaleItem>>((internalItem: SeriesMarker<InternalHorzScaleItem, HorzScaleItem>) => {
-			const { time, ...item } = internalItem;
+			const { originalTime, time, ...item } = internalItem;
 			return {
-				time: item.originalTime,
+				time: originalTime,
 				...item as Omit<SeriesMarker<HorzScaleItem, HorzScaleItem>, 'time' | 'originalTIme'>,
 			};
 		});
diff --git a/src/index.ts b/src/index.ts
index dda54e61c2..d787830932 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -9,9 +9,10 @@ export { PriceScaleMode } from './model/price-scale';
 export { PriceLineSource, LastPriceAnimationMode } from './model/series-options';
 export { ColorType } from './model/layout-options';
 
-export { createChart, createOptionsChart } from './api/create-chart';
+export { createChart, createChartWithPricesAtHorzScale } from './api/create-chart';
 
 export { isBusinessDay } from './model/horz-scale-behavior-time/types';
+export { TickMarkType } from './model/horz-scale-behavior-time/types';
 
 /**
  * Returns the current version as a string. For example `'3.3.0'`.
diff --git a/src/model/horz-scale-behavior-price/horz-scale-behavior-price.ts b/src/model/horz-scale-behavior-price/horz-scale-behavior-price.ts
new file mode 100644
index 0000000000..fd1c7e7bce
--- /dev/null
+++ b/src/model/horz-scale-behavior-price/horz-scale-behavior-price.ts
@@ -0,0 +1,99 @@
+import { Nominal } from '../../helpers/nominal';
+import { DeepPartial, merge } from '../../helpers/strict-type-checks';
+
+import { ChartOptions } from '../chart-model';
+import { SeriesDataItemTypeMap } from '../data-consumer';
+import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../ihorz-scale-behavior';
+import { LocalizationOptions } from '../localization-options';
+import { SeriesType } from '../series-options';
+import { TickMark } from '../tick-marks';
+import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
+import { markWithGreaterWeight, TimeMark } from '../time-scale';
+
+/**
+ * Nominal for numbers used as values in the horizontal scale
+ */
+export type Price = Nominal<number, 'Price'>;
+
+export class HorzScaleBehaviorPrice implements IHorzScaleBehavior<Price> {
+	private _options!: ChartOptions<Price>;
+
+	public options(): ChartOptions<Price> {
+		return this._options;
+	}
+
+	public setOptions(options: ChartOptions<Price>): void {
+		this._options = options;
+	}
+
+	public preprocessData(data: DataItem<Price> | DataItem<Price>[]): void {}
+
+	public createConverterToInternalObj(data: SeriesDataItemTypeMap<Price>[SeriesType][]): HorzScaleItemConverterToInternalObj<Price> {
+		return (price: Price) => price as unknown as InternalHorzScaleItem;
+	}
+
+	public convertInternalToHorzItem(item: InternalHorzScaleItem): Price {
+		return item as unknown as Price;
+	}
+
+	public key(item: InternalHorzScaleItem | Price): InternalHorzScaleItemKey {
+		return item as unknown as InternalHorzScaleItemKey;
+	}
+
+	public cacheKey(item: InternalHorzScaleItem): number {
+		return item as unknown as number;
+	}
+
+	public convertHorzItemToInternal(item: Price): InternalHorzScaleItem {
+		return item as unknown as InternalHorzScaleItem;
+	}
+
+	public updateFormatter(options: LocalizationOptions<Price>): void {}
+
+	public formatHorzItem(item: InternalHorzScaleItem): string {
+		const tp = item as unknown as Price;
+		return tp.toFixed(2);
+	}
+
+	public formatTickmark(tickMark: TickMark<Price>, localizationOptions: LocalizationOptions<Price>): string {
+		return (tickMark.time as unknown as Price).toFixed(2);
+	}
+
+	public maxTickMarkWeight(tickMarks: TimeMark[]): TickMarkWeightValue {
+		return tickMarks.reduce(markWithGreaterWeight, tickMarks[0]).weight;
+	}
+
+	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Price>>[], startIndex: number): void {
+		const priceWeight = (price: Price) => {
+			if (price === Math.ceil(price / 100) * 100) {
+				return 8;
+			}
+			if (price === Math.ceil(price / 50) * 50) {
+				return 7;
+			}
+			if (price === Math.ceil(price / 25) * 25) {
+				return 6;
+			}
+			if (price === Math.ceil(price / 10) * 10) {
+				return 5;
+			}
+			if (price === Math.ceil(price / 5) * 5) {
+				return 4;
+			}
+			if (price === Math.ceil(price)) {
+				return 3;
+			}
+			if (price * 2 === Math.ceil(price * 2)) {
+				return 1;
+			}
+			return 0;
+		};
+		for (let index = startIndex; index < sortedTimePoints.length; ++index) {
+			sortedTimePoints[index].timeWeight = priceWeight(sortedTimePoints[index].time as unknown as Price) as TickMarkWeightValue;
+		}
+	}
+
+	public static applyDefaults(options?: DeepPartial<ChartOptions<Price>>): DeepPartial<ChartOptions<Price>> {
+		return merge({ timeScale: { uniformDistribution: true } }, options ?? {});
+	}
+}
diff --git a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
index ad96ba1019..e45e319486 100644
--- a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
+++ b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
@@ -2,9 +2,8 @@ import { DateFormatter } from '../../formatters/date-formatter';
 import { DateTimeFormatter } from '../../formatters/date-time-formatter';
 
 import { ensureNotNull } from '../../helpers/assertions';
-import { isString } from '../../helpers/strict-type-checks';
+import { DeepPartial, isString, merge } from '../../helpers/strict-type-checks';
 
-import { ChartOptions } from '../chart-model';
 import { SeriesDataItemTypeMap } from '../data-consumer';
 import { TimedData } from '../data-layer';
 import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../ihorz-scale-behavior';
@@ -12,8 +11,9 @@ import { LocalizationOptions } from '../localization-options';
 import { SeriesType } from '../series-options';
 import { TickMark } from '../tick-marks';
 import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
-import { markWithGreaterWeight, TimeMark, TimeScaleOptions } from '../time-scale';
+import { markWithGreaterWeight, TimeMark } from '../time-scale';
 import { defaultTickMarkFormatter } from './default-tick-mark-formatter';
+import { TimeChartOptions } from './time-based-chart-options';
 import { fillWeightsForPoints } from './time-scale-point-weight-generator';
 import { BusinessDay, isBusinessDay, isUTCTimestamp, TickMarkType, TickMarkWeight, Time, TimePoint, UTCTimestamp } from './types';
 
@@ -123,15 +123,6 @@ interface TimeLocalizationOptions extends LocalizationOptions<Time> {
  */
 export type TickMarkFormatter = (time: Time, tickMarkType: TickMarkType, locale: string) => string | null;
 
-interface TimeTimeScaleOptions extends TimeScaleOptions {
-	/**
-	 * Tick marks formatter can be used to customize tick marks labels on the time axis.
-	 *
-	 * @defaultValue `undefined`
-	 */
-	tickMarkFormatter?: TickMarkFormatter;
-}
-
 // eslint-disable-next-line complexity
 function weightToTickMarkType(weight: TickMarkWeight, timeVisible: boolean, secondsVisible: boolean): TickMarkType {
 	switch (weight) {
@@ -163,9 +154,13 @@ function weightToTickMarkType(weight: TickMarkWeight, timeVisible: boolean, seco
 
 export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 	private _dateTimeFormatter!: DateFormatter | DateTimeFormatter;
-	private _options!: ChartOptions<Time>;
+	private _options!: TimeChartOptions;
+
+	public options(): TimeChartOptions {
+		return this._options;
+	}
 
-	public setOptions(options: ChartOptions<Time>): void {
+	public setOptions(options: TimeChartOptions): void {
 		this._options = options;
 		this.updateFormatter(options.localization as TimeLocalizationOptions);
 	}
@@ -188,7 +183,8 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 	}
 
 	public key(item: InternalHorzScaleItem | Time): InternalHorzScaleItemKey {
-		if (typeof item === 'object') {
+		// eslint-disable-next-line no-restricted-syntax
+		if (typeof item === 'object' && 'timestamp' in item) {
 			return (item as unknown as TimePoint).timestamp as unknown as InternalHorzScaleItemKey;
 		} else {
 			return this.key(this.convertHorzItemToInternal(item as Time));
@@ -232,7 +228,7 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 	public formatTickmark(tickMark: TickMark<Time>, localizationOptions: LocalizationOptions<Time>): string {
 		const tickMarkType = weightToTickMarkType(tickMark.weight, this._options.timeScale.timeVisible, this._options.timeScale.secondsVisible);
 
-		const options = this._options.timeScale as TimeTimeScaleOptions;
+		const options = this._options.timeScale;
 
 		if (options.tickMarkFormatter !== undefined) {
 			const tickMarkString = options.tickMarkFormatter(
@@ -262,4 +258,8 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Time>>[], startIndex: number): void {
 		fillWeightsForPoints(sortedTimePoints, startIndex);
 	}
+
+	public static applyDefaults(options?: DeepPartial<TimeChartOptions>): DeepPartial<TimeChartOptions> {
+		return merge({ localization: { dateFormat: 'dd MMM \'yy' } }, options ?? {});
+	}
 }
diff --git a/src/model/horz-scale-behavior-time/time-based-chart-options.ts b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
new file mode 100644
index 0000000000..50eaea55af
--- /dev/null
+++ b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
@@ -0,0 +1,26 @@
+import { ChartOptions } from '../chart-model';
+import { TimeScaleOptions } from '../time-scale';
+import { TickMarkFormatter } from './horz-scale-behavior-time';
+import { Time } from './types';
+
+/**
+ * Extended time scale options for time-base horz scale
+ */
+export interface TimeChartTimeScaleOptions extends TimeScaleOptions {
+	/**
+	 * Tick marks formatter can be used to customize tick marks labels on the time axis.
+	 *
+	 * @defaultValue `undefined`
+	 */
+	tickMarkFormatter?: TickMarkFormatter;
+}
+
+/**
+ * Options for chart with time at the horizontal scale
+ */
+export interface TimeChartOptions extends ChartOptions<Time> {
+	/**
+	 * Extended time scale options with option to override tickMarkFormatter
+	 */
+	timeScale: TimeChartTimeScaleOptions;
+}
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
index 98d8bbf89e..ba387cf441 100644
--- a/src/model/ihorz-scale-behavior.ts
+++ b/src/model/ihorz-scale-behavior.ts
@@ -17,6 +17,7 @@ export type DataItem<HorzScaleItem> = SeriesDataItemTypeMap<HorzScaleItem>[Serie
 export type InternalHorzScaleItemKey = Nominal<number, 'InternalHorzScaleItemKey'>;
 
 export interface IHorzScaleBehavior<HorzScaleItem> {
+	options(): ChartOptions<HorzScaleItem>;
 	setOptions(options: ChartOptions<HorzScaleItem>): void;
 	preprocessData(data: DataItem<HorzScaleItem> | DataItem<HorzScaleItem>[]): void;
 	convertHorzItemToInternal(item: HorzScaleItem): InternalHorzScaleItem;
diff --git a/src/views/pane/grid-pane-view.ts b/src/views/pane/grid-pane-view.ts
index bed7dc0193..50a58c881f 100644
--- a/src/views/pane/grid-pane-view.ts
+++ b/src/views/pane/grid-pane-view.ts
@@ -1,4 +1,5 @@
 import { Pane } from '../../model/pane';
+import { TimeMark } from '../../model/time-scale';
 import { GridRenderer, GridRendererData } from '../../renderers/grid-renderer';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
@@ -29,7 +30,11 @@ export class GridPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScale
 				horzLineStyle: gridOptions.horzLines.style,
 				vertLineStyle: gridOptions.vertLines.style,
 				priceMarks: this._pane.defaultPriceScale().marks(),
-				timeMarks: this._pane.model().timeScale().marks() || [],
+				// need this conversiom because TimeMark is a part of external interface
+				// and fields inside TimeMark are not minified
+				timeMarks: (this._pane.model().timeScale().marks() || []).map((tm: TimeMark) => {
+					return { coord: tm.coord };
+				}),
 			};
 
 			this._renderer.setData(data);

From d74aeb2f8f948c909dd1b4ac675481609c4e4ada Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Mon, 10 Apr 2023 11:14:22 +0300
Subject: [PATCH 07/23] Try to minimize typing changes

---
 debug-price.html                              | 35 -------
 src/api/chart-api.ts                          | 14 +--
 src/api/create-chart.ts                       | 23 +++--
 src/api/ichart-api.ts                         |  6 +-
 src/index.ts                                  |  4 +-
 src/model/chart-model.ts                      |  4 +-
 .../horz-scale-behavior-price.ts              | 99 -------------------
 .../time-based-chart-options.ts               |  4 +-
 src/model/ihorz-scale-behavior.ts             |  6 +-
 src/model/pane.ts                             |  4 +-
 10 files changed, 37 insertions(+), 162 deletions(-)
 delete mode 100644 debug-price.html
 delete mode 100644 src/model/horz-scale-behavior-price/horz-scale-behavior-price.ts

diff --git a/debug-price.html b/debug-price.html
deleted file mode 100644
index 3ddc65eef7..0000000000
--- a/debug-price.html
+++ /dev/null
@@ -1,35 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-	<meta charset="UTF-8">
-	<meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,minimum-scale=1.0">
-	<title>Debug page</title>
-
-	<script type="text/javascript" src="./dist/lightweight-charts.standalone.development.js"></script>
-
-	<script language="javascript">
-		function init() {
-			const chart = LightweightCharts.createOptionsChart(document.getElementById('container'), 
-			{
-				width: 900,
-				height: 600, 
-			});
-			const s1 = chart.addLineSeries({
-				color: 'red'
-			});
-			const arr = []
-			for (let i = 0; i < 5000; i++) {
-				arr.push({time: i * 0.25, value: Math.round(Math.random() * 10000) / 100 });
-			}
-			s1.setData(arr);
-		}
-	</script>
-		
-</head>
-
-<body style="padding: 0; margin: 0; background-color: #505050" onload="init()">
-	<div id="container" style="position: absolute; width: 600px; height: 600px"></div>
-</body>
-
-</html>
diff --git a/src/api/chart-api.ts b/src/api/chart-api.ts
index e6f8fe9f06..562e6eb39b 100644
--- a/src/api/chart-api.ts
+++ b/src/api/chart-api.ts
@@ -5,7 +5,7 @@ import { Delegate } from '../helpers/delegate';
 import { warn } from '../helpers/logger';
 import { clone, DeepPartial, isBoolean, merge } from '../helpers/strict-type-checks';
 
-import { ChartOptions, ChartOptionsInternal } from '../model/chart-model';
+import { ChartOptionsBase, ChartOptionsInternal } from '../model/chart-model';
 import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap } from '../model/data-consumer';
 import { DataLayer, DataUpdateResponse, SeriesChanges } from '../model/data-layer';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
@@ -58,7 +58,7 @@ function patchPriceFormat(priceFormat?: DeepPartial<PriceFormat>): void {
 	}
 }
 
-function migrateHandleScaleScrollOptions<HorzScaleItem>(options: DeepPartial<ChartOptions<HorzScaleItem>>): void {
+function migrateHandleScaleScrollOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): void {
 	if (isBoolean(options.handleScale)) {
 		const handleScale = options.handleScale;
 		options.handleScale = {
@@ -100,7 +100,7 @@ function migrateHandleScaleScrollOptions<HorzScaleItem>(options: DeepPartial<Cha
 	}
 }
 
-function toInternalOptions<HorzScaleItem>(options: DeepPartial<ChartOptions<HorzScaleItem>>): DeepPartial<ChartOptionsInternal<HorzScaleItem>> {
+function toInternalOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): DeepPartial<ChartOptionsInternal<HorzScaleItem>> {
 	migrateHandleScaleScrollOptions(options);
 
 	return options as DeepPartial<ChartOptionsInternal<HorzScaleItem>>;
@@ -121,7 +121,7 @@ export class ChartApi<HorzScaleItem> implements IChartApi<HorzScaleItem>, DataUp
 
 	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
 
-	public constructor(container: HTMLElement, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, options?: DeepPartial<ChartOptions<HorzScaleItem>>) {
+	public constructor(container: HTMLElement, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, options?: DeepPartial<ChartOptionsBase<HorzScaleItem>>) {
 		this._dataLayer = new DataLayer<HorzScaleItem>(horzScaleBehavior);
 		const internalOptions = (options === undefined) ?
 			clone(chartOptionsDefaults<HorzScaleItem>()) :
@@ -247,12 +247,12 @@ export class ChartApi<HorzScaleItem> implements IChartApi<HorzScaleItem>, DataUp
 		return this._timeScaleApi;
 	}
 
-	public applyOptions(options: DeepPartial<ChartOptions<HorzScaleItem>>): void {
+	public applyOptions(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): void {
 		this._chartWidget.applyOptions(toInternalOptions(options));
 	}
 
-	public options(): Readonly<ChartOptions<HorzScaleItem>> {
-		return this._chartWidget.options() as Readonly<ChartOptions<HorzScaleItem>>;
+	public options(): Readonly<ChartOptionsBase<HorzScaleItem>> {
+		return this._chartWidget.options() as Readonly<ChartOptionsBase<HorzScaleItem>>;
 	}
 
 	public takeScreenshot(): HTMLCanvasElement {
diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index 36bac6f86e..c1d2a33995 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -1,8 +1,6 @@
 import { assert } from '../helpers/assertions';
 import { DeepPartial, isString } from '../helpers/strict-type-checks';
 
-import { ChartOptions } from '../model/chart-model';
-import { HorzScaleBehaviorPrice, Price } from '../model/horz-scale-behavior-price/horz-scale-behavior-price';
 import { HorzScaleBehaviorTime } from '../model/horz-scale-behavior-time/horz-scale-behavior-time';
 import { TimeChartOptions } from '../model/horz-scale-behavior-time/time-based-chart-options';
 import { Time } from '../model/horz-scale-behavior-time/types';
@@ -14,6 +12,9 @@ import { IChartApi } from './ichart-api';
 /**
  * This function is the main entry point of the Lightweight Charting Library.
  *
+ * @template HorzScaleItem - type of points at the horizontal scale
+ * @template THorzScaleBehavior - type of horz axis strategy that encapsulate all the speicific moment of the certain horz scale type
+ *
  * @param container - ID of HTML element or element itself
  * @param options - Any subset of options to be applied at start.
  * @returns An interface to the created chart
@@ -37,14 +38,22 @@ export function createChartEx<HorzScaleItem, THorzScaleBehavior extends IHorzSca
 	return res;
 }
 
-export function createChart(container: string | HTMLElement, options?: DeepPartial<TimeChartOptions>): IChartApi<Time> {
+/**
+ * Structure describing options of the chart with time points at the horizontal scale. Series options are to be set separately
+ */
+export type ChartOptions = TimeChartOptions;
+
+/**
+ * This function is the simplified main entry point of the Lightweight Charting Library with time points at horizontal scale.
+ *
+ * @param container - ID of HTML element or element itself
+ * @param options - Any subset of options to be applied at start.
+ * @returns An interface to the created chart
+ */
+export function createChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions>): IChartApi<Time> {
 	return createChartEx<Time, HorzScaleBehaviorTime>(
 		container,
 		new HorzScaleBehaviorTime(),
 		HorzScaleBehaviorTime.applyDefaults(options)
 	);
 }
-
-export function createChartWithPricesAtHorzScale(container: string | HTMLElement, options?: DeepPartial<ChartOptions<Price>>): IChartApi<Price> {
-	return createChartEx<Price, HorzScaleBehaviorPrice>(container, new HorzScaleBehaviorPrice(), HorzScaleBehaviorPrice.applyDefaults(options));
-}
diff --git a/src/api/ichart-api.ts b/src/api/ichart-api.ts
index 378ae32c7b..162d14025c 100644
--- a/src/api/ichart-api.ts
+++ b/src/api/ichart-api.ts
@@ -1,6 +1,6 @@
 import { DeepPartial } from '../helpers/strict-type-checks';
 
-import { ChartOptions } from '../model/chart-model';
+import { ChartOptionsBase } from '../model/chart-model';
 import { BarData, HistogramData, LineData } from '../model/data-consumer';
 import { Time } from '../model/horz-scale-behavior-time/types';
 import { Point } from '../model/point';
@@ -249,14 +249,14 @@ export interface IChartApi<HorzScaleItem = Time> {
 	 *
 	 * @param options - Any subset of options.
 	 */
-	applyOptions(options: DeepPartial<ChartOptions<HorzScaleItem>>): void;
+	applyOptions(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): void;
 
 	/**
 	 * Returns currently applied options
 	 *
 	 * @returns Full set of currently applied options, including defaults
 	 */
-	options(): Readonly<ChartOptions<HorzScaleItem>>;
+	options(): Readonly<ChartOptionsBase<HorzScaleItem>>;
 
 	/**
 	 * Make a screenshot of the chart with all the elements excluding crosshair.
diff --git a/src/index.ts b/src/index.ts
index d787830932..6972d63afd 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -9,9 +9,9 @@ export { PriceScaleMode } from './model/price-scale';
 export { PriceLineSource, LastPriceAnimationMode } from './model/series-options';
 export { ColorType } from './model/layout-options';
 
-export { createChart, createChartWithPricesAtHorzScale } from './api/create-chart';
+export { createChart } from './api/create-chart';
 
-export { isBusinessDay } from './model/horz-scale-behavior-time/types';
+export { isBusinessDay, isUTCTimestamp } from './model/horz-scale-behavior-time/types';
 export { TickMarkType } from './model/horz-scale-behavior-time/types';
 
 /**
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index 50f7c2b4a8..eb5ad954fd 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -233,7 +233,7 @@ export interface TrackingModeOptions {
 /**
  * Structure describing options of the chart. Series options are to be set separately
  */
-export interface ChartOptions<HorzScaleItem> {
+export interface ChartOptionsBase<HorzScaleItem> {
 	/**
 	 * Width of the chart in pixels
 	 *
@@ -338,7 +338,7 @@ export interface ChartOptions<HorzScaleItem> {
 }
 
 export type ChartOptionsInternal<HorzScaleItem> =
-	Omit<ChartOptions<HorzScaleItem>, 'handleScroll' | 'handleScale' | 'layout'>
+	Omit<ChartOptionsBase<HorzScaleItem>, 'handleScroll' | 'handleScale' | 'layout'>
 	& {
 		/** @public */
 		handleScroll: HandleScrollOptions;
diff --git a/src/model/horz-scale-behavior-price/horz-scale-behavior-price.ts b/src/model/horz-scale-behavior-price/horz-scale-behavior-price.ts
deleted file mode 100644
index fd1c7e7bce..0000000000
--- a/src/model/horz-scale-behavior-price/horz-scale-behavior-price.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import { Nominal } from '../../helpers/nominal';
-import { DeepPartial, merge } from '../../helpers/strict-type-checks';
-
-import { ChartOptions } from '../chart-model';
-import { SeriesDataItemTypeMap } from '../data-consumer';
-import { DataItem, HorzScaleItemConverterToInternalObj, IHorzScaleBehavior, InternalHorzScaleItem, InternalHorzScaleItemKey } from '../ihorz-scale-behavior';
-import { LocalizationOptions } from '../localization-options';
-import { SeriesType } from '../series-options';
-import { TickMark } from '../tick-marks';
-import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
-import { markWithGreaterWeight, TimeMark } from '../time-scale';
-
-/**
- * Nominal for numbers used as values in the horizontal scale
- */
-export type Price = Nominal<number, 'Price'>;
-
-export class HorzScaleBehaviorPrice implements IHorzScaleBehavior<Price> {
-	private _options!: ChartOptions<Price>;
-
-	public options(): ChartOptions<Price> {
-		return this._options;
-	}
-
-	public setOptions(options: ChartOptions<Price>): void {
-		this._options = options;
-	}
-
-	public preprocessData(data: DataItem<Price> | DataItem<Price>[]): void {}
-
-	public createConverterToInternalObj(data: SeriesDataItemTypeMap<Price>[SeriesType][]): HorzScaleItemConverterToInternalObj<Price> {
-		return (price: Price) => price as unknown as InternalHorzScaleItem;
-	}
-
-	public convertInternalToHorzItem(item: InternalHorzScaleItem): Price {
-		return item as unknown as Price;
-	}
-
-	public key(item: InternalHorzScaleItem | Price): InternalHorzScaleItemKey {
-		return item as unknown as InternalHorzScaleItemKey;
-	}
-
-	public cacheKey(item: InternalHorzScaleItem): number {
-		return item as unknown as number;
-	}
-
-	public convertHorzItemToInternal(item: Price): InternalHorzScaleItem {
-		return item as unknown as InternalHorzScaleItem;
-	}
-
-	public updateFormatter(options: LocalizationOptions<Price>): void {}
-
-	public formatHorzItem(item: InternalHorzScaleItem): string {
-		const tp = item as unknown as Price;
-		return tp.toFixed(2);
-	}
-
-	public formatTickmark(tickMark: TickMark<Price>, localizationOptions: LocalizationOptions<Price>): string {
-		return (tickMark.time as unknown as Price).toFixed(2);
-	}
-
-	public maxTickMarkWeight(tickMarks: TimeMark[]): TickMarkWeightValue {
-		return tickMarks.reduce(markWithGreaterWeight, tickMarks[0]).weight;
-	}
-
-	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Price>>[], startIndex: number): void {
-		const priceWeight = (price: Price) => {
-			if (price === Math.ceil(price / 100) * 100) {
-				return 8;
-			}
-			if (price === Math.ceil(price / 50) * 50) {
-				return 7;
-			}
-			if (price === Math.ceil(price / 25) * 25) {
-				return 6;
-			}
-			if (price === Math.ceil(price / 10) * 10) {
-				return 5;
-			}
-			if (price === Math.ceil(price / 5) * 5) {
-				return 4;
-			}
-			if (price === Math.ceil(price)) {
-				return 3;
-			}
-			if (price * 2 === Math.ceil(price * 2)) {
-				return 1;
-			}
-			return 0;
-		};
-		for (let index = startIndex; index < sortedTimePoints.length; ++index) {
-			sortedTimePoints[index].timeWeight = priceWeight(sortedTimePoints[index].time as unknown as Price) as TickMarkWeightValue;
-		}
-	}
-
-	public static applyDefaults(options?: DeepPartial<ChartOptions<Price>>): DeepPartial<ChartOptions<Price>> {
-		return merge({ timeScale: { uniformDistribution: true } }, options ?? {});
-	}
-}
diff --git a/src/model/horz-scale-behavior-time/time-based-chart-options.ts b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
index 50eaea55af..8a277ff7e3 100644
--- a/src/model/horz-scale-behavior-time/time-based-chart-options.ts
+++ b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
@@ -1,4 +1,4 @@
-import { ChartOptions } from '../chart-model';
+import { ChartOptionsBase } from '../chart-model';
 import { TimeScaleOptions } from '../time-scale';
 import { TickMarkFormatter } from './horz-scale-behavior-time';
 import { Time } from './types';
@@ -18,7 +18,7 @@ export interface TimeChartTimeScaleOptions extends TimeScaleOptions {
 /**
  * Options for chart with time at the horizontal scale
  */
-export interface TimeChartOptions extends ChartOptions<Time> {
+export interface TimeChartOptions extends ChartOptionsBase<Time> {
 	/**
 	 * Extended time scale options with option to override tickMarkFormatter
 	 */
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
index ba387cf441..31fea18e4a 100644
--- a/src/model/ihorz-scale-behavior.ts
+++ b/src/model/ihorz-scale-behavior.ts
@@ -1,6 +1,6 @@
 import { Nominal } from '../helpers/nominal';
 
-import { ChartOptions } from './chart-model';
+import { ChartOptionsBase } from './chart-model';
 import { SeriesDataItemTypeMap } from './data-consumer';
 import { LocalizationOptions } from './localization-options';
 import { SeriesType } from './series-options';
@@ -17,8 +17,8 @@ export type DataItem<HorzScaleItem> = SeriesDataItemTypeMap<HorzScaleItem>[Serie
 export type InternalHorzScaleItemKey = Nominal<number, 'InternalHorzScaleItemKey'>;
 
 export interface IHorzScaleBehavior<HorzScaleItem> {
-	options(): ChartOptions<HorzScaleItem>;
-	setOptions(options: ChartOptions<HorzScaleItem>): void;
+	options(): ChartOptionsBase<HorzScaleItem>;
+	setOptions(options: ChartOptionsBase<HorzScaleItem>): void;
 	preprocessData(data: DataItem<HorzScaleItem> | DataItem<HorzScaleItem>[]): void;
 	convertHorzItemToInternal(item: HorzScaleItem): InternalHorzScaleItem;
 	convertInternalToHorzItem(item: InternalHorzScaleItem): HorzScaleItem;
diff --git a/src/model/pane.ts b/src/model/pane.ts
index 2a254bae4a..855445eb76 100644
--- a/src/model/pane.ts
+++ b/src/model/pane.ts
@@ -4,7 +4,7 @@ import { IDestroyable } from '../helpers/idestroyable';
 import { ISubscription } from '../helpers/isubscription';
 import { clone, DeepPartial } from '../helpers/strict-type-checks';
 
-import { ChartModel, ChartOptions, OverlayPriceScaleOptions, VisiblePriceScaleOptions } from './chart-model';
+import { ChartModel, ChartOptionsBase, OverlayPriceScaleOptions, VisiblePriceScaleOptions } from './chart-model';
 import { DefaultPriceScaleId, isDefaultPriceScale } from './default-price-scale';
 import { Grid } from './grid';
 import { IPriceDataSource } from './iprice-data-source';
@@ -55,7 +55,7 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		this.applyScaleOptions(options);
 	}
 
-	public applyScaleOptions(options: DeepPartial<ChartOptions<HorzScaleItem>>): void {
+	public applyScaleOptions(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): void {
 		if (options.leftPriceScale) {
 			this._leftPriceScale.applyOptions(options.leftPriceScale);
 		}

From 3a44d4073079492ca7043207336f032361e54c98 Mon Sep 17 00:00:00 2001
From: Mark Silverwood <msilverwood@gmail.com>
Date: Tue, 11 Apr 2023 09:40:08 +0100
Subject: [PATCH 08/23] increase size-limit

---
 .size-limit.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.size-limit.js b/.size-limit.js
index cb3cb2eaa0..8172e725a8 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -4,21 +4,21 @@ module.exports = [
 	{
 		name: 'CJS',
 		path: 'dist/lightweight-charts.production.cjs',
-		limit: '44.45 KB',
+		limit: '44.80 KB',
 	},
 	{
 		name: 'ESM',
 		path: 'dist/lightweight-charts.production.mjs',
-		limit: '44.35 KB',
+		limit: '44.75 KB',
 	},
 	{
 		name: 'Standalone-ESM',
 		path: 'dist/lightweight-charts.standalone.production.mjs',
-		limit: '46.05 KB',
+		limit: '46.50 KB',
 	},
 	{
 		name: 'Standalone',
 		path: 'dist/lightweight-charts.standalone.production.js',
-		limit: '46.1 KB',
+		limit: '46.55 KB',
 	},
 ];

From 6acce46b96333705e0d3eebd06c8d3f3622a90be Mon Sep 17 00:00:00 2001
From: Mark Silverwood <msilverwood@gmail.com>
Date: Tue, 11 Apr 2023 10:09:47 +0100
Subject: [PATCH 09/23] fix eslint error and website building

---
 src/api/create-chart.ts | 4 ++--
 tsdoc.json              | 9 +++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)
 create mode 100644 tsdoc.json

diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index c1d2a33995..18733f023e 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -12,8 +12,8 @@ import { IChartApi } from './ichart-api';
 /**
  * This function is the main entry point of the Lightweight Charting Library.
  *
- * @template HorzScaleItem - type of points at the horizontal scale
- * @template THorzScaleBehavior - type of horz axis strategy that encapsulate all the speicific moment of the certain horz scale type
+ * @template HorzScaleItem - type of points on the horizontal scale
+ * @template THorzScaleBehavior - type of horizontal axis strategy that encapsulate all the specific behaviors of the horizontal scale type
  *
  * @param container - ID of HTML element or element itself
  * @param options - Any subset of options to be applied at start.
diff --git a/tsdoc.json b/tsdoc.json
new file mode 100644
index 0000000000..3079b13700
--- /dev/null
+++ b/tsdoc.json
@@ -0,0 +1,9 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+	"tagDefinitions": [
+        {
+            "tagName": "@template",
+            "syntaxKind": "block"
+        }
+	]
+}

From b638b31c56362c1f474c389b0667153f7f382bc0 Mon Sep 17 00:00:00 2001
From: Mark Silverwood <msilverwood@gmail.com>
Date: Tue, 11 Apr 2023 10:53:17 +0100
Subject: [PATCH 10/23] update links on price-scale documentation page

---
 website/docs/price-scale.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/docs/price-scale.md b/website/docs/price-scale.md
index 64379464b8..a3ef8527f3 100644
--- a/website/docs/price-scale.md
+++ b/website/docs/price-scale.md
@@ -13,7 +13,7 @@ By default, chart has 2 predefined price scales: `left` and `right`, and an unli
 
 Only `left` and `right` price scales could be displayed on the chart, all overlay scales are hidden.
 
-If you want to change `left` price scale, you need to use [`leftPriceScale`](/api/interfaces/ChartOptions.md#leftpricescale) option, to change `right` price scale use [`rightPriceScale`](/api/interfaces/ChartOptions.md#rightpricescale), to change default options for an overlay price scale use [`overlayPriceScales`](/api/interfaces/ChartOptions.md#overlaypricescales) option.
+If you want to change `left` price scale, you need to use [`leftPriceScale`](/api/interfaces/ChartOptionsBase.md#leftpricescale) option, to change `right` price scale use [`rightPriceScale`](/api/interfaces/ChartOptionsBase.md#rightpricescale), to change default options for an overlay price scale use [`overlayPriceScales`](/api/interfaces/ChartOptionsBase.md#overlaypricescales) option.
 
 Alternatively, you can use [`IChartApi.priceScale`](/api/interfaces/IChartApi.md#pricescale) method to get an API object of any price scale or [`ISeriesApi.priceScale`](/api/interfaces/ISeriesApi.md#pricescale) to get an API object of series' price scale (the price scale that the series is attached to).
 

From 6e8dbeeb638629e004aec9182868d91bd925174b Mon Sep 17 00:00:00 2001
From: Mark Silverwood <msilverwood@gmail.com>
Date: Tue, 11 Apr 2023 12:54:50 +0100
Subject: [PATCH 11/23] export createChartEx function

JSDoc comments should be reviewed to check they are correct
---
 .size-limit.js                                |  8 +-
 src/api/create-chart.ts                       |  6 +-
 src/helpers/mutable.ts                        |  6 ++
 src/index.ts                                  |  2 +-
 src/model/data-layer.ts                       |  1 +
 src/model/get-series-plot-row-creator.ts      |  3 +
 .../horz-scale-behavior-time.ts               |  1 +
 .../time-scale-point-weight-generator.ts      |  2 +
 src/model/ihorz-scale-behavior.ts             | 96 +++++++++++++++++++
 src/model/tick-marks.ts                       |  7 ++
 src/model/time-data.ts                        | 12 +++
 src/model/time-scale.ts                       |  7 ++
 src/typings/_global-types/index.d.ts          |  7 --
 13 files changed, 144 insertions(+), 14 deletions(-)
 create mode 100644 src/helpers/mutable.ts

diff --git a/.size-limit.js b/.size-limit.js
index 8172e725a8..ac5408feb1 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -4,21 +4,21 @@ module.exports = [
 	{
 		name: 'CJS',
 		path: 'dist/lightweight-charts.production.cjs',
-		limit: '44.80 KB',
+		limit: '45.00 KB',
 	},
 	{
 		name: 'ESM',
 		path: 'dist/lightweight-charts.production.mjs',
-		limit: '44.75 KB',
+		limit: '44.95 KB',
 	},
 	{
 		name: 'Standalone-ESM',
 		path: 'dist/lightweight-charts.standalone.production.mjs',
-		limit: '46.50 KB',
+		limit: '46.65 KB',
 	},
 	{
 		name: 'Standalone',
 		path: 'dist/lightweight-charts.standalone.production.js',
-		limit: '46.55 KB',
+		limit: '46.70 KB',
 	},
 ];
diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index 18733f023e..c91a823649 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -10,12 +10,14 @@ import { ChartApi } from './chart-api';
 import { IChartApi } from './ichart-api';
 
 /**
- * This function is the main entry point of the Lightweight Charting Library.
+ * This function is the main entry point of the Lightweight Charting Library. If you are using time values
+ * for the horizontal scale then it is recommended that you rather use the {@link createChart} function.
  *
  * @template HorzScaleItem - type of points on the horizontal scale
  * @template THorzScaleBehavior - type of horizontal axis strategy that encapsulate all the specific behaviors of the horizontal scale type
  *
  * @param container - ID of HTML element or element itself
+ * @param horzScaleBehavior - Horizontal scale behavior
  * @param options - Any subset of options to be applied at start.
  * @returns An interface to the created chart
  */
@@ -44,7 +46,7 @@ export function createChartEx<HorzScaleItem, THorzScaleBehavior extends IHorzSca
 export type ChartOptions = TimeChartOptions;
 
 /**
- * This function is the simplified main entry point of the Lightweight Charting Library with time points at horizontal scale.
+ * This function is the simplified main entry point of the Lightweight Charting Library with time points for the horizontal scale.
  *
  * @param container - ID of HTML element or element itself
  * @param options - Any subset of options to be applied at start.
diff --git a/src/helpers/mutable.ts b/src/helpers/mutable.ts
new file mode 100644
index 0000000000..85cf269f8c
--- /dev/null
+++ b/src/helpers/mutable.ts
@@ -0,0 +1,6 @@
+/**
+ * Removes "readonly" from all properties
+ */
+export type Mutable<T> = {
+	-readonly [P in keyof T]: T[P];
+};
diff --git a/src/index.ts b/src/index.ts
index 6972d63afd..3dabfaf139 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -9,7 +9,7 @@ export { PriceScaleMode } from './model/price-scale';
 export { PriceLineSource, LastPriceAnimationMode } from './model/series-options';
 export { ColorType } from './model/layout-options';
 
-export { createChart } from './api/create-chart';
+export { createChart, createChartEx } from './api/create-chart';
 
 export { isBusinessDay, isUTCTimestamp } from './model/horz-scale-behavior-time/types';
 export { TickMarkType } from './model/horz-scale-behavior-time/types';
diff --git a/src/model/data-layer.ts b/src/model/data-layer.ts
index 66d5539e1d..50d2dcc9ef 100644
--- a/src/model/data-layer.ts
+++ b/src/model/data-layer.ts
@@ -2,6 +2,7 @@
 
 import { lowerbound } from '../helpers/algorithms';
 import { ensureDefined } from '../helpers/assertions';
+import { Mutable } from '../helpers/mutable';
 
 import { SeriesDataItemTypeMap } from './data-consumer';
 import { getSeriesPlotRowCreator, isSeriesPlotRow, WhitespacePlotRow } from './get-series-plot-row-creator';
diff --git a/src/model/get-series-plot-row-creator.ts b/src/model/get-series-plot-row-creator.ts
index cd8b929fb6..ac39c37961 100644
--- a/src/model/get-series-plot-row-creator.ts
+++ b/src/model/get-series-plot-row-creator.ts
@@ -1,3 +1,6 @@
+
+import { Mutable } from '../helpers/mutable';
+
 import { AreaData, BarData, BaselineData, CandlestickData, HistogramData, isWhitespaceData, LineData, SeriesDataItemTypeMap } from './data-consumer';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { PlotRow } from './plot-data';
diff --git a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
index e45e319486..8cf3ef01ed 100644
--- a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
+++ b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
@@ -2,6 +2,7 @@ import { DateFormatter } from '../../formatters/date-formatter';
 import { DateTimeFormatter } from '../../formatters/date-time-formatter';
 
 import { ensureNotNull } from '../../helpers/assertions';
+import { Mutable } from '../../helpers/mutable';
 import { DeepPartial, isString, merge } from '../../helpers/strict-type-checks';
 
 import { SeriesDataItemTypeMap } from '../data-consumer';
diff --git a/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts b/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
index 3943a3b13a..476520d466 100644
--- a/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
+++ b/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
@@ -1,3 +1,5 @@
+import { Mutable } from '../../helpers/mutable';
+
 import { InternalHorzScaleItem } from '../ihorz-scale-behavior';
 import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
 import { TickMarkWeight, Time, TimePoint } from './types';
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
index 31fea18e4a..b870ba9528 100644
--- a/src/model/ihorz-scale-behavior.ts
+++ b/src/model/ihorz-scale-behavior.ts
@@ -1,3 +1,4 @@
+import { Mutable } from '../helpers/mutable';
 import { Nominal } from '../helpers/nominal';
 
 import { ChartOptionsBase } from './chart-model';
@@ -8,26 +9,121 @@ import { TickMark } from './tick-marks';
 import { TickMarkWeightValue, TimeScalePoint } from './time-data';
 import { TimeMark } from './time-scale';
 
+/**
+ * Internal Horizontal Scale Item
+ */
 export type InternalHorzScaleItem = Nominal<unknown, 'InternalHorzScaleItem'>;
 
+/**
+ * Function for converting a horizontal scale item to an internal item.
+ */
 export type HorzScaleItemConverterToInternalObj<HorzScaleItem> = (time: HorzScaleItem) => InternalHorzScaleItem;
 
+/**
+ * Represents the type of data that a series contains.
+ */
 export type DataItem<HorzScaleItem> = SeriesDataItemTypeMap<HorzScaleItem>[SeriesType];
 
+/**
+ * Index key for a horizontal scale item.
+ */
 export type InternalHorzScaleItemKey = Nominal<number, 'InternalHorzScaleItemKey'>;
 
+/**
+ * Class interface for Horizontal scale behavior
+ */
 export interface IHorzScaleBehavior<HorzScaleItem> {
+	/**
+	 * Structure describing options of the chart.
+	 *
+	 * @returns ChartOptionsBase
+	 */
 	options(): ChartOptionsBase<HorzScaleItem>;
+	/**
+	 * Set the chart options. Note that this is different to `applyOptions` since the provided options will overwrite the current options
+	 * instead of merging with the current options.
+	 *
+	 * @param options - Chart options to be set
+	 * @returns void
+	 */
 	setOptions(options: ChartOptionsBase<HorzScaleItem>): void;
+	/**
+	 * Method to preprocess the data.
+	 *
+	 * @param data - Data items for the series
+	 * @returns void
+	 */
 	preprocessData(data: DataItem<HorzScaleItem> | DataItem<HorzScaleItem>[]): void;
+	/**
+	 * Convert horizontal scale item into an internal horizontal scale item.
+	 *
+	 * @param item - item to be converted
+	 * @returns InternalHorzScaleItem
+	 */
 	convertHorzItemToInternal(item: HorzScaleItem): InternalHorzScaleItem;
+	/**
+	 * Convert an internal horizontal item into a horizontal scale item.
+	 *
+	 * @param item - item to be converted
+	 * @returns HorzScaleItem
+	 */
 	convertInternalToHorzItem(item: InternalHorzScaleItem): HorzScaleItem;
+	/**
+	 * Creates and returns a converter for changing series data into internal horizontal scale items.
+	 *
+	 * @param data - series data
+	 * @returns HorzScaleItemConverterToInternalObj
+	 */
 	createConverterToInternalObj(data: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType][]): HorzScaleItemConverterToInternalObj<HorzScaleItem>;
+	/**
+	 * Returns the key for the specified horizontal scale item.
+	 *
+	 * @param internalItem - horizontal scale item for which the key should be returned
+	 * @returns InternalHorzScaleItemKey
+	 */
 	key(internalItem: InternalHorzScaleItem | HorzScaleItem): InternalHorzScaleItemKey;
+	/**
+	 * Returns the cache key for the specified horizontal scale item.
+	 *
+	 * @param internalItem - horizontal scale item for which the cache key should be returned
+	 * @returns number
+	 */
 	cacheKey(internalItem: InternalHorzScaleItem): number;
+	/**
+	 * Update the formatter with the localization options.
+	 *
+	 * @param options - Localization options
+	 * @returns void
+	 */
 	updateFormatter(options: LocalizationOptions<HorzScaleItem>): void;
+	/**
+	 * Format the horizontal scale item into a display string.
+	 *
+	 * @param item - horizontal scale item to be formatted as a string
+	 * @returns string
+	 */
 	formatHorzItem(item: InternalHorzScaleItem): string;
+	/**
+	 * Format the horizontal scale tickmark into a display string.
+	 *
+	 * @param item - tickmark item
+	 * @param localizationOptions - Localization options
+	 * @returns string
+	 */
 	formatTickmark(item: TickMark<HorzScaleItem>, localizationOptions: LocalizationOptions<HorzScaleItem>): string;
+	/**
+	 * Returns the maximum tickmark weight value for the specified tickmarks on the time scale.
+	 *
+	 * @param marks - Timescale tick marks
+	 * @returns TickMarkWeightValue
+	 */
 	maxTickMarkWeight(marks: TimeMark[]): TickMarkWeightValue;
+	/**
+	 * Fill the weights for the sorted time scale points.
+	 *
+	 * @param sortedTimePoints - sorted time scale points
+	 * @param startIndex - starting index
+	 * @returns void
+	 */
 	fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<HorzScaleItem>>[], startIndex: number): void;
 }
diff --git a/src/model/tick-marks.ts b/src/model/tick-marks.ts
index 5fa7d0c62a..425d3035a7 100644
--- a/src/model/tick-marks.ts
+++ b/src/model/tick-marks.ts
@@ -4,10 +4,17 @@ import { ensureDefined } from '../helpers/assertions';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { TickMarkWeightValue, TimePointIndex, TimeScalePoint } from './time-data';
 
+/**
+ * Tick mark for the horizontal scale.
+ */
 export interface TickMark<HorzScaleItem> {
+	/** Index */
 	index: TimePointIndex;
+	/** Time / Coordinate */
 	time: InternalHorzScaleItem;
+	/** Weight of the tick mark */
 	weight: TickMarkWeightValue;
+	/** Original value for the `time` property */
 	originalTime: HorzScaleItem;
 }
 
diff --git a/src/model/time-data.ts b/src/model/time-data.ts
index bb7c75f013..5c199af3e0 100644
--- a/src/model/time-data.ts
+++ b/src/model/time-data.ts
@@ -5,11 +5,20 @@ import { Coordinate } from './coordinate';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { RangeImpl } from './range-impl';
 
+/**
+ * Weight of the tick mark. @see TickMarkWeight enum
+ */
 export type TickMarkWeightValue = Nominal<number, 'TickMarkWeightValue'>;
 
+/**
+ * Represents a point on the time scale
+ */
 export interface TimeScalePoint<HorzScaleItem> {
+	/** Weight of the point */
 	readonly timeWeight: TickMarkWeightValue;
+	/** Time of the point */
 	readonly time: InternalHorzScaleItem;
+	/** Original time for the point */
 	readonly originalTime: HorzScaleItem;
 }
 
@@ -29,6 +38,9 @@ export interface Range<T> {
 
 export type TimePointsRange = Range<InternalHorzScaleItem>;
 
+/**
+ * Index for a point on the horizontal (time) scale.
+ */
 export type TimePointIndex = Nominal<number, 'TimePointIndex'>;
 
 /**
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index 60e605467f..d8008deff0 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -36,10 +36,17 @@ interface TransitionState {
 	rightOffset: number;
 }
 
+/**
+ * Represents a tick mark on the horizontal (time) scale.
+ */
 export interface TimeMark {
+	/** Does time mark need to be aligned */
 	needAlignCoordinate: boolean;
+	/** Coordinate for the time mark */
 	coord: number;
+	/** Display label for the time mark */
 	label: string;
+	/** Weight of the time mark */
 	weight: TickMarkWeightValue;
 }
 
diff --git a/src/typings/_global-types/index.d.ts b/src/typings/_global-types/index.d.ts
index 9f3342a8fb..d8b272a8d4 100644
--- a/src/typings/_global-types/index.d.ts
+++ b/src/typings/_global-types/index.d.ts
@@ -16,10 +16,3 @@ declare const enum MouseEventButton {
 	Fourth = 3,
 	Fifth = 4,
 }
-
-/**
- * Removes "readonly" from all properties
- */
-type Mutable<T> = {
-	-readonly [P in keyof T]: T[P];
-};

From b7c3b24b8818c246fb5b1c554442308f4bb46c04 Mon Sep 17 00:00:00 2001
From: Mark Silverwood <msilverwood@gmail.com>
Date: Tue, 11 Apr 2023 13:32:05 +0100
Subject: [PATCH 12/23] add coverage and graphics test cases

---
 .../test-cases/chart/horizontal-scale.js      | 103 ++++++++++++++++++
 .../test-cases/horizontal-price-scale.js      |  93 ++++++++++++++++
 2 files changed, 196 insertions(+)
 create mode 100644 tests/e2e/coverage/test-cases/chart/horizontal-scale.js
 create mode 100644 tests/e2e/graphics/test-cases/horizontal-price-scale.js

diff --git a/tests/e2e/coverage/test-cases/chart/horizontal-scale.js b/tests/e2e/coverage/test-cases/chart/horizontal-scale.js
new file mode 100644
index 0000000000..edabc00696
--- /dev/null
+++ b/tests/e2e/coverage/test-cases/chart/horizontal-scale.js
@@ -0,0 +1,103 @@
+function markWithGreaterWeight(a, b) {
+	return a.weight > b.weight ? a : b;
+}
+
+class HorzScaleBehaviorPrice {
+	options() {}
+	setOptions() {}
+	preprocessData() {}
+	updateFormatter() {}
+	createConverterToInternalObj() {
+		return price => price;
+	}
+
+	convertInternalToHorzItem(item) {
+		return item;
+	}
+
+	key(item) {
+		return item;
+	}
+
+	cacheKey(item) {
+		return item;
+	}
+
+	convertHorzItemToInternal(item) {
+		return item;
+	}
+
+	formatHorzItem(item) {
+		const tp = item;
+		return tp.toFixed(2);
+	}
+
+	formatTickmark(tickMark) {
+		return tickMark.time.toFixed(2);
+	}
+
+	maxTickMarkWeight(tickMarks) {
+		return tickMarks.reduce(markWithGreaterWeight, tickMarks[0]).weight;
+	}
+
+	fillWeightsForPoints(sortedTimePoints, startIndex) {
+		const priceWeight = price => {
+			if (price === Math.ceil(price / 100) * 100) {
+				return 8;
+			}
+			if (price === Math.ceil(price / 50) * 50) {
+				return 7;
+			}
+			if (price === Math.ceil(price / 25) * 25) {
+				return 6;
+			}
+			if (price === Math.ceil(price / 10) * 10) {
+				return 5;
+			}
+			if (price === Math.ceil(price / 5) * 5) {
+				return 4;
+			}
+			if (price === Math.ceil(price)) {
+				return 3;
+			}
+			if (price * 2 === Math.ceil(price * 2)) {
+				return 1;
+			}
+			return 0;
+		};
+		for (let index = startIndex; index < sortedTimePoints.length; ++index) {
+			sortedTimePoints[index].timeWeight = priceWeight(
+				sortedTimePoints[index].time
+			);
+		}
+	}
+}
+
+function interactionsToPerform() {
+	return [
+		{ action: 'scrollUpRight', target: 'pane' },
+		{ action: 'scrollDownLeft', target: 'pane' },
+	];
+}
+
+function beforeInteractions(container) {
+	const horzItemBehavior = new HorzScaleBehaviorPrice();
+	const chart = LightweightCharts.createChartEx(container, horzItemBehavior);
+	const s1 = chart.addLineSeries({
+		color: 'red',
+	});
+	const arr = [];
+	for (let i = 0; i < 5000; i++) {
+		arr.push({
+			time: i * 0.25,
+			value: Math.round(Math.random() * 10000) / 100,
+		});
+	}
+	s1.setData(arr);
+
+	return Promise.resolve();
+}
+
+function afterInteractions() {
+	return Promise.resolve();
+}
diff --git a/tests/e2e/graphics/test-cases/horizontal-price-scale.js b/tests/e2e/graphics/test-cases/horizontal-price-scale.js
new file mode 100644
index 0000000000..0ee32dc4fd
--- /dev/null
+++ b/tests/e2e/graphics/test-cases/horizontal-price-scale.js
@@ -0,0 +1,93 @@
+function markWithGreaterWeight(a, b) {
+	return a.weight > b.weight ? a : b;
+}
+
+class HorzScaleBehaviorPrice {
+	options() {}
+	setOptions() {}
+	preprocessData() {}
+	updateFormatter() {}
+	createConverterToInternalObj() {
+		return price => price;
+	}
+
+	convertInternalToHorzItem(item) {
+		return item;
+	}
+
+	key(item) {
+		return item;
+	}
+
+	cacheKey(item) {
+		return item;
+	}
+
+	convertHorzItemToInternal(item) {
+		return item;
+	}
+
+	formatHorzItem(item) {
+		const tp = item;
+		return tp.toFixed(2);
+	}
+
+	formatTickmark(tickMark) {
+		return tickMark.time.toFixed(2);
+	}
+
+	maxTickMarkWeight(tickMarks) {
+		return tickMarks.reduce(markWithGreaterWeight, tickMarks[0]).weight;
+	}
+
+	fillWeightsForPoints(sortedTimePoints, startIndex) {
+		const priceWeight = price => {
+			if (price === Math.ceil(price / 100) * 100) {
+				return 8;
+			}
+			if (price === Math.ceil(price / 50) * 50) {
+				return 7;
+			}
+			if (price === Math.ceil(price / 25) * 25) {
+				return 6;
+			}
+			if (price === Math.ceil(price / 10) * 10) {
+				return 5;
+			}
+			if (price === Math.ceil(price / 5) * 5) {
+				return 4;
+			}
+			if (price === Math.ceil(price)) {
+				return 3;
+			}
+			if (price * 2 === Math.ceil(price * 2)) {
+				return 1;
+			}
+			return 0;
+		};
+		for (let index = startIndex; index < sortedTimePoints.length; ++index) {
+			sortedTimePoints[index].timeWeight = priceWeight(
+				sortedTimePoints[index].time
+			);
+		}
+	}
+}
+
+function runTestCase(container) {
+	const horzItemBehavior = new HorzScaleBehaviorPrice();
+	const chart = (window.chart = LightweightCharts.createChartEx(
+		container,
+		horzItemBehavior
+	));
+	const s1 = chart.addLineSeries({
+		color: 'red',
+	});
+	const arr = [];
+	for (let i = 0; i < 5000; i++) {
+		arr.push({
+			time: i * 0.25,
+			value: Math.round(i / 10),
+		});
+	}
+	s1.setData(arr);
+}

From 38c6d8edd066febed66f214d128c5b143a6b5951 Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 11 Apr 2023 15:59:01 +0300
Subject: [PATCH 13/23] Fixed compile-time back compatibility

---
 src/api/chart-api.ts                          |  6 ++---
 src/api/create-chart.ts                       | 10 +++++---
 src/api/ichart-api.ts                         |  2 +-
 src/api/iseries-api.ts                        |  3 ++-
 src/api/itime-scale-api.ts                    |  6 ++---
 .../options/time-scale-options-defaults.ts    |  4 +--
 src/api/time-scale-api.ts                     |  6 ++---
 src/model/chart-model.ts                      |  4 +--
 src/model/data-consumer.ts                    | 25 ++++++++++---------
 .../time-based-chart-options.ts               |  6 ++---
 src/model/localization-options.ts             |  3 ++-
 src/model/series-markers.ts                   |  4 ++-
 src/model/time-scale.ts                       | 10 ++++----
 .../graphics/helpers/testcase-window-type.ts  |  2 +-
 14 files changed, 50 insertions(+), 41 deletions(-)

diff --git a/src/api/chart-api.ts b/src/api/chart-api.ts
index 562e6eb39b..610b7ef412 100644
--- a/src/api/chart-api.ts
+++ b/src/api/chart-api.ts
@@ -30,7 +30,7 @@ import {
 import { Logical } from '../model/time-data';
 
 import { getSeriesDataCreator } from './get-series-data-creator';
-import { IChartApi, MouseEventHandler, MouseEventParams } from './ichart-api';
+import { IChartApiBase, MouseEventHandler, MouseEventParams } from './ichart-api';
 import { IPriceScaleApi } from './iprice-scale-api';
 import { ISeriesApi } from './iseries-api';
 import { ITimeScaleApi } from './itime-scale-api';
@@ -106,9 +106,9 @@ function toInternalOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsBase<
 	return options as DeepPartial<ChartOptionsInternal<HorzScaleItem>>;
 }
 
-export type IPriceScaleApiProvider<HorzScaleItem> = Pick<IChartApi<HorzScaleItem>, 'priceScale'>;
+export type IPriceScaleApiProvider<HorzScaleItem> = Pick<IChartApiBase<HorzScaleItem>, 'priceScale'>;
 
-export class ChartApi<HorzScaleItem> implements IChartApi<HorzScaleItem>, DataUpdatesConsumer<SeriesType, HorzScaleItem> {
+export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, DataUpdatesConsumer<SeriesType, HorzScaleItem> {
 	private _chartWidget: ChartWidget<HorzScaleItem>;
 	private _dataLayer: DataLayer<HorzScaleItem>;
 	private readonly _seriesMap: Map<SeriesApi<SeriesType, HorzScaleItem>, Series<SeriesType, HorzScaleItem>> = new Map();
diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index c1d2a33995..cc3d12dac1 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -7,7 +7,7 @@ import { Time } from '../model/horz-scale-behavior-time/types';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 
 import { ChartApi } from './chart-api';
-import { IChartApi } from './ichart-api';
+import { IChartApiBase } from './ichart-api';
 
 /**
  * This function is the main entry point of the Lightweight Charting Library.
@@ -23,7 +23,7 @@ export function createChartEx<HorzScaleItem, THorzScaleBehavior extends IHorzSca
 	container: string | HTMLElement,
 	horzScaleBehavior: THorzScaleBehavior,
 	options?: DeepPartial<ReturnType<THorzScaleBehavior['options']>>
-): IChartApi<HorzScaleItem> {
+): IChartApiBase<HorzScaleItem> {
 	let htmlElement: HTMLElement;
 	if (isString(container)) {
 		const element = document.getElementById(container);
@@ -43,6 +43,10 @@ export function createChartEx<HorzScaleItem, THorzScaleBehavior extends IHorzSca
  */
 export type ChartOptions = TimeChartOptions;
 
+export interface IChartApi extends IChartApiBase<Time> {
+	applyOptions(options: DeepPartial<ChartOptions>): void;
+}
+
 /**
  * This function is the simplified main entry point of the Lightweight Charting Library with time points at horizontal scale.
  *
@@ -50,7 +54,7 @@ export type ChartOptions = TimeChartOptions;
  * @param options - Any subset of options to be applied at start.
  * @returns An interface to the created chart
  */
-export function createChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions>): IChartApi<Time> {
+export function createChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions>): IChartApi {
 	return createChartEx<Time, HorzScaleBehaviorTime>(
 		container,
 		new HorzScaleBehaviorTime(),
diff --git a/src/api/ichart-api.ts b/src/api/ichart-api.ts
index 162d14025c..1107bb3407 100644
--- a/src/api/ichart-api.ts
+++ b/src/api/ichart-api.ts
@@ -69,7 +69,7 @@ export type MouseEventHandler<HorzScaleItem> = (param: MouseEventParams<HorzScal
 /**
  * The main interface of a single chart.
  */
-export interface IChartApi<HorzScaleItem = Time> {
+export interface IChartApiBase<HorzScaleItem = Time> {
 	/**
 	 * Removes the chart object including all DOM elements. This is an irreversible operation, you cannot do anything with the chart after removing it.
 	 */
diff --git a/src/api/iseries-api.ts b/src/api/iseries-api.ts
index b7847fae2d..47fd9de4d5 100644
--- a/src/api/iseries-api.ts
+++ b/src/api/iseries-api.ts
@@ -3,6 +3,7 @@ import { IPriceFormatter } from '../formatters/iprice-formatter';
 import { BarPrice } from '../model/bar';
 import { Coordinate } from '../model/coordinate';
 import { SeriesDataItemTypeMap } from '../model/data-consumer';
+import { Time } from '../model/horz-scale-behavior-time/types';
 import { MismatchDirection } from '../model/plot-list';
 import { CreatePriceLineOptions } from '../model/price-line-options';
 import { SeriesMarker } from '../model/series-markers';
@@ -40,7 +41,7 @@ export interface BarsInfo<HorzScaleItem> extends Partial<Range<HorzScaleItem>> {
 /**
  * Represents the interface for interacting with series.
  */
-export interface ISeriesApi<TSeriesType extends SeriesType, HorzScaleItem> {
+export interface ISeriesApi<TSeriesType extends SeriesType, HorzScaleItem = Time> {
 	/**
 	 * Returns current price formatter
 	 *
diff --git a/src/api/itime-scale-api.ts b/src/api/itime-scale-api.ts
index 4d754d0305..bd25d9f16a 100644
--- a/src/api/itime-scale-api.ts
+++ b/src/api/itime-scale-api.ts
@@ -2,7 +2,7 @@ import { DeepPartial } from '../helpers/strict-type-checks';
 
 import { Coordinate } from '../model/coordinate';
 import { Logical, LogicalRange, Range } from '../model/time-data';
-import { TimeScaleOptions } from '../model/time-scale';
+import { HorzScaleOptions } from '../model/time-scale';
 
 /**
  * A custom function used to handle changes to the time scale's time range.
@@ -219,12 +219,12 @@ export interface ITimeScaleApi<HorzScaleItem> {
 	 *
 	 * @param options - Any subset of options.
 	 */
-	applyOptions(options: DeepPartial<TimeScaleOptions>): void;
+	applyOptions(options: DeepPartial<HorzScaleOptions>): void;
 
 	/**
 	 * Returns current options
 	 *
 	 * @returns Currently applied options
 	 */
-	options(): Readonly<TimeScaleOptions>;
+	options(): Readonly<HorzScaleOptions>;
 }
diff --git a/src/api/options/time-scale-options-defaults.ts b/src/api/options/time-scale-options-defaults.ts
index 2b3a6891e8..3e512903a7 100644
--- a/src/api/options/time-scale-options-defaults.ts
+++ b/src/api/options/time-scale-options-defaults.ts
@@ -1,6 +1,6 @@
-import { TimeScaleOptions } from '../../model/time-scale';
+import { HorzScaleOptions } from '../../model/time-scale';
 
-export const timeScaleOptionsDefaults: TimeScaleOptions = {
+export const timeScaleOptionsDefaults: HorzScaleOptions = {
 	rightOffset: 0,
 	barSpacing: 6,
 	minBarSpacing: 0.5,
diff --git a/src/api/time-scale-api.ts b/src/api/time-scale-api.ts
index a482181ac8..4a448cd938 100644
--- a/src/api/time-scale-api.ts
+++ b/src/api/time-scale-api.ts
@@ -11,7 +11,7 @@ import { ChartModel } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 import { Logical, LogicalRange, Range, TimePointIndex, TimePointsRange } from '../model/time-data';
-import { TimeScale, TimeScaleOptions } from '../model/time-scale';
+import { TimeScale, HorzScaleOptions } from '../model/time-scale';
 
 import {
 	ITimeScaleApi,
@@ -189,11 +189,11 @@ export class TimeScaleApi<HorzScaleItem> implements ITimeScaleApi<HorzScaleItem>
 		this._sizeChanged.unsubscribe(handler);
 	}
 
-	public applyOptions(options: DeepPartial<TimeScaleOptions>): void {
+	public applyOptions(options: DeepPartial<HorzScaleOptions>): void {
 		this._timeScale.applyOptions(options);
 	}
 
-	public options(): Readonly<TimeScaleOptions> {
+	public options(): Readonly<HorzScaleOptions> {
 		return clone(this._timeScale.options());
 	}
 
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index eb5ad954fd..f90ba7ff14 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -26,7 +26,7 @@ import { PriceScale, PriceScaleOptions } from './price-scale';
 import { Series, SeriesOptionsInternal } from './series';
 import { SeriesOptionsMap, SeriesType } from './series-options';
 import { LogicalRange, TimePointIndex, TimeScalePoint } from './time-data';
-import { TimeScale, TimeScaleOptions } from './time-scale';
+import { TimeScale, HorzScaleOptions } from './time-scale';
 import { TouchMouseEventData } from './touch-mouse-event-data';
 import { Watermark, WatermarkOptions } from './watermark';
 
@@ -297,7 +297,7 @@ export interface ChartOptionsBase<HorzScaleItem> {
 	/**
 	 * Time scale options
 	 */
-	timeScale: TimeScaleOptions;
+	timeScale: HorzScaleOptions;
 
 	/**
 	 * The crosshair shows the intersection of the price and time scale values at any point on the chart.
diff --git a/src/model/data-consumer.ts b/src/model/data-consumer.ts
index 0f5da4485c..9428146d71 100644
--- a/src/model/data-consumer.ts
+++ b/src/model/data-consumer.ts
@@ -1,3 +1,4 @@
+import { Time } from './horz-scale-behavior-time/types';
 import { Series } from './series';
 import { SeriesType } from './series-options';
 
@@ -17,7 +18,7 @@ import { SeriesType } from './series-options';
  * ];
  * ```
  */
-export interface WhitespaceData<HorzScaleItem> {
+export interface WhitespaceData<HorzScaleItem = Time> {
 	/**
 	 * The time of the data.
 	 */
@@ -27,7 +28,7 @@ export interface WhitespaceData<HorzScaleItem> {
 /**
  * A base interface for a data point of single-value series.
  */
-export interface SingleValueData<HorzScaleItem> {
+export interface SingleValueData<HorzScaleItem = Time> {
 	/**
 	 * The time of the data.
 	 */
@@ -42,7 +43,7 @@ export interface SingleValueData<HorzScaleItem> {
 /**
  * Structure describing a single item of data for line series
  */
-export interface LineData<HorzScaleItem> extends SingleValueData<HorzScaleItem> {
+export interface LineData<HorzScaleItem = Time> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -52,7 +53,7 @@ export interface LineData<HorzScaleItem> extends SingleValueData<HorzScaleItem>
 /**
  * Structure describing a single item of data for histogram series
  */
-export interface HistogramData<HorzScaleItem> extends SingleValueData<HorzScaleItem> {
+export interface HistogramData<HorzScaleItem = Time> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -62,7 +63,7 @@ export interface HistogramData<HorzScaleItem> extends SingleValueData<HorzScaleI
 /**
  * Structure describing a single item of data for area series
  */
-export interface AreaData<HorzScaleItem> extends SingleValueData<HorzScaleItem> {
+export interface AreaData<HorzScaleItem = Time> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional line color value for certain data item. If missed, color from options is used
 	 */
@@ -82,7 +83,7 @@ export interface AreaData<HorzScaleItem> extends SingleValueData<HorzScaleItem>
 /**
  * Structure describing a single item of data for baseline series
  */
-export interface BaselineData<HorzScaleItem> extends SingleValueData<HorzScaleItem> {
+export interface BaselineData<HorzScaleItem = Time> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional top area top fill color value for certain data item. If missed, color from options is used
 	 */
@@ -117,7 +118,7 @@ export interface BaselineData<HorzScaleItem> extends SingleValueData<HorzScaleIt
 /**
  * Represents a bar with a {@link Time} and open, high, low, and close prices.
  */
-export interface OhlcData<HorzScaleItem> {
+export interface OhlcData<HorzScaleItem = Time> {
 	/**
 	 * The bar time.
 	 */
@@ -144,7 +145,7 @@ export interface OhlcData<HorzScaleItem> {
 /**
  * Structure describing a single item of data for bar series
  */
-export interface BarData<HorzScaleItem> extends OhlcData<HorzScaleItem> {
+export interface BarData<HorzScaleItem = Time> extends OhlcData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -154,7 +155,7 @@ export interface BarData<HorzScaleItem> extends OhlcData<HorzScaleItem> {
 /**
  * Structure describing a single item of data for candlestick series
  */
-export interface CandlestickData<HorzScaleItem> extends OhlcData<HorzScaleItem> {
+export interface CandlestickData<HorzScaleItem = Time> extends OhlcData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -169,7 +170,7 @@ export interface CandlestickData<HorzScaleItem> extends OhlcData<HorzScaleItem>
 	wickColor?: string;
 }
 
-export function isWhitespaceData<HorzScaleItem>(data: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType]): data is WhitespaceData<HorzScaleItem> {
+export function isWhitespaceData<HorzScaleItem = Time>(data: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType]): data is WhitespaceData<HorzScaleItem> {
 	return (data as Partial<BarData<HorzScaleItem>>).open === undefined && (data as Partial<LineData<HorzScaleItem>>).value === undefined;
 }
 
@@ -187,7 +188,7 @@ export function isFulfilledData<HorzScaleItem, T extends SeriesDataItemTypeMap<H
  *
  * For example a bar series contains {@link BarData} or {@link WhitespaceData}.
  */
-export interface SeriesDataItemTypeMap<HorzScaleItem> {
+export interface SeriesDataItemTypeMap<HorzScaleItem = Time> {
 	/**
 	 * The types of bar series data.
 	 */
@@ -214,7 +215,7 @@ export interface SeriesDataItemTypeMap<HorzScaleItem> {
 	Histogram: HistogramData<HorzScaleItem> | WhitespaceData<HorzScaleItem>;
 }
 
-export interface DataUpdatesConsumer<TSeriesType extends SeriesType, HorzScaleItem> {
+export interface DataUpdatesConsumer<TSeriesType extends SeriesType, HorzScaleItem = Time> {
 	applyNewData(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void;
 	updateData(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void;
 }
diff --git a/src/model/horz-scale-behavior-time/time-based-chart-options.ts b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
index 8a277ff7e3..77a86c0845 100644
--- a/src/model/horz-scale-behavior-time/time-based-chart-options.ts
+++ b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
@@ -1,12 +1,12 @@
 import { ChartOptionsBase } from '../chart-model';
-import { TimeScaleOptions } from '../time-scale';
+import { HorzScaleOptions } from '../time-scale';
 import { TickMarkFormatter } from './horz-scale-behavior-time';
 import { Time } from './types';
 
 /**
  * Extended time scale options for time-base horz scale
  */
-export interface TimeChartTimeScaleOptions extends TimeScaleOptions {
+export interface TimeScaleOptions extends HorzScaleOptions {
 	/**
 	 * Tick marks formatter can be used to customize tick marks labels on the time axis.
 	 *
@@ -22,5 +22,5 @@ export interface TimeChartOptions extends ChartOptionsBase<Time> {
 	/**
 	 * Extended time scale options with option to override tickMarkFormatter
 	 */
-	timeScale: TimeChartTimeScaleOptions;
+	timeScale: TimeScaleOptions;
 }
diff --git a/src/model/localization-options.ts b/src/model/localization-options.ts
index a8afa35e5a..3d3c3a3a7a 100644
--- a/src/model/localization-options.ts
+++ b/src/model/localization-options.ts
@@ -1,9 +1,10 @@
+import { Time } from './horz-scale-behavior-time/types';
 import { PriceFormatterFn } from './price-formatter-fn';
 
 /**
  * A custom function used to override formatting of a time to a string.
  */
-export type TimeFormatterFn<HorzScaleItem> = (time: HorzScaleItem) => string;
+export type TimeFormatterFn<HorzScaleItem = Time> = (time: HorzScaleItem) => string;
 
 /**
  * Represents options for formatting dates, times, and prices according to a locale.
diff --git a/src/model/series-markers.ts b/src/model/series-markers.ts
index a172527783..e3209e78a9 100644
--- a/src/model/series-markers.ts
+++ b/src/model/series-markers.ts
@@ -1,3 +1,5 @@
+import { Time } from "./horz-scale-behavior-time/types";
+
 /**
  * Represents the position of a series marker relative to a bar.
  */
@@ -11,7 +13,7 @@ export type SeriesMarkerShape = 'circle' | 'square' | 'arrowUp' | 'arrowDown';
 /**
  * Represents a series marker.
  */
-export interface SeriesMarker<TimeType, HorzScaleItem> {
+export interface SeriesMarker<TimeType, HorzScaleItem = Time> {
 	/**
 	 * The time of the marker.
 	 */
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index 60e605467f..1eed233d07 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -50,7 +50,7 @@ export function markWithGreaterWeight(a: TimeMark, b: TimeMark): TimeMark {
 /**
  * Options for the time scale; the horizontal scale at the bottom of the chart that displays the time of data.
  */
-export interface TimeScaleOptions {
+export interface HorzScaleOptions {
 	/**
 	 * The margin space in bars from the right side of the chart.
 	 *
@@ -159,7 +159,7 @@ export interface TimeScaleOptions {
 }
 
 export class TimeScale<HorzScaleItem> {
-	private readonly _options: TimeScaleOptions;
+	private readonly _options: HorzScaleOptions;
 	private readonly _model: ChartModel<HorzScaleItem>;
 	private readonly _localizationOptions: LocalizationOptions<HorzScaleItem>;
 
@@ -187,7 +187,7 @@ export class TimeScale<HorzScaleItem> {
 
 	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
 
-	public constructor(model: ChartModel<HorzScaleItem>, options: TimeScaleOptions, localizationOptions: LocalizationOptions<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
+	public constructor(model: ChartModel<HorzScaleItem>, options: HorzScaleOptions, localizationOptions: LocalizationOptions<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
 		this._options = options;
 		this._localizationOptions = localizationOptions;
 		this._rightOffset = options.rightOffset;
@@ -201,7 +201,7 @@ export class TimeScale<HorzScaleItem> {
 		this._tickMarks.setUniformDistribution(options.uniformDistribution);
 	}
 
-	public options(): Readonly<TimeScaleOptions> {
+	public options(): Readonly<HorzScaleOptions> {
 		return this._options;
 	}
 
@@ -212,7 +212,7 @@ export class TimeScale<HorzScaleItem> {
 		this._updateDateTimeFormatter();
 	}
 
-	public applyOptions(options: DeepPartial<TimeScaleOptions>, localizationOptions?: DeepPartial<LocalizationOptions<HorzScaleItem>>): void {
+	public applyOptions(options: DeepPartial<HorzScaleOptions>, localizationOptions?: DeepPartial<LocalizationOptions<HorzScaleItem>>): void {
 		merge(this._options, options);
 
 		if (this._options.fixLeftEdge) {
diff --git a/tests/e2e/graphics/helpers/testcase-window-type.ts b/tests/e2e/graphics/helpers/testcase-window-type.ts
index 29182f702b..8c1ac89dd3 100644
--- a/tests/e2e/graphics/helpers/testcase-window-type.ts
+++ b/tests/e2e/graphics/helpers/testcase-window-type.ts
@@ -1,4 +1,4 @@
-import { IChartApi } from '../../../../src/api/ichart-api';
+import { IChartApi } from '../../../../src/api/create-chart';
 
 export interface TestCaseWindow extends Window {
 	testCaseReady: void | Promise<void>;

From eb094c709cd7aedace48f19648b7a07c6540531e Mon Sep 17 00:00:00 2001
From: Mark Silverwood <msilverwood@gmail.com>
Date: Tue, 11 Apr 2023 15:17:13 +0100
Subject: [PATCH 14/23] fix eslint warnings

---
 src/api/create-chart.ts     | 8 ++++++++
 src/api/time-scale-api.ts   | 2 +-
 src/model/chart-model.ts    | 2 +-
 src/model/series-markers.ts | 2 +-
 4 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/api/create-chart.ts b/src/api/create-chart.ts
index fb031c518b..0f0cf3f68e 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -45,7 +45,15 @@ export function createChartEx<HorzScaleItem, THorzScaleBehavior extends IHorzSca
  */
 export type ChartOptions = TimeChartOptions;
 
+/**
+ * The main interface of a single chart using time for horizontal scale.
+ */
 export interface IChartApi extends IChartApiBase<Time> {
+	/**
+	 * Applies new options to the chart
+	 *
+	 * @param options - Any subset of options.
+	 */
 	applyOptions(options: DeepPartial<ChartOptions>): void;
 }
 
diff --git a/src/api/time-scale-api.ts b/src/api/time-scale-api.ts
index 4a448cd938..be913bea94 100644
--- a/src/api/time-scale-api.ts
+++ b/src/api/time-scale-api.ts
@@ -11,7 +11,7 @@ import { ChartModel } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 import { Logical, LogicalRange, Range, TimePointIndex, TimePointsRange } from '../model/time-data';
-import { TimeScale, HorzScaleOptions } from '../model/time-scale';
+import { HorzScaleOptions, TimeScale } from '../model/time-scale';
 
 import {
 	ITimeScaleApi,
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index f90ba7ff14..d82d02472a 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -26,7 +26,7 @@ import { PriceScale, PriceScaleOptions } from './price-scale';
 import { Series, SeriesOptionsInternal } from './series';
 import { SeriesOptionsMap, SeriesType } from './series-options';
 import { LogicalRange, TimePointIndex, TimeScalePoint } from './time-data';
-import { TimeScale, HorzScaleOptions } from './time-scale';
+import { HorzScaleOptions, TimeScale } from './time-scale';
 import { TouchMouseEventData } from './touch-mouse-event-data';
 import { Watermark, WatermarkOptions } from './watermark';
 
diff --git a/src/model/series-markers.ts b/src/model/series-markers.ts
index e3209e78a9..b18a7e6aa3 100644
--- a/src/model/series-markers.ts
+++ b/src/model/series-markers.ts
@@ -1,4 +1,4 @@
-import { Time } from "./horz-scale-behavior-time/types";
+import { Time } from './horz-scale-behavior-time/types';
 
 /**
  * Represents the position of a series marker relative to a bar.

From 0cf14aa29d4c4421accd457935d0839416c54b4a Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Thu, 1 Jun 2023 10:42:57 +0300
Subject: [PATCH 15/23] Get rid of generic param in IPaneView

---
 src/gui/pane-widget.ts                             | 14 +++++++-------
 src/model/crosshair.ts                             |  2 +-
 src/model/custom-price-line.ts                     |  4 ++--
 src/model/data-source.ts                           |  4 ++--
 src/model/grid.ts                                  |  2 +-
 src/model/idata-source.ts                          |  6 +++---
 src/model/series.ts                                | 10 +++++-----
 src/model/watermark.ts                             |  2 +-
 src/views/pane/crosshair-marks-pane-view.ts        |  2 +-
 src/views/pane/crosshair-pane-view.ts              |  2 +-
 src/views/pane/grid-pane-view.ts                   |  2 +-
 src/views/pane/ipane-view.ts                       |  2 +-
 src/views/pane/iupdatable-pane-view.ts             |  2 +-
 src/views/pane/pane-price-axis-view.ts             |  2 +-
 src/views/pane/series-horizontal-line-pane-view.ts |  2 +-
 .../pane/series-last-price-animation-pane-view.ts  |  2 +-
 src/views/pane/series-markers-pane-view.ts         |  2 +-
 src/views/pane/series-pane-view-base.ts            |  2 +-
 src/views/pane/watermark-pane-view.ts              |  2 +-
 19 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/src/gui/pane-widget.ts b/src/gui/pane-widget.ts
index 24c64bd8e2..596d09f949 100644
--- a/src/gui/pane-widget.ts
+++ b/src/gui/pane-widget.ts
@@ -51,28 +51,28 @@ function drawForeground(renderer: IPaneRenderer, target: CanvasRenderingTarget2D
 	renderer.draw(target, isHovered, hitTestData);
 }
 
-type PaneViewsGetter<HorzScaleItem> = (source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>) => readonly IPaneView<HorzScaleItem>[];
+type PaneViewsGetter<HorzScaleItem> = (source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>) => readonly IPaneView[];
 
-function sourcePaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
+function sourcePaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
 	return source.paneViews(pane);
 }
 
-function sourceLabelPaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
+function sourceLabelPaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
 	return source.labelPaneViews(pane);
 }
 
-function sourceTopPaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
+function sourceTopPaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
 	return source.topPaneViews !== undefined ? source.topPaneViews(pane) : [];
 }
 
 export interface HitTestResult<HorzScaleItem> {
 	source: IPriceDataSource<HorzScaleItem>;
 	object?: HoveredObject;
-	view: IPaneView<HorzScaleItem>;
+	view: IPaneView;
 }
 
 interface HitTestPaneViewResult<HorzScaleItem> {
-	view: IPaneView<HorzScaleItem>;
+	view: IPaneView;
 	object?: HoveredObject;
 }
 
@@ -604,7 +604,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		}
 	}
 
-	private _hitTestPaneView(paneViews: readonly IPaneView<HorzScaleItem>[], x: Coordinate, y: Coordinate): HitTestPaneViewResult<HorzScaleItem> | null {
+	private _hitTestPaneView(paneViews: readonly IPaneView[], x: Coordinate, y: Coordinate): HitTestPaneViewResult<HorzScaleItem> | null {
 		for (const paneView of paneViews) {
 			const renderer = paneView.renderer();
 			if (renderer !== null && renderer.hitTest) {
diff --git a/src/model/crosshair.ts b/src/model/crosshair.ts
index 5c02b7cd7b..bc4b25d449 100644
--- a/src/model/crosshair.ts
+++ b/src/model/crosshair.ts
@@ -255,7 +255,7 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		this.clearOriginCoord();
 	}
 
-	public paneViews(pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
+	public paneViews(pane: Pane<HorzScaleItem>): readonly IPaneView[] {
 		return this._pane !== null ? [this._paneView, this._markersPaneView] : [];
 	}
 
diff --git a/src/model/custom-price-line.ts b/src/model/custom-price-line.ts
index 334bfc81af..1b902898d9 100644
--- a/src/model/custom-price-line.ts
+++ b/src/model/custom-price-line.ts
@@ -36,11 +36,11 @@ export class CustomPriceLine<HorzScaleItem> {
 		return this._options;
 	}
 
-	public paneView(): IPaneView<HorzScaleItem> {
+	public paneView(): IPaneView {
 		return this._priceLineView;
 	}
 
-	public labelPaneView(): IPaneView<HorzScaleItem> {
+	public labelPaneView(): IPaneView {
 		return this._panePriceAxisView;
 	}
 
diff --git a/src/model/data-source.ts b/src/model/data-source.ts
index 4fbf9660da..7ab7fa515b 100644
--- a/src/model/data-source.ts
+++ b/src/model/data-source.ts
@@ -28,9 +28,9 @@ export abstract class DataSource<HorzScaleItem> implements IDataSource<HorzScale
 	}
 
 	public abstract priceAxisViews(pane?: Pane<HorzScaleItem>, priceScale?: PriceScale<HorzScaleItem>): readonly IPriceAxisView<HorzScaleItem>[];
-	public abstract paneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[];
+	public abstract paneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[];
 
-	public labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
+	public labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[] {
 		return [];
 	}
 
diff --git a/src/model/grid.ts b/src/model/grid.ts
index d8870cf6d1..839b0dac84 100644
--- a/src/model/grid.ts
+++ b/src/model/grid.ts
@@ -48,7 +48,7 @@ export class Grid<HorzScaleItem> {
 		this._paneView = new GridPaneView(pane);
 	}
 
-	public paneView(): IUpdatablePaneView<HorzScaleItem> {
+	public paneView(): IUpdatablePaneView {
 		return this._paneView;
 	}
 }
diff --git a/src/model/idata-source.ts b/src/model/idata-source.ts
index ac9a4500c3..5547649c7f 100644
--- a/src/model/idata-source.ts
+++ b/src/model/idata-source.ts
@@ -15,13 +15,13 @@ export interface IDataSource<HorzScaleItem> {
 
 	priceAxisViews(pane?: Pane<HorzScaleItem>, priceScale?: PriceScale<HorzScaleItem>): readonly IPriceAxisView<HorzScaleItem>[];
 	timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[];
-	paneViews(pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[];
-	labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[];
+	paneViews(pane: Pane<HorzScaleItem>): readonly IPaneView[];
+	labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[];
 
 	/**
 	 * Pane views that are painted on the most top layer
 	 */
-	topPaneViews?(pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[];
+	topPaneViews?(pane: Pane<HorzScaleItem>): readonly IPaneView[];
 
 	visible(): boolean;
 
diff --git a/src/model/series.ts b/src/model/series.ts
index c23d8aed13..b03dba9550 100644
--- a/src/model/series.ts
+++ b/src/model/series.ts
@@ -104,7 +104,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 	private readonly _priceLineView: SeriesPriceLinePaneView<HorzScaleItem> = new SeriesPriceLinePaneView(this);
 	private readonly _customPriceLines: CustomPriceLine<HorzScaleItem>[] = [];
 	private readonly _baseHorizontalLineView: SeriesHorizontalBaseLinePaneView<HorzScaleItem> = new SeriesHorizontalBaseLinePaneView(this);
-	private _paneView!: IUpdatablePaneView<HorzScaleItem>;
+	private _paneView!: IUpdatablePaneView;
 	private readonly _lastPriceAnimationPaneView: SeriesLastPriceAnimationPaneView<HorzScaleItem> | null = null;
 	private _barColorerCache: SeriesBarColorer<T, HorzScaleItem> | null = null;
 	private readonly _options: SeriesOptionsInternal<T>;
@@ -343,7 +343,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		}
 	}
 
-	public topPaneViews(pane: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
+	public topPaneViews(pane: Pane<HorzScaleItem>): readonly IPaneView[] {
 		const animationPaneView = this._lastPriceAnimationPaneView;
 		if (animationPaneView === null || !animationPaneView.visible()) {
 			return [];
@@ -363,8 +363,8 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		return [animationPaneView];
 	}
 
-	public paneViews(): readonly IPaneView<HorzScaleItem>[] {
-		const res: IPaneView<HorzScaleItem>[] = [];
+	public paneViews(): readonly IPaneView[] {
+		const res: IPaneView[] = [];
 
 		if (!this._isOverlay()) {
 			res.push(this._baseHorizontalLineView);
@@ -382,7 +382,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		return res;
 	}
 
-	public override labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView<HorzScaleItem>[] {
+	public override labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[] {
 		return [
 			this._panePriceAxisView,
 			...this._customPriceLines.map((line: CustomPriceLine<HorzScaleItem>) => line.labelPaneView()),
diff --git a/src/model/watermark.ts b/src/model/watermark.ts
index 848dc688b2..f5c6c50b39 100644
--- a/src/model/watermark.ts
+++ b/src/model/watermark.ts
@@ -79,7 +79,7 @@ export class Watermark<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		return [];
 	}
 
-	public paneViews(): readonly IPaneView<HorzScaleItem>[] {
+	public paneViews(): readonly IPaneView[] {
 		return [this._paneView];
 	}
 
diff --git a/src/views/pane/crosshair-marks-pane-view.ts b/src/views/pane/crosshair-marks-pane-view.ts
index 7ee1525770..63ce5397a7 100644
--- a/src/views/pane/crosshair-marks-pane-view.ts
+++ b/src/views/pane/crosshair-marks-pane-view.ts
@@ -31,7 +31,7 @@ function createEmptyMarkerData(): MarksRendererData {
 
 const rangeForSinglePoint: SeriesItemsIndexesRange = { from: 0, to: 1 };
 
-export class CrosshairMarksPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+export class CrosshairMarksPaneView<HorzScaleItem> implements IUpdatablePaneView {
 	private readonly _chartModel: ChartModel<HorzScaleItem>;
 	private readonly _crosshair: Crosshair<HorzScaleItem>;
 	private readonly _compositeRenderer: CompositeRenderer = new CompositeRenderer();
diff --git a/src/views/pane/crosshair-pane-view.ts b/src/views/pane/crosshair-pane-view.ts
index 0448ac162c..283680473a 100644
--- a/src/views/pane/crosshair-pane-view.ts
+++ b/src/views/pane/crosshair-pane-view.ts
@@ -6,7 +6,7 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IPaneView } from './ipane-view';
 
-export class CrosshairPaneView<HorzScaleItem> implements IPaneView<HorzScaleItem> {
+export class CrosshairPaneView<HorzScaleItem> implements IPaneView {
 	private _invalidated: boolean = true;
 	private readonly _source: Crosshair<HorzScaleItem>;
 	private readonly _rendererData: CrosshairRendererData = {
diff --git a/src/views/pane/grid-pane-view.ts b/src/views/pane/grid-pane-view.ts
index 50a58c881f..8314053129 100644
--- a/src/views/pane/grid-pane-view.ts
+++ b/src/views/pane/grid-pane-view.ts
@@ -5,7 +5,7 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IUpdatablePaneView } from './iupdatable-pane-view';
 
-export class GridPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+export class GridPaneView<HorzScaleItem> implements IUpdatablePaneView {
 	private readonly _pane: Pane<HorzScaleItem>;
 	private readonly _renderer: GridRenderer = new GridRenderer();
 	private _invalidated: boolean = true;
diff --git a/src/views/pane/ipane-view.ts b/src/views/pane/ipane-view.ts
index de344cbbf9..87324a9511 100644
--- a/src/views/pane/ipane-view.ts
+++ b/src/views/pane/ipane-view.ts
@@ -1,5 +1,5 @@
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
-export interface IPaneView<HorzScaleItem> {
+export interface IPaneView {
 	renderer(addAnchors?: boolean): IPaneRenderer | null;
 }
diff --git a/src/views/pane/iupdatable-pane-view.ts b/src/views/pane/iupdatable-pane-view.ts
index 1f0c49ce14..10b070a164 100644
--- a/src/views/pane/iupdatable-pane-view.ts
+++ b/src/views/pane/iupdatable-pane-view.ts
@@ -2,6 +2,6 @@ import { IPaneView } from './ipane-view';
 
 export type UpdateType = 'data' | 'other' | 'options';
 
-export interface IUpdatablePaneView<HorzScaleItem> extends IPaneView<HorzScaleItem> {
+export interface IUpdatablePaneView extends IPaneView {
 	update(updateType?: UpdateType): void;
 }
diff --git a/src/views/pane/pane-price-axis-view.ts b/src/views/pane/pane-price-axis-view.ts
index d0b2a39cf8..305d4b9d8a 100644
--- a/src/views/pane/pane-price-axis-view.ts
+++ b/src/views/pane/pane-price-axis-view.ts
@@ -38,7 +38,7 @@ class PanePriceAxisViewRenderer implements IPaneRenderer {
 	}
 }
 
-export class PanePriceAxisView<HorzScaleItem> implements IPaneView<HorzScaleItem> {
+export class PanePriceAxisView<HorzScaleItem> implements IPaneView {
 	private _priceAxisView: IPriceAxisView<HorzScaleItem>;
 	private readonly _textWidthCache: TextWidthCache;
 	private readonly _dataSource: IPriceDataSource<HorzScaleItem>;
diff --git a/src/views/pane/series-horizontal-line-pane-view.ts b/src/views/pane/series-horizontal-line-pane-view.ts
index 1114cfdfb8..8e6e12dfc9 100644
--- a/src/views/pane/series-horizontal-line-pane-view.ts
+++ b/src/views/pane/series-horizontal-line-pane-view.ts
@@ -8,7 +8,7 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IPaneView } from './ipane-view';
 
-export abstract class SeriesHorizontalLinePaneView<HorzScaleItem> implements IPaneView<HorzScaleItem> {
+export abstract class SeriesHorizontalLinePaneView<HorzScaleItem> implements IPaneView {
 	protected readonly _lineRendererData: HorizontalLineRendererData = {
 		y: 0 as Coordinate,
 		color: 'rgba(0, 0, 0, 0)',
diff --git a/src/views/pane/series-last-price-animation-pane-view.ts b/src/views/pane/series-last-price-animation-pane-view.ts
index 6fccaa01cf..7f71ee9123 100644
--- a/src/views/pane/series-last-price-animation-pane-view.ts
+++ b/src/views/pane/series-last-price-animation-pane-view.ts
@@ -119,7 +119,7 @@ function animationData(durationSinceStart: number, lineColor: string): Animation
 	};
 }
 
-export class SeriesLastPriceAnimationPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+export class SeriesLastPriceAnimationPaneView<HorzScaleItem> implements IUpdatablePaneView {
 	private readonly _series: Series<'Area', HorzScaleItem> | Series<'Line', HorzScaleItem> | Series<'Baseline', HorzScaleItem>;
 	private readonly _renderer: SeriesLastPriceAnimationRenderer = new SeriesLastPriceAnimationRenderer();
 	private _invalidated: boolean = true;
diff --git a/src/views/pane/series-markers-pane-view.ts b/src/views/pane/series-markers-pane-view.ts
index 49599281cc..6ea2858438 100644
--- a/src/views/pane/series-markers-pane-view.ts
+++ b/src/views/pane/series-markers-pane-view.ts
@@ -84,7 +84,7 @@ function fillSizeAndY<HorzScaleItem>(
 	ensureNever(marker.position);
 }
 
-export class SeriesMarkersPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+export class SeriesMarkersPaneView<HorzScaleItem> implements IUpdatablePaneView {
 	private readonly _series: Series<SeriesType, HorzScaleItem>;
 	private readonly _model: ChartModel<HorzScaleItem>;
 	private _data: SeriesMarkerRendererData;
diff --git a/src/views/pane/series-pane-view-base.ts b/src/views/pane/series-pane-view-base.ts
index faacf450d6..258c9edcf5 100644
--- a/src/views/pane/series-pane-view-base.ts
+++ b/src/views/pane/series-pane-view-base.ts
@@ -8,7 +8,7 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IUpdatablePaneView, UpdateType } from './iupdatable-pane-view';
 
-export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemType extends TimedValue, TRenderer extends IPaneRenderer, HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemType extends TimedValue, TRenderer extends IPaneRenderer, HorzScaleItem> implements IUpdatablePaneView {
 	protected readonly _series: Series<TSeriesType, HorzScaleItem>;
 	protected readonly _model: ChartModel<HorzScaleItem>;
 	protected _invalidated: boolean = true;
diff --git a/src/views/pane/watermark-pane-view.ts b/src/views/pane/watermark-pane-view.ts
index 9c22749eb6..87cb7b5a12 100644
--- a/src/views/pane/watermark-pane-view.ts
+++ b/src/views/pane/watermark-pane-view.ts
@@ -6,7 +6,7 @@ import { WatermarkRenderer, WatermarkRendererData } from '../../renderers/waterm
 
 import { IUpdatablePaneView } from './iupdatable-pane-view';
 
-export class WatermarkPaneView<HorzScaleItem> implements IUpdatablePaneView<HorzScaleItem> {
+export class WatermarkPaneView<HorzScaleItem> implements IUpdatablePaneView {
 	private _source: Watermark<HorzScaleItem>;
 	private _invalidated: boolean = true;
 

From cb28599d3e3eaf0476a855b7f039d881ba37266b Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Fri, 2 Jun 2023 17:55:44 +0300
Subject: [PATCH 16/23] Reduce number of generics

---
 src/api/chart-api.ts                          | 14 ++--
 src/api/ichart-api.ts                         |  6 +-
 src/api/price-scale-api.ts                    | 10 +--
 src/gui/chart-widget.ts                       |  9 ++-
 src/gui/price-axis-widget.ts                  | 42 +++++------
 src/model/chart-model.ts                      | 72 ++++++++++++-------
 src/model/crosshair.ts                        | 16 ++---
 src/model/custom-price-line.ts                |  2 +-
 src/model/data-source.ts                      | 14 ++--
 src/model/grid.ts                             |  8 +--
 .../time-based-chart-options.ts               |  4 +-
 src/model/idata-source.ts                     | 26 ++++---
 src/model/ihorz-scale-behavior.ts             |  6 +-
 src/model/iprice-data-source.ts               |  9 ++-
 src/model/localization-options.ts             | 11 +--
 src/model/pane.ts                             | 64 +++++++++--------
 src/model/price-scale.ts                      | 34 ++++-----
 src/model/price-tick-mark-builder.ts          |  6 +-
 src/model/series.ts                           |  6 +-
 src/model/sort-sources.ts                     |  7 +-
 src/model/time-scale.ts                       |  6 +-
 src/model/watermark.ts                        |  2 +-
 src/views/pane/bars-pane-view-base.ts         |  2 +-
 src/views/pane/grid-pane-view.ts              |  8 +--
 src/views/pane/line-pane-view-base.ts         |  2 +-
 src/views/pane/pane-price-axis-view.ts        |  4 +-
 src/views/pane/series-markers-pane-view.ts    |  2 +-
 src/views/pane/series-pane-view-base.ts       |  2 +-
 .../price-axis/crosshair-price-axis-view.ts   |  8 +--
 src/views/price-axis/iprice-axis-view.ts      |  4 +-
 src/views/price-axis/price-axis-view.ts       |  4 +-
 31 files changed, 229 insertions(+), 181 deletions(-)

diff --git a/src/api/chart-api.ts b/src/api/chart-api.ts
index 610b7ef412..b9734e4385 100644
--- a/src/api/chart-api.ts
+++ b/src/api/chart-api.ts
@@ -5,7 +5,7 @@ import { Delegate } from '../helpers/delegate';
 import { warn } from '../helpers/logger';
 import { clone, DeepPartial, isBoolean, merge } from '../helpers/strict-type-checks';
 
-import { ChartOptionsBase, ChartOptionsInternal } from '../model/chart-model';
+import { ChartOptionsImpl, ChartOptionsInternal } from '../model/chart-model';
 import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap } from '../model/data-consumer';
 import { DataLayer, DataUpdateResponse, SeriesChanges } from '../model/data-layer';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
@@ -58,7 +58,7 @@ function patchPriceFormat(priceFormat?: DeepPartial<PriceFormat>): void {
 	}
 }
 
-function migrateHandleScaleScrollOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): void {
+function migrateHandleScaleScrollOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsImpl<HorzScaleItem>>): void {
 	if (isBoolean(options.handleScale)) {
 		const handleScale = options.handleScale;
 		options.handleScale = {
@@ -100,7 +100,7 @@ function migrateHandleScaleScrollOptions<HorzScaleItem>(options: DeepPartial<Cha
 	}
 }
 
-function toInternalOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): DeepPartial<ChartOptionsInternal<HorzScaleItem>> {
+function toInternalOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsImpl<HorzScaleItem>>): DeepPartial<ChartOptionsInternal<HorzScaleItem>> {
 	migrateHandleScaleScrollOptions(options);
 
 	return options as DeepPartial<ChartOptionsInternal<HorzScaleItem>>;
@@ -121,7 +121,7 @@ export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, Da
 
 	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
 
-	public constructor(container: HTMLElement, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, options?: DeepPartial<ChartOptionsBase<HorzScaleItem>>) {
+	public constructor(container: HTMLElement, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, options?: DeepPartial<ChartOptionsImpl<HorzScaleItem>>) {
 		this._dataLayer = new DataLayer<HorzScaleItem>(horzScaleBehavior);
 		const internalOptions = (options === undefined) ?
 			clone(chartOptionsDefaults<HorzScaleItem>()) :
@@ -247,12 +247,12 @@ export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, Da
 		return this._timeScaleApi;
 	}
 
-	public applyOptions(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): void {
+	public applyOptions(options: DeepPartial<ChartOptionsImpl<HorzScaleItem>>): void {
 		this._chartWidget.applyOptions(toInternalOptions(options));
 	}
 
-	public options(): Readonly<ChartOptionsBase<HorzScaleItem>> {
-		return this._chartWidget.options() as Readonly<ChartOptionsBase<HorzScaleItem>>;
+	public options(): Readonly<ChartOptionsImpl<HorzScaleItem>> {
+		return this._chartWidget.options() as Readonly<ChartOptionsImpl<HorzScaleItem>>;
 	}
 
 	public takeScreenshot(): HTMLCanvasElement {
diff --git a/src/api/ichart-api.ts b/src/api/ichart-api.ts
index 1107bb3407..7682959924 100644
--- a/src/api/ichart-api.ts
+++ b/src/api/ichart-api.ts
@@ -1,6 +1,6 @@
 import { DeepPartial } from '../helpers/strict-type-checks';
 
-import { ChartOptionsBase } from '../model/chart-model';
+import { ChartOptionsImpl } from '../model/chart-model';
 import { BarData, HistogramData, LineData } from '../model/data-consumer';
 import { Time } from '../model/horz-scale-behavior-time/types';
 import { Point } from '../model/point';
@@ -249,14 +249,14 @@ export interface IChartApiBase<HorzScaleItem = Time> {
 	 *
 	 * @param options - Any subset of options.
 	 */
-	applyOptions(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): void;
+	applyOptions(options: DeepPartial<ChartOptionsImpl<HorzScaleItem>>): void;
 
 	/**
 	 * Returns currently applied options
 	 *
 	 * @returns Full set of currently applied options, including defaults
 	 */
-	options(): Readonly<ChartOptionsBase<HorzScaleItem>>;
+	options(): Readonly<ChartOptionsImpl<HorzScaleItem>>;
 
 	/**
 	 * Make a screenshot of the chart with all the elements excluding crosshair.
diff --git a/src/api/price-scale-api.ts b/src/api/price-scale-api.ts
index 2ab28ad86e..14e2e5820b 100644
--- a/src/api/price-scale-api.ts
+++ b/src/api/price-scale-api.ts
@@ -1,4 +1,4 @@
-import { ChartWidget } from '../gui/chart-widget';
+import { IChartWidgetBase } from '../gui/chart-widget';
 
 import { ensureNotNull } from '../helpers/assertions';
 import { DeepPartial } from '../helpers/strict-type-checks';
@@ -8,11 +8,11 @@ import { PriceScale, PriceScaleOptions } from '../model/price-scale';
 
 import { IPriceScaleApi } from './iprice-scale-api';
 
-export class PriceScaleApi<HorzScaleItem> implements IPriceScaleApi {
-	private _chartWidget: ChartWidget<HorzScaleItem>;
+export class PriceScaleApi implements IPriceScaleApi {
+	private _chartWidget: IChartWidgetBase;
 	private readonly _priceScaleId: string;
 
-	public constructor(chartWidget: ChartWidget<HorzScaleItem>, priceScaleId: string) {
+	public constructor(chartWidget: IChartWidgetBase, priceScaleId: string) {
 		this._chartWidget = chartWidget;
 		this._priceScaleId = priceScaleId;
 	}
@@ -33,7 +33,7 @@ export class PriceScaleApi<HorzScaleItem> implements IPriceScaleApi {
 		return this._chartWidget.getPriceAxisWidth(this._priceScaleId);
 	}
 
-	private _priceScale(): PriceScale<HorzScaleItem> {
+	private _priceScale(): PriceScale {
 		return ensureNotNull(this._chartWidget.model().findPriceScale(this._priceScaleId)).priceScale;
 	}
 }
diff --git a/src/gui/chart-widget.ts b/src/gui/chart-widget.ts
index 1e6e6b1932..423369ced6 100644
--- a/src/gui/chart-widget.ts
+++ b/src/gui/chart-widget.ts
@@ -8,7 +8,7 @@ import { ISubscription } from '../helpers/isubscription';
 import { warn } from '../helpers/logger';
 import { DeepPartial } from '../helpers/strict-type-checks';
 
-import { ChartModel, ChartOptionsInternal } from '../model/chart-model';
+import { IChartModelBase, ChartModel, ChartOptionsInternal } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { DefaultPriceScaleId } from '../model/default-price-scale';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
@@ -43,7 +43,12 @@ export type MouseEventParamsImplSupplier<HorzScaleItem> = () => MouseEventParams
 
 const windowsChrome = isChromiumBased() && isWindows();
 
-export class ChartWidget<HorzScaleItem> implements IDestroyable {
+export interface IChartWidgetBase {
+	getPriceAxisWidth(position: DefaultPriceScaleId): number;
+	model(): IChartModelBase;
+}
+
+export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBase {
 	private readonly _options: ChartOptionsInternal<HorzScaleItem>;
 	private _paneWidgets: PaneWidget<HorzScaleItem>[] = [];
 	// private _paneSeparators: PaneSeparator[] = [];
diff --git a/src/gui/price-axis-widget.ts b/src/gui/price-axis-widget.ts
index e8068633fa..a94fb05337 100644
--- a/src/gui/price-axis-widget.ts
+++ b/src/gui/price-axis-widget.ts
@@ -16,7 +16,7 @@ import { makeFont } from '../helpers/make-font';
 
 import { ChartOptionsInternal } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
-import { IDataSource } from '../model/idata-source';
+import { IDataSource, IDataSourceBase } from '../model/idata-source';
 import { InvalidationLevel } from '../model/invalidate-mask';
 import { IPriceDataSource } from '../model/iprice-data-source';
 import { LayoutOptions } from '../model/layout-options';
@@ -43,7 +43,7 @@ const enum Constants {
 	DefaultOptimalWidth = 34,
 }
 
-type IPriceAxisViewArray<HorzScaleItem> = readonly IPriceAxisView<HorzScaleItem>[];
+type IPriceAxisViewArray = readonly IPriceAxisView[];
 
 const enum Constants {
 	LabelOffset = 5,
@@ -56,7 +56,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
 	private readonly _isLeft: boolean;
 
-	private _priceScale: PriceScale<HorzScaleItem> | null = null;
+	private _priceScale: PriceScale | null = null;
 
 	private _size: Size | null = null;
 
@@ -238,7 +238,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		return ensureNotNull(this._size).width;
 	}
 
-	public setPriceScale(priceScale: PriceScale<HorzScaleItem>): void {
+	public setPriceScale(priceScale: PriceScale): void {
 		if (this._priceScale === priceScale) {
 			return;
 		}
@@ -251,7 +251,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		priceScale.onMarksChanged().subscribe(this._onMarksChanged.bind(this), this);
 	}
 
-	public priceScale(): PriceScale<HorzScaleItem> | null {
+	public priceScale(): PriceScale | null {
 		return this._priceScale;
 	}
 
@@ -374,8 +374,8 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		this._setCursor(CursorType.Default);
 	}
 
-	private _backLabels(): IPriceAxisView<HorzScaleItem>[] {
-		const res: IPriceAxisView<HorzScaleItem>[] = [];
+	private _backLabels(): IPriceAxisView[] {
+		const res: IPriceAxisView[] = [];
 
 		const priceScale = (this._priceScale === null) ? undefined : this._priceScale;
 
@@ -486,7 +486,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		}
 		let center = this._size.height / 2;
 
-		const views: IPriceAxisView<HorzScaleItem>[] = [];
+		const views: IPriceAxisView[] = [];
 		const orderedSources = this._priceScale.orderedSources().slice(); // Copy of array
 		const pane = this._pane;
 		const paneState = pane.state();
@@ -507,11 +507,11 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		const centerSource = this._priceScale.dataSources()[0];
 		const priceScale = this._priceScale;
 
-		const updateForSources = (sources: IDataSource<HorzScaleItem>[]) => {
-			sources.forEach((source: IDataSource<HorzScaleItem>) => {
+		const updateForSources = (sources: IDataSourceBase[]) => {
+			sources.forEach((source: IDataSourceBase) => {
 				const sourceViews = source.priceAxisViews(paneState, priceScale);
 				// never align selected sources
-				sourceViews.forEach((view: IPriceAxisView<HorzScaleItem>) => {
+				sourceViews.forEach((view: IPriceAxisView) => {
 					view.setFixedCoordinate(null);
 					if (view.isVisible()) {
 						views.push(view);
@@ -526,7 +526,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		// crosshair individually
 		updateForSources(orderedSources);
 
-		views.forEach((view: IPriceAxisView<HorzScaleItem>) => view.setFixedCoordinate(view.coordinate()));
+		views.forEach((view: IPriceAxisView) => view.setFixedCoordinate(view.coordinate()));
 
 		const options = this._priceScale.options();
 		if (!options.alignLabels) {
@@ -536,24 +536,24 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		this._fixLabelOverlap(views, rendererOptions, center);
 	}
 
-	private _fixLabelOverlap(views: IPriceAxisView<HorzScaleItem>[], rendererOptions: Readonly<PriceAxisViewRendererOptions>, center: number): void {
+	private _fixLabelOverlap(views: IPriceAxisView[], rendererOptions: Readonly<PriceAxisViewRendererOptions>, center: number): void {
 		if (this._size === null) {
 			return;
 		}
 
 		// split into two parts
-		const top = views.filter((view: IPriceAxisView<HorzScaleItem>) => view.coordinate() <= center);
-		const bottom = views.filter((view: IPriceAxisView<HorzScaleItem>) => view.coordinate() > center);
+		const top = views.filter((view: IPriceAxisView) => view.coordinate() <= center);
+		const bottom = views.filter((view: IPriceAxisView) => view.coordinate() > center);
 
 		// sort top from center to top
-		top.sort((l: IPriceAxisView<HorzScaleItem>, r: IPriceAxisView<HorzScaleItem>) => r.coordinate() - l.coordinate());
+		top.sort((l: IPriceAxisView, r: IPriceAxisView) => r.coordinate() - l.coordinate());
 
 		// share center label
 		if (top.length && bottom.length) {
 			bottom.push(top[0]);
 		}
 
-		bottom.sort((l: IPriceAxisView<HorzScaleItem>, r: IPriceAxisView<HorzScaleItem>) => l.coordinate() - r.coordinate());
+		bottom.sort((l: IPriceAxisView, r: IPriceAxisView) => l.coordinate() - r.coordinate());
 
 		for (const view of views) {
 			const halfHeight = Math.floor(view.height(rendererOptions) / 2);
@@ -602,7 +602,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		const rendererOptions = this.rendererOptions();
 		const align = this._isLeft ? 'right' : 'left';
 
-		views.forEach((view: IPriceAxisView<HorzScaleItem>) => {
+		views.forEach((view: IPriceAxisView) => {
 			if (view.isAxisLabelVisible()) {
 				const renderer = view.renderer(ensureNotNull(this._priceScale));
 				renderer.draw(target, rendererOptions, this._widthCache, align);
@@ -617,7 +617,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 
 		const model = this._pane.chart().model();
 
-		const views: IPriceAxisViewArray<HorzScaleItem>[] = []; // array of arrays
+		const views: IPriceAxisViewArray[] = []; // array of arrays
 		const pane = this._pane.state();
 
 		const v = model.crosshairSource().priceAxisViews(pane, this._priceScale);
@@ -628,8 +628,8 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		const ro = this.rendererOptions();
 		const align = this._isLeft ? 'right' : 'left';
 
-		views.forEach((arr: IPriceAxisViewArray<HorzScaleItem>) => {
-			arr.forEach((view: IPriceAxisView<HorzScaleItem>) => {
+		views.forEach((arr: IPriceAxisViewArray) => {
+			arr.forEach((view: IPriceAxisView) => {
 				view.renderer(ensureNotNull(this._priceScale)).draw(target, ro, this._widthCache, align);
 			});
 		});
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index d82d02472a..2cf0ed85b7 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -18,15 +18,15 @@ import { IHorzScaleBehavior } from './ihorz-scale-behavior';
 import { InvalidateMask, InvalidationLevel, ITimeScaleAnimation } from './invalidate-mask';
 import { IPriceDataSource } from './iprice-data-source';
 import { ColorType, LayoutOptions } from './layout-options';
-import { LocalizationOptions } from './localization-options';
+import { LocalizationOptions, LocalizationOptionsBase } from './localization-options';
 import { Magnet } from './magnet';
-import { DEFAULT_STRETCH_FACTOR, Pane } from './pane';
+import { DEFAULT_STRETCH_FACTOR, IPaneBase, Pane } from './pane';
 import { Point } from './point';
 import { PriceScale, PriceScaleOptions } from './price-scale';
 import { Series, SeriesOptionsInternal } from './series';
 import { SeriesOptionsMap, SeriesType } from './series-options';
 import { LogicalRange, TimePointIndex, TimeScalePoint } from './time-data';
-import { HorzScaleOptions, TimeScale } from './time-scale';
+import { HorzScaleOptions, ITimeScale, TimeScale } from './time-scale';
 import { TouchMouseEventData } from './touch-mouse-event-data';
 import { Watermark, WatermarkOptions } from './watermark';
 
@@ -173,9 +173,9 @@ export interface HoveredSource<HorzScaleItem> {
 	object?: HoveredObject;
 }
 
-export interface PriceScaleOnPane<HorzScaleItem> {
-	priceScale: PriceScale<HorzScaleItem>;
-	pane: Pane<HorzScaleItem>;
+export interface PriceScaleOnPane {
+	priceScale: PriceScale;
+	pane: IPaneBase;
 }
 
 const enum BackgroundColorSide {
@@ -230,10 +230,7 @@ export interface TrackingModeOptions {
 	exitMode: TrackingModeExitMode;
 }
 
-/**
- * Structure describing options of the chart. Series options are to be set separately
- */
-export interface ChartOptionsBase<HorzScaleItem> {
+export interface ChartOptionsBase {
 	/**
 	 * Width of the chart in pixels
 	 *
@@ -310,11 +307,6 @@ export interface ChartOptionsBase<HorzScaleItem> {
 	 */
 	grid: GridOptions;
 
-	/**
-	 * Localization options.
-	 */
-	localization: LocalizationOptions<HorzScaleItem>;
-
 	/**
 	 * Scroll options, or a boolean flag that enables/disables scrolling
 	 */
@@ -335,10 +327,33 @@ export interface ChartOptionsBase<HorzScaleItem> {
 	 */
 	trackingMode: TrackingModeOptions;
 
+	localization: LocalizationOptionsBase;
 }
 
+/**
+ * Structure describing options of the chart. Series options are to be set separately
+ */
+export interface ChartOptionsImpl<HorzScaleItem> extends ChartOptionsBase {
+
+	/**
+	 * Localization options.
+	 */
+	localization: LocalizationOptions<HorzScaleItem>;
+}
+
+export type ChartOptionsInternalBase =
+	Omit<ChartOptionsBase, 'handleScroll' | 'handleScale' | 'layout'>
+	& {
+		/** @public */
+		handleScroll: HandleScrollOptions;
+		/** @public */
+		handleScale: HandleScaleOptionsInternal;
+		/** @public */
+		layout: LayoutOptions;
+	};
+
 export type ChartOptionsInternal<HorzScaleItem> =
-	Omit<ChartOptionsBase<HorzScaleItem>, 'handleScroll' | 'handleScale' | 'layout'>
+	Omit<ChartOptionsImpl<HorzScaleItem>, 'handleScroll' | 'handleScale' | 'layout'>
 	& {
 		/** @public */
 		handleScroll: HandleScrollOptions;
@@ -354,7 +369,14 @@ interface GradientColorsCache {
 	colors: Map<number, string>;
 }
 
-export class ChartModel<HorzScaleItem> implements IDestroyable {
+export interface IChartModelBase {
+	applyPriceScaleOptions(priceScaleId: string, options: DeepPartial<PriceScaleOptions>): void;
+	findPriceScale(priceScaleId: string): PriceScaleOnPane | null;
+	options(): Readonly<ChartOptionsInternalBase>;
+	timeScale(): ITimeScale;
+}
+
+export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase {
 	private readonly _options: ChartOptionsInternal<HorzScaleItem>;
 	private readonly _invalidateHandler: InvalidateHandler;
 
@@ -484,7 +506,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable {
 		this._priceScalesOptionsChanged.fire();
 	}
 
-	public findPriceScale(priceScaleId: string): PriceScaleOnPane<HorzScaleItem> | null {
+	public findPriceScale(priceScaleId: string): PriceScaleOnPane | null {
 		for (const pane of this._panes) {
 			const priceScale = pane.priceScaleById(priceScaleId);
 			if (priceScale !== null) {
@@ -555,29 +577,29 @@ export class ChartModel<HorzScaleItem> implements IDestroyable {
 		return pane;
 	}
 
-	public startScalePrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, x: number): void {
+	public startScalePrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale, x: number): void {
 		pane.startScalePrice(priceScale, x);
 	}
 
-	public scalePriceTo(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, x: number): void {
+	public scalePriceTo(pane: Pane<HorzScaleItem>, priceScale: PriceScale, x: number): void {
 		pane.scalePriceTo(priceScale, x);
 		this.updateCrosshair();
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public endScalePrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): void {
+	public endScalePrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale): void {
 		pane.endScalePrice(priceScale);
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public startScrollPrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, x: number): void {
+	public startScrollPrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale, x: number): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
 		pane.startScrollPrice(priceScale, x);
 	}
 
-	public scrollPriceTo(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, x: number): void {
+	public scrollPriceTo(pane: Pane<HorzScaleItem>, priceScale: PriceScale, x: number): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
@@ -586,7 +608,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable {
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public endScrollPrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): void {
+	public endScrollPrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
@@ -594,7 +616,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable {
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public resetPriceScale(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): void {
+	public resetPriceScale(pane: Pane<HorzScaleItem>, priceScale: PriceScale): void {
 		pane.resetPriceScale(priceScale);
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
diff --git a/src/model/crosshair.ts b/src/model/crosshair.ts
index bc4b25d449..c7b2772137 100644
--- a/src/model/crosshair.ts
+++ b/src/model/crosshair.ts
@@ -32,7 +32,7 @@ export interface CrosshairTimeAndCoordinate {
 	coordinate: number;
 }
 
-export type PriceAndCoordinateProvider<HorzScaleItem> = (priceScale: PriceScale<HorzScaleItem>) => CrosshairPriceAndCoordinate;
+export type PriceAndCoordinateProvider = (priceScale: PriceScale) => CrosshairPriceAndCoordinate;
 export type TimeAndCoordinateProvider = () => CrosshairTimeAndCoordinate | null;
 
 /**
@@ -130,11 +130,11 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 	private _index: TimePointIndex = 0 as TimePointIndex;
 	private _visible: boolean = true;
 	private readonly _model: ChartModel<HorzScaleItem>;
-	private _priceAxisViews: Map<PriceScale<HorzScaleItem>, CrosshairPriceAxisView<HorzScaleItem>> = new Map();
+	private _priceAxisViews: Map<PriceScale, CrosshairPriceAxisView<HorzScaleItem>> = new Map();
 	private readonly _timeAxisView: CrosshairTimeAxisView<HorzScaleItem>;
 	private readonly _markersPaneView: CrosshairMarksPaneView<HorzScaleItem>;
 	private _subscribed: boolean = false;
-	private readonly _currentPosPriceProvider: PriceAndCoordinateProvider<HorzScaleItem>;
+	private readonly _currentPosPriceProvider: PriceAndCoordinateProvider;
 	private readonly _options: CrosshairOptions;
 	private readonly _paneView: CrosshairPaneView<HorzScaleItem>;
 
@@ -151,7 +151,7 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		this._markersPaneView = new CrosshairMarksPaneView(model, this);
 
 		const valuePriceProvider = (rawPriceProvider: RawPriceProvider, rawCoordinateProvider: RawCoordinateProvider) => {
-			return (priceScale: PriceScale<HorzScaleItem>) => {
+			return (priceScale: PriceScale) => {
 				const coordinate = rawCoordinateProvider();
 				const rawPrice = rawPriceProvider();
 				if (priceScale === ensureNotNull(this._pane).defaultPriceScale()) {
@@ -267,12 +267,12 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		return this._options.vertLine.visible;
 	}
 
-	public override priceAxisViews(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): IPriceAxisView<HorzScaleItem>[] {
+	public override priceAxisViews(pane: Pane<HorzScaleItem>, priceScale: PriceScale): IPriceAxisView[] {
 		if (!this._visible || this._pane !== pane) {
 			this._priceAxisViews.clear();
 		}
 
-		const views: IPriceAxisView<HorzScaleItem>[] = [];
+		const views: IPriceAxisView[] = [];
 		if (this._pane === pane) {
 			views.push(this._createPriceAxisViewOnDemand(this._priceAxisViews, priceScale, this._currentPosPriceProvider));
 		}
@@ -295,7 +295,7 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		this._markersPaneView.update();
 	}
 
-	private _priceScaleByPane(pane: Pane<HorzScaleItem>): PriceScale<HorzScaleItem> | null {
+	private _priceScaleByPane(pane: Pane<HorzScaleItem>): PriceScale | null {
 		if (pane && !pane.defaultPriceScale().isEmpty()) {
 			return pane.defaultPriceScale();
 		}
@@ -342,7 +342,7 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		this._index = lastBarIndex !== null ? lastBarIndex : NaN as TimePointIndex;
 	}
 
-	private _createPriceAxisViewOnDemand(map: Map<PriceScale<HorzScaleItem>, CrosshairPriceAxisView<HorzScaleItem>>, priceScale: PriceScale<HorzScaleItem>, valueProvider: PriceAndCoordinateProvider<HorzScaleItem>): IPriceAxisView<HorzScaleItem> {
+	private _createPriceAxisViewOnDemand(map: Map<PriceScale, CrosshairPriceAxisView<HorzScaleItem>>, priceScale: PriceScale, valueProvider: PriceAndCoordinateProvider): IPriceAxisView {
 		let view = map.get(priceScale);
 
 		if (view === undefined) {
diff --git a/src/model/custom-price-line.ts b/src/model/custom-price-line.ts
index 1b902898d9..56cedb651f 100644
--- a/src/model/custom-price-line.ts
+++ b/src/model/custom-price-line.ts
@@ -44,7 +44,7 @@ export class CustomPriceLine<HorzScaleItem> {
 		return this._panePriceAxisView;
 	}
 
-	public priceAxisView(): IPriceAxisView<HorzScaleItem> {
+	public priceAxisView(): IPriceAxisView {
 		return this._priceAxisView;
 	}
 
diff --git a/src/model/data-source.ts b/src/model/data-source.ts
index 7ab7fa515b..e0482e8eed 100644
--- a/src/model/data-source.ts
+++ b/src/model/data-source.ts
@@ -3,11 +3,11 @@ import { IPriceAxisView } from '../views/price-axis/iprice-axis-view';
 import { ITimeAxisView } from '../views/time-axis/itime-axis-view';
 
 import { IDataSource } from './idata-source';
-import { Pane } from './pane';
+import { IPaneBase, Pane } from './pane';
 import { PriceScale } from './price-scale';
 
 export abstract class DataSource<HorzScaleItem> implements IDataSource<HorzScaleItem> {
-	protected _priceScale: PriceScale<HorzScaleItem> | null = null;
+	protected _priceScale: PriceScale | null = null;
 
 	private _zorder: number = 0;
 
@@ -19,18 +19,18 @@ export abstract class DataSource<HorzScaleItem> implements IDataSource<HorzScale
 		this._zorder = zorder;
 	}
 
-	public priceScale(): PriceScale<HorzScaleItem> | null {
+	public priceScale(): PriceScale | null {
 		return this._priceScale;
 	}
 
-	public setPriceScale(priceScale: PriceScale<HorzScaleItem> | null): void {
+	public setPriceScale(priceScale: PriceScale | null): void {
 		this._priceScale = priceScale;
 	}
 
-	public abstract priceAxisViews(pane?: Pane<HorzScaleItem>, priceScale?: PriceScale<HorzScaleItem>): readonly IPriceAxisView<HorzScaleItem>[];
-	public abstract paneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[];
+	public abstract priceAxisViews(pane?: Pane<HorzScaleItem>, priceScale?: PriceScale): readonly IPriceAxisView[];
+	public abstract paneViews(pane?: IPaneBase): readonly IPaneView[];
 
-	public labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[] {
+	public labelPaneViews(pane?: IPaneBase): readonly IPaneView[] {
 		return [];
 	}
 
diff --git a/src/model/grid.ts b/src/model/grid.ts
index 839b0dac84..16372339eb 100644
--- a/src/model/grid.ts
+++ b/src/model/grid.ts
@@ -2,7 +2,7 @@ import { LineStyle } from '../renderers/draw-line';
 import { GridPaneView } from '../views/pane/grid-pane-view';
 import { IUpdatablePaneView } from '../views/pane/iupdatable-pane-view';
 
-import { Pane } from './pane';
+import { IPaneBase } from './pane';
 
 /** Grid line options. */
 export interface GridLineOptions {
@@ -41,10 +41,10 @@ export interface GridOptions {
 	horzLines: GridLineOptions;
 }
 
-export class Grid<HorzScaleItem> {
-	private _paneView: GridPaneView<HorzScaleItem>;
+export class Grid {
+	private _paneView: GridPaneView;
 
-	public constructor(pane: Pane<HorzScaleItem>) {
+	public constructor(pane: IPaneBase) {
 		this._paneView = new GridPaneView(pane);
 	}
 
diff --git a/src/model/horz-scale-behavior-time/time-based-chart-options.ts b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
index 77a86c0845..a2fe524d8a 100644
--- a/src/model/horz-scale-behavior-time/time-based-chart-options.ts
+++ b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
@@ -1,4 +1,4 @@
-import { ChartOptionsBase } from '../chart-model';
+import { ChartOptionsImpl } from '../chart-model';
 import { HorzScaleOptions } from '../time-scale';
 import { TickMarkFormatter } from './horz-scale-behavior-time';
 import { Time } from './types';
@@ -18,7 +18,7 @@ export interface TimeScaleOptions extends HorzScaleOptions {
 /**
  * Options for chart with time at the horizontal scale
  */
-export interface TimeChartOptions extends ChartOptionsBase<Time> {
+export interface TimeChartOptions extends ChartOptionsImpl<Time> {
 	/**
 	 * Extended time scale options with option to override tickMarkFormatter
 	 */
diff --git a/src/model/idata-source.ts b/src/model/idata-source.ts
index 5547649c7f..5e3cdfb13f 100644
--- a/src/model/idata-source.ts
+++ b/src/model/idata-source.ts
@@ -2,28 +2,34 @@ import { IPaneView } from '../views/pane/ipane-view';
 import { IPriceAxisView } from '../views/price-axis/iprice-axis-view';
 import { ITimeAxisView } from '../views/time-axis/itime-axis-view';
 
-import { Pane } from './pane';
+import { IPaneBase } from './pane';
 import { PriceScale } from './price-scale';
 
-export interface IDataSource<HorzScaleItem> {
-	zorder(): number | null;
+export interface ZOrdered {
+	zorder(): number;
+}
+
+export interface IDataSourceBase extends ZOrdered {
 	setZorder(value: number): void;
-	priceScale(): PriceScale<HorzScaleItem> | null;
-	setPriceScale(scale: PriceScale<HorzScaleItem> | null): void;
+	priceScale(): PriceScale | null;
+	setPriceScale(scale: PriceScale | null): void;
 
 	updateAllViews(): void;
 
-	priceAxisViews(pane?: Pane<HorzScaleItem>, priceScale?: PriceScale<HorzScaleItem>): readonly IPriceAxisView<HorzScaleItem>[];
-	timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[];
-	paneViews(pane: Pane<HorzScaleItem>): readonly IPaneView[];
-	labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[];
+	priceAxisViews(pane?: IPaneBase, priceScale?: PriceScale): readonly IPriceAxisView[];
+	paneViews(pane: IPaneBase): readonly IPaneView[];
+	labelPaneViews(pane?: IPaneBase): readonly IPaneView[];
 
 	/**
 	 * Pane views that are painted on the most top layer
 	 */
-	topPaneViews?(pane: Pane<HorzScaleItem>): readonly IPaneView[];
+	topPaneViews?(pane: IPaneBase): readonly IPaneView[];
 
 	visible(): boolean;
 
 	destroy?(): void;
 }
+
+export interface IDataSource<HorzScaleItem> extends IDataSourceBase {
+	timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[];
+}
\ No newline at end of file
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
index b870ba9528..c6b5c3de20 100644
--- a/src/model/ihorz-scale-behavior.ts
+++ b/src/model/ihorz-scale-behavior.ts
@@ -1,7 +1,7 @@
 import { Mutable } from '../helpers/mutable';
 import { Nominal } from '../helpers/nominal';
 
-import { ChartOptionsBase } from './chart-model';
+import { ChartOptionsImpl } from './chart-model';
 import { SeriesDataItemTypeMap } from './data-consumer';
 import { LocalizationOptions } from './localization-options';
 import { SeriesType } from './series-options';
@@ -38,7 +38,7 @@ export interface IHorzScaleBehavior<HorzScaleItem> {
 	 *
 	 * @returns ChartOptionsBase
 	 */
-	options(): ChartOptionsBase<HorzScaleItem>;
+	options(): ChartOptionsImpl<HorzScaleItem>;
 	/**
 	 * Set the chart options. Note that this is different to `applyOptions` since the provided options will overwrite the current options
 	 * instead of merging with the current options.
@@ -46,7 +46,7 @@ export interface IHorzScaleBehavior<HorzScaleItem> {
 	 * @param options - Chart options to be set
 	 * @returns void
 	 */
-	setOptions(options: ChartOptionsBase<HorzScaleItem>): void;
+	setOptions(options: ChartOptionsImpl<HorzScaleItem>): void;
 	/**
 	 * Method to preprocess the data.
 	 *
diff --git a/src/model/iprice-data-source.ts b/src/model/iprice-data-source.ts
index a24edb0c1c..004ce8682c 100644
--- a/src/model/iprice-data-source.ts
+++ b/src/model/iprice-data-source.ts
@@ -2,7 +2,7 @@ import { IPriceFormatter } from '../formatters/iprice-formatter';
 
 import { AutoscaleInfoImpl } from './autoscale-info-impl';
 import { ChartModel } from './chart-model';
-import { IDataSource } from './idata-source';
+import { IDataSource, IDataSourceBase } from './idata-source';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { TimePointIndex } from './time-data';
 
@@ -11,11 +11,14 @@ export interface FirstValue {
 	timePoint: InternalHorzScaleItem;
 }
 
-export interface IPriceDataSource<HorzScaleItem> extends IDataSource<HorzScaleItem> {
+export interface IPriceDataSourceBase extends IDataSourceBase {
 	firstValue(): FirstValue | null;
 	formatter(): IPriceFormatter;
 	priceLineColor(lastBarColor: string): string;
-	model(): ChartModel<HorzScaleItem>;
 	minMove(): number;
 	autoscaleInfo(startTimePoint: TimePointIndex, endTimePoint: TimePointIndex): AutoscaleInfoImpl | null;
 }
+
+export interface IPriceDataSource<HorzScaleItem> extends IPriceDataSourceBase, IDataSource<HorzScaleItem> {
+	model(): ChartModel<HorzScaleItem>;
+}
diff --git a/src/model/localization-options.ts b/src/model/localization-options.ts
index 3d3c3a3a7a..6b7481c814 100644
--- a/src/model/localization-options.ts
+++ b/src/model/localization-options.ts
@@ -6,10 +6,7 @@ import { PriceFormatterFn } from './price-formatter-fn';
  */
 export type TimeFormatterFn<HorzScaleItem = Time> = (time: HorzScaleItem) => string;
 
-/**
- * Represents options for formatting dates, times, and prices according to a locale.
- */
-export interface LocalizationOptions<HorzScaleItem> {
+export interface LocalizationOptionsBase {
 	/**
 	 * Current locale used to format dates. Uses the browser's language settings by default.
 	 *
@@ -26,6 +23,12 @@ export interface LocalizationOptions<HorzScaleItem> {
 	 */
 	priceFormatter?: PriceFormatterFn;
 
+}
+
+/**
+ * Represents options for formatting dates, times, and prices according to a locale.
+ */
+export interface LocalizationOptions<HorzScaleItem> extends LocalizationOptionsBase {
 	/**
 	 * Override formatting of the time scale crosshair label.
 	 *
diff --git a/src/model/pane.ts b/src/model/pane.ts
index 855445eb76..1e1670e6aa 100644
--- a/src/model/pane.ts
+++ b/src/model/pane.ts
@@ -4,10 +4,10 @@ import { IDestroyable } from '../helpers/idestroyable';
 import { ISubscription } from '../helpers/isubscription';
 import { clone, DeepPartial } from '../helpers/strict-type-checks';
 
-import { ChartModel, ChartOptionsBase, OverlayPriceScaleOptions, VisiblePriceScaleOptions } from './chart-model';
+import { ChartModel, ChartOptionsImpl, IChartModelBase, OverlayPriceScaleOptions, VisiblePriceScaleOptions } from './chart-model';
 import { DefaultPriceScaleId, isDefaultPriceScale } from './default-price-scale';
 import { Grid } from './grid';
-import { IPriceDataSource } from './iprice-data-source';
+import { IPriceDataSource, IPriceDataSourceBase } from './iprice-data-source';
 import { PriceScale, PriceScaleOptions, PriceScaleState } from './price-scale';
 import { sortSources } from './sort-sources';
 import { TimeScale } from './time-scale';
@@ -21,10 +21,16 @@ interface MinMaxOrderInfo {
 	maxZOrder: number;
 }
 
-export class Pane<HorzScaleItem> implements IDestroyable {
+export interface IPaneBase {
+	addDataSource(source: IPriceDataSourceBase, targetScaleId: string, zOrder?: number): void;
+	model(): IChartModelBase;
+	defaultPriceScale(): PriceScale;
+}
+
+export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 	private readonly _timeScale: TimeScale<HorzScaleItem>;
 	private readonly _model: ChartModel<HorzScaleItem>;
-	private readonly _grid: Grid<HorzScaleItem>;
+	private readonly _grid: Grid;
 
 	private _dataSources: IPriceDataSource<HorzScaleItem>[] = [];
 	private _overlaySourcesByScaleId: Map<string, IPriceDataSource<HorzScaleItem>[]> = new Map();
@@ -36,8 +42,8 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 
 	private _destroyed: Delegate = new Delegate();
 
-	private _leftPriceScale: PriceScale<HorzScaleItem>;
-	private _rightPriceScale: PriceScale<HorzScaleItem>;
+	private _leftPriceScale: PriceScale;
+	private _rightPriceScale: PriceScale;
 
 	public constructor(timeScale: TimeScale<HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
 		this._timeScale = timeScale;
@@ -55,7 +61,7 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		this.applyScaleOptions(options);
 	}
 
-	public applyScaleOptions(options: DeepPartial<ChartOptionsBase<HorzScaleItem>>): void {
+	public applyScaleOptions(options: DeepPartial<ChartOptionsImpl<HorzScaleItem>>): void {
 		if (options.leftPriceScale) {
 			this._leftPriceScale.applyOptions(options.leftPriceScale);
 		}
@@ -78,7 +84,7 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		}
 	}
 
-	public priceScaleById(id: string): PriceScale<HorzScaleItem> | null {
+	public priceScaleById(id: string): PriceScale | null {
 		switch (id) {
 			case DefaultPriceScaleId.Left: {
 				return this._leftPriceScale;
@@ -201,7 +207,7 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		this._cachedOrderedSources = null;
 	}
 
-	public priceScalePosition(priceScale: PriceScale<HorzScaleItem>): PriceScalePosition {
+	public priceScalePosition(priceScale: PriceScale): PriceScalePosition {
 		if (priceScale === this._leftPriceScale) {
 			return 'left';
 		}
@@ -212,39 +218,39 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		return 'overlay';
 	}
 
-	public leftPriceScale(): PriceScale<HorzScaleItem> {
+	public leftPriceScale(): PriceScale {
 		return this._leftPriceScale;
 	}
 
-	public rightPriceScale(): PriceScale<HorzScaleItem> {
+	public rightPriceScale(): PriceScale {
 		return this._rightPriceScale;
 	}
 
-	public startScalePrice(priceScale: PriceScale<HorzScaleItem>, x: number): void {
+	public startScalePrice(priceScale: PriceScale, x: number): void {
 		priceScale.startScale(x);
 	}
 
-	public scalePriceTo(priceScale: PriceScale<HorzScaleItem>, x: number): void {
+	public scalePriceTo(priceScale: PriceScale, x: number): void {
 		priceScale.scaleTo(x);
 
 		// TODO: be more smart and update only affected views
 		this.updateAllSources();
 	}
 
-	public endScalePrice(priceScale: PriceScale<HorzScaleItem>): void {
+	public endScalePrice(priceScale: PriceScale): void {
 		priceScale.endScale();
 	}
 
-	public startScrollPrice(priceScale: PriceScale<HorzScaleItem>, x: number): void {
+	public startScrollPrice(priceScale: PriceScale, x: number): void {
 		priceScale.startScroll(x);
 	}
 
-	public scrollPriceTo(priceScale: PriceScale<HorzScaleItem>, x: number): void {
+	public scrollPriceTo(priceScale: PriceScale, x: number): void {
 		priceScale.scrollTo(x);
 		this.updateAllSources();
 	}
 
-	public endScrollPrice(priceScale: PriceScale<HorzScaleItem>): void {
+	public endScrollPrice(priceScale: PriceScale): void {
 		priceScale.endScroll();
 	}
 
@@ -254,8 +260,8 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		});
 	}
 
-	public defaultPriceScale(): PriceScale<HorzScaleItem> {
-		let priceScale: PriceScale<HorzScaleItem> | null = null;
+	public defaultPriceScale(): PriceScale {
+		let priceScale: PriceScale | null = null;
 
 		if (this._model.options().rightPriceScale.visible && this._rightPriceScale.dataSources().length !== 0) {
 			priceScale = this._rightPriceScale;
@@ -272,8 +278,8 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		return priceScale;
 	}
 
-	public defaultVisiblePriceScale(): PriceScale<HorzScaleItem> | null {
-		let priceScale: PriceScale<HorzScaleItem> | null = null;
+	public defaultVisiblePriceScale(): PriceScale | null {
+		let priceScale: PriceScale | null = null;
 
 		if (this._model.options().rightPriceScale.visible) {
 			priceScale = this._rightPriceScale;
@@ -283,7 +289,7 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		return priceScale;
 	}
 
-	public recalculatePriceScale(priceScale: PriceScale<HorzScaleItem> | null): void {
+	public recalculatePriceScale(priceScale: PriceScale | null): void {
 		if (priceScale === null || !priceScale.isAutoScale()) {
 			return;
 		}
@@ -291,7 +297,7 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		this._recalculatePriceScaleImpl(priceScale);
 	}
 
-	public resetPriceScale(priceScale: PriceScale<HorzScaleItem>): void {
+	public resetPriceScale(priceScale: PriceScale): void {
 		const visibleBars = this._timeScale.visibleStrictRange();
 		priceScale.setMode({ autoScale: true });
 		if (visibleBars !== null) {
@@ -321,7 +327,7 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 
 	public orderedSources(): readonly IPriceDataSource<HorzScaleItem>[] {
 		if (this._cachedOrderedSources === null) {
-			this._cachedOrderedSources = sortSources<HorzScaleItem, IPriceDataSource<HorzScaleItem>>(this._dataSources);
+			this._cachedOrderedSources = sortSources<IPriceDataSource<HorzScaleItem>>(this._dataSources);
 		}
 
 		return this._cachedOrderedSources;
@@ -331,11 +337,11 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		return this._destroyed;
 	}
 
-	public grid(): Grid<HorzScaleItem> {
+	public grid(): Grid {
 		return this._grid;
 	}
 
-	private _recalculatePriceScaleImpl(priceScale: PriceScale<HorzScaleItem>): void {
+	private _recalculatePriceScaleImpl(priceScale: PriceScale): void {
 		// TODO: can use this checks
 		const sourceForAutoScale = priceScale.sourcesForAutoScale();
 
@@ -398,7 +404,7 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		this._cachedOrderedSources = null;
 	}
 
-	private _onPriceScaleModeChanged(priceScale: PriceScale<HorzScaleItem>, oldMode: PriceScaleState, newMode: PriceScaleState): void {
+	private _onPriceScaleModeChanged(priceScale: PriceScale, oldMode: PriceScaleState, newMode: PriceScaleState): void {
 		if (oldMode.mode === newMode.mode) {
 			return;
 		}
@@ -407,9 +413,9 @@ export class Pane<HorzScaleItem> implements IDestroyable {
 		this._recalculatePriceScaleImpl(priceScale);
 	}
 
-	private _createPriceScale(id: string, options: OverlayPriceScaleOptions | VisiblePriceScaleOptions): PriceScale<HorzScaleItem> {
+	private _createPriceScale(id: string, options: OverlayPriceScaleOptions | VisiblePriceScaleOptions): PriceScale {
 		const actualOptions: PriceScaleOptions = { visible: true, autoScale: true, ...clone(options) };
-		const priceScale = new PriceScale<HorzScaleItem>(
+		const priceScale = new PriceScale(
 			id,
 			actualOptions,
 			this._model.options().layout,
diff --git a/src/model/price-scale.ts b/src/model/price-scale.ts
index bb483215ce..490182eede 100644
--- a/src/model/price-scale.ts
+++ b/src/model/price-scale.ts
@@ -9,9 +9,9 @@ import { DeepPartial, merge } from '../helpers/strict-type-checks';
 
 import { BarCoordinates, BarPrice, BarPrices } from './bar';
 import { Coordinate } from './coordinate';
-import { FirstValue, IPriceDataSource } from './iprice-data-source';
+import { FirstValue, IPriceDataSource, IPriceDataSourceBase } from './iprice-data-source';
 import { LayoutOptions } from './layout-options';
-import { LocalizationOptions } from './localization-options';
+import { LocalizationOptionsBase } from './localization-options';
 import { PriceRangeImpl } from './price-range-impl';
 import {
 	canConvertPriceRangeFromLog,
@@ -193,11 +193,11 @@ interface MarksCache {
 	firstValueIsNull: boolean;
 }
 
-export class PriceScale<HorzScaleItem> {
+export class PriceScale {
 	private readonly _id: string;
 
 	private readonly _layoutOptions: LayoutOptions;
-	private readonly _localizationOptions: LocalizationOptions<HorzScaleItem>;
+	private readonly _localizationOptions: LocalizationOptionsBase;
 	private readonly _options: PriceScaleOptions;
 
 	private _height: number = 0;
@@ -210,13 +210,13 @@ export class PriceScale<HorzScaleItem> {
 	private _marginAbove: number = 0;
 	private _marginBelow: number = 0;
 
-	private _markBuilder: PriceTickMarkBuilder<HorzScaleItem>;
+	private _markBuilder: PriceTickMarkBuilder;
 	private _onMarksChanged: Delegate = new Delegate();
 
 	private _modeChanged: Delegate<PriceScaleState, PriceScaleState> = new Delegate();
 
-	private _dataSources: IPriceDataSource<HorzScaleItem>[] = [];
-	private _cachedOrderedSources: IPriceDataSource<HorzScaleItem>[] | null = null;
+	private _dataSources: IPriceDataSourceBase[] = [];
+	private _cachedOrderedSources: IPriceDataSourceBase[] | null = null;
 
 	private _marksCache: MarksCache | null = null;
 
@@ -226,7 +226,7 @@ export class PriceScale<HorzScaleItem> {
 
 	private _logFormula: LogFormula = logFormulaForPriceRange(null);
 
-	public constructor(id: string, options: PriceScaleOptions, layoutOptions: LayoutOptions, localizationOptions: LocalizationOptions<HorzScaleItem>) {
+	public constructor(id: string, options: PriceScaleOptions, layoutOptions: LayoutOptions, localizationOptions: LocalizationOptionsBase) {
 		this._id = id;
 		this._options = options;
 		this._layoutOptions = layoutOptions;
@@ -518,16 +518,16 @@ export class PriceScale<HorzScaleItem> {
 		return value as BarPrice;
 	}
 
-	public dataSources(): readonly IPriceDataSource<HorzScaleItem>[] {
+	public dataSources(): readonly IPriceDataSourceBase[] {
 		return this._dataSources;
 	}
 
-	public orderedSources(): readonly IPriceDataSource<HorzScaleItem>[] {
+	public orderedSources(): readonly IPriceDataSourceBase[] {
 		if (this._cachedOrderedSources) {
 			return this._cachedOrderedSources;
 		}
 
-		let sources: IPriceDataSource<HorzScaleItem>[] = [];
+		let sources: IPriceDataSourceBase[] = [];
 		for (let i = 0; i < this._dataSources.length; i++) {
 			const ds = this._dataSources[i];
 			if (ds.zorder() === null) {
@@ -537,12 +537,12 @@ export class PriceScale<HorzScaleItem> {
 			sources.push(ds);
 		}
 
-		sources = sortSources<HorzScaleItem, IPriceDataSource<HorzScaleItem>>(sources);
+		sources = sortSources<IPriceDataSourceBase>(sources);
 		this._cachedOrderedSources = sources;
 		return this._cachedOrderedSources;
 	}
 
-	public addDataSource(source: IPriceDataSource<HorzScaleItem>): void {
+	public addDataSource(source: IPriceDataSourceBase): void {
 		if (this._dataSources.indexOf(source) !== -1) {
 			return;
 		}
@@ -552,7 +552,7 @@ export class PriceScale<HorzScaleItem> {
 		this.invalidateSourcesCache();
 	}
 
-	public removeDataSource(source: IPriceDataSource<HorzScaleItem>): void {
+	public removeDataSource(source: IPriceDataSourceBase): void {
 		const index = this._dataSources.indexOf(source);
 		if (index === -1) {
 			throw new Error('source is not attached to scale');
@@ -768,7 +768,7 @@ export class PriceScale<HorzScaleItem> {
 		return percentageFormatter.format(price);
 	}
 
-	public sourcesForAutoScale(): readonly IPriceDataSource<HorzScaleItem>[] {
+	public sourcesForAutoScale(): readonly IPriceDataSourceBase[] {
 		return this._dataSources;
 	}
 
@@ -780,7 +780,7 @@ export class PriceScale<HorzScaleItem> {
 	}
 
 	public updateAllViews(): void {
-		this._dataSources.forEach((s: IPriceDataSource<HorzScaleItem>) => s.updateAllViews());
+		this._dataSources.forEach((s: IPriceDataSourceBase) => s.updateAllViews());
 	}
 
 	public updateFormatter(): void {
@@ -822,7 +822,7 @@ export class PriceScale<HorzScaleItem> {
 	/**
 	 * @returns The {@link IPriceDataSource} that will be used as the "formatter source" (take minMove for formatter).
 	 */
-	private _formatterSource(): IPriceDataSource<HorzScaleItem> | null {
+	private _formatterSource(): IPriceDataSourceBase | null {
 		return this._dataSources[0] || null;
 	}
 
diff --git a/src/model/price-tick-mark-builder.ts b/src/model/price-tick-mark-builder.ts
index 4ba78e9be0..cf7c19f74f 100644
--- a/src/model/price-tick-mark-builder.ts
+++ b/src/model/price-tick-mark-builder.ts
@@ -9,15 +9,15 @@ export type LogicalToCoordinateConverter = (x: number, firstValue: number, keepI
 
 const TICK_DENSITY = 2.5;
 
-export class PriceTickMarkBuilder<HorzScaleItem> {
+export class PriceTickMarkBuilder {
 	private _marks: PriceMark[] = [];
 	private _base: number;
-	private readonly _priceScale: PriceScale<HorzScaleItem>;
+	private readonly _priceScale: PriceScale;
 	private readonly _coordinateToLogicalFunc: CoordinateToLogicalConverter;
 	private readonly _logicalToCoordinateFunc: LogicalToCoordinateConverter;
 
 	public constructor(
-		priceScale: PriceScale<HorzScaleItem>,
+		priceScale: PriceScale,
 		base: number,
 		coordinateToLogicalFunc: CoordinateToLogicalConverter,
 		logicalToCoordinateFunc: LogicalToCoordinateConverter
diff --git a/src/model/series.ts b/src/model/series.ts
index b03dba9550..d477bd6730 100644
--- a/src/model/series.ts
+++ b/src/model/series.ts
@@ -98,7 +98,7 @@ export type SeriesPartialOptionsInternal<T extends SeriesType = SeriesType> = Se
 export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource<HorzScaleItem> implements IDestroyable {
 	private readonly _seriesType: T;
 	private _data: SeriesPlotList<T, HorzScaleItem> = createSeriesPlotList<T, HorzScaleItem>();
-	private readonly _priceAxisViews: IPriceAxisView<HorzScaleItem>[];
+	private readonly _priceAxisViews: IPriceAxisView[];
 	private readonly _panePriceAxisView: PanePriceAxisView<HorzScaleItem>;
 	private _formatter!: IPriceFormatter;
 	private readonly _priceLineView: SeriesPriceLinePaneView<HorzScaleItem> = new SeriesPriceLinePaneView(this);
@@ -389,7 +389,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		];
 	}
 
-	public override priceAxisViews(pane: Pane<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>): readonly IPriceAxisView<HorzScaleItem>[] {
+	public override priceAxisViews(pane: Pane<HorzScaleItem>, priceScale: PriceScale): readonly IPriceAxisView[] {
 		if (priceScale !== this._priceScale && !this._isOverlay()) {
 			return [];
 		}
@@ -437,7 +437,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		this._lastPriceAnimationPaneView?.update();
 	}
 
-	public override priceScale(): PriceScale<HorzScaleItem> {
+	public override priceScale(): PriceScale {
 		return ensureNotNull(super.priceScale());
 	}
 
diff --git a/src/model/sort-sources.ts b/src/model/sort-sources.ts
index aebd918b62..1d9152c7d6 100644
--- a/src/model/sort-sources.ts
+++ b/src/model/sort-sources.ts
@@ -1,9 +1,8 @@
 import { ensureNotNull } from '../helpers/assertions';
+import { ZOrdered } from './idata-source';
 
-import { IDataSource } from './idata-source';
-
-export function sortSources<HorzScaleItem, T extends IDataSource<HorzScaleItem>>(sources: readonly T[]): T[] {
-	return sources.slice().sort((s1: IDataSource<HorzScaleItem>, s2: IDataSource<HorzScaleItem>) => {
+export function sortSources<T extends ZOrdered>(sources: readonly T[]): T[] {
+	return sources.slice().sort((s1: ZOrdered, s2: ZOrdered) => {
 		return (ensureNotNull(s1.zorder()) - ensureNotNull(s2.zorder()));
 	});
 }
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index 1dd9c5b117..4e1b1ee6b2 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -165,7 +165,11 @@ export interface HorzScaleOptions {
 	uniformDistribution: boolean;
 }
 
-export class TimeScale<HorzScaleItem> {
+export interface ITimeScale {
+	marks(): TimeMark[] | null;
+}
+
+export class TimeScale<HorzScaleItem> implements ITimeScale {
 	private readonly _options: HorzScaleOptions;
 	private readonly _model: ChartModel<HorzScaleItem>;
 	private readonly _localizationOptions: LocalizationOptions<HorzScaleItem>;
diff --git a/src/model/watermark.ts b/src/model/watermark.ts
index f5c6c50b39..b7d3692b91 100644
--- a/src/model/watermark.ts
+++ b/src/model/watermark.ts
@@ -75,7 +75,7 @@ export class Watermark<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		this._paneView = new WatermarkPaneView(this);
 	}
 
-	public override priceAxisViews(): readonly IPriceAxisView<HorzScaleItem>[] {
+	public override priceAxisViews(): readonly IPriceAxisView[] {
 		return [];
 	}
 
diff --git a/src/views/pane/bars-pane-view-base.ts b/src/views/pane/bars-pane-view-base.ts
index 9a2abae5d9..3547eb577a 100644
--- a/src/views/pane/bars-pane-view-base.ts
+++ b/src/views/pane/bars-pane-view-base.ts
@@ -20,7 +20,7 @@ export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick'
 		super(series, model, false);
 	}
 
-	protected _convertToCoordinates(priceScale: PriceScale<HorzScaleItem>, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void {
+	protected _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void {
 		timeScale.indexesToCoordinates(this._items, undefinedIfNull(this._itemsVisibleRange));
 		priceScale.barPricesToCoordinates(this._items, firstValue, undefinedIfNull(this._itemsVisibleRange));
 	}
diff --git a/src/views/pane/grid-pane-view.ts b/src/views/pane/grid-pane-view.ts
index 8314053129..063afa4b59 100644
--- a/src/views/pane/grid-pane-view.ts
+++ b/src/views/pane/grid-pane-view.ts
@@ -1,16 +1,16 @@
-import { Pane } from '../../model/pane';
+import { IPaneBase } from '../../model/pane';
 import { TimeMark } from '../../model/time-scale';
 import { GridRenderer, GridRendererData } from '../../renderers/grid-renderer';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IUpdatablePaneView } from './iupdatable-pane-view';
 
-export class GridPaneView<HorzScaleItem> implements IUpdatablePaneView {
-	private readonly _pane: Pane<HorzScaleItem>;
+export class GridPaneView implements IUpdatablePaneView {
+	private readonly _pane: IPaneBase;
 	private readonly _renderer: GridRenderer = new GridRenderer();
 	private _invalidated: boolean = true;
 
-	public constructor(pane: Pane<HorzScaleItem>) {
+	public constructor(pane: IPaneBase) {
 		this._pane = pane;
 	}
 
diff --git a/src/views/pane/line-pane-view-base.ts b/src/views/pane/line-pane-view-base.ts
index 3e9dd2c6db..0cf967a9d8 100644
--- a/src/views/pane/line-pane-view-base.ts
+++ b/src/views/pane/line-pane-view-base.ts
@@ -24,7 +24,7 @@ export abstract class LinePaneViewBase<
 		super(series, model, true);
 	}
 
-	protected _convertToCoordinates(priceScale: PriceScale<HorzScaleItem>, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void {
+	protected _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void {
 		timeScale.indexesToCoordinates(this._items, undefinedIfNull(this._itemsVisibleRange));
 		priceScale.pointsArrayToCoordinates(this._items, firstValue, undefinedIfNull(this._itemsVisibleRange));
 	}
diff --git a/src/views/pane/pane-price-axis-view.ts b/src/views/pane/pane-price-axis-view.ts
index 305d4b9d8a..9df1a3e536 100644
--- a/src/views/pane/pane-price-axis-view.ts
+++ b/src/views/pane/pane-price-axis-view.ts
@@ -39,14 +39,14 @@ class PanePriceAxisViewRenderer implements IPaneRenderer {
 }
 
 export class PanePriceAxisView<HorzScaleItem> implements IPaneView {
-	private _priceAxisView: IPriceAxisView<HorzScaleItem>;
+	private _priceAxisView: IPriceAxisView;
 	private readonly _textWidthCache: TextWidthCache;
 	private readonly _dataSource: IPriceDataSource<HorzScaleItem>;
 	private readonly _chartModel: ChartModel<HorzScaleItem>;
 	private readonly _renderer: PanePriceAxisViewRenderer;
 	private _fontSize: number;
 
-	public constructor(priceAxisView: IPriceAxisView<HorzScaleItem>, dataSource: IPriceDataSource<HorzScaleItem>, chartModel: ChartModel<HorzScaleItem>) {
+	public constructor(priceAxisView: IPriceAxisView, dataSource: IPriceDataSource<HorzScaleItem>, chartModel: ChartModel<HorzScaleItem>) {
 		this._priceAxisView = priceAxisView;
 		this._textWidthCache = new TextWidthCache(50); // when should we clear cache?
 		this._dataSource = dataSource;
diff --git a/src/views/pane/series-markers-pane-view.ts b/src/views/pane/series-markers-pane-view.ts
index 6ea2858438..c0a46c1d1e 100644
--- a/src/views/pane/series-markers-pane-view.ts
+++ b/src/views/pane/series-markers-pane-view.ts
@@ -41,7 +41,7 @@ function fillSizeAndY<HorzScaleItem>(
 	offsets: Offsets,
 	textHeight: number,
 	shapeMargin: number,
-	priceScale: PriceScale<HorzScaleItem>,
+	priceScale: PriceScale,
 	timeScale: TimeScale<HorzScaleItem>,
 	firstValue: number
 ): void {
diff --git a/src/views/pane/series-pane-view-base.ts b/src/views/pane/series-pane-view-base.ts
index 258c9edcf5..3abb115258 100644
--- a/src/views/pane/series-pane-view-base.ts
+++ b/src/views/pane/series-pane-view-base.ts
@@ -54,7 +54,7 @@ export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemTyp
 		}));
 	}
 
-	protected abstract _convertToCoordinates(priceScale: PriceScale<HorzScaleItem>, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void;
+	protected abstract _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void;
 
 	protected _clearVisibleRange(): void {
 		this._itemsVisibleRange = null;
diff --git a/src/views/price-axis/crosshair-price-axis-view.ts b/src/views/price-axis/crosshair-price-axis-view.ts
index 21c1c85f26..363179c35d 100644
--- a/src/views/price-axis/crosshair-price-axis-view.ts
+++ b/src/views/price-axis/crosshair-price-axis-view.ts
@@ -6,14 +6,14 @@ import { PriceAxisViewRendererCommonData, PriceAxisViewRendererData } from '../.
 
 import { PriceAxisView } from './price-axis-view';
 
-export type CrosshairPriceAxisViewValueProvider<HorzScaleItem> = (priceScale: PriceScale<HorzScaleItem>) => CrosshairPriceAndCoordinate;
+export type CrosshairPriceAxisViewValueProvider = (priceScale: PriceScale) => CrosshairPriceAndCoordinate;
 
 export class CrosshairPriceAxisView<HorzScaleItem> extends PriceAxisView<HorzScaleItem> {
 	private _source: Crosshair<HorzScaleItem>;
-	private readonly _priceScale: PriceScale<HorzScaleItem>;
-	private readonly _valueProvider: CrosshairPriceAxisViewValueProvider<HorzScaleItem>;
+	private readonly _priceScale: PriceScale;
+	private readonly _valueProvider: CrosshairPriceAxisViewValueProvider;
 
-	public constructor(source: Crosshair<HorzScaleItem>, priceScale: PriceScale<HorzScaleItem>, valueProvider: CrosshairPriceAxisViewValueProvider<HorzScaleItem>) {
+	public constructor(source: Crosshair<HorzScaleItem>, priceScale: PriceScale, valueProvider: CrosshairPriceAxisViewValueProvider) {
 		super();
 		this._source = source;
 		this._priceScale = priceScale;
diff --git a/src/views/price-axis/iprice-axis-view.ts b/src/views/price-axis/iprice-axis-view.ts
index 9c1bc10449..93b7b74cad 100644
--- a/src/views/price-axis/iprice-axis-view.ts
+++ b/src/views/price-axis/iprice-axis-view.ts
@@ -4,13 +4,13 @@ import {
 	PriceAxisViewRendererOptions,
 } from '../../renderers/iprice-axis-view-renderer';
 
-export interface IPriceAxisView<HorzScaleItem> {
+export interface IPriceAxisView {
 	coordinate(): number;
 	getFixedCoordinate(): number;
 	height(rendererOptions: PriceAxisViewRendererOptions, useSecondLine?: boolean): number;
 	isVisible(): boolean;
 	isAxisLabelVisible(): boolean;
-	renderer(priceScale: PriceScale<HorzScaleItem>): IPriceAxisViewRenderer;
+	renderer(priceScale: PriceScale): IPriceAxisViewRenderer;
 	paneRenderer(): IPriceAxisViewRenderer;
 	setFixedCoordinate(value: number | null): void;
 	text(): string;
diff --git a/src/views/price-axis/price-axis-view.ts b/src/views/price-axis/price-axis-view.ts
index fc6fc66254..2b3ce759da 100644
--- a/src/views/price-axis/price-axis-view.ts
+++ b/src/views/price-axis/price-axis-view.ts
@@ -10,7 +10,7 @@ import { PriceAxisViewRenderer } from '../../renderers/price-axis-view-renderer'
 
 import { IPriceAxisView } from './iprice-axis-view';
 
-export abstract class PriceAxisView<HorzScaleItem> implements IPriceAxisView<HorzScaleItem> {
+export abstract class PriceAxisView<HorzScaleItem> implements IPriceAxisView {
 	private readonly _commonRendererData: PriceAxisViewRendererCommonData = {
 		coordinate: 0,
 		background: '#000',
@@ -88,7 +88,7 @@ export abstract class PriceAxisView<HorzScaleItem> implements IPriceAxisView<Hor
 		return this._axisRendererData.visible;
 	}
 
-	public renderer(priceScale: PriceScale<HorzScaleItem>): IPriceAxisViewRenderer {
+	public renderer(priceScale: PriceScale): IPriceAxisViewRenderer {
 		this._updateRendererDataIfNeeded();
 
 		// force update tickVisible state from price scale options

From 9219b23b38e7e89bd1c6670f75482c24f6d0a1c5 Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Fri, 2 Jun 2023 18:44:19 +0300
Subject: [PATCH 17/23] Remove generic from data source interfaces

---
 src/gui/pane-widget.ts                        | 20 ++++++------
 src/gui/price-axis-widget.ts                  | 10 +++---
 src/gui/time-axis-widget.ts                   |  2 +-
 src/model/chart-model.ts                      | 16 +++++-----
 src/model/crosshair.ts                        |  2 +-
 src/model/data-source.ts                      |  4 +--
 src/model/idata-source.ts                     |  8 ++---
 src/model/iprice-data-source.ts               | 11 +++----
 src/model/magnet.ts                           |  2 +-
 src/model/pane.ts                             | 32 +++++++++----------
 src/model/price-data-source.ts                |  2 +-
 src/model/price-scale.ts                      | 24 +++++++-------
 src/renderers/itime-axis-view-renderer.ts     |  2 +-
 src/renderers/time-axis-view-renderer.ts      |  2 +-
 src/views/pane/pane-price-axis-view.ts        |  4 +--
 .../time-axis/crosshair-time-axis-view.ts     |  6 ++--
 src/views/time-axis/itime-axis-view.ts        |  4 +--
 17 files changed, 73 insertions(+), 78 deletions(-)

diff --git a/src/gui/pane-widget.ts b/src/gui/pane-widget.ts
index 596d09f949..303f882d2d 100644
--- a/src/gui/pane-widget.ts
+++ b/src/gui/pane-widget.ts
@@ -51,27 +51,27 @@ function drawForeground(renderer: IPaneRenderer, target: CanvasRenderingTarget2D
 	renderer.draw(target, isHovered, hitTestData);
 }
 
-type PaneViewsGetter<HorzScaleItem> = (source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>) => readonly IPaneView[];
+type PaneViewsGetter<HorzScaleItem> = (source: IDataSource, pane: Pane<HorzScaleItem>) => readonly IPaneView[];
 
-function sourcePaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
+function sourcePaneViews<HorzScaleItem>(source: IDataSource, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
 	return source.paneViews(pane);
 }
 
-function sourceLabelPaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
+function sourceLabelPaneViews<HorzScaleItem>(source: IDataSource, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
 	return source.labelPaneViews(pane);
 }
 
-function sourceTopPaneViews<HorzScaleItem>(source: IDataSource<HorzScaleItem>, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
+function sourceTopPaneViews<HorzScaleItem>(source: IDataSource, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
 	return source.topPaneViews !== undefined ? source.topPaneViews(pane) : [];
 }
 
-export interface HitTestResult<HorzScaleItem> {
-	source: IPriceDataSource<HorzScaleItem>;
+export interface HitTestResult {
+	source: IPriceDataSource;
 	object?: HoveredObject;
 	view: IPaneView;
 }
 
-interface HitTestPaneViewResult<HorzScaleItem> {
+interface HitTestPaneViewResult {
 	view: IPaneView;
 	object?: HoveredObject;
 }
@@ -391,7 +391,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		this._endScroll(event);
 	}
 
-	public hitTest(x: Coordinate, y: Coordinate): HitTestResult<HorzScaleItem> | null {
+	public hitTest(x: Coordinate, y: Coordinate): HitTestResult | null {
 		const state = this._state;
 		if (state === null) {
 			return null;
@@ -586,7 +586,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		target: CanvasRenderingTarget2D,
 		paneViewsGetter: PaneViewsGetter<HorzScaleItem>,
 		drawFn: DrawFunction,
-		source: IDataSource<HorzScaleItem>
+		source: IDataSource
 	): void {
 		const state = ensureNotNull(this._state);
 		const paneViews = paneViewsGetter(source, state);
@@ -604,7 +604,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		}
 	}
 
-	private _hitTestPaneView(paneViews: readonly IPaneView[], x: Coordinate, y: Coordinate): HitTestPaneViewResult<HorzScaleItem> | null {
+	private _hitTestPaneView(paneViews: readonly IPaneView[], x: Coordinate, y: Coordinate): HitTestPaneViewResult | null {
 		for (const paneView of paneViews) {
 			const renderer = paneView.renderer();
 			if (renderer !== null && renderer.hitTest) {
diff --git a/src/gui/price-axis-widget.ts b/src/gui/price-axis-widget.ts
index a94fb05337..6678d0733a 100644
--- a/src/gui/price-axis-widget.ts
+++ b/src/gui/price-axis-widget.ts
@@ -16,7 +16,7 @@ import { makeFont } from '../helpers/make-font';
 
 import { ChartOptionsInternal } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
-import { IDataSource, IDataSourceBase } from '../model/idata-source';
+import { IDataSource } from '../model/idata-source';
 import { InvalidationLevel } from '../model/invalidate-mask';
 import { IPriceDataSource } from '../model/iprice-data-source';
 import { LayoutOptions } from '../model/layout-options';
@@ -379,7 +379,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 
 		const priceScale = (this._priceScale === null) ? undefined : this._priceScale;
 
-		const addViewsForSources = (sources: readonly IDataSource<HorzScaleItem>[]) => {
+		const addViewsForSources = (sources: readonly IDataSource[]) => {
 			for (let i = 0; i < sources.length; ++i) {
 				const source = sources[i];
 				const views = source.priceAxisViews(this._pane.state(), priceScale);
@@ -496,7 +496,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		const isDefault = this._priceScale === paneState.defaultVisiblePriceScale();
 
 		if (isDefault) {
-			this._pane.state().orderedSources().forEach((source: IPriceDataSource<HorzScaleItem>) => {
+			this._pane.state().orderedSources().forEach((source: IPriceDataSource) => {
 				if (paneState.isOverlay(source)) {
 					orderedSources.push(source);
 				}
@@ -507,8 +507,8 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 		const centerSource = this._priceScale.dataSources()[0];
 		const priceScale = this._priceScale;
 
-		const updateForSources = (sources: IDataSourceBase[]) => {
-			sources.forEach((source: IDataSourceBase) => {
+		const updateForSources = (sources: IDataSource[]) => {
+			sources.forEach((source: IDataSource) => {
 				const sourceViews = source.priceAxisViews(paneState, priceScale);
 				// never align selected sources
 				sourceViews.forEach((view: IPriceAxisView) => {
diff --git a/src/gui/time-axis-widget.ts b/src/gui/time-axis-widget.ts
index 89f1d3c884..2447f11be8 100644
--- a/src/gui/time-axis-widget.ts
+++ b/src/gui/time-axis-widget.ts
@@ -406,7 +406,7 @@ export class TimeAxisWidget<HorzScaleItem> implements MouseEventHandlers, IDestr
 		return coordinate;
 	}
 
-	private _drawLabels(sources: readonly IDataSource<HorzScaleItem>[], target: CanvasRenderingTarget2D): void {
+	private _drawLabels(sources: readonly IDataSource[], target: CanvasRenderingTarget2D): void {
 		const rendererOptions = this._getRendererOptions();
 		for (const source of sources) {
 			for (const view of source.timeAxisViews()) {
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index 2cf0ed85b7..5a142379e6 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -168,8 +168,8 @@ export interface HoveredObject {
 	externalId?: string;
 }
 
-export interface HoveredSource<HorzScaleItem> {
-	source: IPriceDataSource<HorzScaleItem>;
+export interface HoveredSource {
+	source: IPriceDataSource;
 	object?: HoveredObject;
 }
 
@@ -391,7 +391,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 	private _serieses: Series<SeriesType, HorzScaleItem>[] = [];
 
 	private _width: number = 0;
-	private _hoveredSource: HoveredSource<HorzScaleItem> | null = null;
+	private _hoveredSource: HoveredSource | null = null;
 	private readonly _priceScalesOptionsChanged: Delegate = new Delegate();
 	private _crosshairMoved: Delegate<TimePointIndex | null, Point | null, TouchMouseEventData | null> = new Delegate();
 
@@ -432,16 +432,16 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		this._invalidate(new InvalidateMask(InvalidationLevel.Cursor));
 	}
 
-	public updateSource(source: IPriceDataSource<HorzScaleItem>): void {
+	public updateSource(source: IPriceDataSource): void {
 		const inv = this._invalidationMaskForSource(source);
 		this._invalidate(inv);
 	}
 
-	public hoveredSource(): HoveredSource<HorzScaleItem> | null {
+	public hoveredSource(): HoveredSource | null {
 		return this._hoveredSource;
 	}
 
-	public setHoveredSource(source: HoveredSource<HorzScaleItem> | null): void {
+	public setHoveredSource(source: HoveredSource | null): void {
 		const prevSource = this._hoveredSource;
 		this._hoveredSource = source;
 		if (prevSource !== null) {
@@ -758,7 +758,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		}
 	}
 
-	public paneForSource(source: IPriceDataSource<HorzScaleItem>): Pane<HorzScaleItem> | null {
+	public paneForSource(source: IPriceDataSource): Pane<HorzScaleItem> | null {
 		const pane = this._panes.find((p: Pane<HorzScaleItem>) => p.orderedSources().includes(source));
 		return pane === undefined ? null : pane;
 	}
@@ -934,7 +934,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return inv;
 	}
 
-	private _invalidationMaskForSource(source: IPriceDataSource<HorzScaleItem>, invalidateType?: InvalidationLevel): InvalidateMask {
+	private _invalidationMaskForSource(source: IPriceDataSource, invalidateType?: InvalidationLevel): InvalidateMask {
 		if (invalidateType === undefined) {
 			invalidateType = InvalidationLevel.Light;
 		}
diff --git a/src/model/crosshair.ts b/src/model/crosshair.ts
index c7b2772137..bd4666dc01 100644
--- a/src/model/crosshair.ts
+++ b/src/model/crosshair.ts
@@ -280,7 +280,7 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		return views;
 	}
 
-	public override timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[] {
+	public override timeAxisViews(): readonly ITimeAxisView[] {
 		return this._visible ? [this._timeAxisView] : [];
 	}
 
diff --git a/src/model/data-source.ts b/src/model/data-source.ts
index e0482e8eed..5df5a94aba 100644
--- a/src/model/data-source.ts
+++ b/src/model/data-source.ts
@@ -6,7 +6,7 @@ import { IDataSource } from './idata-source';
 import { IPaneBase, Pane } from './pane';
 import { PriceScale } from './price-scale';
 
-export abstract class DataSource<HorzScaleItem> implements IDataSource<HorzScaleItem> {
+export abstract class DataSource<HorzScaleItem> implements IDataSource {
 	protected _priceScale: PriceScale | null = null;
 
 	private _zorder: number = 0;
@@ -34,7 +34,7 @@ export abstract class DataSource<HorzScaleItem> implements IDataSource<HorzScale
 		return [];
 	}
 
-	public timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[] {
+	public timeAxisViews(): readonly ITimeAxisView[] {
 		return [];
 	}
 
diff --git a/src/model/idata-source.ts b/src/model/idata-source.ts
index 5e3cdfb13f..3e7e46faa5 100644
--- a/src/model/idata-source.ts
+++ b/src/model/idata-source.ts
@@ -9,7 +9,7 @@ export interface ZOrdered {
 	zorder(): number;
 }
 
-export interface IDataSourceBase extends ZOrdered {
+export interface IDataSource extends ZOrdered {
 	setZorder(value: number): void;
 	priceScale(): PriceScale | null;
 	setPriceScale(scale: PriceScale | null): void;
@@ -28,8 +28,6 @@ export interface IDataSourceBase extends ZOrdered {
 	visible(): boolean;
 
 	destroy?(): void;
-}
 
-export interface IDataSource<HorzScaleItem> extends IDataSourceBase {
-	timeAxisViews(): readonly ITimeAxisView<HorzScaleItem>[];
-}
\ No newline at end of file
+	timeAxisViews(): readonly ITimeAxisView[];
+}
diff --git a/src/model/iprice-data-source.ts b/src/model/iprice-data-source.ts
index 004ce8682c..7bdb8c2a5c 100644
--- a/src/model/iprice-data-source.ts
+++ b/src/model/iprice-data-source.ts
@@ -1,8 +1,8 @@
 import { IPriceFormatter } from '../formatters/iprice-formatter';
 
 import { AutoscaleInfoImpl } from './autoscale-info-impl';
-import { ChartModel } from './chart-model';
-import { IDataSource, IDataSourceBase } from './idata-source';
+import { IChartModelBase } from './chart-model';
+import { IDataSource } from './idata-source';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
 import { TimePointIndex } from './time-data';
 
@@ -11,14 +11,11 @@ export interface FirstValue {
 	timePoint: InternalHorzScaleItem;
 }
 
-export interface IPriceDataSourceBase extends IDataSourceBase {
+export interface IPriceDataSource extends IDataSource {
 	firstValue(): FirstValue | null;
 	formatter(): IPriceFormatter;
 	priceLineColor(lastBarColor: string): string;
 	minMove(): number;
 	autoscaleInfo(startTimePoint: TimePointIndex, endTimePoint: TimePointIndex): AutoscaleInfoImpl | null;
-}
-
-export interface IPriceDataSource<HorzScaleItem> extends IPriceDataSourceBase, IDataSource<HorzScaleItem> {
-	model(): ChartModel<HorzScaleItem>;
+	model(): IChartModelBase;
 }
diff --git a/src/model/magnet.ts b/src/model/magnet.ts
index 88b85773fd..6dfceb528c 100644
--- a/src/model/magnet.ts
+++ b/src/model/magnet.ts
@@ -33,7 +33,7 @@ export class Magnet<HorzScaleItem> {
 
 		// get all serieses from the pane
 		const serieses: readonly Series<SeriesType, HorzScaleItem>[] = pane.dataSources().filter(
-			((ds: IPriceDataSource<HorzScaleItem>) => (ds instanceof Series<SeriesType, HorzScaleItem>)) as (ds: IPriceDataSource<HorzScaleItem>) => ds is Series<SeriesType, HorzScaleItem>);
+			((ds: IPriceDataSource) => (ds instanceof Series<SeriesType, HorzScaleItem>)) as (ds: IPriceDataSource) => ds is Series<SeriesType, HorzScaleItem>);
 
 		const candidates = serieses.reduce(
 			(acc: Coordinate[], series: Series<SeriesType, HorzScaleItem>) => {
diff --git a/src/model/pane.ts b/src/model/pane.ts
index 1e1670e6aa..6b350ef094 100644
--- a/src/model/pane.ts
+++ b/src/model/pane.ts
@@ -7,7 +7,7 @@ import { clone, DeepPartial } from '../helpers/strict-type-checks';
 import { ChartModel, ChartOptionsImpl, IChartModelBase, OverlayPriceScaleOptions, VisiblePriceScaleOptions } from './chart-model';
 import { DefaultPriceScaleId, isDefaultPriceScale } from './default-price-scale';
 import { Grid } from './grid';
-import { IPriceDataSource, IPriceDataSourceBase } from './iprice-data-source';
+import { IPriceDataSource } from './iprice-data-source';
 import { PriceScale, PriceScaleOptions, PriceScaleState } from './price-scale';
 import { sortSources } from './sort-sources';
 import { TimeScale } from './time-scale';
@@ -22,7 +22,7 @@ interface MinMaxOrderInfo {
 }
 
 export interface IPaneBase {
-	addDataSource(source: IPriceDataSourceBase, targetScaleId: string, zOrder?: number): void;
+	addDataSource(source: IPriceDataSource, targetScaleId: string, zOrder?: number): void;
 	model(): IChartModelBase;
 	defaultPriceScale(): PriceScale;
 }
@@ -32,13 +32,13 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 	private readonly _model: ChartModel<HorzScaleItem>;
 	private readonly _grid: Grid;
 
-	private _dataSources: IPriceDataSource<HorzScaleItem>[] = [];
-	private _overlaySourcesByScaleId: Map<string, IPriceDataSource<HorzScaleItem>[]> = new Map();
+	private _dataSources: IPriceDataSource[] = [];
+	private _overlaySourcesByScaleId: Map<string, IPriceDataSource[]> = new Map();
 
 	private _height: number = 0;
 	private _width: number = 0;
 	private _stretchFactor: number = DEFAULT_STRETCH_FACTOR;
-	private _cachedOrderedSources: readonly IPriceDataSource<HorzScaleItem>[] | null = null;
+	private _cachedOrderedSources: readonly IPriceDataSource[] | null = null;
 
 	private _destroyed: Delegate = new Delegate();
 
@@ -105,7 +105,7 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		this._leftPriceScale.modeChanged().unsubscribeAll(this);
 		this._rightPriceScale.modeChanged().unsubscribeAll(this);
 
-		this._dataSources.forEach((source: IPriceDataSource<HorzScaleItem>) => {
+		this._dataSources.forEach((source: IPriceDataSource) => {
 			if (source.destroy) {
 				source.destroy();
 			}
@@ -145,7 +145,7 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		this._rightPriceScale.setHeight(height);
 
 		// process overlays
-		this._dataSources.forEach((ds: IPriceDataSource<HorzScaleItem>) => {
+		this._dataSources.forEach((ds: IPriceDataSource) => {
 			if (this.isOverlay(ds)) {
 				const priceScale = ds.priceScale();
 				if (priceScale !== null) {
@@ -157,11 +157,11 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		this.updateAllSources();
 	}
 
-	public dataSources(): readonly IPriceDataSource<HorzScaleItem>[] {
+	public dataSources(): readonly IPriceDataSource[] {
 		return this._dataSources;
 	}
 
-	public isOverlay(source: IPriceDataSource<HorzScaleItem>): boolean {
+	public isOverlay(source: IPriceDataSource): boolean {
 		const priceScale = source.priceScale();
 		if (priceScale === null) {
 			return true;
@@ -169,12 +169,12 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		return this._leftPriceScale !== priceScale && this._rightPriceScale !== priceScale;
 	}
 
-	public addDataSource(source: IPriceDataSource<HorzScaleItem>, targetScaleId: string, zOrder?: number): void {
+	public addDataSource(source: IPriceDataSource, targetScaleId: string, zOrder?: number): void {
 		const targetZOrder = (zOrder !== undefined) ? zOrder : this._getZOrderMinMax().maxZOrder + 1;
 		this._insertDataSource(source, targetScaleId, targetZOrder);
 	}
 
-	public removeDataSource(source: IPriceDataSource<HorzScaleItem>): void {
+	public removeDataSource(source: IPriceDataSource): void {
 		const index = this._dataSources.indexOf(source);
 		assert(index !== -1, 'removeDataSource: invalid data source');
 
@@ -255,7 +255,7 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 	}
 
 	public updateAllSources(): void {
-		this._dataSources.forEach((source: IPriceDataSource<HorzScaleItem>) => {
+		this._dataSources.forEach((source: IPriceDataSource) => {
 			source.updateAllViews();
 		});
 	}
@@ -315,7 +315,7 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		this.recalculatePriceScale(this._leftPriceScale);
 		this.recalculatePriceScale(this._rightPriceScale);
 
-		this._dataSources.forEach((ds: IPriceDataSource<HorzScaleItem>) => {
+		this._dataSources.forEach((ds: IPriceDataSource) => {
 			if (this.isOverlay(ds)) {
 				this.recalculatePriceScale(ds.priceScale());
 			}
@@ -325,9 +325,9 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		this._model.lightUpdate();
 	}
 
-	public orderedSources(): readonly IPriceDataSource<HorzScaleItem>[] {
+	public orderedSources(): readonly IPriceDataSource[] {
 		if (this._cachedOrderedSources === null) {
-			this._cachedOrderedSources = sortSources<IPriceDataSource<HorzScaleItem>>(this._dataSources);
+			this._cachedOrderedSources = sortSources<IPriceDataSource>(this._dataSources);
 		}
 
 		return this._cachedOrderedSources;
@@ -380,7 +380,7 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		return { minZOrder: minZOrder, maxZOrder: maxZOrder };
 	}
 
-	private _insertDataSource(source: IPriceDataSource<HorzScaleItem>, priceScaleId: string, zOrder: number): void {
+	private _insertDataSource(source: IPriceDataSource, priceScaleId: string, zOrder: number): void {
 		let priceScale = this.priceScaleById(priceScaleId);
 
 		if (priceScale === null) {
diff --git a/src/model/price-data-source.ts b/src/model/price-data-source.ts
index 5cb5107b55..1943a58725 100644
--- a/src/model/price-data-source.ts
+++ b/src/model/price-data-source.ts
@@ -6,7 +6,7 @@ import { DataSource } from './data-source';
 import { FirstValue, IPriceDataSource } from './iprice-data-source';
 import { TimePointIndex } from './time-data';
 
-export abstract class PriceDataSource<HorzScaleItem> extends DataSource<HorzScaleItem> implements IPriceDataSource<HorzScaleItem> {
+export abstract class PriceDataSource<HorzScaleItem> extends DataSource<HorzScaleItem> implements IPriceDataSource {
 	private readonly _model: ChartModel<HorzScaleItem>;
 
 	public constructor(model: ChartModel<HorzScaleItem>) {
diff --git a/src/model/price-scale.ts b/src/model/price-scale.ts
index 490182eede..9a1c059ed5 100644
--- a/src/model/price-scale.ts
+++ b/src/model/price-scale.ts
@@ -9,7 +9,7 @@ import { DeepPartial, merge } from '../helpers/strict-type-checks';
 
 import { BarCoordinates, BarPrice, BarPrices } from './bar';
 import { Coordinate } from './coordinate';
-import { FirstValue, IPriceDataSource, IPriceDataSourceBase } from './iprice-data-source';
+import { FirstValue, IPriceDataSource } from './iprice-data-source';
 import { LayoutOptions } from './layout-options';
 import { LocalizationOptionsBase } from './localization-options';
 import { PriceRangeImpl } from './price-range-impl';
@@ -215,8 +215,8 @@ export class PriceScale {
 
 	private _modeChanged: Delegate<PriceScaleState, PriceScaleState> = new Delegate();
 
-	private _dataSources: IPriceDataSourceBase[] = [];
-	private _cachedOrderedSources: IPriceDataSourceBase[] | null = null;
+	private _dataSources: IPriceDataSource[] = [];
+	private _cachedOrderedSources: IPriceDataSource[] | null = null;
 
 	private _marksCache: MarksCache | null = null;
 
@@ -518,16 +518,16 @@ export class PriceScale {
 		return value as BarPrice;
 	}
 
-	public dataSources(): readonly IPriceDataSourceBase[] {
+	public dataSources(): readonly IPriceDataSource[] {
 		return this._dataSources;
 	}
 
-	public orderedSources(): readonly IPriceDataSourceBase[] {
+	public orderedSources(): readonly IPriceDataSource[] {
 		if (this._cachedOrderedSources) {
 			return this._cachedOrderedSources;
 		}
 
-		let sources: IPriceDataSourceBase[] = [];
+		let sources: IPriceDataSource[] = [];
 		for (let i = 0; i < this._dataSources.length; i++) {
 			const ds = this._dataSources[i];
 			if (ds.zorder() === null) {
@@ -537,12 +537,12 @@ export class PriceScale {
 			sources.push(ds);
 		}
 
-		sources = sortSources<IPriceDataSourceBase>(sources);
+		sources = sortSources<IPriceDataSource>(sources);
 		this._cachedOrderedSources = sources;
 		return this._cachedOrderedSources;
 	}
 
-	public addDataSource(source: IPriceDataSourceBase): void {
+	public addDataSource(source: IPriceDataSource): void {
 		if (this._dataSources.indexOf(source) !== -1) {
 			return;
 		}
@@ -552,7 +552,7 @@ export class PriceScale {
 		this.invalidateSourcesCache();
 	}
 
-	public removeDataSource(source: IPriceDataSourceBase): void {
+	public removeDataSource(source: IPriceDataSource): void {
 		const index = this._dataSources.indexOf(source);
 		if (index === -1) {
 			throw new Error('source is not attached to scale');
@@ -768,7 +768,7 @@ export class PriceScale {
 		return percentageFormatter.format(price);
 	}
 
-	public sourcesForAutoScale(): readonly IPriceDataSourceBase[] {
+	public sourcesForAutoScale(): readonly IPriceDataSource[] {
 		return this._dataSources;
 	}
 
@@ -780,7 +780,7 @@ export class PriceScale {
 	}
 
 	public updateAllViews(): void {
-		this._dataSources.forEach((s: IPriceDataSourceBase) => s.updateAllViews());
+		this._dataSources.forEach((s: IPriceDataSource) => s.updateAllViews());
 	}
 
 	public updateFormatter(): void {
@@ -822,7 +822,7 @@ export class PriceScale {
 	/**
 	 * @returns The {@link IPriceDataSource} that will be used as the "formatter source" (take minMove for formatter).
 	 */
-	private _formatterSource(): IPriceDataSourceBase | null {
+	private _formatterSource(): IPriceDataSource | null {
 		return this._dataSources[0] || null;
 	}
 
diff --git a/src/renderers/itime-axis-view-renderer.ts b/src/renderers/itime-axis-view-renderer.ts
index 80b3521346..ee71da0417 100644
--- a/src/renderers/itime-axis-view-renderer.ts
+++ b/src/renderers/itime-axis-view-renderer.ts
@@ -15,6 +15,6 @@ export interface TimeAxisViewRendererOptions {
 	labelBottomOffset: number;
 }
 
-export interface ITimeAxisViewRenderer<HorzScaleItem> {
+export interface ITimeAxisViewRenderer {
 	draw(target: CanvasRenderingTarget2D, rendererOptions: TimeAxisViewRendererOptions): void;
 }
diff --git a/src/renderers/time-axis-view-renderer.ts b/src/renderers/time-axis-view-renderer.ts
index f196574a84..788835cc0e 100644
--- a/src/renderers/time-axis-view-renderer.ts
+++ b/src/renderers/time-axis-view-renderer.ts
@@ -18,7 +18,7 @@ const optimizationReplacementRe = /[1-9]/g;
 
 const radius = 2;
 
-export class TimeAxisViewRenderer<HorzScaleItem> implements ITimeAxisViewRenderer<HorzScaleItem> {
+export class TimeAxisViewRenderer implements ITimeAxisViewRenderer {
 	private _data: TimeAxisViewRendererData | null;
 
 	public constructor() {
diff --git a/src/views/pane/pane-price-axis-view.ts b/src/views/pane/pane-price-axis-view.ts
index 9df1a3e536..74683954ca 100644
--- a/src/views/pane/pane-price-axis-view.ts
+++ b/src/views/pane/pane-price-axis-view.ts
@@ -41,12 +41,12 @@ class PanePriceAxisViewRenderer implements IPaneRenderer {
 export class PanePriceAxisView<HorzScaleItem> implements IPaneView {
 	private _priceAxisView: IPriceAxisView;
 	private readonly _textWidthCache: TextWidthCache;
-	private readonly _dataSource: IPriceDataSource<HorzScaleItem>;
+	private readonly _dataSource: IPriceDataSource;
 	private readonly _chartModel: ChartModel<HorzScaleItem>;
 	private readonly _renderer: PanePriceAxisViewRenderer;
 	private _fontSize: number;
 
-	public constructor(priceAxisView: IPriceAxisView, dataSource: IPriceDataSource<HorzScaleItem>, chartModel: ChartModel<HorzScaleItem>) {
+	public constructor(priceAxisView: IPriceAxisView, dataSource: IPriceDataSource, chartModel: ChartModel<HorzScaleItem>) {
 		this._priceAxisView = priceAxisView;
 		this._textWidthCache = new TextWidthCache(50); // when should we clear cache?
 		this._dataSource = dataSource;
diff --git a/src/views/time-axis/crosshair-time-axis-view.ts b/src/views/time-axis/crosshair-time-axis-view.ts
index f940630b5e..84b277f10c 100644
--- a/src/views/time-axis/crosshair-time-axis-view.ts
+++ b/src/views/time-axis/crosshair-time-axis-view.ts
@@ -7,12 +7,12 @@ import { TimeAxisViewRenderer, TimeAxisViewRendererData } from '../../renderers/
 
 import { ITimeAxisView } from './itime-axis-view';
 
-export class CrosshairTimeAxisView<HorzScaleItem> implements ITimeAxisView<HorzScaleItem> {
+export class CrosshairTimeAxisView<HorzScaleItem> implements ITimeAxisView {
 	private _invalidated: boolean = true;
 	private readonly _crosshair: Crosshair<HorzScaleItem>;
 	private readonly _model: ChartModel<HorzScaleItem>;
 	private readonly _valueProvider: TimeAndCoordinateProvider;
-	private readonly _renderer: TimeAxisViewRenderer<HorzScaleItem> = new TimeAxisViewRenderer();
+	private readonly _renderer: TimeAxisViewRenderer = new TimeAxisViewRenderer();
 	private readonly _rendererData: TimeAxisViewRendererData = {
 		visible: false,
 		background: '#4c525e',
@@ -33,7 +33,7 @@ export class CrosshairTimeAxisView<HorzScaleItem> implements ITimeAxisView<HorzS
 		this._invalidated = true;
 	}
 
-	public renderer(): TimeAxisViewRenderer<HorzScaleItem> {
+	public renderer(): TimeAxisViewRenderer {
 		if (this._invalidated) {
 			this._updateImpl();
 			this._invalidated = false;
diff --git a/src/views/time-axis/itime-axis-view.ts b/src/views/time-axis/itime-axis-view.ts
index 23e7040a93..cda658e993 100644
--- a/src/views/time-axis/itime-axis-view.ts
+++ b/src/views/time-axis/itime-axis-view.ts
@@ -1,5 +1,5 @@
 import { TimeAxisViewRenderer } from '../../renderers/time-axis-view-renderer';
 
-export interface ITimeAxisView<HorzScaleItem> {
-	renderer(): TimeAxisViewRenderer<HorzScaleItem>;
+export interface ITimeAxisView {
+	renderer(): TimeAxisViewRenderer;
 }

From 215ec5cc4fc3accd45efde510de802f683294683 Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 6 Jun 2023 12:52:53 +0300
Subject: [PATCH 18/23] Next stage of removing generics

---
 src/api/price-line-api.ts                     |  8 ++--
 src/api/series-api.ts                         |  2 +-
 src/model/chart-model.ts                      | 29 +++++++++---
 src/model/crosshair.ts                        | 44 +++++++++----------
 src/model/custom-price-line.ts                | 14 +++---
 src/model/data-source.ts                      |  6 +--
 src/model/magnet.ts                           | 14 +++---
 src/model/pane.ts                             |  4 ++
 src/model/price-data-source.ts                | 10 ++---
 src/model/series-bar-colorer.ts               |  6 ++-
 src/model/series.ts                           | 41 +++++++++++------
 src/model/time-scale.ts                       | 14 ++++++
 src/model/watermark.ts                        |  8 ++--
 src/views/pane/area-pane-view.ts              | 12 ++---
 src/views/pane/bars-pane-view-base.ts         | 20 ++++-----
 src/views/pane/bars-pane-view.ts              |  4 +-
 src/views/pane/baseline-pane-view.ts          | 12 ++---
 src/views/pane/candlesticks-pane-view.ts      |  4 +-
 src/views/pane/crosshair-marks-pane-view.ts   | 14 +++---
 src/views/pane/crosshair-pane-view.ts         |  6 +--
 src/views/pane/custom-price-line-pane-view.ts |  8 ++--
 src/views/pane/histogram-pane-view.ts         |  6 +--
 src/views/pane/line-pane-view-base.ts         | 21 +++++----
 src/views/pane/line-pane-view.ts              |  6 +--
 src/views/pane/pane-price-axis-view.ts        |  8 ++--
 .../series-horizontal-base-line-pane-view.ts  |  6 +--
 .../pane/series-horizontal-line-pane-view.ts  | 12 ++---
 .../series-last-price-animation-pane-view.ts  |  8 ++--
 src/views/pane/series-markers-pane-view.ts    | 22 +++++-----
 src/views/pane/series-pane-view-base.ts       | 16 +++----
 src/views/pane/series-price-line-pane-view.ts |  6 +--
 src/views/pane/watermark-pane-view.ts         |  6 +--
 .../price-axis/crosshair-price-axis-view.ts   |  6 +--
 .../custom-price-line-price-axis-view.ts      | 10 ++---
 src/views/price-axis/price-axis-view.ts       |  2 +-
 .../price-axis/series-price-axis-view.ts      |  8 ++--
 .../time-axis/crosshair-time-axis-view.ts     | 10 ++---
 37 files changed, 241 insertions(+), 192 deletions(-)

diff --git a/src/api/price-line-api.ts b/src/api/price-line-api.ts
index d27fe8db4e..c531241379 100644
--- a/src/api/price-line-api.ts
+++ b/src/api/price-line-api.ts
@@ -3,10 +3,10 @@ import { PriceLineOptions } from '../model/price-line-options';
 
 import { IPriceLine } from './iprice-line';
 
-export class PriceLine<HorzScaleItem> implements IPriceLine {
-	private readonly _priceLine: CustomPriceLine<HorzScaleItem>;
+export class PriceLine implements IPriceLine {
+	private readonly _priceLine: CustomPriceLine;
 
-	public constructor(priceLine: CustomPriceLine<HorzScaleItem>) {
+	public constructor(priceLine: CustomPriceLine) {
 		this._priceLine = priceLine;
 	}
 
@@ -17,7 +17,7 @@ export class PriceLine<HorzScaleItem> implements IPriceLine {
 		return this._priceLine.options();
 	}
 
-	public priceLine(): CustomPriceLine<HorzScaleItem> {
+	public priceLine(): CustomPriceLine {
 		return this._priceLine;
 	}
 }
diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index 7c043da4d5..036332e2ef 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -183,7 +183,7 @@ export class SeriesApi<TSeriesType extends SeriesType, HorzScaleItem> implements
 	}
 
 	public removePriceLine(line: IPriceLine): void {
-		this._series.removePriceLine((line as PriceLine<HorzScaleItem>).priceLine());
+		this._series.removePriceLine((line as PriceLine).priceLine());
 	}
 
 	public seriesType(): TSeriesType {
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index 5a142379e6..d0aec696ea 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -23,7 +23,7 @@ import { Magnet } from './magnet';
 import { DEFAULT_STRETCH_FACTOR, IPaneBase, Pane } from './pane';
 import { Point } from './point';
 import { PriceScale, PriceScaleOptions } from './price-scale';
-import { Series, SeriesOptionsInternal } from './series';
+import { ISeries, Series, SeriesOptionsInternal } from './series';
 import { SeriesOptionsMap, SeriesType } from './series-options';
 import { LogicalRange, TimePointIndex, TimeScalePoint } from './time-data';
 import { HorzScaleOptions, ITimeScale, TimeScale } from './time-scale';
@@ -374,6 +374,21 @@ export interface IChartModelBase {
 	findPriceScale(priceScaleId: string): PriceScaleOnPane | null;
 	options(): Readonly<ChartOptionsInternalBase>;
 	timeScale(): ITimeScale;
+	serieses(): readonly ISeries<SeriesType>[];
+
+	updateSource(source: IPriceDataSource): void;
+	updateCrosshair(): void;
+	cursorUpdate(): void;
+
+	recalculatePane(pane: IPaneBase | null): void;
+
+	lightUpdate(): void;
+	fullUpdate(): void;
+	backgroundColorAtYPercentFromTop(percent: number): string;
+	paneForSource(source: IPriceDataSource): IPaneBase | null;
+	moveSeriesToScale(series: ISeries<SeriesType>, targetScaleId: string): void;
+
+	priceAxisRendererOptions(): Readonly<PriceAxisViewRendererOptions>;
 }
 
 export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase {
@@ -384,9 +399,9 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 
 	private readonly _timeScale: TimeScale<HorzScaleItem>;
 	private readonly _panes: Pane<HorzScaleItem>[] = [];
-	private readonly _crosshair: Crosshair<HorzScaleItem>;
-	private readonly _magnet: Magnet<HorzScaleItem>;
-	private readonly _watermark: Watermark<HorzScaleItem>;
+	private readonly _crosshair: Crosshair;
+	private readonly _magnet: Magnet;
+	private readonly _watermark: Watermark;
 
 	private _serieses: Series<SeriesType, HorzScaleItem>[] = [];
 
@@ -527,11 +542,11 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return this._panes;
 	}
 
-	public watermarkSource(): Watermark<HorzScaleItem> {
+	public watermarkSource(): Watermark {
 		return this._watermark;
 	}
 
-	public crosshairSource(): Crosshair<HorzScaleItem> {
+	public crosshairSource(): Crosshair {
 		return this._crosshair;
 	}
 
@@ -679,7 +694,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return this._serieses;
 	}
 
-	public setAndSaveCurrentPosition(x: Coordinate, y: Coordinate, event: TouchMouseEventData | null, pane: Pane<HorzScaleItem>): void {
+	public setAndSaveCurrentPosition(x: Coordinate, y: Coordinate, event: TouchMouseEventData | null, pane: IPaneBase): void {
 		this._crosshair.saveOriginCoord(x, y);
 		let price = NaN;
 		let index = this._timeScale.coordinateToIndex(x);
diff --git a/src/model/crosshair.ts b/src/model/crosshair.ts
index bd4666dc01..fbed3b5faf 100644
--- a/src/model/crosshair.ts
+++ b/src/model/crosshair.ts
@@ -12,13 +12,13 @@ import { CrosshairTimeAxisView } from '../views/time-axis/crosshair-time-axis-vi
 import { ITimeAxisView } from '../views/time-axis/itime-axis-view';
 
 import { BarPrice } from './bar';
-import { ChartModel } from './chart-model';
+import { IChartModelBase } from './chart-model';
 import { Coordinate } from './coordinate';
 import { DataSource } from './data-source';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
-import { Pane } from './pane';
+import { IPaneBase } from './pane';
 import { PriceScale } from './price-scale';
-import { Series } from './series';
+import { ISeries } from './series';
 import { SeriesType } from './series-options';
 import { TimePointIndex } from './time-data';
 
@@ -124,19 +124,19 @@ type RawPriceProvider = () => BarPrice;
 type RawCoordinateProvider = () => Coordinate;
 type RawIndexProvider = () => TimePointIndex;
 
-export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
-	private _pane: Pane<HorzScaleItem> | null = null;
+export class Crosshair extends DataSource {
+	private _pane: IPaneBase | null = null;
 	private _price: number = NaN;
 	private _index: TimePointIndex = 0 as TimePointIndex;
 	private _visible: boolean = true;
-	private readonly _model: ChartModel<HorzScaleItem>;
-	private _priceAxisViews: Map<PriceScale, CrosshairPriceAxisView<HorzScaleItem>> = new Map();
-	private readonly _timeAxisView: CrosshairTimeAxisView<HorzScaleItem>;
-	private readonly _markersPaneView: CrosshairMarksPaneView<HorzScaleItem>;
+	private readonly _model: IChartModelBase;
+	private _priceAxisViews: Map<PriceScale, CrosshairPriceAxisView> = new Map();
+	private readonly _timeAxisView: CrosshairTimeAxisView;
+	private readonly _markersPaneView: CrosshairMarksPaneView;
 	private _subscribed: boolean = false;
 	private readonly _currentPosPriceProvider: PriceAndCoordinateProvider;
 	private readonly _options: CrosshairOptions;
-	private readonly _paneView: CrosshairPaneView<HorzScaleItem>;
+	private readonly _paneView: CrosshairPaneView;
 
 	private _x: Coordinate = NaN as Coordinate;
 	private _y: Coordinate = NaN as Coordinate;
@@ -144,7 +144,7 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 	private _originX: Coordinate = NaN as Coordinate;
 	private _originY: Coordinate = NaN as Coordinate;
 
-	public constructor(model: ChartModel<HorzScaleItem>, options: CrosshairOptions) {
+	public constructor(model: IChartModelBase, options: CrosshairOptions) {
 		super();
 		this._model = model;
 		this._options = options;
@@ -217,7 +217,7 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		return this._originY;
 	}
 
-	public setPosition(index: TimePointIndex, price: number, pane: Pane<HorzScaleItem>): void {
+	public setPosition(index: TimePointIndex, price: number, pane: IPaneBase): void {
 		if (!this._subscribed) {
 			this._subscribed = true;
 		}
@@ -255,11 +255,11 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		this.clearOriginCoord();
 	}
 
-	public paneViews(pane: Pane<HorzScaleItem>): readonly IPaneView[] {
+	public paneViews(pane: IPaneBase): readonly IPaneView[] {
 		return this._pane !== null ? [this._paneView, this._markersPaneView] : [];
 	}
 
-	public horzLineVisible(pane: Pane<HorzScaleItem>): boolean {
+	public horzLineVisible(pane: IPaneBase): boolean {
 		return pane === this._pane && this._options.horzLine.visible;
 	}
 
@@ -267,7 +267,7 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		return this._options.vertLine.visible;
 	}
 
-	public override priceAxisViews(pane: Pane<HorzScaleItem>, priceScale: PriceScale): IPriceAxisView[] {
+	public override priceAxisViews(pane: IPaneBase, priceScale: PriceScale): IPriceAxisView[] {
 		if (!this._visible || this._pane !== pane) {
 			this._priceAxisViews.clear();
 		}
@@ -284,18 +284,18 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		return this._visible ? [this._timeAxisView] : [];
 	}
 
-	public pane(): Pane<HorzScaleItem> | null {
+	public pane(): IPaneBase | null {
 		return this._pane;
 	}
 
 	public updateAllViews(): void {
 		this._paneView.update();
-		this._priceAxisViews.forEach((value: PriceAxisView<HorzScaleItem>) => value.update());
+		this._priceAxisViews.forEach((value: PriceAxisView) => value.update());
 		this._timeAxisView.update();
 		this._markersPaneView.update();
 	}
 
-	private _priceScaleByPane(pane: Pane<HorzScaleItem>): PriceScale | null {
+	private _priceScaleByPane(pane: IPaneBase): PriceScale | null {
 		if (pane && !pane.defaultPriceScale().isEmpty()) {
 			return pane.defaultPriceScale();
 		}
@@ -303,13 +303,13 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 		return null;
 	}
 
-	private _tryToUpdateViews(index: TimePointIndex, price: number, pane: Pane<HorzScaleItem>): void {
+	private _tryToUpdateViews(index: TimePointIndex, price: number, pane: IPaneBase): void {
 		if (this._tryToUpdateData(index, price, pane)) {
 			this.updateAllViews();
 		}
 	}
 
-	private _tryToUpdateData(newIndex: TimePointIndex, newPrice: number, newPane: Pane<HorzScaleItem>): boolean {
+	private _tryToUpdateData(newIndex: TimePointIndex, newPrice: number, newPane: IPaneBase): boolean {
 		const oldX = this._x;
 		const oldY = this._y;
 		const oldPrice = this._price;
@@ -336,13 +336,13 @@ export class Crosshair<HorzScaleItem> extends DataSource<HorzScaleItem> {
 
 	private _setIndexToLastSeriesBarIndex(): void {
 		const lastIndexes = this._model.serieses()
-			.map((s: Series<SeriesType, HorzScaleItem>) => s.bars().lastIndex())
+			.map((s: ISeries<SeriesType>) => s.bars().lastIndex())
 			.filter(notNull);
 		const lastBarIndex = (lastIndexes.length === 0) ? null : (Math.max(...lastIndexes) as TimePointIndex);
 		this._index = lastBarIndex !== null ? lastBarIndex : NaN as TimePointIndex;
 	}
 
-	private _createPriceAxisViewOnDemand(map: Map<PriceScale, CrosshairPriceAxisView<HorzScaleItem>>, priceScale: PriceScale, valueProvider: PriceAndCoordinateProvider): IPriceAxisView {
+	private _createPriceAxisViewOnDemand(map: Map<PriceScale, CrosshairPriceAxisView>, priceScale: PriceScale, valueProvider: PriceAndCoordinateProvider): IPriceAxisView {
 		let view = map.get(priceScale);
 
 		if (view === undefined) {
diff --git a/src/model/custom-price-line.ts b/src/model/custom-price-line.ts
index 56cedb651f..3fec202946 100644
--- a/src/model/custom-price-line.ts
+++ b/src/model/custom-price-line.ts
@@ -8,17 +8,17 @@ import { IPriceAxisView } from '../views/price-axis/iprice-axis-view';
 
 import { Coordinate } from './coordinate';
 import { PriceLineOptions } from './price-line-options';
-import { Series } from './series';
+import { ISeries } from './series';
 import { SeriesType } from './series-options';
 
-export class CustomPriceLine<HorzScaleItem> {
-	private readonly _series: Series<SeriesType, HorzScaleItem>;
-	private readonly _priceLineView: CustomPriceLinePaneView<HorzScaleItem>;
-	private readonly _priceAxisView: CustomPriceLinePriceAxisView<HorzScaleItem>;
-	private readonly _panePriceAxisView: PanePriceAxisView<HorzScaleItem>;
+export class CustomPriceLine {
+	private readonly _series: ISeries<SeriesType>;
+	private readonly _priceLineView: CustomPriceLinePaneView;
+	private readonly _priceAxisView: CustomPriceLinePriceAxisView;
+	private readonly _panePriceAxisView: PanePriceAxisView;
 	private readonly _options: PriceLineOptions;
 
-	public constructor(series: Series<SeriesType, HorzScaleItem>, options: PriceLineOptions) {
+	public constructor(series: ISeries<SeriesType>, options: PriceLineOptions) {
 		this._series = series;
 		this._options = options;
 		this._priceLineView = new CustomPriceLinePaneView(series, this);
diff --git a/src/model/data-source.ts b/src/model/data-source.ts
index 5df5a94aba..c0c9f0e51b 100644
--- a/src/model/data-source.ts
+++ b/src/model/data-source.ts
@@ -3,10 +3,10 @@ import { IPriceAxisView } from '../views/price-axis/iprice-axis-view';
 import { ITimeAxisView } from '../views/time-axis/itime-axis-view';
 
 import { IDataSource } from './idata-source';
-import { IPaneBase, Pane } from './pane';
+import { IPaneBase } from './pane';
 import { PriceScale } from './price-scale';
 
-export abstract class DataSource<HorzScaleItem> implements IDataSource {
+export abstract class DataSource implements IDataSource {
 	protected _priceScale: PriceScale | null = null;
 
 	private _zorder: number = 0;
@@ -27,7 +27,7 @@ export abstract class DataSource<HorzScaleItem> implements IDataSource {
 		this._priceScale = priceScale;
 	}
 
-	public abstract priceAxisViews(pane?: Pane<HorzScaleItem>, priceScale?: PriceScale): readonly IPriceAxisView[];
+	public abstract priceAxisViews(pane?: IPaneBase, priceScale?: PriceScale): readonly IPriceAxisView[];
 	public abstract paneViews(pane?: IPaneBase): readonly IPaneView[];
 
 	public labelPaneViews(pane?: IPaneBase): readonly IPaneView[] {
diff --git a/src/model/magnet.ts b/src/model/magnet.ts
index 6dfceb528c..46960a2466 100644
--- a/src/model/magnet.ts
+++ b/src/model/magnet.ts
@@ -3,20 +3,20 @@ import { ensure } from '../helpers/assertions';
 import { Coordinate } from './coordinate';
 import { CrosshairMode, CrosshairOptions } from './crosshair';
 import { IPriceDataSource } from './iprice-data-source';
-import { Pane } from './pane';
+import { IPaneBase } from './pane';
 import { PlotRowValueIndex } from './plot-data';
-import { Series } from './series';
+import { ISeries, Series } from './series';
 import { SeriesType } from './series-options';
 import { TimePointIndex } from './time-data';
 
-export class Magnet<HorzScaleItem> {
+export class Magnet {
 	private readonly _options: CrosshairOptions;
 
 	public constructor(options: CrosshairOptions) {
 		this._options = options;
 	}
 
-	public align(price: number, index: TimePointIndex, pane: Pane<HorzScaleItem>): number {
+	public align(price: number, index: TimePointIndex, pane: IPaneBase): number {
 		let res = price;
 		if (this._options.mode === CrosshairMode.Normal) {
 			return res;
@@ -32,11 +32,11 @@ export class Magnet<HorzScaleItem> {
 		const y = defaultPriceScale.priceToCoordinate(price, firstValue);
 
 		// get all serieses from the pane
-		const serieses: readonly Series<SeriesType, HorzScaleItem>[] = pane.dataSources().filter(
-			((ds: IPriceDataSource) => (ds instanceof Series<SeriesType, HorzScaleItem>)) as (ds: IPriceDataSource) => ds is Series<SeriesType, HorzScaleItem>);
+		const serieses: readonly ISeries<SeriesType>[] = pane.dataSources().filter(
+			((ds: IPriceDataSource) => (ds instanceof Series<SeriesType, unknown>)) as (ds: IPriceDataSource) => ds is Series<SeriesType, unknown>);
 
 		const candidates = serieses.reduce(
-			(acc: Coordinate[], series: Series<SeriesType, HorzScaleItem>) => {
+			(acc: Coordinate[], series: ISeries<SeriesType>) => {
 				if (pane.isOverlay(series) || !series.visible()) {
 					return acc;
 				}
diff --git a/src/model/pane.ts b/src/model/pane.ts
index 6b350ef094..ab2fdc973b 100644
--- a/src/model/pane.ts
+++ b/src/model/pane.ts
@@ -25,6 +25,10 @@ export interface IPaneBase {
 	addDataSource(source: IPriceDataSource, targetScaleId: string, zOrder?: number): void;
 	model(): IChartModelBase;
 	defaultPriceScale(): PriceScale;
+	defaultVisiblePriceScale(): PriceScale | null;
+	dataSources(): readonly IPriceDataSource[];
+	isOverlay(source: IPriceDataSource): boolean;
+	priceScalePosition(priceScale: PriceScale): PriceScalePosition;
 }
 
 export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
diff --git a/src/model/price-data-source.ts b/src/model/price-data-source.ts
index 1943a58725..08c73e3442 100644
--- a/src/model/price-data-source.ts
+++ b/src/model/price-data-source.ts
@@ -1,20 +1,20 @@
 import { IPriceFormatter } from '../formatters/iprice-formatter';
 
 import { AutoscaleInfoImpl } from './autoscale-info-impl';
-import { ChartModel } from './chart-model';
+import { IChartModelBase } from './chart-model';
 import { DataSource } from './data-source';
 import { FirstValue, IPriceDataSource } from './iprice-data-source';
 import { TimePointIndex } from './time-data';
 
-export abstract class PriceDataSource<HorzScaleItem> extends DataSource<HorzScaleItem> implements IPriceDataSource {
-	private readonly _model: ChartModel<HorzScaleItem>;
+export abstract class PriceDataSource extends DataSource implements IPriceDataSource {
+	private readonly _model: IChartModelBase;
 
-	public constructor(model: ChartModel<HorzScaleItem>) {
+	public constructor(model: IChartModelBase) {
 		super();
 		this._model = model;
 	}
 
-	public model(): ChartModel<HorzScaleItem> {
+	public model(): IChartModelBase {
 		return this._model;
 	}
 
diff --git a/src/model/series-bar-colorer.ts b/src/model/series-bar-colorer.ts
index e2ae8c4d14..9f53db857c 100644
--- a/src/model/series-bar-colorer.ts
+++ b/src/model/series-bar-colorer.ts
@@ -85,7 +85,11 @@ type BarStylesFnMap<HorzScaleItem> = {
 	[T in keyof SeriesOptionsMap]: StyleGetterFn<T, HorzScaleItem>;
 };
 
-export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> {
+export interface ISeriesBarColorer<T extends SeriesType> {
+	barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<unknown>): BarStylesMap[T];
+}
+
+export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements ISeriesBarColorer<T> {
 	private _series: Series<T, HorzScaleItem>;
 	private readonly _styleGetter: BarStylesFnMap<HorzScaleItem>[T];
 	private readonly _barStyleFnMap: BarStylesFnMap<HorzScaleItem>;
diff --git a/src/model/series.ts b/src/model/series.ts
index d477bd6730..4d49df9b34 100644
--- a/src/model/series.ts
+++ b/src/model/series.ts
@@ -30,7 +30,7 @@ import { Coordinate } from './coordinate';
 import { CustomPriceLine } from './custom-price-line';
 import { isDefaultPriceScale } from './default-price-scale';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
-import { FirstValue } from './iprice-data-source';
+import { FirstValue, IPriceDataSource } from './iprice-data-source';
 import { Pane } from './pane';
 import { PlotRowValueIndex } from './plot-data';
 import { MismatchDirection } from './plot-list';
@@ -38,7 +38,7 @@ import { PriceDataSource } from './price-data-source';
 import { PriceLineOptions } from './price-line-options';
 import { PriceRangeImpl } from './price-range-impl';
 import { PriceScale } from './price-scale';
-import { SeriesBarColorer } from './series-bar-colorer';
+import { ISeriesBarColorer, SeriesBarColorer } from './series-bar-colorer';
 import { createSeriesPlotList, SeriesPlotList, SeriesPlotRow } from './series-data';
 import { InternalSeriesMarker, SeriesMarker } from './series-markers';
 import {
@@ -95,22 +95,35 @@ export interface SeriesUpdateInfo {
 export type SeriesOptionsInternal<T extends SeriesType = SeriesType> = SeriesOptionsMap[T];
 export type SeriesPartialOptionsInternal<T extends SeriesType = SeriesType> = SeriesPartialOptionsMap[T];
 
-export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource<HorzScaleItem> implements IDestroyable {
+export interface ISeries<T extends SeriesType> extends IPriceDataSource {
+	bars(): SeriesPlotList<T, unknown>;
+	visible(): boolean;
+	options(): Readonly<SeriesOptionsMap[T]>;
+	title(): string;
+	priceScale(): PriceScale;
+	lastValueData(globalLast: boolean): LastValueDataResult;
+	indexedMarkers(): InternalSeriesMarker<TimePointIndex, unknown>[];
+	barColorer(): ISeriesBarColorer<T>;
+	markerDataAtIndex(index: TimePointIndex): MarkerData | null;
+	dataAt(time: TimePointIndex): SeriesDataAtTypeMap[SeriesType] | null;
+}
+
+export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource implements IDestroyable, ISeries<SeriesType> {
 	private readonly _seriesType: T;
 	private _data: SeriesPlotList<T, HorzScaleItem> = createSeriesPlotList<T, HorzScaleItem>();
 	private readonly _priceAxisViews: IPriceAxisView[];
-	private readonly _panePriceAxisView: PanePriceAxisView<HorzScaleItem>;
+	private readonly _panePriceAxisView: PanePriceAxisView;
 	private _formatter!: IPriceFormatter;
-	private readonly _priceLineView: SeriesPriceLinePaneView<HorzScaleItem> = new SeriesPriceLinePaneView(this);
-	private readonly _customPriceLines: CustomPriceLine<HorzScaleItem>[] = [];
-	private readonly _baseHorizontalLineView: SeriesHorizontalBaseLinePaneView<HorzScaleItem> = new SeriesHorizontalBaseLinePaneView(this);
+	private readonly _priceLineView: SeriesPriceLinePaneView = new SeriesPriceLinePaneView(this);
+	private readonly _customPriceLines: CustomPriceLine[] = [];
+	private readonly _baseHorizontalLineView: SeriesHorizontalBaseLinePaneView = new SeriesHorizontalBaseLinePaneView(this);
 	private _paneView!: IUpdatablePaneView;
-	private readonly _lastPriceAnimationPaneView: SeriesLastPriceAnimationPaneView<HorzScaleItem> | null = null;
+	private readonly _lastPriceAnimationPaneView: SeriesLastPriceAnimationPaneView | null = null;
 	private _barColorerCache: SeriesBarColorer<T, HorzScaleItem> | null = null;
 	private readonly _options: SeriesOptionsInternal<T>;
 	private _markers: readonly SeriesMarker<InternalHorzScaleItem, HorzScaleItem>[] = [];
 	private _indexedMarkers: InternalSeriesMarker<TimePointIndex, HorzScaleItem>[] = [];
-	private _markersPaneView!: SeriesMarkersPaneView<HorzScaleItem>;
+	private _markersPaneView!: SeriesMarkersPaneView;
 	private _animationTimeoutId: TimerId | null = null;
 
 	public constructor(model: ChartModel<HorzScaleItem>, options: SeriesOptionsInternal<T>, seriesType: T) {
@@ -281,14 +294,14 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		return this._indexedMarkers;
 	}
 
-	public createPriceLine(options: PriceLineOptions): CustomPriceLine<HorzScaleItem> {
-		const result = new CustomPriceLine<HorzScaleItem>(this, options);
+	public createPriceLine(options: PriceLineOptions): CustomPriceLine {
+		const result = new CustomPriceLine(this, options);
 		this._customPriceLines.push(result);
 		this.model().updateSource(this);
 		return result;
 	}
 
-	public removePriceLine(line: CustomPriceLine<HorzScaleItem>): void {
+	public removePriceLine(line: CustomPriceLine): void {
 		const index = this._customPriceLines.indexOf(line);
 		if (index !== -1) {
 			this._customPriceLines.splice(index, 1);
@@ -376,7 +389,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 			this._markersPaneView
 		);
 
-		const priceLineViews = this._customPriceLines.map((line: CustomPriceLine<HorzScaleItem>) => line.paneView());
+		const priceLineViews = this._customPriceLines.map((line: CustomPriceLine) => line.paneView());
 		res.push(...priceLineViews);
 
 		return res;
@@ -385,7 +398,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 	public override labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[] {
 		return [
 			this._panePriceAxisView,
-			...this._customPriceLines.map((line: CustomPriceLine<HorzScaleItem>) => line.labelPaneView()),
+			...this._customPriceLines.map((line: CustomPriceLine) => line.labelPaneView()),
 		];
 	}
 
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index 4e1b1ee6b2..84f0c30054 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -167,6 +167,20 @@ export interface HorzScaleOptions {
 
 export interface ITimeScale {
 	marks(): TimeMark[] | null;
+	isEmpty(): boolean;
+	width(): number;
+	indexToTime(index: TimePointIndex): InternalHorzScaleItem | null;
+	indexToCoordinate(index: TimePointIndex): Coordinate;
+	visibleStrictRange(): RangeImpl<TimePointIndex> | null;
+	hasPoints(): boolean;
+	timeToIndex(time: InternalHorzScaleItem, findNearest: boolean): TimePointIndex | null;
+	barSpacing(): number;
+
+	indexesToCoordinates<T extends TimedValue>(points: T[], visibleRange?: SeriesItemsIndexesRange): void;
+	indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint<unknown> | null;
+	formatDateTime(timeScalePoint: TimeScalePoint<unknown>): string;
+
+	options(): Readonly<HorzScaleOptions>;
 }
 
 export class TimeScale<HorzScaleItem> implements ITimeScale {
diff --git a/src/model/watermark.ts b/src/model/watermark.ts
index b7d3692b91..0cb88ca98e 100644
--- a/src/model/watermark.ts
+++ b/src/model/watermark.ts
@@ -3,7 +3,7 @@ import { IPaneView } from '../views/pane/ipane-view';
 import { WatermarkPaneView } from '../views/pane/watermark-pane-view';
 import { IPriceAxisView } from '../views/price-axis/iprice-axis-view';
 
-import { ChartModel } from './chart-model';
+import { IChartModelBase } from './chart-model';
 import { DataSource } from './data-source';
 
 /** Watermark options. */
@@ -65,11 +65,11 @@ export interface WatermarkOptions {
 	vertAlign: VertAlign;
 }
 
-export class Watermark<HorzScaleItem> extends DataSource<HorzScaleItem> {
-	private readonly _paneView: WatermarkPaneView<HorzScaleItem>;
+export class Watermark extends DataSource {
+	private readonly _paneView: WatermarkPaneView;
 	private readonly _options: WatermarkOptions;
 
-	public constructor(model: ChartModel<HorzScaleItem>, options: WatermarkOptions) {
+	public constructor(model: IChartModelBase, options: WatermarkOptions) {
 		super();
 		this._options = options;
 		this._paneView = new WatermarkPaneView(this);
diff --git a/src/views/pane/area-pane-view.ts b/src/views/pane/area-pane-view.ts
index 11ef7fdff2..43b9a24b67 100644
--- a/src/views/pane/area-pane-view.ts
+++ b/src/views/pane/area-pane-view.ts
@@ -1,7 +1,7 @@
 import { BarPrice } from '../../model/bar';
-import { ChartModel } from '../../model/chart-model';
-import { Series } from '../../model/series';
-import { SeriesBarColorer } from '../../model/series-bar-colorer';
+import { IChartModelBase } from '../../model/chart-model';
+import { ISeries } from '../../model/series';
+import { ISeriesBarColorer } from '../../model/series-bar-colorer';
 import { TimePointIndex } from '../../model/time-data';
 import { AreaFillItem, PaneRendererArea } from '../../renderers/area-renderer';
 import { CompositeRenderer } from '../../renderers/composite-renderer';
@@ -9,17 +9,17 @@ import { LineStrokeItem, PaneRendererLine } from '../../renderers/line-renderer'
 
 import { LinePaneViewBase } from './line-pane-view-base';
 
-export class SeriesAreaPaneView<HorzScaleItem> extends LinePaneViewBase<'Area', AreaFillItem & LineStrokeItem, CompositeRenderer, HorzScaleItem> {
+export class SeriesAreaPaneView extends LinePaneViewBase<'Area', AreaFillItem & LineStrokeItem, CompositeRenderer> {
 	protected readonly _renderer: CompositeRenderer = new CompositeRenderer();
 	private readonly _areaRenderer: PaneRendererArea = new PaneRendererArea();
 	private readonly _lineRenderer: PaneRendererLine = new PaneRendererLine();
 
-	public constructor(series: Series<'Area', HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
+	public constructor(series: ISeries<'Area'>, model: IChartModelBase) {
 		super(series, model);
 		this._renderer.setRenderers([this._areaRenderer, this._lineRenderer]);
 	}
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Area', HorzScaleItem>): AreaFillItem & LineStrokeItem {
+	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: ISeriesBarColorer<'Area'>): AreaFillItem & LineStrokeItem {
 		return {
 			...this._createRawItemBase(time, price),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/bars-pane-view-base.ts b/src/views/pane/bars-pane-view-base.ts
index 3547eb577a..9645dd6a01 100644
--- a/src/views/pane/bars-pane-view-base.ts
+++ b/src/views/pane/bars-pane-view-base.ts
@@ -1,33 +1,33 @@
 import { undefinedIfNull } from '../../helpers/strict-type-checks';
 
 import { BarPrice } from '../../model/bar';
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { Coordinate } from '../../model/coordinate';
 import { PlotRowValueIndex } from '../../model/plot-data';
 import { PriceScale } from '../../model/price-scale';
-import { Series } from '../../model/series';
-import { SeriesBarColorer } from '../../model/series-bar-colorer';
+import { ISeries } from '../../model/series';
+import { ISeriesBarColorer } from '../../model/series-bar-colorer';
 import { SeriesPlotRow } from '../../model/series-data';
 import { TimePointIndex } from '../../model/time-data';
-import { TimeScale } from '../../model/time-scale';
+import { ITimeScale } from '../../model/time-scale';
 import { BarCandlestickItemBase } from '../../renderers/bars-renderer';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { SeriesPaneViewBase } from './series-pane-view-base';
 
-export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick', ItemType extends BarCandlestickItemBase, TRenderer extends IPaneRenderer, HorzScaleItem> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer, HorzScaleItem> {
-	public constructor(series: Series<TSeriesType, HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
+export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick', ItemType extends BarCandlestickItemBase, TRenderer extends IPaneRenderer> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer> {
+	public constructor(series: ISeries<TSeriesType>, model: IChartModelBase) {
 		super(series, model, false);
 	}
 
-	protected _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void {
+	protected _convertToCoordinates(priceScale: PriceScale, timeScale: ITimeScale, firstValue: number): void {
 		timeScale.indexesToCoordinates(this._items, undefinedIfNull(this._itemsVisibleRange));
 		priceScale.barPricesToCoordinates(this._items, firstValue, undefinedIfNull(this._itemsVisibleRange));
 	}
 
-	protected abstract _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType, HorzScaleItem>, colorer: SeriesBarColorer<TSeriesType, HorzScaleItem>): ItemType;
+	protected abstract _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType, unknown>, colorer: ISeriesBarColorer<TSeriesType>): ItemType;
 
-	protected _createDefaultItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType, HorzScaleItem>, colorer: SeriesBarColorer<TSeriesType, HorzScaleItem>): BarCandlestickItemBase {
+	protected _createDefaultItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType, unknown>, colorer: ISeriesBarColorer<TSeriesType>): BarCandlestickItemBase {
 		return {
 			time: time,
 			open: bar.value[PlotRowValueIndex.Open] as BarPrice,
@@ -45,6 +45,6 @@ export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick'
 	protected _fillRawPoints(): void {
 		const colorer = this._series.barColorer();
 
-		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType, HorzScaleItem>) => this._createRawItem(row.index, row, colorer));
+		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType, unknown>) => this._createRawItem(row.index, row, colorer));
 	}
 }
diff --git a/src/views/pane/bars-pane-view.ts b/src/views/pane/bars-pane-view.ts
index 31b4793aba..37f85cfebb 100644
--- a/src/views/pane/bars-pane-view.ts
+++ b/src/views/pane/bars-pane-view.ts
@@ -9,10 +9,10 @@ import {
 
 import { BarsPaneViewBase } from './bars-pane-view-base';
 
-export class SeriesBarsPaneView<HorzScaleItem> extends BarsPaneViewBase<'Bar', BarItem, PaneRendererBars, HorzScaleItem> {
+export class SeriesBarsPaneView extends BarsPaneViewBase<'Bar', BarItem, PaneRendererBars> {
 	protected readonly _renderer: PaneRendererBars = new PaneRendererBars();
 
-	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<SeriesType, HorzScaleItem>, colorer: SeriesBarColorer<'Bar', HorzScaleItem>): BarItem {
+	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<SeriesType, unknown>, colorer: SeriesBarColorer<'Bar', unknown>): BarItem {
 		return {
 			...this._createDefaultItem(time, bar, colorer),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/baseline-pane-view.ts b/src/views/pane/baseline-pane-view.ts
index 03aaaa286e..7f29963a7a 100644
--- a/src/views/pane/baseline-pane-view.ts
+++ b/src/views/pane/baseline-pane-view.ts
@@ -1,7 +1,7 @@
 import { BarPrice } from '../../model/bar';
-import { ChartModel } from '../../model/chart-model';
-import { Series } from '../../model/series';
-import { SeriesBarColorer } from '../../model/series-bar-colorer';
+import { IChartModelBase } from '../../model/chart-model';
+import { ISeries } from '../../model/series';
+import { ISeriesBarColorer } from '../../model/series-bar-colorer';
 import { TimePointIndex } from '../../model/time-data';
 import { BaselineFillItem, PaneRendererBaselineArea } from '../../renderers/baseline-renderer-area';
 import { BaselineStrokeItem, PaneRendererBaselineLine } from '../../renderers/baseline-renderer-line';
@@ -9,17 +9,17 @@ import { CompositeRenderer } from '../../renderers/composite-renderer';
 
 import { LinePaneViewBase } from './line-pane-view-base';
 
-export class SeriesBaselinePaneView<HorzScaleItem> extends LinePaneViewBase<'Baseline', BaselineFillItem & BaselineStrokeItem, CompositeRenderer, HorzScaleItem> {
+export class SeriesBaselinePaneView extends LinePaneViewBase<'Baseline', BaselineFillItem & BaselineStrokeItem, CompositeRenderer> {
 	protected readonly _renderer: CompositeRenderer = new CompositeRenderer();
 	private readonly _baselineAreaRenderer: PaneRendererBaselineArea = new PaneRendererBaselineArea();
 	private readonly _baselineLineRenderer: PaneRendererBaselineLine = new PaneRendererBaselineLine();
 
-	public constructor(series: Series<'Baseline', HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
+	public constructor(series: ISeries<'Baseline'>, model: IChartModelBase) {
 		super(series, model);
 		this._renderer.setRenderers([this._baselineAreaRenderer, this._baselineLineRenderer]);
 	}
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Baseline', HorzScaleItem>): BaselineFillItem & BaselineStrokeItem {
+	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: ISeriesBarColorer<'Baseline'>): BaselineFillItem & BaselineStrokeItem {
 		return {
 			...this._createRawItemBase(time, price),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/candlesticks-pane-view.ts b/src/views/pane/candlesticks-pane-view.ts
index d606ac3f98..12c52cf721 100644
--- a/src/views/pane/candlesticks-pane-view.ts
+++ b/src/views/pane/candlesticks-pane-view.ts
@@ -8,10 +8,10 @@ import {
 
 import { BarsPaneViewBase } from './bars-pane-view-base';
 
-export class SeriesCandlesticksPaneView<HorzScaleItem> extends BarsPaneViewBase<'Candlestick', CandlestickItem, PaneRendererCandlesticks, HorzScaleItem> {
+export class SeriesCandlesticksPaneView extends BarsPaneViewBase<'Candlestick', CandlestickItem, PaneRendererCandlesticks> {
 	protected readonly _renderer: PaneRendererCandlesticks = new PaneRendererCandlesticks();
 
-	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<'Candlestick', HorzScaleItem>, colorer: SeriesBarColorer<'Candlestick', HorzScaleItem>): CandlestickItem {
+	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<'Candlestick', unknown>, colorer: SeriesBarColorer<'Candlestick', unknown>): CandlestickItem {
 		return {
 			...this._createDefaultItem(time, bar, colorer),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/crosshair-marks-pane-view.ts b/src/views/pane/crosshair-marks-pane-view.ts
index 63ce5397a7..63bc43b250 100644
--- a/src/views/pane/crosshair-marks-pane-view.ts
+++ b/src/views/pane/crosshair-marks-pane-view.ts
@@ -1,10 +1,10 @@
 import { ensureNotNull } from '../../helpers/assertions';
 
 import { BarPrice } from '../../model/bar';
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { Coordinate } from '../../model/coordinate';
 import { Crosshair } from '../../model/crosshair';
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { SeriesType } from '../../model/series-options';
 import { SeriesItemsIndexesRange, TimePointIndex } from '../../model/time-data';
 import { CompositeRenderer } from '../../renderers/composite-renderer';
@@ -31,15 +31,15 @@ function createEmptyMarkerData(): MarksRendererData {
 
 const rangeForSinglePoint: SeriesItemsIndexesRange = { from: 0, to: 1 };
 
-export class CrosshairMarksPaneView<HorzScaleItem> implements IUpdatablePaneView {
-	private readonly _chartModel: ChartModel<HorzScaleItem>;
-	private readonly _crosshair: Crosshair<HorzScaleItem>;
+export class CrosshairMarksPaneView implements IUpdatablePaneView {
+	private readonly _chartModel: IChartModelBase;
+	private readonly _crosshair: Crosshair;
 	private readonly _compositeRenderer: CompositeRenderer = new CompositeRenderer();
 	private _markersRenderers: PaneRendererMarks[] = [];
 	private _markersData: MarksRendererData[] = [];
 	private _invalidated: boolean = true;
 
-	public constructor(chartModel: ChartModel<HorzScaleItem>, crosshair: Crosshair<HorzScaleItem>) {
+	public constructor(chartModel: IChartModelBase, crosshair: Crosshair) {
 		this._chartModel = chartModel;
 		this._crosshair = crosshair;
 		this._compositeRenderer.setRenderers(this._markersRenderers);
@@ -74,7 +74,7 @@ export class CrosshairMarksPaneView<HorzScaleItem> implements IUpdatablePaneView
 		const timePointIndex = this._crosshair.appliedIndex();
 		const timeScale = this._chartModel.timeScale();
 
-		serieses.forEach((s: Series<SeriesType, HorzScaleItem>, index: number) => {
+		serieses.forEach((s: ISeries<SeriesType>, index: number) => {
 			const data = this._markersData[index];
 			const seriesData = s.markerDataAtIndex(timePointIndex);
 
diff --git a/src/views/pane/crosshair-pane-view.ts b/src/views/pane/crosshair-pane-view.ts
index 283680473a..bb96748fe4 100644
--- a/src/views/pane/crosshair-pane-view.ts
+++ b/src/views/pane/crosshair-pane-view.ts
@@ -6,9 +6,9 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IPaneView } from './ipane-view';
 
-export class CrosshairPaneView<HorzScaleItem> implements IPaneView {
+export class CrosshairPaneView implements IPaneView {
 	private _invalidated: boolean = true;
-	private readonly _source: Crosshair<HorzScaleItem>;
+	private readonly _source: Crosshair;
 	private readonly _rendererData: CrosshairRendererData = {
 		vertLine: {
 			lineWidth: 1,
@@ -27,7 +27,7 @@ export class CrosshairPaneView<HorzScaleItem> implements IPaneView {
 	};
 	private _renderer: CrosshairRenderer = new CrosshairRenderer(this._rendererData);
 
-	public constructor(source: Crosshair<HorzScaleItem>) {
+	public constructor(source: Crosshair) {
 		this._source = source;
 	}
 
diff --git a/src/views/pane/custom-price-line-pane-view.ts b/src/views/pane/custom-price-line-pane-view.ts
index cab387fa5e..4b501ecd5a 100644
--- a/src/views/pane/custom-price-line-pane-view.ts
+++ b/src/views/pane/custom-price-line-pane-view.ts
@@ -1,13 +1,13 @@
 import { CustomPriceLine } from '../../model/custom-price-line';
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { SeriesType } from '../../model/series-options';
 
 import { SeriesHorizontalLinePaneView } from './series-horizontal-line-pane-view';
 
-export class CustomPriceLinePaneView<HorzScaleItem> extends SeriesHorizontalLinePaneView<HorzScaleItem> {
-	private readonly _priceLine: CustomPriceLine<HorzScaleItem>;
+export class CustomPriceLinePaneView extends SeriesHorizontalLinePaneView {
+	private readonly _priceLine: CustomPriceLine;
 
-	public constructor(series: Series<SeriesType, HorzScaleItem>, priceLine: CustomPriceLine<HorzScaleItem>) {
+	public constructor(series: ISeries<SeriesType>, priceLine: CustomPriceLine) {
 		super(series);
 		this._priceLine = priceLine;
 	}
diff --git a/src/views/pane/histogram-pane-view.ts b/src/views/pane/histogram-pane-view.ts
index 605fc5d925..b6ea4336f3 100644
--- a/src/views/pane/histogram-pane-view.ts
+++ b/src/views/pane/histogram-pane-view.ts
@@ -1,16 +1,16 @@
 import { ensureNotNull } from '../../helpers/assertions';
 
 import { BarPrice } from '../../model/bar';
-import { SeriesBarColorer } from '../../model/series-bar-colorer';
+import { ISeriesBarColorer } from '../../model/series-bar-colorer';
 import { TimePointIndex } from '../../model/time-data';
 import { HistogramItem, PaneRendererHistogram, PaneRendererHistogramData } from '../../renderers/histogram-renderer';
 
 import { LinePaneViewBase } from './line-pane-view-base';
 
-export class SeriesHistogramPaneView<HorzScaleItem> extends LinePaneViewBase<'Histogram', HistogramItem, PaneRendererHistogram, HorzScaleItem> {
+export class SeriesHistogramPaneView extends LinePaneViewBase<'Histogram', HistogramItem, PaneRendererHistogram> {
 	protected readonly _renderer: PaneRendererHistogram = new PaneRendererHistogram();
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Histogram', HorzScaleItem>): HistogramItem {
+	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: ISeriesBarColorer<'Histogram'>): HistogramItem {
 		return {
 			...this._createRawItemBase(time, price),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/line-pane-view-base.ts b/src/views/pane/line-pane-view-base.ts
index 0cf967a9d8..51a8467ef0 100644
--- a/src/views/pane/line-pane-view-base.ts
+++ b/src/views/pane/line-pane-view-base.ts
@@ -1,15 +1,15 @@
 import { undefinedIfNull } from '../../helpers/strict-type-checks';
 
 import { BarPrice } from '../../model/bar';
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { Coordinate } from '../../model/coordinate';
 import { PlotRowValueIndex } from '../../model/plot-data';
 import { PricedValue, PriceScale } from '../../model/price-scale';
-import { Series } from '../../model/series';
-import { SeriesBarColorer } from '../../model/series-bar-colorer';
+import { ISeries } from '../../model/series';
+import { ISeriesBarColorer } from '../../model/series-bar-colorer';
 import { SeriesPlotRow } from '../../model/series-data';
 import { TimedValue, TimePointIndex } from '../../model/time-data';
-import { TimeScale } from '../../model/time-scale';
+import { ITimeScale } from '../../model/time-scale';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { SeriesPaneViewBase } from './series-pane-view-base';
@@ -17,19 +17,18 @@ import { SeriesPaneViewBase } from './series-pane-view-base';
 export abstract class LinePaneViewBase<
 	TSeriesType extends 'Line' | 'Area' | 'Baseline' | 'Histogram',
 	ItemType extends PricedValue & TimedValue,
-	TRenderer extends IPaneRenderer,
-	HorzScaleItem
-> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer, HorzScaleItem> {
-	public constructor(series: Series<TSeriesType, HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
+	TRenderer extends IPaneRenderer
+> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer> {
+	public constructor(series: ISeries<TSeriesType>, model: IChartModelBase) {
 		super(series, model, true);
 	}
 
-	protected _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void {
+	protected _convertToCoordinates(priceScale: PriceScale, timeScale: ITimeScale, firstValue: number): void {
 		timeScale.indexesToCoordinates(this._items, undefinedIfNull(this._itemsVisibleRange));
 		priceScale.pointsArrayToCoordinates(this._items, firstValue, undefinedIfNull(this._itemsVisibleRange));
 	}
 
-	protected abstract _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<TSeriesType, HorzScaleItem>): ItemType;
+	protected abstract _createRawItem(time: TimePointIndex, price: BarPrice, colorer: ISeriesBarColorer<TSeriesType>): ItemType;
 
 	protected _createRawItemBase(time: TimePointIndex, price: BarPrice): PricedValue & TimedValue {
 		return {
@@ -42,7 +41,7 @@ export abstract class LinePaneViewBase<
 
 	protected _fillRawPoints(): void {
 		const colorer = this._series.barColorer();
-		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType, HorzScaleItem>) => {
+		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType, unknown>) => {
 			const value = row.value[PlotRowValueIndex.Close] as BarPrice;
 			return this._createRawItem(row.index, value, colorer);
 		});
diff --git a/src/views/pane/line-pane-view.ts b/src/views/pane/line-pane-view.ts
index d4941dad7f..bda198258a 100644
--- a/src/views/pane/line-pane-view.ts
+++ b/src/views/pane/line-pane-view.ts
@@ -1,14 +1,14 @@
 import { BarPrice } from '../../model/bar';
-import { SeriesBarColorer } from '../../model/series-bar-colorer';
+import { ISeriesBarColorer } from '../../model/series-bar-colorer';
 import { TimePointIndex } from '../../model/time-data';
 import { LineStrokeItem, PaneRendererLine, PaneRendererLineData } from '../../renderers/line-renderer';
 
 import { LinePaneViewBase } from './line-pane-view-base';
 
-export class SeriesLinePaneView<HorzScaleItem> extends LinePaneViewBase<'Line', LineStrokeItem, PaneRendererLine, HorzScaleItem> {
+export class SeriesLinePaneView extends LinePaneViewBase<'Line', LineStrokeItem, PaneRendererLine> {
 	protected readonly _renderer: PaneRendererLine = new PaneRendererLine();
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Line', HorzScaleItem>): LineStrokeItem {
+	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: ISeriesBarColorer<'Line'>): LineStrokeItem {
 		return {
 			...this._createRawItemBase(time, price),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/pane-price-axis-view.ts b/src/views/pane/pane-price-axis-view.ts
index 74683954ca..bf2aa8ee6a 100644
--- a/src/views/pane/pane-price-axis-view.ts
+++ b/src/views/pane/pane-price-axis-view.ts
@@ -1,6 +1,6 @@
 import { CanvasRenderingTarget2D } from 'fancy-canvas';
 
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { IPriceDataSource } from '../../model/iprice-data-source';
 import { TextWidthCache } from '../../model/text-width-cache';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
@@ -38,15 +38,15 @@ class PanePriceAxisViewRenderer implements IPaneRenderer {
 	}
 }
 
-export class PanePriceAxisView<HorzScaleItem> implements IPaneView {
+export class PanePriceAxisView implements IPaneView {
 	private _priceAxisView: IPriceAxisView;
 	private readonly _textWidthCache: TextWidthCache;
 	private readonly _dataSource: IPriceDataSource;
-	private readonly _chartModel: ChartModel<HorzScaleItem>;
+	private readonly _chartModel: IChartModelBase;
 	private readonly _renderer: PanePriceAxisViewRenderer;
 	private _fontSize: number;
 
-	public constructor(priceAxisView: IPriceAxisView, dataSource: IPriceDataSource, chartModel: ChartModel<HorzScaleItem>) {
+	public constructor(priceAxisView: IPriceAxisView, dataSource: IPriceDataSource, chartModel: IChartModelBase) {
 		this._priceAxisView = priceAxisView;
 		this._textWidthCache = new TextWidthCache(50); // when should we clear cache?
 		this._dataSource = dataSource;
diff --git a/src/views/pane/series-horizontal-base-line-pane-view.ts b/src/views/pane/series-horizontal-base-line-pane-view.ts
index e5a1f78a9c..acc602daf0 100644
--- a/src/views/pane/series-horizontal-base-line-pane-view.ts
+++ b/src/views/pane/series-horizontal-base-line-pane-view.ts
@@ -1,12 +1,12 @@
 import { PriceScaleMode } from '../../model/price-scale';
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { SeriesType } from '../../model/series-options';
 
 import { SeriesHorizontalLinePaneView } from './series-horizontal-line-pane-view';
 
-export class SeriesHorizontalBaseLinePaneView<HorzScaleItem> extends SeriesHorizontalLinePaneView<HorzScaleItem> {
+export class SeriesHorizontalBaseLinePaneView extends SeriesHorizontalLinePaneView {
 	// eslint-disable-next-line no-useless-constructor
-	public constructor(series: Series<SeriesType, HorzScaleItem>) {
+	public constructor(series: ISeries<SeriesType>) {
 		super(series);
 	}
 
diff --git a/src/views/pane/series-horizontal-line-pane-view.ts b/src/views/pane/series-horizontal-line-pane-view.ts
index 8e6e12dfc9..8fe2e24564 100644
--- a/src/views/pane/series-horizontal-line-pane-view.ts
+++ b/src/views/pane/series-horizontal-line-pane-view.ts
@@ -1,6 +1,6 @@
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { Coordinate } from '../../model/coordinate';
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { SeriesType } from '../../model/series-options';
 import { LineStyle } from '../../renderers/draw-line';
 import { HorizontalLineRenderer, HorizontalLineRendererData } from '../../renderers/horizontal-line-renderer';
@@ -8,7 +8,7 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IPaneView } from './ipane-view';
 
-export abstract class SeriesHorizontalLinePaneView<HorzScaleItem> implements IPaneView {
+export abstract class SeriesHorizontalLinePaneView implements IPaneView {
 	protected readonly _lineRendererData: HorizontalLineRendererData = {
 		y: 0 as Coordinate,
 		color: 'rgba(0, 0, 0, 0)',
@@ -17,12 +17,12 @@ export abstract class SeriesHorizontalLinePaneView<HorzScaleItem> implements IPa
 		visible: false,
 	};
 
-	protected readonly _series: Series<SeriesType, HorzScaleItem>;
-	protected readonly _model: ChartModel<HorzScaleItem>;
+	protected readonly _series: ISeries<SeriesType>;
+	protected readonly _model: IChartModelBase;
 	protected readonly _lineRenderer: HorizontalLineRenderer = new HorizontalLineRenderer();
 	private _invalidated: boolean = true;
 
-	protected constructor(series: Series<SeriesType, HorzScaleItem>) {
+	protected constructor(series: ISeries<SeriesType>) {
 		this._series = series;
 		this._model = series.model();
 		this._lineRenderer.setData(this._lineRendererData);
diff --git a/src/views/pane/series-last-price-animation-pane-view.ts b/src/views/pane/series-last-price-animation-pane-view.ts
index 7f71ee9123..4f2f5dc5aa 100644
--- a/src/views/pane/series-last-price-animation-pane-view.ts
+++ b/src/views/pane/series-last-price-animation-pane-view.ts
@@ -2,7 +2,7 @@ import { assert } from '../../helpers/assertions';
 import { applyAlpha } from '../../helpers/color';
 
 import { Point } from '../../model/point';
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { LastPriceAnimationMode } from '../../model/series-options';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 import { SeriesLastPriceAnimationRenderer } from '../../renderers/series-last-price-animation-renderer';
@@ -119,8 +119,8 @@ function animationData(durationSinceStart: number, lineColor: string): Animation
 	};
 }
 
-export class SeriesLastPriceAnimationPaneView<HorzScaleItem> implements IUpdatablePaneView {
-	private readonly _series: Series<'Area', HorzScaleItem> | Series<'Line', HorzScaleItem> | Series<'Baseline', HorzScaleItem>;
+export class SeriesLastPriceAnimationPaneView implements IUpdatablePaneView {
+	private readonly _series: ISeries<'Area'> | ISeries<'Line'> | ISeries<'Baseline'>;
 	private readonly _renderer: SeriesLastPriceAnimationRenderer = new SeriesLastPriceAnimationRenderer();
 	private _invalidated: boolean = true;
 	private _stageInvalidated: boolean = true;
@@ -128,7 +128,7 @@ export class SeriesLastPriceAnimationPaneView<HorzScaleItem> implements IUpdatab
 	private _startTime: number = performance.now();
 	private _endTime: number = this._startTime - 1;
 
-	public constructor(series: Series<'Area', HorzScaleItem> | Series<'Line', HorzScaleItem> | Series<'Baseline', HorzScaleItem>) {
+	public constructor(series: ISeries<'Area'> | ISeries<'Line'> | ISeries<'Baseline'>) {
 		this._series = series;
 	}
 
diff --git a/src/views/pane/series-markers-pane-view.ts b/src/views/pane/series-markers-pane-view.ts
index c0a46c1d1e..738f146ca5 100644
--- a/src/views/pane/series-markers-pane-view.ts
+++ b/src/views/pane/series-markers-pane-view.ts
@@ -3,14 +3,14 @@ import { isNumber } from '../../helpers/strict-type-checks';
 
 import { AutoScaleMargins } from '../../model/autoscale-info-impl';
 import { BarPrice, BarPrices } from '../../model/bar';
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { Coordinate } from '../../model/coordinate';
 import { PriceScale } from '../../model/price-scale';
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { InternalSeriesMarker } from '../../model/series-markers';
 import { SeriesType } from '../../model/series-options';
 import { TimePointIndex, visibleTimedValues } from '../../model/time-data';
-import { TimeScale } from '../../model/time-scale';
+import { ITimeScale } from '../../model/time-scale';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 import {
 	SeriesMarkerRendererData,
@@ -34,15 +34,15 @@ interface Offsets {
 }
 
 // eslint-disable-next-line max-params
-function fillSizeAndY<HorzScaleItem>(
+function fillSizeAndY(
 	rendererItem: SeriesMarkerRendererDataItem,
-	marker: InternalSeriesMarker<TimePointIndex, HorzScaleItem>,
+	marker: InternalSeriesMarker<TimePointIndex, unknown>,
 	seriesData: BarPrices | BarPrice,
 	offsets: Offsets,
 	textHeight: number,
 	shapeMargin: number,
 	priceScale: PriceScale,
-	timeScale: TimeScale<HorzScaleItem>,
+	timeScale: ITimeScale,
 	firstValue: number
 ): void {
 	const inBarPrice = isNumber(seriesData) ? seriesData : seriesData.close;
@@ -84,9 +84,9 @@ function fillSizeAndY<HorzScaleItem>(
 	ensureNever(marker.position);
 }
 
-export class SeriesMarkersPaneView<HorzScaleItem> implements IUpdatablePaneView {
-	private readonly _series: Series<SeriesType, HorzScaleItem>;
-	private readonly _model: ChartModel<HorzScaleItem>;
+export class SeriesMarkersPaneView implements IUpdatablePaneView {
+	private readonly _series: ISeries<SeriesType>;
+	private readonly _model: IChartModelBase;
 	private _data: SeriesMarkerRendererData;
 
 	private _invalidated: boolean = true;
@@ -97,7 +97,7 @@ export class SeriesMarkersPaneView<HorzScaleItem> implements IUpdatablePaneView
 
 	private _renderer: SeriesMarkersRenderer = new SeriesMarkersRenderer();
 
-	public constructor(series: Series<SeriesType, HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
+	public constructor(series: ISeries<SeriesType>, model: IChartModelBase) {
 		this._series = series;
 		this._model = model;
 		this._data = {
@@ -155,7 +155,7 @@ export class SeriesMarkersPaneView<HorzScaleItem> implements IUpdatablePaneView
 		const timeScale = this._model.timeScale();
 		const seriesMarkers = this._series.indexedMarkers();
 		if (this._dataInvalidated) {
-			this._data.items = seriesMarkers.map<SeriesMarkerRendererDataItem>((marker: InternalSeriesMarker<TimePointIndex, HorzScaleItem>) => ({
+			this._data.items = seriesMarkers.map<SeriesMarkerRendererDataItem>((marker: InternalSeriesMarker<TimePointIndex, unknown>) => ({
 				time: marker.time,
 				x: 0 as Coordinate,
 				y: 0 as Coordinate,
diff --git a/src/views/pane/series-pane-view-base.ts b/src/views/pane/series-pane-view-base.ts
index 3abb115258..5462493e8a 100644
--- a/src/views/pane/series-pane-view-base.ts
+++ b/src/views/pane/series-pane-view-base.ts
@@ -1,16 +1,16 @@
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { PriceScale } from '../../model/price-scale';
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { SeriesType } from '../../model/series-options';
 import { SeriesItemsIndexesRange, TimedValue, visibleTimedValues } from '../../model/time-data';
-import { TimeScale } from '../../model/time-scale';
+import { ITimeScale } from '../../model/time-scale';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
 
 import { IUpdatablePaneView, UpdateType } from './iupdatable-pane-view';
 
-export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemType extends TimedValue, TRenderer extends IPaneRenderer, HorzScaleItem> implements IUpdatablePaneView {
-	protected readonly _series: Series<TSeriesType, HorzScaleItem>;
-	protected readonly _model: ChartModel<HorzScaleItem>;
+export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemType extends TimedValue, TRenderer extends IPaneRenderer> implements IUpdatablePaneView {
+	protected readonly _series: ISeries<TSeriesType>;
+	protected readonly _model: IChartModelBase;
 	protected _invalidated: boolean = true;
 	protected _dataInvalidated: boolean = true;
 	protected _optionsInvalidated: boolean = true;
@@ -19,7 +19,7 @@ export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemTyp
 	protected readonly abstract _renderer: TRenderer;
 	private readonly _extendedVisibleRange: boolean;
 
-	public constructor(series: Series<TSeriesType, HorzScaleItem>, model: ChartModel<HorzScaleItem>, extendedVisibleRange: boolean) {
+	public constructor(series: ISeries<TSeriesType>, model: IChartModelBase, extendedVisibleRange: boolean) {
 		this._series = series;
 		this._model = model;
 		this._extendedVisibleRange = extendedVisibleRange;
@@ -54,7 +54,7 @@ export abstract class SeriesPaneViewBase<TSeriesType extends SeriesType, ItemTyp
 		}));
 	}
 
-	protected abstract _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale<HorzScaleItem>, firstValue: number): void;
+	protected abstract _convertToCoordinates(priceScale: PriceScale, timeScale: ITimeScale, firstValue: number): void;
 
 	protected _clearVisibleRange(): void {
 		this._itemsVisibleRange = null;
diff --git a/src/views/pane/series-price-line-pane-view.ts b/src/views/pane/series-price-line-pane-view.ts
index 4e0d71fc47..a50816ee84 100644
--- a/src/views/pane/series-price-line-pane-view.ts
+++ b/src/views/pane/series-price-line-pane-view.ts
@@ -1,11 +1,11 @@
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { PriceLineSource, SeriesType } from '../../model/series-options';
 
 import { SeriesHorizontalLinePaneView } from './series-horizontal-line-pane-view';
 
-export class SeriesPriceLinePaneView<HorzScaleItem> extends SeriesHorizontalLinePaneView<HorzScaleItem> {
+export class SeriesPriceLinePaneView extends SeriesHorizontalLinePaneView {
 	// eslint-disable-next-line no-useless-constructor
-	public constructor(series: Series<SeriesType, HorzScaleItem>) {
+	public constructor(series: ISeries<SeriesType>) {
 		super(series);
 	}
 
diff --git a/src/views/pane/watermark-pane-view.ts b/src/views/pane/watermark-pane-view.ts
index 87cb7b5a12..d3d94d1ddd 100644
--- a/src/views/pane/watermark-pane-view.ts
+++ b/src/views/pane/watermark-pane-view.ts
@@ -6,8 +6,8 @@ import { WatermarkRenderer, WatermarkRendererData } from '../../renderers/waterm
 
 import { IUpdatablePaneView } from './iupdatable-pane-view';
 
-export class WatermarkPaneView<HorzScaleItem> implements IUpdatablePaneView {
-	private _source: Watermark<HorzScaleItem>;
+export class WatermarkPaneView implements IUpdatablePaneView {
+	private _source: Watermark;
 	private _invalidated: boolean = true;
 
 	private readonly _rendererData: WatermarkRendererData = {
@@ -19,7 +19,7 @@ export class WatermarkPaneView<HorzScaleItem> implements IUpdatablePaneView {
 	};
 	private readonly _renderer: WatermarkRenderer = new WatermarkRenderer(this._rendererData);
 
-	public constructor(source: Watermark<HorzScaleItem>) {
+	public constructor(source: Watermark) {
 		this._source = source;
 	}
 
diff --git a/src/views/price-axis/crosshair-price-axis-view.ts b/src/views/price-axis/crosshair-price-axis-view.ts
index 363179c35d..4b40811362 100644
--- a/src/views/price-axis/crosshair-price-axis-view.ts
+++ b/src/views/price-axis/crosshair-price-axis-view.ts
@@ -8,12 +8,12 @@ import { PriceAxisView } from './price-axis-view';
 
 export type CrosshairPriceAxisViewValueProvider = (priceScale: PriceScale) => CrosshairPriceAndCoordinate;
 
-export class CrosshairPriceAxisView<HorzScaleItem> extends PriceAxisView<HorzScaleItem> {
-	private _source: Crosshair<HorzScaleItem>;
+export class CrosshairPriceAxisView extends PriceAxisView {
+	private _source: Crosshair;
 	private readonly _priceScale: PriceScale;
 	private readonly _valueProvider: CrosshairPriceAxisViewValueProvider;
 
-	public constructor(source: Crosshair<HorzScaleItem>, priceScale: PriceScale, valueProvider: CrosshairPriceAxisViewValueProvider) {
+	public constructor(source: Crosshair, priceScale: PriceScale, valueProvider: CrosshairPriceAxisViewValueProvider) {
 		super();
 		this._source = source;
 		this._priceScale = priceScale;
diff --git a/src/views/price-axis/custom-price-line-price-axis-view.ts b/src/views/price-axis/custom-price-line-price-axis-view.ts
index f8c77b40f3..731fca7c27 100644
--- a/src/views/price-axis/custom-price-line-price-axis-view.ts
+++ b/src/views/price-axis/custom-price-line-price-axis-view.ts
@@ -1,7 +1,7 @@
 import { generateContrastColors } from '../../helpers/color';
 
 import { CustomPriceLine } from '../../model/custom-price-line';
-import { Series } from '../../model/series';
+import { ISeries } from '../../model/series';
 import { SeriesType } from '../../model/series-options';
 import {
 	PriceAxisViewRendererCommonData,
@@ -10,11 +10,11 @@ import {
 
 import { PriceAxisView } from './price-axis-view';
 
-export class CustomPriceLinePriceAxisView<HorzScaleItem> extends PriceAxisView<HorzScaleItem> {
-	private readonly _series: Series<SeriesType, HorzScaleItem>;
-	private readonly _priceLine: CustomPriceLine<HorzScaleItem>;
+export class CustomPriceLinePriceAxisView extends PriceAxisView {
+	private readonly _series: ISeries<SeriesType>;
+	private readonly _priceLine: CustomPriceLine;
 
-	public constructor(series: Series<SeriesType, HorzScaleItem>, priceLine: CustomPriceLine<HorzScaleItem>) {
+	public constructor(series: ISeries<SeriesType>, priceLine: CustomPriceLine) {
 		super();
 		this._series = series;
 		this._priceLine = priceLine;
diff --git a/src/views/price-axis/price-axis-view.ts b/src/views/price-axis/price-axis-view.ts
index 2b3ce759da..4223b467b2 100644
--- a/src/views/price-axis/price-axis-view.ts
+++ b/src/views/price-axis/price-axis-view.ts
@@ -10,7 +10,7 @@ import { PriceAxisViewRenderer } from '../../renderers/price-axis-view-renderer'
 
 import { IPriceAxisView } from './iprice-axis-view';
 
-export abstract class PriceAxisView<HorzScaleItem> implements IPriceAxisView {
+export abstract class PriceAxisView implements IPriceAxisView {
 	private readonly _commonRendererData: PriceAxisViewRendererCommonData = {
 		coordinate: 0,
 		background: '#000',
diff --git a/src/views/price-axis/series-price-axis-view.ts b/src/views/price-axis/series-price-axis-view.ts
index ea58e6835c..4d70e12a96 100644
--- a/src/views/price-axis/series-price-axis-view.ts
+++ b/src/views/price-axis/series-price-axis-view.ts
@@ -1,15 +1,15 @@
 import { generateContrastColors } from '../../helpers/color';
 
-import { LastValueDataResultWithData, Series } from '../../model/series';
+import { ISeries, LastValueDataResultWithData } from '../../model/series';
 import { PriceAxisLastValueMode, SeriesType } from '../../model/series-options';
 import { PriceAxisViewRendererCommonData, PriceAxisViewRendererData } from '../../renderers/iprice-axis-view-renderer';
 
 import { PriceAxisView } from './price-axis-view';
 
-export class SeriesPriceAxisView<HorzScaleItem> extends PriceAxisView<HorzScaleItem> {
-	private readonly _source: Series<SeriesType, HorzScaleItem>;
+export class SeriesPriceAxisView extends PriceAxisView {
+	private readonly _source: ISeries<SeriesType>;
 
-	public constructor(source: Series<SeriesType, HorzScaleItem>) {
+	public constructor(source: ISeries<SeriesType>) {
 		super();
 		this._source = source;
 	}
diff --git a/src/views/time-axis/crosshair-time-axis-view.ts b/src/views/time-axis/crosshair-time-axis-view.ts
index 84b277f10c..9cd17d4057 100644
--- a/src/views/time-axis/crosshair-time-axis-view.ts
+++ b/src/views/time-axis/crosshair-time-axis-view.ts
@@ -1,16 +1,16 @@
 import { ensureNotNull } from '../../helpers/assertions';
 import { generateContrastColors } from '../../helpers/color';
 
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { Crosshair, TimeAndCoordinateProvider } from '../../model/crosshair';
 import { TimeAxisViewRenderer, TimeAxisViewRendererData } from '../../renderers/time-axis-view-renderer';
 
 import { ITimeAxisView } from './itime-axis-view';
 
-export class CrosshairTimeAxisView<HorzScaleItem> implements ITimeAxisView {
+export class CrosshairTimeAxisView implements ITimeAxisView {
 	private _invalidated: boolean = true;
-	private readonly _crosshair: Crosshair<HorzScaleItem>;
-	private readonly _model: ChartModel<HorzScaleItem>;
+	private readonly _crosshair: Crosshair;
+	private readonly _model: IChartModelBase;
 	private readonly _valueProvider: TimeAndCoordinateProvider;
 	private readonly _renderer: TimeAxisViewRenderer = new TimeAxisViewRenderer();
 	private readonly _rendererData: TimeAxisViewRendererData = {
@@ -23,7 +23,7 @@ export class CrosshairTimeAxisView<HorzScaleItem> implements ITimeAxisView {
 		tickVisible: true,
 	};
 
-	public constructor(crosshair: Crosshair<HorzScaleItem>, model: ChartModel<HorzScaleItem>, valueProvider: TimeAndCoordinateProvider) {
+	public constructor(crosshair: Crosshair, model: IChartModelBase, valueProvider: TimeAndCoordinateProvider) {
 		this._crosshair = crosshair;
 		this._model = model;
 		this._valueProvider = valueProvider;

From 38039bda8e3f926290d36d3beefa08b6c49c68d9 Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 6 Jun 2023 13:24:32 +0300
Subject: [PATCH 19/23] Make Pane class non-generic, removed interface

---
 src/gui/pane-widget.ts           | 20 +++++------
 src/model/chart-model.ts         | 61 ++++++++++++++++++--------------
 src/model/crosshair.ts           | 20 +++++------
 src/model/data-source.ts         |  8 ++---
 src/model/grid.ts                |  4 +--
 src/model/idata-source.ts        | 10 +++---
 src/model/magnet.ts              |  4 +--
 src/model/pane.ts                | 26 +++++---------
 src/model/series.ts              |  6 ++--
 src/views/pane/grid-pane-view.ts |  6 ++--
 10 files changed, 82 insertions(+), 83 deletions(-)

diff --git a/src/gui/pane-widget.ts b/src/gui/pane-widget.ts
index 303f882d2d..71642383e8 100644
--- a/src/gui/pane-widget.ts
+++ b/src/gui/pane-widget.ts
@@ -51,17 +51,17 @@ function drawForeground(renderer: IPaneRenderer, target: CanvasRenderingTarget2D
 	renderer.draw(target, isHovered, hitTestData);
 }
 
-type PaneViewsGetter<HorzScaleItem> = (source: IDataSource, pane: Pane<HorzScaleItem>) => readonly IPaneView[];
+type PaneViewsGetter = (source: IDataSource, pane: Pane) => readonly IPaneView[];
 
-function sourcePaneViews<HorzScaleItem>(source: IDataSource, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
+function sourcePaneViews(source: IDataSource, pane: Pane): readonly IPaneView[] {
 	return source.paneViews(pane);
 }
 
-function sourceLabelPaneViews<HorzScaleItem>(source: IDataSource, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
+function sourceLabelPaneViews(source: IDataSource, pane: Pane): readonly IPaneView[] {
 	return source.labelPaneViews(pane);
 }
 
-function sourceTopPaneViews<HorzScaleItem>(source: IDataSource, pane: Pane<HorzScaleItem>): readonly IPaneView[] {
+function sourceTopPaneViews(source: IDataSource, pane: Pane): readonly IPaneView[] {
 	return source.topPaneViews !== undefined ? source.topPaneViews(pane) : [];
 }
 
@@ -84,7 +84,7 @@ interface StartScrollPosition extends Point {
 
 export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandlers {
 	private readonly _chart: ChartWidget<HorzScaleItem>;
-	private _state: Pane<HorzScaleItem> | null;
+	private _state: Pane | null;
 	private _size: Size = size({ width: 0, height: 0 });
 	private _leftPriceAxisWidget: PriceAxisWidget<HorzScaleItem> | null = null;
 	private _rightPriceAxisWidget: PriceAxisWidget<HorzScaleItem> | null = null;
@@ -108,7 +108,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 
 	private _isSettingSize: boolean = false;
 
-	public constructor(chart: ChartWidget<HorzScaleItem>, state: Pane<HorzScaleItem>) {
+	public constructor(chart: ChartWidget<HorzScaleItem>, state: Pane) {
 		this._chart = chart;
 
 		this._state = state;
@@ -185,11 +185,11 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		this._mouseEventHandler.destroy();
 	}
 
-	public state(): Pane<HorzScaleItem> {
+	public state(): Pane {
 		return ensureNotNull(this._state);
 	}
 
-	public setState(pane: Pane<HorzScaleItem> | null): void {
+	public setState(pane: Pane | null): void {
 		if (this._state !== null) {
 			this._state.onDestroyed().unsubscribeAll(this);
 		}
@@ -569,7 +569,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		this._drawSourceImpl(target, sourcePaneViews, drawForeground, this._model().crosshairSource());
 	}
 
-	private _drawSources(target: CanvasRenderingTarget2D, paneViewsGetter: PaneViewsGetter<HorzScaleItem>): void {
+	private _drawSources(target: CanvasRenderingTarget2D, paneViewsGetter: PaneViewsGetter): void {
 		const state = ensureNotNull(this._state);
 		const sources = state.orderedSources();
 
@@ -584,7 +584,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 
 	private _drawSourceImpl(
 		target: CanvasRenderingTarget2D,
-		paneViewsGetter: PaneViewsGetter<HorzScaleItem>,
+		paneViewsGetter: PaneViewsGetter,
 		drawFn: DrawFunction,
 		source: IDataSource
 	): void {
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index d0aec696ea..090ae80f57 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -20,7 +20,7 @@ import { IPriceDataSource } from './iprice-data-source';
 import { ColorType, LayoutOptions } from './layout-options';
 import { LocalizationOptions, LocalizationOptionsBase } from './localization-options';
 import { Magnet } from './magnet';
-import { DEFAULT_STRETCH_FACTOR, IPaneBase, Pane } from './pane';
+import { DEFAULT_STRETCH_FACTOR, Pane } from './pane';
 import { Point } from './point';
 import { PriceScale, PriceScaleOptions } from './price-scale';
 import { ISeries, Series, SeriesOptionsInternal } from './series';
@@ -175,7 +175,7 @@ export interface HoveredSource {
 
 export interface PriceScaleOnPane {
 	priceScale: PriceScale;
-	pane: IPaneBase;
+	pane: Pane;
 }
 
 const enum BackgroundColorSide {
@@ -380,15 +380,24 @@ export interface IChartModelBase {
 	updateCrosshair(): void;
 	cursorUpdate(): void;
 
-	recalculatePane(pane: IPaneBase | null): void;
+	recalculatePane(pane: Pane | null): void;
 
 	lightUpdate(): void;
 	fullUpdate(): void;
+
+	backgroundBottomColor(): string;
+	backgroundTopColor(): string;
 	backgroundColorAtYPercentFromTop(percent: number): string;
-	paneForSource(source: IPriceDataSource): IPaneBase | null;
+
+	paneForSource(source: IPriceDataSource): Pane | null;
 	moveSeriesToScale(series: ISeries<SeriesType>, targetScaleId: string): void;
 
 	priceAxisRendererOptions(): Readonly<PriceAxisViewRendererOptions>;
+
+	priceScalesOptionsChanged(): ISubscription;
+
+	hoveredSource(): HoveredSource | null;
+	setHoveredSource(source: HoveredSource | null): void;
 }
 
 export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase {
@@ -398,7 +407,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
 
 	private readonly _timeScale: TimeScale<HorzScaleItem>;
-	private readonly _panes: Pane<HorzScaleItem>[] = [];
+	private readonly _panes: Pane[] = [];
 	private readonly _crosshair: Crosshair;
 	private readonly _magnet: Magnet;
 	private readonly _watermark: Watermark;
@@ -474,7 +483,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 	public applyOptions(options: DeepPartial<ChartOptionsInternal<HorzScaleItem>>): void {
 		merge(this._options, options);
 
-		this._panes.forEach((p: Pane<HorzScaleItem>) => p.applyScaleOptions(options));
+		this._panes.forEach((p: Pane) => p.applyScaleOptions(options));
 
 		if (options.timeScale !== undefined) {
 			this._timeScale.applyOptions(options.timeScale);
@@ -538,7 +547,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return this._timeScale;
 	}
 
-	public panes(): readonly Pane<HorzScaleItem>[] {
+	public panes(): readonly Pane[] {
 		return this._panes;
 	}
 
@@ -554,7 +563,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return this._crosshairMoved;
 	}
 
-	public setPaneHeight(pane: Pane<HorzScaleItem>, height: number): void {
+	public setPaneHeight(pane: Pane, height: number): void {
 		pane.setHeight(height);
 		this.recalculateAllPanes();
 	}
@@ -562,11 +571,11 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 	public setWidth(width: number): void {
 		this._width = width;
 		this._timeScale.setWidth(this._width);
-		this._panes.forEach((pane: Pane<HorzScaleItem>) => pane.setWidth(width));
+		this._panes.forEach((pane: Pane) => pane.setWidth(width));
 		this.recalculateAllPanes();
 	}
 
-	public createPane(index?: number): Pane<HorzScaleItem> {
+	public createPane(index?: number): Pane {
 		const pane = new Pane(this._timeScale, this);
 
 		if (index !== undefined) {
@@ -592,29 +601,29 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return pane;
 	}
 
-	public startScalePrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale, x: number): void {
+	public startScalePrice(pane: Pane, priceScale: PriceScale, x: number): void {
 		pane.startScalePrice(priceScale, x);
 	}
 
-	public scalePriceTo(pane: Pane<HorzScaleItem>, priceScale: PriceScale, x: number): void {
+	public scalePriceTo(pane: Pane, priceScale: PriceScale, x: number): void {
 		pane.scalePriceTo(priceScale, x);
 		this.updateCrosshair();
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public endScalePrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale): void {
+	public endScalePrice(pane: Pane, priceScale: PriceScale): void {
 		pane.endScalePrice(priceScale);
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public startScrollPrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale, x: number): void {
+	public startScrollPrice(pane: Pane, priceScale: PriceScale, x: number): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
 		pane.startScrollPrice(priceScale, x);
 	}
 
-	public scrollPriceTo(pane: Pane<HorzScaleItem>, priceScale: PriceScale, x: number): void {
+	public scrollPriceTo(pane: Pane, priceScale: PriceScale, x: number): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
@@ -623,7 +632,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public endScrollPrice(pane: Pane<HorzScaleItem>, priceScale: PriceScale): void {
+	public endScrollPrice(pane: Pane, priceScale: PriceScale): void {
 		if (priceScale.isAutoScale()) {
 			return;
 		}
@@ -631,7 +640,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
 
-	public resetPriceScale(pane: Pane<HorzScaleItem>, priceScale: PriceScale): void {
+	public resetPriceScale(pane: Pane, priceScale: PriceScale): void {
 		pane.resetPriceScale(priceScale);
 		this._invalidate(this._paneInvalidationMask(pane, InvalidationLevel.Light));
 	}
@@ -694,7 +703,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return this._serieses;
 	}
 
-	public setAndSaveCurrentPosition(x: Coordinate, y: Coordinate, event: TouchMouseEventData | null, pane: IPaneBase): void {
+	public setAndSaveCurrentPosition(x: Coordinate, y: Coordinate, event: TouchMouseEventData | null, pane: Pane): void {
 		this._crosshair.saveOriginCoord(x, y);
 		let price = NaN;
 		let index = this._timeScale.coordinateToIndex(x);
@@ -767,25 +776,25 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		this._timeScale.setBaseIndex(newBaseIndex);
 	}
 
-	public recalculatePane(pane: Pane<HorzScaleItem> | null): void {
+	public recalculatePane(pane: Pane | null): void {
 		if (pane !== null) {
 			pane.recalculate();
 		}
 	}
 
-	public paneForSource(source: IPriceDataSource): Pane<HorzScaleItem> | null {
-		const pane = this._panes.find((p: Pane<HorzScaleItem>) => p.orderedSources().includes(source));
+	public paneForSource(source: IPriceDataSource): Pane | null {
+		const pane = this._panes.find((p: Pane) => p.orderedSources().includes(source));
 		return pane === undefined ? null : pane;
 	}
 
 	public recalculateAllPanes(): void {
 		this._watermark.updateAllViews();
-		this._panes.forEach((p: Pane<HorzScaleItem>) => p.recalculate());
+		this._panes.forEach((p: Pane) => p.recalculate());
 		this.updateCrosshair();
 	}
 
 	public destroy(): void {
-		this._panes.forEach((p: Pane<HorzScaleItem>) => p.destroy());
+		this._panes.forEach((p: Pane) => p.destroy());
 		this._panes.length = 0;
 
 		// to avoid memleaks
@@ -938,7 +947,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return result;
 	}
 
-	private _paneInvalidationMask(pane: Pane<HorzScaleItem> | null, level: InvalidationLevel): InvalidateMask {
+	private _paneInvalidationMask(pane: Pane | null, level: InvalidationLevel): InvalidateMask {
 		const inv = new InvalidateMask(level);
 		if (pane !== null) {
 			const index = this._panes.indexOf(pane);
@@ -962,10 +971,10 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 			this._invalidateHandler(mask);
 		}
 
-		this._panes.forEach((pane: Pane<HorzScaleItem>) => pane.grid().paneView().update());
+		this._panes.forEach((pane: Pane) => pane.grid().paneView().update());
 	}
 
-	private _createSeries<T extends SeriesType>(options: SeriesOptionsInternal<T>, seriesType: T, pane: Pane<HorzScaleItem>): Series<T, HorzScaleItem> {
+	private _createSeries<T extends SeriesType>(options: SeriesOptionsInternal<T>, seriesType: T, pane: Pane): Series<T, HorzScaleItem> {
 		const series = new Series<T, HorzScaleItem>(this, options, seriesType);
 
 		const targetScaleId = options.priceScaleId !== undefined ? options.priceScaleId : this.defaultVisiblePriceScaleId();
diff --git a/src/model/crosshair.ts b/src/model/crosshair.ts
index fbed3b5faf..f012569e12 100644
--- a/src/model/crosshair.ts
+++ b/src/model/crosshair.ts
@@ -16,7 +16,7 @@ import { IChartModelBase } from './chart-model';
 import { Coordinate } from './coordinate';
 import { DataSource } from './data-source';
 import { InternalHorzScaleItem } from './ihorz-scale-behavior';
-import { IPaneBase } from './pane';
+import { Pane } from './pane';
 import { PriceScale } from './price-scale';
 import { ISeries } from './series';
 import { SeriesType } from './series-options';
@@ -125,7 +125,7 @@ type RawCoordinateProvider = () => Coordinate;
 type RawIndexProvider = () => TimePointIndex;
 
 export class Crosshair extends DataSource {
-	private _pane: IPaneBase | null = null;
+	private _pane: Pane | null = null;
 	private _price: number = NaN;
 	private _index: TimePointIndex = 0 as TimePointIndex;
 	private _visible: boolean = true;
@@ -217,7 +217,7 @@ export class Crosshair extends DataSource {
 		return this._originY;
 	}
 
-	public setPosition(index: TimePointIndex, price: number, pane: IPaneBase): void {
+	public setPosition(index: TimePointIndex, price: number, pane: Pane): void {
 		if (!this._subscribed) {
 			this._subscribed = true;
 		}
@@ -255,11 +255,11 @@ export class Crosshair extends DataSource {
 		this.clearOriginCoord();
 	}
 
-	public paneViews(pane: IPaneBase): readonly IPaneView[] {
+	public paneViews(pane: Pane): readonly IPaneView[] {
 		return this._pane !== null ? [this._paneView, this._markersPaneView] : [];
 	}
 
-	public horzLineVisible(pane: IPaneBase): boolean {
+	public horzLineVisible(pane: Pane): boolean {
 		return pane === this._pane && this._options.horzLine.visible;
 	}
 
@@ -267,7 +267,7 @@ export class Crosshair extends DataSource {
 		return this._options.vertLine.visible;
 	}
 
-	public override priceAxisViews(pane: IPaneBase, priceScale: PriceScale): IPriceAxisView[] {
+	public override priceAxisViews(pane: Pane, priceScale: PriceScale): IPriceAxisView[] {
 		if (!this._visible || this._pane !== pane) {
 			this._priceAxisViews.clear();
 		}
@@ -284,7 +284,7 @@ export class Crosshair extends DataSource {
 		return this._visible ? [this._timeAxisView] : [];
 	}
 
-	public pane(): IPaneBase | null {
+	public pane(): Pane | null {
 		return this._pane;
 	}
 
@@ -295,7 +295,7 @@ export class Crosshair extends DataSource {
 		this._markersPaneView.update();
 	}
 
-	private _priceScaleByPane(pane: IPaneBase): PriceScale | null {
+	private _priceScaleByPane(pane: Pane): PriceScale | null {
 		if (pane && !pane.defaultPriceScale().isEmpty()) {
 			return pane.defaultPriceScale();
 		}
@@ -303,13 +303,13 @@ export class Crosshair extends DataSource {
 		return null;
 	}
 
-	private _tryToUpdateViews(index: TimePointIndex, price: number, pane: IPaneBase): void {
+	private _tryToUpdateViews(index: TimePointIndex, price: number, pane: Pane): void {
 		if (this._tryToUpdateData(index, price, pane)) {
 			this.updateAllViews();
 		}
 	}
 
-	private _tryToUpdateData(newIndex: TimePointIndex, newPrice: number, newPane: IPaneBase): boolean {
+	private _tryToUpdateData(newIndex: TimePointIndex, newPrice: number, newPane: Pane): boolean {
 		const oldX = this._x;
 		const oldY = this._y;
 		const oldPrice = this._price;
diff --git a/src/model/data-source.ts b/src/model/data-source.ts
index c0c9f0e51b..322e9b2051 100644
--- a/src/model/data-source.ts
+++ b/src/model/data-source.ts
@@ -3,7 +3,7 @@ import { IPriceAxisView } from '../views/price-axis/iprice-axis-view';
 import { ITimeAxisView } from '../views/time-axis/itime-axis-view';
 
 import { IDataSource } from './idata-source';
-import { IPaneBase } from './pane';
+import { Pane } from './pane';
 import { PriceScale } from './price-scale';
 
 export abstract class DataSource implements IDataSource {
@@ -27,10 +27,10 @@ export abstract class DataSource implements IDataSource {
 		this._priceScale = priceScale;
 	}
 
-	public abstract priceAxisViews(pane?: IPaneBase, priceScale?: PriceScale): readonly IPriceAxisView[];
-	public abstract paneViews(pane?: IPaneBase): readonly IPaneView[];
+	public abstract priceAxisViews(pane?: Pane, priceScale?: PriceScale): readonly IPriceAxisView[];
+	public abstract paneViews(pane?: Pane): readonly IPaneView[];
 
-	public labelPaneViews(pane?: IPaneBase): readonly IPaneView[] {
+	public labelPaneViews(pane?: Pane): readonly IPaneView[] {
 		return [];
 	}
 
diff --git a/src/model/grid.ts b/src/model/grid.ts
index 16372339eb..92b5a3a367 100644
--- a/src/model/grid.ts
+++ b/src/model/grid.ts
@@ -2,7 +2,7 @@ import { LineStyle } from '../renderers/draw-line';
 import { GridPaneView } from '../views/pane/grid-pane-view';
 import { IUpdatablePaneView } from '../views/pane/iupdatable-pane-view';
 
-import { IPaneBase } from './pane';
+import { Pane } from './pane';
 
 /** Grid line options. */
 export interface GridLineOptions {
@@ -44,7 +44,7 @@ export interface GridOptions {
 export class Grid {
 	private _paneView: GridPaneView;
 
-	public constructor(pane: IPaneBase) {
+	public constructor(pane: Pane) {
 		this._paneView = new GridPaneView(pane);
 	}
 
diff --git a/src/model/idata-source.ts b/src/model/idata-source.ts
index 3e7e46faa5..17a85735df 100644
--- a/src/model/idata-source.ts
+++ b/src/model/idata-source.ts
@@ -2,7 +2,7 @@ import { IPaneView } from '../views/pane/ipane-view';
 import { IPriceAxisView } from '../views/price-axis/iprice-axis-view';
 import { ITimeAxisView } from '../views/time-axis/itime-axis-view';
 
-import { IPaneBase } from './pane';
+import { Pane } from './pane';
 import { PriceScale } from './price-scale';
 
 export interface ZOrdered {
@@ -16,14 +16,14 @@ export interface IDataSource extends ZOrdered {
 
 	updateAllViews(): void;
 
-	priceAxisViews(pane?: IPaneBase, priceScale?: PriceScale): readonly IPriceAxisView[];
-	paneViews(pane: IPaneBase): readonly IPaneView[];
-	labelPaneViews(pane?: IPaneBase): readonly IPaneView[];
+	priceAxisViews(pane?: Pane, priceScale?: PriceScale): readonly IPriceAxisView[];
+	paneViews(pane: Pane): readonly IPaneView[];
+	labelPaneViews(pane?: Pane): readonly IPaneView[];
 
 	/**
 	 * Pane views that are painted on the most top layer
 	 */
-	topPaneViews?(pane: IPaneBase): readonly IPaneView[];
+	topPaneViews?(pane: Pane): readonly IPaneView[];
 
 	visible(): boolean;
 
diff --git a/src/model/magnet.ts b/src/model/magnet.ts
index 46960a2466..a623351a7c 100644
--- a/src/model/magnet.ts
+++ b/src/model/magnet.ts
@@ -3,7 +3,7 @@ import { ensure } from '../helpers/assertions';
 import { Coordinate } from './coordinate';
 import { CrosshairMode, CrosshairOptions } from './crosshair';
 import { IPriceDataSource } from './iprice-data-source';
-import { IPaneBase } from './pane';
+import { Pane } from './pane';
 import { PlotRowValueIndex } from './plot-data';
 import { ISeries, Series } from './series';
 import { SeriesType } from './series-options';
@@ -16,7 +16,7 @@ export class Magnet {
 		this._options = options;
 	}
 
-	public align(price: number, index: TimePointIndex, pane: IPaneBase): number {
+	public align(price: number, index: TimePointIndex, pane: Pane): number {
 		let res = price;
 		if (this._options.mode === CrosshairMode.Normal) {
 			return res;
diff --git a/src/model/pane.ts b/src/model/pane.ts
index ab2fdc973b..c07feabde8 100644
--- a/src/model/pane.ts
+++ b/src/model/pane.ts
@@ -4,13 +4,13 @@ import { IDestroyable } from '../helpers/idestroyable';
 import { ISubscription } from '../helpers/isubscription';
 import { clone, DeepPartial } from '../helpers/strict-type-checks';
 
-import { ChartModel, ChartOptionsImpl, IChartModelBase, OverlayPriceScaleOptions, VisiblePriceScaleOptions } from './chart-model';
+import { ChartOptionsBase, IChartModelBase, OverlayPriceScaleOptions, VisiblePriceScaleOptions } from './chart-model';
 import { DefaultPriceScaleId, isDefaultPriceScale } from './default-price-scale';
 import { Grid } from './grid';
 import { IPriceDataSource } from './iprice-data-source';
 import { PriceScale, PriceScaleOptions, PriceScaleState } from './price-scale';
 import { sortSources } from './sort-sources';
-import { TimeScale } from './time-scale';
+import { ITimeScale } from './time-scale';
 
 export const DEFAULT_STRETCH_FACTOR = 1000;
 
@@ -21,19 +21,9 @@ interface MinMaxOrderInfo {
 	maxZOrder: number;
 }
 
-export interface IPaneBase {
-	addDataSource(source: IPriceDataSource, targetScaleId: string, zOrder?: number): void;
-	model(): IChartModelBase;
-	defaultPriceScale(): PriceScale;
-	defaultVisiblePriceScale(): PriceScale | null;
-	dataSources(): readonly IPriceDataSource[];
-	isOverlay(source: IPriceDataSource): boolean;
-	priceScalePosition(priceScale: PriceScale): PriceScalePosition;
-}
-
-export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
-	private readonly _timeScale: TimeScale<HorzScaleItem>;
-	private readonly _model: ChartModel<HorzScaleItem>;
+export class Pane implements IDestroyable {
+	private readonly _timeScale: ITimeScale;
+	private readonly _model: IChartModelBase;
 	private readonly _grid: Grid;
 
 	private _dataSources: IPriceDataSource[] = [];
@@ -49,7 +39,7 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 	private _leftPriceScale: PriceScale;
 	private _rightPriceScale: PriceScale;
 
-	public constructor(timeScale: TimeScale<HorzScaleItem>, model: ChartModel<HorzScaleItem>) {
+	public constructor(timeScale: ITimeScale, model: IChartModelBase) {
 		this._timeScale = timeScale;
 		this._model = model;
 		this._grid = new Grid(this);
@@ -65,7 +55,7 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		this.applyScaleOptions(options);
 	}
 
-	public applyScaleOptions(options: DeepPartial<ChartOptionsImpl<HorzScaleItem>>): void {
+	public applyScaleOptions(options: DeepPartial<ChartOptionsBase>): void {
 		if (options.leftPriceScale) {
 			this._leftPriceScale.applyOptions(options.leftPriceScale);
 		}
@@ -125,7 +115,7 @@ export class Pane<HorzScaleItem> implements IDestroyable, IPaneBase {
 		this._stretchFactor = factor;
 	}
 
-	public model(): ChartModel<HorzScaleItem> {
+	public model(): IChartModelBase {
 		return this._model;
 	}
 
diff --git a/src/model/series.ts b/src/model/series.ts
index 4d49df9b34..a21a2950af 100644
--- a/src/model/series.ts
+++ b/src/model/series.ts
@@ -356,7 +356,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		}
 	}
 
-	public topPaneViews(pane: Pane<HorzScaleItem>): readonly IPaneView[] {
+	public topPaneViews(pane: Pane): readonly IPaneView[] {
 		const animationPaneView = this._lastPriceAnimationPaneView;
 		if (animationPaneView === null || !animationPaneView.visible()) {
 			return [];
@@ -395,14 +395,14 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		return res;
 	}
 
-	public override labelPaneViews(pane?: Pane<HorzScaleItem>): readonly IPaneView[] {
+	public override labelPaneViews(pane?: Pane): readonly IPaneView[] {
 		return [
 			this._panePriceAxisView,
 			...this._customPriceLines.map((line: CustomPriceLine) => line.labelPaneView()),
 		];
 	}
 
-	public override priceAxisViews(pane: Pane<HorzScaleItem>, priceScale: PriceScale): readonly IPriceAxisView[] {
+	public override priceAxisViews(pane: Pane, priceScale: PriceScale): readonly IPriceAxisView[] {
 		if (priceScale !== this._priceScale && !this._isOverlay()) {
 			return [];
 		}
diff --git a/src/views/pane/grid-pane-view.ts b/src/views/pane/grid-pane-view.ts
index 063afa4b59..06a2f96614 100644
--- a/src/views/pane/grid-pane-view.ts
+++ b/src/views/pane/grid-pane-view.ts
@@ -1,4 +1,4 @@
-import { IPaneBase } from '../../model/pane';
+import { Pane } from '../../model/pane';
 import { TimeMark } from '../../model/time-scale';
 import { GridRenderer, GridRendererData } from '../../renderers/grid-renderer';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
@@ -6,11 +6,11 @@ import { IPaneRenderer } from '../../renderers/ipane-renderer';
 import { IUpdatablePaneView } from './iupdatable-pane-view';
 
 export class GridPaneView implements IUpdatablePaneView {
-	private readonly _pane: IPaneBase;
+	private readonly _pane: Pane;
 	private readonly _renderer: GridRenderer = new GridRenderer();
 	private _invalidated: boolean = true;
 
-	public constructor(pane: IPaneBase) {
+	public constructor(pane: Pane) {
 		this._pane = pane;
 	}
 

From 9ae2fc67c426d1a60061380ab84ca860e18b31c2 Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 6 Jun 2023 18:57:18 +0300
Subject: [PATCH 20/23] Remove generic params from widget

---
 src/gui/chart-widget.ts                       | 10 ++++---
 src/gui/pane-separator.ts                     | 12 ++++----
 src/gui/pane-widget.ts                        | 22 +++++++--------
 src/gui/price-axis-stub.ts                    | 16 +++++------
 src/gui/price-axis-widget.ts                  | 12 ++++----
 src/gui/time-axis-widget.ts                   | 10 +++----
 src/model/chart-model.ts                      | 28 +++++++++++++++++--
 src/model/time-scale.ts                       |  3 ++
 .../price-axis-renderer-options-provider.ts   |  8 +++---
 9 files changed, 75 insertions(+), 46 deletions(-)

diff --git a/src/gui/chart-widget.ts b/src/gui/chart-widget.ts
index 423369ced6..ec0d2b93c4 100644
--- a/src/gui/chart-widget.ts
+++ b/src/gui/chart-widget.ts
@@ -8,7 +8,7 @@ import { ISubscription } from '../helpers/isubscription';
 import { warn } from '../helpers/logger';
 import { DeepPartial } from '../helpers/strict-type-checks';
 
-import { IChartModelBase, ChartModel, ChartOptionsInternal } from '../model/chart-model';
+import { IChartModelBase, ChartModel, ChartOptionsInternal, ChartOptionsInternalBase } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { DefaultPriceScaleId } from '../model/default-price-scale';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
@@ -46,11 +46,13 @@ const windowsChrome = isChromiumBased() && isWindows();
 export interface IChartWidgetBase {
 	getPriceAxisWidth(position: DefaultPriceScaleId): number;
 	model(): IChartModelBase;
+	paneWidgets(): PaneWidget[];
+	options(): ChartOptionsInternalBase;
 }
 
 export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBase {
 	private readonly _options: ChartOptionsInternal<HorzScaleItem>;
-	private _paneWidgets: PaneWidget<HorzScaleItem>[] = [];
+	private _paneWidgets: PaneWidget[] = [];
 	// private _paneSeparators: PaneSeparator[] = [];
 	private readonly _model: ChartModel<HorzScaleItem>;
 	private _drawRafId: number = 0;
@@ -136,7 +138,7 @@ export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBas
 		return this._options;
 	}
 
-	public paneWidgets(): PaneWidget<HorzScaleItem>[] {
+	public paneWidgets(): PaneWidget[] {
 		return this._paneWidgets;
 	}
 
@@ -561,7 +563,7 @@ export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBas
 			this._applyTimeScaleInvalidations(invalidateMask, time);
 
 			this._timeAxisWidget.update();
-			this._paneWidgets.forEach((pane: PaneWidget<HorzScaleItem>) => {
+			this._paneWidgets.forEach((pane: PaneWidget) => {
 				pane.updatePriceAxisWidgets();
 			});
 
diff --git a/src/gui/pane-separator.ts b/src/gui/pane-separator.ts
index 8818b9905e..97fd2b16f5 100644
--- a/src/gui/pane-separator.ts
+++ b/src/gui/pane-separator.ts
@@ -1,20 +1,20 @@
 import { IDestroyable } from '../helpers/idestroyable';
 import { clamp } from '../helpers/mathex';
 
-import { ChartWidget } from './chart-widget';
+import { IChartWidgetBase } from './chart-widget';
 import { MouseEventHandler, MouseEventHandlers, TouchMouseEvent } from './mouse-event-handler';
 import { PaneWidget } from './pane-widget';
 
 export const SEPARATOR_HEIGHT = 1;
 
-export class PaneSeparator<HorzScaleItem> implements IDestroyable {
-	private readonly _chartWidget: ChartWidget<HorzScaleItem>;
+export class PaneSeparator implements IDestroyable {
+	private readonly _chartWidget: IChartWidgetBase;
 	private readonly _rowElement: HTMLTableRowElement;
 	private readonly _cell: HTMLTableCellElement;
 	private readonly _handle: HTMLDivElement | null;
 	private readonly _mouseEventHandler: MouseEventHandler | null;
-	private readonly _paneA: PaneWidget<HorzScaleItem>;
-	private readonly _paneB: PaneWidget<HorzScaleItem>;
+	private readonly _paneA: PaneWidget;
+	private readonly _paneB: PaneWidget;
 
 	private _startY: number = 0;
 	private _deltaY: number = 0;
@@ -24,7 +24,7 @@ export class PaneSeparator<HorzScaleItem> implements IDestroyable {
 	private _maxPaneHeight: number = 0;
 	private _pixelStretchFactor: number = 0;
 
-	public constructor(chartWidget: ChartWidget<HorzScaleItem>, topPaneIndex: number, bottomPaneIndex: number, disableResize: boolean) {
+	public constructor(chartWidget: IChartWidgetBase, topPaneIndex: number, bottomPaneIndex: number, disableResize: boolean) {
 		this._chartWidget = chartWidget;
 		this._paneA = chartWidget.paneWidgets()[topPaneIndex];
 		this._paneB = chartWidget.paneWidgets()[bottomPaneIndex];
diff --git a/src/gui/pane-widget.ts b/src/gui/pane-widget.ts
index 71642383e8..cdcac71b5e 100644
--- a/src/gui/pane-widget.ts
+++ b/src/gui/pane-widget.ts
@@ -14,7 +14,7 @@ import { Delegate } from '../helpers/delegate';
 import { IDestroyable } from '../helpers/idestroyable';
 import { ISubscription } from '../helpers/isubscription';
 
-import { ChartModel, HoveredObject, TrackingModeExitMode } from '../model/chart-model';
+import { IChartModelBase, HoveredObject, TrackingModeExitMode } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { IDataSource } from '../model/idata-source';
 import { InvalidationLevel } from '../model/invalidate-mask';
@@ -28,7 +28,7 @@ import { IPaneRenderer } from '../renderers/ipane-renderer';
 import { IPaneView } from '../views/pane/ipane-view';
 
 import { createBoundCanvas } from './canvas-utils';
-import { ChartWidget } from './chart-widget';
+import { IChartWidgetBase } from './chart-widget';
 import { MouseEventHandler, MouseEventHandlerEventBase, MouseEventHandlerMouseEvent, MouseEventHandlers, MouseEventHandlerTouchEvent, Position, TouchMouseEvent } from './mouse-event-handler';
 import { PriceAxisWidget, PriceAxisWidgetSide } from './price-axis-widget';
 
@@ -82,12 +82,12 @@ interface StartScrollPosition extends Point {
 	localY: Coordinate;
 }
 
-export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandlers {
-	private readonly _chart: ChartWidget<HorzScaleItem>;
+export class PaneWidget implements IDestroyable, MouseEventHandlers {
+	private readonly _chart: IChartWidgetBase;
 	private _state: Pane | null;
 	private _size: Size = size({ width: 0, height: 0 });
-	private _leftPriceAxisWidget: PriceAxisWidget<HorzScaleItem> | null = null;
-	private _rightPriceAxisWidget: PriceAxisWidget<HorzScaleItem> | null = null;
+	private _leftPriceAxisWidget: PriceAxisWidget | null = null;
+	private _rightPriceAxisWidget: PriceAxisWidget | null = null;
 	private readonly _paneCell: HTMLElement;
 	private readonly _leftAxisCell: HTMLElement;
 	private readonly _rightAxisCell: HTMLElement;
@@ -108,7 +108,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 
 	private _isSettingSize: boolean = false;
 
-	public constructor(chart: ChartWidget<HorzScaleItem>, state: Pane) {
+	public constructor(chart: IChartWidgetBase, state: Pane) {
 		this._chart = chart;
 
 		this._state = state;
@@ -203,7 +203,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		this.updatePriceAxisWidgetsStates();
 	}
 
-	public chart(): ChartWidget<HorzScaleItem> {
+	public chart(): IChartWidgetBase {
 		return this._chart;
 	}
 
@@ -512,11 +512,11 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		}
 	}
 
-	public leftPriceAxisWidget(): PriceAxisWidget<HorzScaleItem> | null {
+	public leftPriceAxisWidget(): PriceAxisWidget | null {
 		return this._leftPriceAxisWidget;
 	}
 
-	public rightPriceAxisWidget(): PriceAxisWidget<HorzScaleItem> | null {
+	public rightPriceAxisWidget(): PriceAxisWidget | null {
 		return this._rightPriceAxisWidget;
 	}
 
@@ -684,7 +684,7 @@ export class PaneWidget<HorzScaleItem> implements IDestroyable, MouseEventHandle
 		this._initCrosshairPosition = { x: crosshair.appliedX(), y: crosshair.appliedY() };
 	}
 
-	private _model(): ChartModel<HorzScaleItem> {
+	private _model(): IChartModelBase {
 		return this._chart.model();
 	}
 
diff --git a/src/gui/price-axis-stub.ts b/src/gui/price-axis-stub.ts
index b1535fd821..83298bebd7 100644
--- a/src/gui/price-axis-stub.ts
+++ b/src/gui/price-axis-stub.ts
@@ -10,27 +10,27 @@ import {
 import { clearRect } from '../helpers/canvas-helpers';
 import { IDestroyable } from '../helpers/idestroyable';
 
-import { ChartOptionsInternal } from '../model/chart-model';
+import { ChartOptionsBase } from '../model/chart-model';
 import { InvalidationLevel } from '../model/invalidate-mask';
 import { PriceAxisRendererOptionsProvider } from '../renderers/price-axis-renderer-options-provider';
 
 import { createBoundCanvas } from './canvas-utils';
 import { PriceAxisWidgetSide } from './price-axis-widget';
 
-export interface PriceAxisStubParams<HorzScaleItem> {
-	rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
+export interface PriceAxisStubParams {
+	rendererOptionsProvider: PriceAxisRendererOptionsProvider;
 }
 
 export type BorderVisibleGetter = () => boolean;
 export type ColorGetter = () => string;
 
-export class PriceAxisStub<HorzScaleItem> implements IDestroyable {
+export class PriceAxisStub implements IDestroyable {
 	private readonly _cell: HTMLDivElement;
 	private readonly _canvasBinding: CanvasElementBitmapSizeBinding;
 
-	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
+	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider;
 
-	private _options: ChartOptionsInternal<HorzScaleItem>;
+	private _options: ChartOptionsBase;
 
 	private _invalidated: boolean = true;
 
@@ -41,8 +41,8 @@ export class PriceAxisStub<HorzScaleItem> implements IDestroyable {
 
 	public constructor(
 		side: PriceAxisWidgetSide,
-		options: ChartOptionsInternal<HorzScaleItem>,
-		params: PriceAxisStubParams<HorzScaleItem>,
+		options: ChartOptionsBase,
+		params: PriceAxisStubParams,
 		borderVisible: BorderVisibleGetter,
 		bottomColor: ColorGetter
 	) {
diff --git a/src/gui/price-axis-widget.ts b/src/gui/price-axis-widget.ts
index 6678d0733a..bda8ed608f 100644
--- a/src/gui/price-axis-widget.ts
+++ b/src/gui/price-axis-widget.ts
@@ -14,7 +14,7 @@ import { clearRect, clearRectWithGradient } from '../helpers/canvas-helpers';
 import { IDestroyable } from '../helpers/idestroyable';
 import { makeFont } from '../helpers/make-font';
 
-import { ChartOptionsInternal } from '../model/chart-model';
+import { ChartOptionsInternalBase } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { IDataSource } from '../model/idata-source';
 import { InvalidationLevel } from '../model/invalidate-mask';
@@ -49,11 +49,11 @@ const enum Constants {
 	LabelOffset = 5,
 }
 
-export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
-	private readonly _pane: PaneWidget<HorzScaleItem>;
-	private readonly _options: Readonly<ChartOptionsInternal<HorzScaleItem>>;
+export class PriceAxisWidget implements IDestroyable {
+	private readonly _pane: PaneWidget;
+	private readonly _options: Readonly<ChartOptionsInternalBase>;
 	private readonly _layoutOptions: Readonly<LayoutOptions>;
-	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
+	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider;
 	private readonly _isLeft: boolean;
 
 	private _priceScale: PriceScale | null = null;
@@ -73,7 +73,7 @@ export class PriceAxisWidget<HorzScaleItem> implements IDestroyable {
 	private _prevOptimalWidth: number = 0;
 	private _isSettingSize: boolean = false;
 
-	public constructor(pane: PaneWidget<HorzScaleItem>, options: Readonly<ChartOptionsInternal<HorzScaleItem>>, rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>, side: PriceAxisWidgetSide) {
+	public constructor(pane: PaneWidget, options: Readonly<ChartOptionsInternalBase>, rendererOptionsProvider: PriceAxisRendererOptionsProvider, side: PriceAxisWidgetSide) {
 		this._pane = pane;
 		this._options = options;
 		this._layoutOptions = options.layout;
diff --git a/src/gui/time-axis-widget.ts b/src/gui/time-axis-widget.ts
index 2447f11be8..8c909974f8 100644
--- a/src/gui/time-axis-widget.ts
+++ b/src/gui/time-axis-widget.ts
@@ -47,8 +47,8 @@ export class TimeAxisWidget<HorzScaleItem> implements MouseEventHandlers, IDestr
 	private readonly _dv: HTMLElement;
 	private readonly _canvasBinding: CanvasElementBitmapSizeBinding;
 	private readonly _topCanvasBinding: CanvasElementBitmapSizeBinding;
-	private _leftStub: PriceAxisStub<HorzScaleItem> | null = null;
-	private _rightStub: PriceAxisStub<HorzScaleItem> | null = null;
+	private _leftStub: PriceAxisStub | null = null;
+	private _rightStub: PriceAxisStub | null = null;
 	private readonly _mouseEventHandler: MouseEventHandler;
 	private _rendererOptions: TimeAxisViewRendererOptions | null = null;
 	private _mouseDown: boolean = false;
@@ -136,11 +136,11 @@ export class TimeAxisWidget<HorzScaleItem> implements MouseEventHandlers, IDestr
 		return this._element;
 	}
 
-	public leftStub(): PriceAxisStub<HorzScaleItem> | null {
+	public leftStub(): PriceAxisStub | null {
 		return this._leftStub;
 	}
 
-	public rightStub(): PriceAxisStub<HorzScaleItem> | null {
+	public rightStub(): PriceAxisStub | null {
 		return this._rightStub;
 	}
 
@@ -487,7 +487,7 @@ export class TimeAxisWidget<HorzScaleItem> implements MouseEventHandlers, IDestr
 			this._rightStub = null;
 		}
 		const rendererOptionsProvider = this._chart.model().rendererOptionsProvider();
-		const params: PriceAxisStubParams<HorzScaleItem> = {
+		const params: PriceAxisStubParams = {
 			rendererOptionsProvider: rendererOptionsProvider,
 		};
 
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index 090ae80f57..0f9e097303 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -379,6 +379,8 @@ export interface IChartModelBase {
 	updateSource(source: IPriceDataSource): void;
 	updateCrosshair(): void;
 	cursorUpdate(): void;
+	clearCurrentPosition(): void;
+	setAndSaveCurrentPosition(x: Coordinate, y: Coordinate, event: TouchMouseEventData | null, pane: Pane): void;
 
 	recalculatePane(pane: Pane | null): void;
 
@@ -393,18 +395,40 @@ export interface IChartModelBase {
 	moveSeriesToScale(series: ISeries<SeriesType>, targetScaleId: string): void;
 
 	priceAxisRendererOptions(): Readonly<PriceAxisViewRendererOptions>;
+	rendererOptionsProvider(): PriceAxisRendererOptionsProvider;
 
 	priceScalesOptionsChanged(): ISubscription;
 
 	hoveredSource(): HoveredSource | null;
 	setHoveredSource(source: HoveredSource | null): void;
+
+	crosshairSource(): Crosshair;
+	watermarkSource(): Watermark;
+
+	startScrollPrice(pane: Pane, priceScale: PriceScale, x: number): void;
+	scrollPriceTo(pane: Pane, priceScale: PriceScale, x: number): void;
+	endScrollPrice(pane: Pane, priceScale: PriceScale): void;
+	resetPriceScale(pane: Pane, priceScale: PriceScale): void;
+
+	startScalePrice(pane: Pane, priceScale: PriceScale, x: number): void;
+	scalePriceTo(pane: Pane, priceScale: PriceScale, x: number): void;
+	endScalePrice(pane: Pane, priceScale: PriceScale): void;
+
+	zoomTime(pointX: Coordinate, scale: number): void;
+	startScrollTime(x: Coordinate): void;
+	scrollTimeTo(x: Coordinate): void;
+	endScrollTime(): void;
+
+	setTimeScaleAnimation(animation: ITimeScaleAnimation): void;
+
+	stopTimeScaleAnimation(): void;
 }
 
 export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase {
 	private readonly _options: ChartOptionsInternal<HorzScaleItem>;
 	private readonly _invalidateHandler: InvalidateHandler;
 
-	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider<HorzScaleItem>;
+	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider;
 
 	private readonly _timeScale: TimeScale<HorzScaleItem>;
 	private readonly _panes: Pane[] = [];
@@ -802,7 +826,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		this._options.localization.timeFormatter = undefined;
 	}
 
-	public rendererOptionsProvider(): PriceAxisRendererOptionsProvider<HorzScaleItem> {
+	public rendererOptionsProvider(): PriceAxisRendererOptionsProvider {
 		return this._rendererOptionsProvider;
 	}
 
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index 84f0c30054..cfe850406f 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -174,11 +174,14 @@ export interface ITimeScale {
 	visibleStrictRange(): RangeImpl<TimePointIndex> | null;
 	hasPoints(): boolean;
 	timeToIndex(time: InternalHorzScaleItem, findNearest: boolean): TimePointIndex | null;
+
 	barSpacing(): number;
+	rightOffset(): number;
 
 	indexesToCoordinates<T extends TimedValue>(points: T[], visibleRange?: SeriesItemsIndexesRange): void;
 	indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint<unknown> | null;
 	formatDateTime(timeScalePoint: TimeScalePoint<unknown>): string;
+	coordinateToIndex(x: Coordinate): TimePointIndex;
 
 	options(): Readonly<HorzScaleOptions>;
 }
diff --git a/src/renderers/price-axis-renderer-options-provider.ts b/src/renderers/price-axis-renderer-options-provider.ts
index 43daf22357..88e0cdc2ca 100644
--- a/src/renderers/price-axis-renderer-options-provider.ts
+++ b/src/renderers/price-axis-renderer-options-provider.ts
@@ -1,6 +1,6 @@
 import { makeFont } from '../helpers/make-font';
 
-import { ChartModel } from '../model/chart-model';
+import { IChartModelBase } from '../model/chart-model';
 
 import { PriceAxisViewRendererOptions } from './iprice-axis-view-renderer';
 
@@ -9,8 +9,8 @@ const enum RendererConstants {
 	TickLength = 5,
 }
 
-export class PriceAxisRendererOptionsProvider<HorzScaleItem> {
-	private readonly _chartModel: ChartModel<HorzScaleItem>;
+export class PriceAxisRendererOptionsProvider {
+	private readonly _chartModel: IChartModelBase;
 
 	private readonly _rendererOptions: PriceAxisViewRendererOptions = {
 		borderSize: RendererConstants.BorderSize,
@@ -27,7 +27,7 @@ export class PriceAxisRendererOptionsProvider<HorzScaleItem> {
 		baselineOffset: 0,
 	};
 
-	public constructor(chartModel: ChartModel<HorzScaleItem>) {
+	public constructor(chartModel: IChartModelBase) {
 		this._chartModel = chartModel;
 	}
 

From 1523310c23cd91e0e5af30aa8712927524084ade Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Mon, 3 Jul 2023 17:21:45 +0300
Subject: [PATCH 21/23] Remove generic parameter from PlotRow

---
 src/api/chart-api.ts                          | 24 +++---
 src/api/get-series-data-creator.ts            | 32 ++++----
 src/api/iseries-api.ts                        |  4 +-
 src/api/series-api.ts                         | 18 ++---
 src/gui/chart-widget.ts                       | 30 +++----
 src/gui/pane-widget.ts                        |  2 +-
 src/model/chart-model.ts                      | 22 +++--
 src/model/data-consumer.ts                    |  4 +-
 src/model/data-layer.ts                       | 80 +++++++++----------
 src/model/data-validators.ts                  |  2 +-
 src/model/formatted-labels-cache.ts           |  8 +-
 src/model/get-series-plot-row-creator.ts      | 28 +++----
 .../horz-scale-behavior-time.ts               |  6 +-
 .../time-scale-point-weight-generator.ts      |  4 +-
 src/model/idata-source.ts                     |  2 +-
 src/model/ihorz-scale-behavior.ts             |  4 +-
 src/model/localization-options.ts             |  3 +
 src/model/magnet.ts                           |  2 +-
 src/model/plot-data.ts                        |  4 +-
 src/model/plot-list.ts                        |  2 +-
 src/model/series-bar-colorer.ts               | 60 +++++++-------
 src/model/series-data.ts                      | 34 ++++----
 src/model/series-markers.ts                   |  8 +-
 src/model/series.ts                           | 50 ++++++------
 src/model/sort-sources.ts                     |  1 +
 src/model/tick-marks.ts                       | 24 +++---
 src/model/time-data.ts                        |  4 +-
 src/model/time-scale.ts                       | 22 ++---
 src/views/pane/bars-pane-view-base.ts         |  6 +-
 src/views/pane/bars-pane-view.ts              |  2 +-
 src/views/pane/candlesticks-pane-view.ts      |  2 +-
 src/views/pane/line-pane-view-base.ts         |  2 +-
 src/views/pane/series-markers-pane-view.ts    |  4 +-
 tests/unittests/data-layer.spec.ts            | 28 +++----
 .../unittests/get-series-data-creator.spec.ts | 16 ++--
 tests/unittests/plot-list.spec.ts             |  6 +-
 tests/unittests/time-scale.spec.ts            |  2 +-
 37 files changed, 280 insertions(+), 272 deletions(-)

diff --git a/src/api/chart-api.ts b/src/api/chart-api.ts
index b9734e4385..88af1b3b93 100644
--- a/src/api/chart-api.ts
+++ b/src/api/chart-api.ts
@@ -111,8 +111,8 @@ export type IPriceScaleApiProvider<HorzScaleItem> = Pick<IChartApiBase<HorzScale
 export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, DataUpdatesConsumer<SeriesType, HorzScaleItem> {
 	private _chartWidget: ChartWidget<HorzScaleItem>;
 	private _dataLayer: DataLayer<HorzScaleItem>;
-	private readonly _seriesMap: Map<SeriesApi<SeriesType, HorzScaleItem>, Series<SeriesType, HorzScaleItem>> = new Map();
-	private readonly _seriesMapReversed: Map<Series<SeriesType, HorzScaleItem>, SeriesApi<SeriesType, HorzScaleItem>> = new Map();
+	private readonly _seriesMap: Map<SeriesApi<SeriesType, HorzScaleItem>, Series<SeriesType>> = new Map();
+	private readonly _seriesMapReversed: Map<Series<SeriesType>, SeriesApi<SeriesType, HorzScaleItem>> = new Map();
 
 	private readonly _clickedDelegate: Delegate<MouseEventParams<HorzScaleItem>> = new Delegate();
 	private readonly _crosshairMovedDelegate: Delegate<MouseEventParams<HorzScaleItem>> = new Delegate();
@@ -131,7 +131,7 @@ export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, Da
 		this._chartWidget = new ChartWidget(container, internalOptions, horzScaleBehavior);
 
 		this._chartWidget.clicked().subscribe(
-			(paramSupplier: MouseEventParamsImplSupplier<HorzScaleItem>) => {
+			(paramSupplier: MouseEventParamsImplSupplier) => {
 				if (this._clickedDelegate.hasListeners()) {
 					this._clickedDelegate.fire(this._convertMouseParams(paramSupplier()));
 				}
@@ -139,7 +139,7 @@ export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, Da
 			this
 		);
 		this._chartWidget.crosshairMoved().subscribe(
-			(paramSupplier: MouseEventParamsImplSupplier<HorzScaleItem>) => {
+			(paramSupplier: MouseEventParamsImplSupplier) => {
 				if (this._crosshairMovedDelegate.hasListeners()) {
 					this._crosshairMovedDelegate.fire(this._convertMouseParams(paramSupplier()));
 				}
@@ -215,11 +215,11 @@ export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, Da
 		this._seriesMapReversed.delete(series);
 	}
 
-	public applyNewData<TSeriesType extends SeriesType>(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void {
+	public applyNewData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void {
 		this._sendUpdateToChart(this._dataLayer.setSeriesData(series, data));
 	}
 
-	public updateData<TSeriesType extends SeriesType>(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void {
+	public updateData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void {
 		this._sendUpdateToChart(this._dataLayer.updateSeriesData(series, data));
 	}
 
@@ -280,22 +280,22 @@ export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, Da
 		return res;
 	}
 
-	private _sendUpdateToChart(update: DataUpdateResponse<HorzScaleItem>): void {
+	private _sendUpdateToChart(update: DataUpdateResponse): void {
 		const model = this._chartWidget.model();
 
 		model.updateTimeScale(update.timeScale.baseIndex, update.timeScale.points, update.timeScale.firstChangedPointIndex);
-		update.series.forEach((value: SeriesChanges<HorzScaleItem>, series: Series<SeriesType, HorzScaleItem>) => series.setData(value.data, value.info));
+		update.series.forEach((value: SeriesChanges, series: Series<SeriesType>) => series.setData(value.data, value.info));
 
 		model.recalculateAllPanes();
 	}
 
-	private _mapSeriesToApi(series: Series<SeriesType, HorzScaleItem>): ISeriesApi<SeriesType, HorzScaleItem> {
+	private _mapSeriesToApi(series: Series<SeriesType>): ISeriesApi<SeriesType, HorzScaleItem> {
 		return ensureDefined(this._seriesMapReversed.get(series));
 	}
 
-	private _convertMouseParams(param: MouseEventParamsImpl<HorzScaleItem>): MouseEventParams<HorzScaleItem> {
+	private _convertMouseParams(param: MouseEventParamsImpl): MouseEventParams<HorzScaleItem> {
 		const seriesData: MouseEventParams<HorzScaleItem>['seriesData'] = new Map();
-		param.seriesData.forEach((plotRow: SeriesPlotRow<SeriesType, HorzScaleItem>, series: Series<SeriesType, HorzScaleItem>) => {
+		param.seriesData.forEach((plotRow: SeriesPlotRow<SeriesType>, series: Series<SeriesType>) => {
 			const data = getSeriesDataCreator<SeriesType, HorzScaleItem>(series.seriesType())(plotRow);
 			assert(isFulfilledData(data));
 			seriesData.set(this._mapSeriesToApi(series), data);
@@ -304,7 +304,7 @@ export class ChartApi<HorzScaleItem> implements IChartApiBase<HorzScaleItem>, Da
 		const hoveredSeries = param.hoveredSeries === undefined ? undefined : this._mapSeriesToApi(param.hoveredSeries);
 
 		return {
-			time: param.time,
+			time: param.originalTime as HorzScaleItem,
 			logical: param.index as Logical | undefined,
 			point: param.point,
 			hoveredSeries,
diff --git a/src/api/get-series-data-creator.ts b/src/api/get-series-data-creator.ts
index 0796d19670..fd11a3c108 100644
--- a/src/api/get-series-data-creator.ts
+++ b/src/api/get-series-data-creator.ts
@@ -20,17 +20,17 @@ import {
 import { SeriesType } from '../model/series-options';
 
 type SeriesPlotRowToDataMap<HorzScaleItem> = {
-	[T in keyof SeriesDataItemTypeMap<HorzScaleItem>]: (plotRow: SeriesPlotRow<T, HorzScaleItem>) => SeriesDataItemTypeMap<HorzScaleItem>[T];
+	[T in keyof SeriesDataItemTypeMap<HorzScaleItem>]: (plotRow: SeriesPlotRow<T>) => SeriesDataItemTypeMap<HorzScaleItem>[T];
 };
 
-function singleValueData<HorzScaleItem>(plotRow: PlotRow<HorzScaleItem>): SingleValueData<HorzScaleItem> {
+function singleValueData<HorzScaleItem>(plotRow: PlotRow): SingleValueData<HorzScaleItem> {
 	return {
 		value: plotRow.value[PlotRowValueIndex.Close],
-		time: plotRow.originalTime as unknown as HorzScaleItem,
+		time: plotRow.originalTime as HorzScaleItem,
 	};
 }
 
-function lineData<HorzScaleItem>(plotRow: LinePlotRow<HorzScaleItem>): LineData<HorzScaleItem> {
+function lineData<HorzScaleItem>(plotRow: LinePlotRow): LineData<HorzScaleItem> {
 	const result: LineData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.color !== undefined) {
@@ -40,7 +40,7 @@ function lineData<HorzScaleItem>(plotRow: LinePlotRow<HorzScaleItem>): LineData<
 	return result;
 }
 
-function areaData<HorzScaleItem>(plotRow: AreaPlotRow<HorzScaleItem>): AreaData<HorzScaleItem> {
+function areaData<HorzScaleItem>(plotRow: AreaPlotRow): AreaData<HorzScaleItem> {
 	const result: AreaData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.lineColor !== undefined) {
@@ -58,7 +58,7 @@ function areaData<HorzScaleItem>(plotRow: AreaPlotRow<HorzScaleItem>): AreaData<
 	return result;
 }
 
-function baselineData<HorzScaleItem>(plotRow: BaselinePlotRow<HorzScaleItem>): BaselineData<HorzScaleItem> {
+function baselineData<HorzScaleItem>(plotRow: BaselinePlotRow): BaselineData<HorzScaleItem> {
 	const result: BaselineData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.topLineColor !== undefined) {
@@ -88,18 +88,18 @@ function baselineData<HorzScaleItem>(plotRow: BaselinePlotRow<HorzScaleItem>): B
 	return result;
 }
 
-function ohlcData<HorzScaleItem>(plotRow: PlotRow<HorzScaleItem>): OhlcData<HorzScaleItem> {
+function ohlcData<HorzScaleItem>(plotRow: PlotRow): OhlcData<HorzScaleItem> {
 	return {
 		open: plotRow.value[PlotRowValueIndex.Open],
 		high: plotRow.value[PlotRowValueIndex.High],
 		low: plotRow.value[PlotRowValueIndex.Low],
 		close: plotRow.value[PlotRowValueIndex.Close],
-		time: plotRow.originalTime as unknown as HorzScaleItem,
+		time: plotRow.originalTime as HorzScaleItem,
 	};
 }
 
-function barData<HorzScaleItem>(plotRow: BarPlotRow<HorzScaleItem>): BarData<HorzScaleItem> {
-	const result: BarData<HorzScaleItem> = ohlcData(plotRow);
+function barData<HorzScaleItem>(plotRow: BarPlotRow): BarData<HorzScaleItem> {
+	const result: BarData<HorzScaleItem> = ohlcData<HorzScaleItem>(plotRow);
 
 	if (plotRow.color !== undefined) {
 		result.color = plotRow.color;
@@ -108,7 +108,7 @@ function barData<HorzScaleItem>(plotRow: BarPlotRow<HorzScaleItem>): BarData<Hor
 	return result;
 }
 
-function candlestickData<HorzScaleItem>(plotRow: CandlestickPlotRow<HorzScaleItem>): CandlestickData<HorzScaleItem> {
+function candlestickData<HorzScaleItem>(plotRow: CandlestickPlotRow): CandlestickData<HorzScaleItem> {
 	const result: CandlestickData<HorzScaleItem> = ohlcData(plotRow);
 	const { color, borderColor, wickColor } = plotRow;
 
@@ -127,12 +127,12 @@ function candlestickData<HorzScaleItem>(plotRow: CandlestickPlotRow<HorzScaleIte
 	return result;
 }
 
-export function getSeriesDataCreator<TSeriesType extends SeriesType, HorzScaleItem>(seriesType: TSeriesType): (plotRow: SeriesPlotRow<TSeriesType, HorzScaleItem>) => SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType] {
+export function getSeriesDataCreator<TSeriesType extends SeriesType, HorzScaleItem>(seriesType: TSeriesType): (plotRow: SeriesPlotRow<TSeriesType>) => SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType] {
 	const seriesPlotRowToDataMap: SeriesPlotRowToDataMap<HorzScaleItem> = {
-		Area: areaData<HorzScaleItem>,
-		Line: lineData<HorzScaleItem>,
-		Baseline: baselineData<HorzScaleItem>,
-		Histogram: lineData<HorzScaleItem>,
+		Area: areaData,
+		Line: lineData,
+		Baseline: baselineData,
+		Histogram: lineData,
 		Bar: barData,
 		Candlestick: candlestickData,
 	};
diff --git a/src/api/iseries-api.ts b/src/api/iseries-api.ts
index 47fd9de4d5..b465f29fbd 100644
--- a/src/api/iseries-api.ts
+++ b/src/api/iseries-api.ts
@@ -213,12 +213,12 @@ export interface ISeriesApi<TSeriesType extends SeriesType, HorzScaleItem = Time
 	 * });
 	 * ```
 	 */
-	setMarkers(data: SeriesMarker<HorzScaleItem, HorzScaleItem>[]): void;
+	setMarkers(data: SeriesMarker<HorzScaleItem>[]): void;
 
 	/**
 	 * Returns an array of series markers.
 	 */
-	markers(): SeriesMarker<HorzScaleItem, HorzScaleItem>[];
+	markers(): SeriesMarker<HorzScaleItem>[];
 
 	/**
 	 * Creates a new price line
diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index 036332e2ef..7e8a59c137 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -30,14 +30,14 @@ import { priceLineOptionsDefaults } from './options/price-line-options-defaults'
 import { PriceLine } from './price-line-api';
 
 export class SeriesApi<TSeriesType extends SeriesType, HorzScaleItem> implements ISeriesApi<TSeriesType, HorzScaleItem> {
-	protected _series: Series<TSeriesType, HorzScaleItem>;
+	protected _series: Series<TSeriesType>;
 	protected _dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType, HorzScaleItem>;
 
 	private readonly _priceScaleApiProvider: IPriceScaleApiProvider<HorzScaleItem>;
 
 	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
 
-	public constructor(series: Series<TSeriesType, HorzScaleItem>, dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType, HorzScaleItem>, priceScaleApiProvider: IPriceScaleApiProvider<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
+	public constructor(series: Series<TSeriesType>, dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType, HorzScaleItem>, priceScaleApiProvider: IPriceScaleApiProvider<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
 		this._series = series;
 		this._dataUpdatesConsumer = dataUpdatesConsumer;
 		this._priceScaleApiProvider = priceScaleApiProvider;
@@ -141,23 +141,23 @@ export class SeriesApi<TSeriesType extends SeriesType, HorzScaleItem> implements
 		return getSeriesDataCreator<TSeriesType, HorzScaleItem>(this.seriesType())(data);
 	}
 
-	public setMarkers(data: SeriesMarker<HorzScaleItem, HorzScaleItem>[]): void {
+	public setMarkers(data: SeriesMarker<HorzScaleItem>[]): void {
 		checkItemsAreOrdered(data, this._horzScaleBehavior, true);
 
-		const convertedMarkers = data.map<SeriesMarker<InternalHorzScaleItem, HorzScaleItem>>((marker: SeriesMarker<HorzScaleItem, HorzScaleItem>) => ({
-			...marker as Omit<SeriesMarker<HorzScaleItem, HorzScaleItem>, 'time'>,
+		const convertedMarkers = data.map((marker: SeriesMarker<HorzScaleItem>) => ({
+			...marker as Omit<SeriesMarker<HorzScaleItem>, 'time' | 'originalTime'>,
 			originalTime: marker.time,
 			time: this._horzScaleBehavior.convertHorzItemToInternal(marker.time),
 		}));
 		this._series.setMarkers(convertedMarkers);
 	}
 
-	public markers(): SeriesMarker<HorzScaleItem, HorzScaleItem>[] {
-		return this._series.markers().map<SeriesMarker<HorzScaleItem, HorzScaleItem>>((internalItem: SeriesMarker<InternalHorzScaleItem, HorzScaleItem>) => {
+	public markers(): SeriesMarker<HorzScaleItem>[] {
+		return this._series.markers().map<SeriesMarker<HorzScaleItem>>((internalItem: SeriesMarker<InternalHorzScaleItem>) => {
 			const { originalTime, time, ...item } = internalItem;
 			return {
-				time: originalTime,
-				...item as Omit<SeriesMarker<HorzScaleItem, HorzScaleItem>, 'time' | 'originalTIme'>,
+				time: originalTime as HorzScaleItem,
+				...item as Omit<SeriesMarker<InternalHorzScaleItem>, 'time' | 'originalTIme'>,
 			};
 		});
 	}
diff --git a/src/gui/chart-widget.ts b/src/gui/chart-widget.ts
index ec0d2b93c4..8a96d52576 100644
--- a/src/gui/chart-widget.ts
+++ b/src/gui/chart-widget.ts
@@ -8,7 +8,7 @@ import { ISubscription } from '../helpers/isubscription';
 import { warn } from '../helpers/logger';
 import { DeepPartial } from '../helpers/strict-type-checks';
 
-import { IChartModelBase, ChartModel, ChartOptionsInternal, ChartOptionsInternalBase } from '../model/chart-model';
+import { ChartModel, ChartOptionsInternal, ChartOptionsInternalBase, IChartModelBase } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { DefaultPriceScaleId } from '../model/default-price-scale';
 import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
@@ -29,17 +29,17 @@ import { suggestChartSize, suggestPriceScaleWidth, suggestTimeScaleHeight } from
 import { PaneWidget } from './pane-widget';
 import { TimeAxisWidget } from './time-axis-widget';
 
-export interface MouseEventParamsImpl<HorzScaleItem> {
-	time?: HorzScaleItem;
+export interface MouseEventParamsImpl {
+	originalTime?: unknown;
 	index?: TimePointIndex;
 	point?: Point;
-	seriesData: Map<Series<SeriesType, HorzScaleItem>, SeriesPlotRow<SeriesType, HorzScaleItem>>;
-	hoveredSeries?: Series<SeriesType, HorzScaleItem>;
+	seriesData: Map<Series<SeriesType>, SeriesPlotRow<SeriesType>>;
+	hoveredSeries?: Series<SeriesType>;
 	hoveredObject?: string;
 	touchMouseEventData?: TouchMouseEventData;
 }
 
-export type MouseEventParamsImplSupplier<HorzScaleItem> = () => MouseEventParamsImpl<HorzScaleItem>;
+export type MouseEventParamsImplSupplier = () => MouseEventParamsImpl;
 
 const windowsChrome = isChromiumBased() && isWindows();
 
@@ -65,8 +65,8 @@ export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBas
 	private _timeAxisWidget: TimeAxisWidget<HorzScaleItem>;
 	private _invalidateMask: InvalidateMask | null = null;
 	private _drawPlanned: boolean = false;
-	private _clicked: Delegate<MouseEventParamsImplSupplier<HorzScaleItem>> = new Delegate();
-	private _crosshairMoved: Delegate<MouseEventParamsImplSupplier<HorzScaleItem>> = new Delegate();
+	private _clicked: Delegate<MouseEventParamsImplSupplier> = new Delegate();
+	private _crosshairMoved: Delegate<MouseEventParamsImplSupplier> = new Delegate();
 	private _onWheelBound: (event: WheelEvent) => void;
 	private _observer: ResizeObserver | null = null;
 
@@ -239,11 +239,11 @@ export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBas
 		this._applyAutoSizeOptions(options);
 	}
 
-	public clicked(): ISubscription<MouseEventParamsImplSupplier<HorzScaleItem>> {
+	public clicked(): ISubscription<MouseEventParamsImplSupplier> {
 		return this._clicked;
 	}
 
-	public crosshairMoved(): ISubscription<MouseEventParamsImplSupplier<HorzScaleItem>> {
+	public crosshairMoved(): ISubscription<MouseEventParamsImplSupplier> {
 		return this._crosshairMoved;
 	}
 
@@ -720,11 +720,11 @@ export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBas
 		index: TimePointIndex | null,
 		point: Point | null,
 		event: TouchMouseEventData | null
-	): MouseEventParamsImpl<HorzScaleItem> {
-		const seriesData = new Map<Series<SeriesType, HorzScaleItem>, SeriesPlotRow<SeriesType, HorzScaleItem>>();
+	): MouseEventParamsImpl {
+		const seriesData = new Map<Series<SeriesType>, SeriesPlotRow<SeriesType>>();
 		if (index !== null) {
 			const serieses = this._model.serieses();
-			serieses.forEach((s: Series<SeriesType, HorzScaleItem>) => {
+			serieses.forEach((s: Series<SeriesType>) => {
 				// TODO: replace with search left
 				const data = s.bars().search(index);
 				if (data !== null) {
@@ -732,7 +732,7 @@ export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBas
 				}
 			});
 		}
-		let clientTime: HorzScaleItem | undefined;
+		let clientTime: unknown | undefined;
 		if (index !== null) {
 			const timePoint = this._model.timeScale().indexToTimeScalePoint(index)?.originalTime;
 			if (timePoint !== undefined) {
@@ -751,7 +751,7 @@ export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBas
 			: undefined;
 
 		return {
-			time: clientTime,
+			originalTime: clientTime,
 			index: index ?? undefined,
 			point: point ?? undefined,
 			hoveredSeries,
diff --git a/src/gui/pane-widget.ts b/src/gui/pane-widget.ts
index cdcac71b5e..42cf31f1b1 100644
--- a/src/gui/pane-widget.ts
+++ b/src/gui/pane-widget.ts
@@ -14,7 +14,7 @@ import { Delegate } from '../helpers/delegate';
 import { IDestroyable } from '../helpers/idestroyable';
 import { ISubscription } from '../helpers/isubscription';
 
-import { IChartModelBase, HoveredObject, TrackingModeExitMode } from '../model/chart-model';
+import { HoveredObject, IChartModelBase, TrackingModeExitMode } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { IDataSource } from '../model/idata-source';
 import { InvalidationLevel } from '../model/invalidate-mask';
diff --git a/src/model/chart-model.ts b/src/model/chart-model.ts
index 0f9e097303..5afcf904b4 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -230,6 +230,9 @@ export interface TrackingModeOptions {
 	exitMode: TrackingModeExitMode;
 }
 
+/**
+ * Represents common chart options
+ */
 export interface ChartOptionsBase {
 	/**
 	 * Width of the chart in pixels
@@ -327,6 +330,9 @@ export interface ChartOptionsBase {
 	 */
 	trackingMode: TrackingModeOptions;
 
+	/**
+	 * Basic localization options
+	 */
 	localization: LocalizationOptionsBase;
 }
 
@@ -436,7 +442,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 	private readonly _magnet: Magnet;
 	private readonly _watermark: Watermark;
 
-	private _serieses: Series<SeriesType, HorzScaleItem>[] = [];
+	private _serieses: Series<SeriesType>[] = [];
 
 	private _width: number = 0;
 	private _hoveredSource: HoveredSource | null = null;
@@ -723,7 +729,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		this.lightUpdate();
 	}
 
-	public serieses(): readonly Series<SeriesType, HorzScaleItem>[] {
+	public serieses(): readonly Series<SeriesType>[] {
 		return this._serieses;
 	}
 
@@ -769,7 +775,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		this._crosshair.updateAllViews();
 	}
 
-	public updateTimeScale(newBaseIndex: TimePointIndex | null, newPoints?: readonly TimeScalePoint<HorzScaleItem>[], firstChangedPointIndex?: number): void {
+	public updateTimeScale(newBaseIndex: TimePointIndex | null, newPoints?: readonly TimeScalePoint[], firstChangedPointIndex?: number): void {
 		const oldFirstTime = this._timeScale.indexToTime(0 as TimePointIndex);
 
 		if (newPoints !== undefined && firstChangedPointIndex !== undefined) {
@@ -838,7 +844,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return this._priceScalesOptionsChanged;
 	}
 
-	public createSeries<T extends SeriesType>(seriesType: T, options: SeriesOptionsMap[T]): Series<T, HorzScaleItem> {
+	public createSeries<T extends SeriesType>(seriesType: T, options: SeriesOptionsMap[T]): Series<T> {
 		const pane = this._panes[0];
 		const series = this._createSeries(options, seriesType, pane);
 		this._serieses.push(series);
@@ -853,7 +859,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		return series;
 	}
 
-	public removeSeries(series: Series<SeriesType, HorzScaleItem>): void {
+	public removeSeries(series: Series<SeriesType>): void {
 		const pane = this.paneForSource(series);
 
 		const seriesIndex = this._serieses.indexOf(series);
@@ -866,7 +872,7 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		}
 	}
 
-	public moveSeriesToScale(series: Series<SeriesType, HorzScaleItem>, targetScaleId: string): void {
+	public moveSeriesToScale(series: Series<SeriesType>, targetScaleId: string): void {
 		const pane = ensureNotNull(this.paneForSource(series));
 		pane.removeDataSource(series);
 
@@ -998,8 +1004,8 @@ export class ChartModel<HorzScaleItem> implements IDestroyable, IChartModelBase
 		this._panes.forEach((pane: Pane) => pane.grid().paneView().update());
 	}
 
-	private _createSeries<T extends SeriesType>(options: SeriesOptionsInternal<T>, seriesType: T, pane: Pane): Series<T, HorzScaleItem> {
-		const series = new Series<T, HorzScaleItem>(this, options, seriesType);
+	private _createSeries<T extends SeriesType>(options: SeriesOptionsInternal<T>, seriesType: T, pane: Pane): Series<T> {
+		const series = new Series<T>(this, options, seriesType);
 
 		const targetScaleId = options.priceScaleId !== undefined ? options.priceScaleId : this.defaultVisiblePriceScaleId();
 		pane.addDataSource(series, targetScaleId);
diff --git a/src/model/data-consumer.ts b/src/model/data-consumer.ts
index 9428146d71..00c9bb1169 100644
--- a/src/model/data-consumer.ts
+++ b/src/model/data-consumer.ts
@@ -216,6 +216,6 @@ export interface SeriesDataItemTypeMap<HorzScaleItem = Time> {
 }
 
 export interface DataUpdatesConsumer<TSeriesType extends SeriesType, HorzScaleItem = Time> {
-	applyNewData(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void;
-	updateData(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void;
+	applyNewData(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void;
+	updateData(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void;
 }
diff --git a/src/model/data-layer.ts b/src/model/data-layer.ts
index 50d2dcc9ef..4618f3943b 100644
--- a/src/model/data-layer.ts
+++ b/src/model/data-layer.ts
@@ -18,7 +18,7 @@ import {
 
 export type TimedData<HorzScaleItem> = Pick<SeriesDataItemTypeMap<HorzScaleItem>[SeriesType], 'time'>;
 
-export interface TimeScaleChanges<HorzScaleItem> {
+export interface TimeScaleChanges {
 	/**
 	 * An index of the first changed time scale point by any type of change (time, weight, etc)
 	 */
@@ -27,7 +27,7 @@ export interface TimeScaleChanges<HorzScaleItem> {
 	/**
 	 * An array of the new time scale points
 	 */
-	points?: readonly TimeScalePoint<HorzScaleItem>[];
+	points?: readonly TimeScalePoint[];
 
 	/**
 	 * In terms of time scale "base index" means the latest time scale point with data (there might be whitespaces)
@@ -35,43 +35,43 @@ export interface TimeScaleChanges<HorzScaleItem> {
 	baseIndex: TimePointIndex | null;
 }
 
-export interface SeriesChanges<HorzScaleItem> {
+export interface SeriesChanges {
 	/**
 	 * Data to be merged into series' plot list
 	 */
-	data: readonly SeriesPlotRow<SeriesType, HorzScaleItem>[];
+	data: readonly SeriesPlotRow<SeriesType>[];
 	/**
 	 * Additional info about this change
 	 */
 	info?: SeriesUpdateInfo;
 }
 
-export interface DataUpdateResponse<HorzScaleItem> {
+export interface DataUpdateResponse {
 	/**
 	 * Contains updates for all _changed_ series (if series data doesn't changed then it will not be here)
 	 */
-	series: Map<Series<SeriesType, HorzScaleItem>, SeriesChanges<HorzScaleItem>>;
+	series: Map<Series<SeriesType>, SeriesChanges>;
 
 	/**
 	 * Contains optional time scale points
 	 */
-	timeScale: TimeScaleChanges<HorzScaleItem>;
+	timeScale: TimeScaleChanges;
 }
 
-interface TimePointData<HorzScaleItem> {
+interface TimePointData {
 	index: TimePointIndex;
 	timePoint: InternalHorzScaleItem;
 
 	// actually the type of the value should be related to the series' type (generic type)
 	// here, in data layer all data for us is "mutable" by default, but to the chart we provide "readonly" data, to avoid modifying it
-	mapping: Map<Series<SeriesType, HorzScaleItem>, Mutable<SeriesPlotRow<SeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>>>;
+	mapping: Map<Series<SeriesType>, Mutable<SeriesPlotRow<SeriesType> | WhitespacePlotRow>>;
 }
 
-export interface InternalTimeScalePoint<HorzScaleItem> extends Mutable<TimeScalePoint<HorzScaleItem>> {
-	pointData: TimePointData<HorzScaleItem>;
+export interface InternalTimeScalePoint extends Mutable<TimeScalePoint> {
+	pointData: TimePointData;
 }
 
-function createEmptyTimePointData<HorzScaleItem>(timePoint: InternalHorzScaleItem): TimePointData<HorzScaleItem> {
+function createEmptyTimePointData(timePoint: InternalHorzScaleItem): TimePointData {
 	return { index: 0 as TimePointIndex, mapping: new Map(), timePoint };
 }
 
@@ -80,7 +80,7 @@ interface SeriesRowsFirstAndLastTime {
 	lastTime: InternalHorzScaleItemKey;
 }
 
-function seriesRowsFirsAndLastTime<TSeriesType extends SeriesType, HorzScaleItem>(seriesRows: SeriesPlotRow<TSeriesType, HorzScaleItem>[] | undefined, bh: IHorzScaleBehavior<HorzScaleItem>): SeriesRowsFirstAndLastTime | undefined {
+function seriesRowsFirsAndLastTime<TSeriesType extends SeriesType, HorzScaleItem>(seriesRows: SeriesPlotRow<TSeriesType>[] | undefined, bh: IHorzScaleBehavior<HorzScaleItem>): SeriesRowsFirstAndLastTime | undefined {
 	if (seriesRows === undefined || seriesRows.length === 0) {
 		return undefined;
 	}
@@ -91,7 +91,7 @@ function seriesRowsFirsAndLastTime<TSeriesType extends SeriesType, HorzScaleItem
 	};
 }
 
-function seriesUpdateInfo<TSeriesType extends SeriesType, HorzScaleItem>(seriesRows: SeriesPlotRow<TSeriesType, HorzScaleItem>[] | undefined, prevSeriesRows: SeriesPlotRow<TSeriesType, HorzScaleItem>[] | undefined, bh: IHorzScaleBehavior<HorzScaleItem>): SeriesUpdateInfo | undefined {
+function seriesUpdateInfo<TSeriesType extends SeriesType, HorzScaleItem>(seriesRows: SeriesPlotRow<TSeriesType>[] | undefined, prevSeriesRows: SeriesPlotRow<TSeriesType>[] | undefined, bh: IHorzScaleBehavior<HorzScaleItem>): SeriesUpdateInfo | undefined {
 	const firstAndLastTime = seriesRowsFirsAndLastTime(seriesRows, bh);
 	const prevFirstAndLastTime = seriesRowsFirsAndLastTime(prevSeriesRows, bh);
 	if (firstAndLastTime !== undefined && prevFirstAndLastTime !== undefined) {
@@ -105,11 +105,11 @@ function seriesUpdateInfo<TSeriesType extends SeriesType, HorzScaleItem>(seriesR
 	return undefined;
 }
 
-function timeScalePointTime<TSeriesType extends SeriesType, HorzScaleItem>(mergedPointData: Map<Series<TSeriesType, HorzScaleItem>, SeriesPlotRow<TSeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>>): HorzScaleItem {
+function timeScalePointTime<TSeriesType extends SeriesType, HorzScaleItem>(mergedPointData: Map<Series<TSeriesType>, SeriesPlotRow<TSeriesType> | WhitespacePlotRow>): HorzScaleItem {
 	let result: HorzScaleItem | undefined;
-	mergedPointData.forEach((v: SeriesPlotRow<TSeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>) => {
+	mergedPointData.forEach((v: SeriesPlotRow<TSeriesType> | WhitespacePlotRow) => {
 		if (result === undefined) {
-			result = v.originalTime;
+			result = v.originalTime as HorzScaleItem;
 		}
 	});
 
@@ -129,12 +129,12 @@ type SeriesDataItemWithOriginalTime<TSeriesType extends SeriesType, HorzScaleIte
 export class DataLayer<HorzScaleItem> {
 	// note that _pointDataByTimePoint and _seriesRowsBySeries shares THE SAME objects in their values between each other
 	// it's just different kind of maps to make usages/perf better
-	private _pointDataByTimePoint: Map<InternalHorzScaleItemKey, TimePointData<HorzScaleItem>> = new Map();
-	private _seriesRowsBySeries: Map<Series<SeriesType, HorzScaleItem>, SeriesPlotRow<SeriesType, HorzScaleItem>[]> = new Map();
-	private _seriesLastTimePoint: Map<Series<SeriesType, HorzScaleItem>, InternalHorzScaleItem> = new Map();
+	private _pointDataByTimePoint: Map<InternalHorzScaleItemKey, TimePointData> = new Map();
+	private _seriesRowsBySeries: Map<Series<SeriesType>, SeriesPlotRow<SeriesType>[]> = new Map();
+	private _seriesLastTimePoint: Map<Series<SeriesType>, InternalHorzScaleItem> = new Map();
 
 	// this is kind of "dest" values (in opposite to "source" ones) - we don't need to modify it manually, the only by calling _updateTimeScalePoints or updateSeriesData methods
-	private _sortedTimePoints: readonly InternalTimeScalePoint<HorzScaleItem>[] = [];
+	private _sortedTimePoints: readonly InternalTimeScalePoint[] = [];
 
 	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
 
@@ -149,7 +149,7 @@ export class DataLayer<HorzScaleItem> {
 		this._sortedTimePoints = [];
 	}
 
-	public setSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): DataUpdateResponse<HorzScaleItem> {
+	public setSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): DataUpdateResponse {
 		let needCleanupPoints = this._pointDataByTimePoint.size !== 0;
 
 		let isTimeScaleAffected = false;
@@ -174,7 +174,7 @@ export class DataLayer<HorzScaleItem> {
 			}
 		}
 
-		let seriesRows: (SeriesPlotRow<TSeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>)[] = [];
+		let seriesRows: (SeriesPlotRow<TSeriesType> | WhitespacePlotRow)[] = [];
 
 		if (data.length !== 0) {
 			const extendedData = data as SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>[];
@@ -220,8 +220,8 @@ export class DataLayer<HorzScaleItem> {
 		if (isTimeScaleAffected) {
 			// then generate the time scale points
 			// timeWeight will be updates in _updateTimeScalePoints later
-			const newTimeScalePoints: InternalTimeScalePoint<HorzScaleItem>[] = [];
-			this._pointDataByTimePoint.forEach((pointData: TimePointData<HorzScaleItem>) => {
+			const newTimeScalePoints: InternalTimeScalePoint[] = [];
+			this._pointDataByTimePoint.forEach((pointData: TimePointData) => {
 				newTimeScalePoints.push({
 					timeWeight: 0 as TickMarkWeightValue,
 					time: pointData.timePoint,
@@ -230,7 +230,7 @@ export class DataLayer<HorzScaleItem> {
 				});
 			});
 
-			newTimeScalePoints.sort((t1: InternalTimeScalePoint<HorzScaleItem>, t2: InternalTimeScalePoint<HorzScaleItem>) => this._horzScaleBehavior.key(t1.time) - this._horzScaleBehavior.key(t2.time));
+			newTimeScalePoints.sort((t1: InternalTimeScalePoint, t2: InternalTimeScalePoint) => this._horzScaleBehavior.key(t1.time) - this._horzScaleBehavior.key(t2.time));
 
 			firstChangedPointIndex = this._replaceTimeScalePoints(newTimeScalePoints);
 		}
@@ -242,11 +242,11 @@ export class DataLayer<HorzScaleItem> {
 		);
 	}
 
-	public removeSeries(series: Series<SeriesType, HorzScaleItem>): DataUpdateResponse<HorzScaleItem> {
+	public removeSeries(series: Series<SeriesType>): DataUpdateResponse {
 		return this.setSeriesData(series, []);
 	}
 
-	public updateSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType, HorzScaleItem>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): DataUpdateResponse<HorzScaleItem> {
+	public updateSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): DataUpdateResponse {
 		const extendedData = data as SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>;
 		saveOriginalTime(extendedData);
 		// convertStringToBusinessDay(data);
@@ -286,19 +286,19 @@ export class DataLayer<HorzScaleItem> {
 			return this._getUpdateResponse(series, -1, info);
 		}
 
-		const newPoint: InternalTimeScalePoint<HorzScaleItem> = {
+		const newPoint: InternalTimeScalePoint = {
 			timeWeight: 0 as TickMarkWeightValue,
 			time: pointDataAtTime.timePoint,
 			pointData: pointDataAtTime,
 			originalTime: timeScalePointTime(pointDataAtTime.mapping),
 		};
 
-		const insertIndex = lowerbound(this._sortedTimePoints, this._horzScaleBehavior.key(newPoint.time), (a: InternalTimeScalePoint<HorzScaleItem>, b: number) => this._horzScaleBehavior.key(a.time) < b);
+		const insertIndex = lowerbound(this._sortedTimePoints, this._horzScaleBehavior.key(newPoint.time), (a: InternalTimeScalePoint, b: number) => this._horzScaleBehavior.key(a.time) < b);
 
 		// yes, I know that this array is readonly and this change is intended to make it performative
 		// we marked _sortedTimePoints array as readonly to avoid modifying this array anywhere else
 		// but this place is exceptional case due performance reasons, sorry
-		(this._sortedTimePoints as InternalTimeScalePoint<HorzScaleItem>[]).splice(insertIndex, 0, newPoint);
+		(this._sortedTimePoints as InternalTimeScalePoint[]).splice(insertIndex, 0, newPoint);
 
 		for (let index = insertIndex; index < this._sortedTimePoints.length; ++index) {
 			assignIndexToPointData(this._sortedTimePoints[index].pointData, index as TimePointIndex);
@@ -309,7 +309,7 @@ export class DataLayer<HorzScaleItem> {
 		return this._getUpdateResponse(series, insertIndex, info);
 	}
 
-	private _updateLastSeriesRow(series: Series<SeriesType, HorzScaleItem>, plotRow: SeriesPlotRow<SeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>): void {
+	private _updateLastSeriesRow(series: Series<SeriesType>, plotRow: SeriesPlotRow<SeriesType> | WhitespacePlotRow): void {
 		let seriesData = this._seriesRowsBySeries.get(series);
 		if (seriesData === undefined) {
 			seriesData = [];
@@ -333,7 +333,7 @@ export class DataLayer<HorzScaleItem> {
 		this._seriesLastTimePoint.set(series, plotRow.time);
 	}
 
-	private _setRowsToSeries(series: Series<SeriesType, HorzScaleItem>, seriesRows: (SeriesPlotRow<SeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>)[]): void {
+	private _setRowsToSeries(series: Series<SeriesType>, seriesRows: (SeriesPlotRow<SeriesType> | WhitespacePlotRow)[]): void {
 		if (seriesRows.length !== 0) {
 			this._seriesRowsBySeries.set(series, seriesRows.filter(isSeriesPlotRow));
 			this._seriesLastTimePoint.set(series, seriesRows[seriesRows.length - 1].time);
@@ -360,7 +360,7 @@ export class DataLayer<HorzScaleItem> {
 	 *
 	 * @returns The index of the first changed point or `-1` if there is no change.
 	 */
-	private _replaceTimeScalePoints(newTimePoints: InternalTimeScalePoint<HorzScaleItem>[]): number {
+	private _replaceTimeScalePoints(newTimePoints: InternalTimeScalePoint[]): number {
 		let firstChangedPointIndex = -1;
 
 		// search the first different point and "syncing" time weight by the way
@@ -411,7 +411,7 @@ export class DataLayer<HorzScaleItem> {
 
 		let baseIndex = 0 as TimePointIndex;
 
-		this._seriesRowsBySeries.forEach((data: SeriesPlotRow<SeriesType, HorzScaleItem>[]) => {
+		this._seriesRowsBySeries.forEach((data: SeriesPlotRow<SeriesType>[]) => {
 			if (data.length !== 0) {
 				baseIndex = Math.max(baseIndex, data[data.length - 1].index) as TimePointIndex;
 			}
@@ -420,8 +420,8 @@ export class DataLayer<HorzScaleItem> {
 		return baseIndex;
 	}
 
-	private _getUpdateResponse(updatedSeries: Series<SeriesType, HorzScaleItem>, firstChangedPointIndex: number, info?: SeriesUpdateInfo): DataUpdateResponse<HorzScaleItem> {
-		const dataUpdateResponse: DataUpdateResponse<HorzScaleItem> = {
+	private _getUpdateResponse(updatedSeries: Series<SeriesType>, firstChangedPointIndex: number, info?: SeriesUpdateInfo): DataUpdateResponse {
+		const dataUpdateResponse: DataUpdateResponse = {
 			series: new Map(),
 			timeScale: {
 				baseIndex: this._getBaseIndex(),
@@ -431,7 +431,7 @@ export class DataLayer<HorzScaleItem> {
 		if (firstChangedPointIndex !== -1) {
 			// TODO: it's possible to make perf improvements by checking what series has data after firstChangedPointIndex
 			// but let's skip for now
-			this._seriesRowsBySeries.forEach((data: SeriesPlotRow<SeriesType, HorzScaleItem>[], s: Series<SeriesType, HorzScaleItem>) => {
+			this._seriesRowsBySeries.forEach((data: SeriesPlotRow<SeriesType>[], s: Series<SeriesType>) => {
 				dataUpdateResponse.series.set(
 					s,
 					{
@@ -460,12 +460,12 @@ export class DataLayer<HorzScaleItem> {
 	}
 }
 
-function assignIndexToPointData<HorzScaleItem>(pointData: TimePointData<HorzScaleItem>, index: TimePointIndex): void {
+function assignIndexToPointData<HorzScaleItem>(pointData: TimePointData, index: TimePointIndex): void {
 	// first, nevertheless update index of point data ("make it valid")
 	pointData.index = index;
 
 	// and then we need to sync indexes for all series
-	pointData.mapping.forEach((seriesRow: Mutable<SeriesPlotRow<SeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>>) => {
+	pointData.mapping.forEach((seriesRow: Mutable<SeriesPlotRow<SeriesType> | WhitespacePlotRow>) => {
 		seriesRow.index = index;
 	});
 }
diff --git a/src/model/data-validators.ts b/src/model/data-validators.ts
index 0956ccb584..a49064c282 100644
--- a/src/model/data-validators.ts
+++ b/src/model/data-validators.ts
@@ -17,7 +17,7 @@ export function checkPriceLineOptions(options: CreatePriceLineOptions): void {
 	assert(typeof options.price === 'number', `the type of 'price' price line's property must be a number, got '${typeof options.price}'`);
 }
 
-export function checkItemsAreOrdered<HorzScaleItem>(data: readonly (SeriesMarker<HorzScaleItem, HorzScaleItem> | SeriesDataItemTypeMap<HorzScaleItem>[SeriesType])[], bh: IHorzScaleBehavior<HorzScaleItem>, allowDuplicates: boolean = false): void {
+export function checkItemsAreOrdered<HorzScaleItem>(data: readonly (SeriesMarker<HorzScaleItem> | SeriesDataItemTypeMap<HorzScaleItem>[SeriesType])[], bh: IHorzScaleBehavior<HorzScaleItem>, allowDuplicates: boolean = false): void {
 	if (process.env.NODE_ENV === 'production') {
 		return;
 	}
diff --git a/src/model/formatted-labels-cache.ts b/src/model/formatted-labels-cache.ts
index c79c53cb86..9119b150e9 100644
--- a/src/model/formatted-labels-cache.ts
+++ b/src/model/formatted-labels-cache.ts
@@ -8,10 +8,10 @@ interface CachedTick {
 	tick: number;
 }
 
-export type FormatFunction<HorzScaleItem> = (tickMark: TickMark<HorzScaleItem>) => string;
+export type FormatFunction = (tickMark: TickMark) => string;
 
 export class FormattedLabelsCache<HorzScaleItem> {
-	private readonly _format: FormatFunction<HorzScaleItem>;
+	private readonly _format: FormatFunction;
 	private readonly _maxSize: number;
 	private _actualSize: number = 0;
 	private _usageTick: number = 1;
@@ -21,13 +21,13 @@ export class FormattedLabelsCache<HorzScaleItem> {
 
 	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
 
-	public constructor(format: FormatFunction<HorzScaleItem>, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, size: number = 50) {
+	public constructor(format: FormatFunction, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, size: number = 50) {
 		this._format = format;
 		this._horzScaleBehavior = horzScaleBehavior;
 		this._maxSize = size;
 	}
 
-	public format(tickMark: TickMark<HorzScaleItem>): string {
+	public format(tickMark: TickMark): string {
 		const time = tickMark.time;
 
 		const cacheKey = this._horzScaleBehavior.cacheKey(time);
diff --git a/src/model/get-series-plot-row-creator.ts b/src/model/get-series-plot-row-creator.ts
index ac39c37961..c7182397e7 100644
--- a/src/model/get-series-plot-row-creator.ts
+++ b/src/model/get-series-plot-row-creator.ts
@@ -8,10 +8,10 @@ import { SeriesPlotRow } from './series-data';
 import { SeriesType } from './series-options';
 import { TimePointIndex } from './time-data';
 
-function getColoredLineBasedSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: LineData<HorzScaleItem> | HistogramData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Line' | 'Histogram', HorzScaleItem>> {
+function getColoredLineBasedSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: LineData<HorzScaleItem> | HistogramData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Line' | 'Histogram'>> {
 	const val = item.value;
 
-	const res: Mutable<SeriesPlotRow<'Line' | 'Histogram', HorzScaleItem>> = { index, time, value: [val, val, val, val], originalTime };
+	const res: Mutable<SeriesPlotRow<'Line' | 'Histogram'>> = { index, time, value: [val, val, val, val], originalTime };
 
 	if (item.color !== undefined) {
 		res.color = item.color;
@@ -20,10 +20,10 @@ function getColoredLineBasedSeriesPlotRow<HorzScaleItem>(time: InternalHorzScale
 	return res;
 }
 
-function getAreaSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: AreaData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Area', HorzScaleItem>> {
+function getAreaSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: AreaData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Area'>> {
 	const val = item.value;
 
-	const res: Mutable<SeriesPlotRow<'Area', HorzScaleItem>> = { index, time, value: [val, val, val, val], originalTime };
+	const res: Mutable<SeriesPlotRow<'Area'>> = { index, time, value: [val, val, val, val], originalTime };
 
 	if (item.lineColor !== undefined) {
 		res.lineColor = item.lineColor;
@@ -40,10 +40,10 @@ function getAreaSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index:
 	return res;
 }
 
-function getBaselineSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: BaselineData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Baseline', HorzScaleItem>> {
+function getBaselineSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: BaselineData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Baseline'>> {
 	const val = item.value;
 
-	const res: Mutable<SeriesPlotRow<'Baseline', HorzScaleItem>> = { index, time, value: [val, val, val, val], originalTime };
+	const res: Mutable<SeriesPlotRow<'Baseline'>> = { index, time, value: [val, val, val, val], originalTime };
 
 	if (item.topLineColor !== undefined) {
 		res.topLineColor = item.topLineColor;
@@ -72,8 +72,8 @@ function getBaselineSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, in
 	return res;
 }
 
-function getBarSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: BarData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Bar', HorzScaleItem>> {
-	const res: Mutable<SeriesPlotRow<'Bar', HorzScaleItem>> = { index, time, value: [item.open, item.high, item.low, item.close], originalTime };
+function getBarSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: BarData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Bar'>> {
+	const res: Mutable<SeriesPlotRow<'Bar'>> = { index, time, value: [item.open, item.high, item.low, item.close], originalTime };
 
 	if (item.color !== undefined) {
 		res.color = item.color;
@@ -82,8 +82,8 @@ function getBarSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index:
 	return res;
 }
 
-function getCandlestickSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: CandlestickData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Candlestick', HorzScaleItem>> {
-	const res: Mutable<SeriesPlotRow<'Candlestick', HorzScaleItem>> = { index, time, value: [item.open, item.high, item.low, item.close], originalTime };
+function getCandlestickSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: CandlestickData<HorzScaleItem>, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Candlestick'>> {
+	const res: Mutable<SeriesPlotRow<'Candlestick'>> = { index, time, value: [item.open, item.high, item.low, item.close], originalTime };
 	if (item.color !== undefined) {
 		res.color = item.color;
 	}
@@ -99,14 +99,14 @@ function getCandlestickSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem,
 	return res;
 }
 
-export type WhitespacePlotRow<HorzScaleItem> = Omit<PlotRow<HorzScaleItem>, 'value'>;
+export type WhitespacePlotRow = Omit<PlotRow, 'value'>;
 
-export function isSeriesPlotRow<TSeriesType extends SeriesType, HorzScaleItem>(row: SeriesPlotRow<TSeriesType, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>): row is SeriesPlotRow<TSeriesType, HorzScaleItem> {
-	return (row as Partial<SeriesPlotRow<TSeriesType, HorzScaleItem>>).value !== undefined;
+export function isSeriesPlotRow<TSeriesType extends SeriesType, HorzScaleItem>(row: SeriesPlotRow<TSeriesType> | WhitespacePlotRow): row is SeriesPlotRow<TSeriesType> {
+	return (row as Partial<SeriesPlotRow<TSeriesType>>).value !== undefined;
 }
 
 type SeriesItemValueFnMap<TSeriesType extends SeriesType, HorzScaleItem> = {
-	[T in keyof SeriesDataItemTypeMap<TSeriesType>]: (time: InternalHorzScaleItem, index: TimePointIndex, item: SeriesDataItemTypeMap<HorzScaleItem>[T], originalTime: HorzScaleItem) => Mutable<SeriesPlotRow<T, HorzScaleItem> | WhitespacePlotRow<HorzScaleItem>>;
+	[T in keyof SeriesDataItemTypeMap<TSeriesType>]: (time: InternalHorzScaleItem, index: TimePointIndex, item: SeriesDataItemTypeMap<HorzScaleItem>[T], originalTime: HorzScaleItem) => Mutable<SeriesPlotRow<T> | WhitespacePlotRow>;
 };
 
 function wrapWhitespaceData<TSeriesType extends SeriesType, HorzScaleItem>(createPlotRowFn: (typeof getBaselineSeriesPlotRow) | (typeof getBarSeriesPlotRow) | (typeof getCandlestickSeriesPlotRow)): SeriesItemValueFnMap<TSeriesType, HorzScaleItem>[TSeriesType] {
diff --git a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
index 8cf3ef01ed..48dcd65349 100644
--- a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
+++ b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
@@ -226,14 +226,14 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 		return this._dateTimeFormatter.format(new Date(tp.timestamp * 1000));
 	}
 
-	public formatTickmark(tickMark: TickMark<Time>, localizationOptions: LocalizationOptions<Time>): string {
+	public formatTickmark(tickMark: TickMark, localizationOptions: LocalizationOptions<Time>): string {
 		const tickMarkType = weightToTickMarkType(tickMark.weight, this._options.timeScale.timeVisible, this._options.timeScale.secondsVisible);
 
 		const options = this._options.timeScale;
 
 		if (options.tickMarkFormatter !== undefined) {
 			const tickMarkString = options.tickMarkFormatter(
-				tickMark.originalTime as unknown as Time,
+				tickMark.originalTime as Time,
 				tickMarkType,
 				localizationOptions.locale
 			);
@@ -256,7 +256,7 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 		return maxWeight;
 	}
 
-	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Time>>[], startIndex: number): void {
+	public fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint>[], startIndex: number): void {
 		fillWeightsForPoints(sortedTimePoints, startIndex);
 	}
 
diff --git a/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts b/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
index 476520d466..fd4513ffc9 100644
--- a/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
+++ b/src/model/horz-scale-behavior-time/time-scale-point-weight-generator.ts
@@ -2,7 +2,7 @@ import { Mutable } from '../../helpers/mutable';
 
 import { InternalHorzScaleItem } from '../ihorz-scale-behavior';
 import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
-import { TickMarkWeight, Time, TimePoint } from './types';
+import { TickMarkWeight, TimePoint } from './types';
 
 function hours(count: number): number {
 	return count * 60 * 60 * 1000;
@@ -54,7 +54,7 @@ function cast(t: InternalHorzScaleItem): TimePoint {
 	return t as unknown as TimePoint;
 }
 
-export function fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<Time>>[], startIndex: number = 0): void {
+export function fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint>[], startIndex: number = 0): void {
 	if (sortedTimePoints.length === 0) {
 		return;
 	}
diff --git a/src/model/idata-source.ts b/src/model/idata-source.ts
index 17a85735df..4f735147ab 100644
--- a/src/model/idata-source.ts
+++ b/src/model/idata-source.ts
@@ -6,7 +6,7 @@ import { Pane } from './pane';
 import { PriceScale } from './price-scale';
 
 export interface ZOrdered {
-	zorder(): number;
+	zorder(): number | null;
 }
 
 export interface IDataSource extends ZOrdered {
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
index c6b5c3de20..f43be98953 100644
--- a/src/model/ihorz-scale-behavior.ts
+++ b/src/model/ihorz-scale-behavior.ts
@@ -110,7 +110,7 @@ export interface IHorzScaleBehavior<HorzScaleItem> {
 	 * @param localizationOptions - Localization options
 	 * @returns string
 	 */
-	formatTickmark(item: TickMark<HorzScaleItem>, localizationOptions: LocalizationOptions<HorzScaleItem>): string;
+	formatTickmark(item: TickMark, localizationOptions: LocalizationOptions<HorzScaleItem>): string;
 	/**
 	 * Returns the maximum tickmark weight value for the specified tickmarks on the time scale.
 	 *
@@ -125,5 +125,5 @@ export interface IHorzScaleBehavior<HorzScaleItem> {
 	 * @param startIndex - starting index
 	 * @returns void
 	 */
-	fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint<HorzScaleItem>>[], startIndex: number): void;
+	fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint>[], startIndex: number): void;
 }
diff --git a/src/model/localization-options.ts b/src/model/localization-options.ts
index 6b7481c814..8c2685cacb 100644
--- a/src/model/localization-options.ts
+++ b/src/model/localization-options.ts
@@ -6,6 +6,9 @@ import { PriceFormatterFn } from './price-formatter-fn';
  */
 export type TimeFormatterFn<HorzScaleItem = Time> = (time: HorzScaleItem) => string;
 
+/**
+ * Represents basic localization options
+ */
 export interface LocalizationOptionsBase {
 	/**
 	 * Current locale used to format dates. Uses the browser's language settings by default.
diff --git a/src/model/magnet.ts b/src/model/magnet.ts
index a623351a7c..5f136891c2 100644
--- a/src/model/magnet.ts
+++ b/src/model/magnet.ts
@@ -33,7 +33,7 @@ export class Magnet {
 
 		// get all serieses from the pane
 		const serieses: readonly ISeries<SeriesType>[] = pane.dataSources().filter(
-			((ds: IPriceDataSource) => (ds instanceof Series<SeriesType, unknown>)) as (ds: IPriceDataSource) => ds is Series<SeriesType, unknown>);
+			((ds: IPriceDataSource) => (ds instanceof Series<SeriesType>)) as (ds: IPriceDataSource) => ds is Series<SeriesType>);
 
 		const candidates = serieses.reduce(
 			(acc: Coordinate[], series: ISeries<SeriesType>) => {
diff --git a/src/model/plot-data.ts b/src/model/plot-data.ts
index f4ea428d7c..4db0535fa2 100644
--- a/src/model/plot-data.ts
+++ b/src/model/plot-data.ts
@@ -18,9 +18,9 @@ export type PlotRowValue = [
 	number, // close
 ];
 
-export interface PlotRow<HorzPlotItem> {
+export interface PlotRow {
 	readonly index: TimePointIndex;
 	readonly time: InternalHorzScaleItem;
+	readonly originalTime: unknown;
 	readonly value: PlotRowValue;
-	readonly originalTime: HorzPlotItem;
 }
diff --git a/src/model/plot-list.ts b/src/model/plot-list.ts
index 7a7027f3b8..3e4029dcad 100644
--- a/src/model/plot-list.ts
+++ b/src/model/plot-list.ts
@@ -37,7 +37,7 @@ const CHUNK_SIZE = 30;
  * PlotList is an array of plot rows
  * each plot row consists of key (index in timescale) and plot value map
  */
-export class PlotList<HorzScaleItem, PlotRowType extends PlotRow<HorzScaleItem> = PlotRow<HorzScaleItem>> {
+export class PlotList<PlotRowType extends PlotRow = PlotRow> {
 	private _items: readonly PlotRowType[] = [];
 	private _minMaxCache: Map<PlotRowValueIndex, Map<number, MinMax | null>> = new Map();
 	private _rowSearchCache: Map<TimePointIndex, Map<MismatchDirection, PlotRowType>> = new Map();
diff --git a/src/model/series-bar-colorer.ts b/src/model/series-bar-colorer.ts
index 9f53db857c..b84b01c68b 100644
--- a/src/model/series-bar-colorer.ts
+++ b/src/model/series-bar-colorer.ts
@@ -15,9 +15,9 @@ import {
 } from './series-options';
 import { TimePointIndex } from './time-data';
 
-export interface PrecomputedBars<HorzScaleItem> {
-	value: SeriesPlotRow<SeriesType, HorzScaleItem>;
-	previousValue?: SeriesPlotRow<SeriesType, HorzScaleItem>;
+export interface PrecomputedBars {
+	value: SeriesPlotRow<SeriesType>;
+	previousValue?: SeriesPlotRow<SeriesType>;
 }
 
 export interface CommonBarColorerStyle {
@@ -72,38 +72,38 @@ export interface BarStylesMap {
 	Histogram: HistogramBarColorerStyle;
 }
 
-type FindBarFn<HorzScaleItem> = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>) => SeriesPlotRow<SeriesType, HorzScaleItem> | null;
+type FindBarFn = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars) => SeriesPlotRow<SeriesType> | null;
 
-type StyleGetterFn<T extends SeriesType, HorzScaleItem> = (
-	findBar: FindBarFn<HorzScaleItem>,
-	barStyle: ReturnType<Series<T, HorzScaleItem>['options']>,
+type StyleGetterFn<T extends SeriesType> = (
+	findBar: FindBarFn,
+	barStyle: ReturnType<Series<T>['options']>,
 	barIndex: TimePointIndex,
-	precomputedBars?: PrecomputedBars<HorzScaleItem>
+	precomputedBars?: PrecomputedBars
 ) => BarStylesMap[T];
 
-type BarStylesFnMap<HorzScaleItem> = {
-	[T in keyof SeriesOptionsMap]: StyleGetterFn<T, HorzScaleItem>;
+type BarStylesFnMap = {
+	[T in keyof SeriesOptionsMap]: StyleGetterFn<T>;
 };
 
 export interface ISeriesBarColorer<T extends SeriesType> {
-	barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<unknown>): BarStylesMap[T];
+	barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BarStylesMap[T];
 }
 
-export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements ISeriesBarColorer<T> {
-	private _series: Series<T, HorzScaleItem>;
-	private readonly _styleGetter: BarStylesFnMap<HorzScaleItem>[T];
-	private readonly _barStyleFnMap: BarStylesFnMap<HorzScaleItem>;
+export class SeriesBarColorer<T extends SeriesType> implements ISeriesBarColorer<T> {
+	private _series: Series<T>;
+	private readonly _styleGetter: BarStylesFnMap[T];
+	private readonly _barStyleFnMap: BarStylesFnMap;
 
-	public constructor(series: Series<T, HorzScaleItem>) {
+	public constructor(series: Series<T>) {
 		this._series = series;
 
 		this._barStyleFnMap = {
 			// eslint-disable-next-line @typescript-eslint/naming-convention
-			Bar: (findBar: FindBarFn<HorzScaleItem>, barStyle: BarStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): BarColorerStyle => {
+			Bar: (findBar: FindBarFn, barStyle: BarStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BarColorerStyle => {
 				const upColor = barStyle.upColor;
 				const downColor = barStyle.downColor;
 
-				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Bar', HorzScaleItem>;
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Bar'>;
 				const isUp = ensure(currentBar.value[PlotRowValueIndex.Open]) <= ensure(currentBar.value[PlotRowValueIndex.Close]);
 
 				return {
@@ -111,7 +111,7 @@ export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements IS
 				};
 			},
 			// eslint-disable-next-line @typescript-eslint/naming-convention
-			Candlestick: (findBar: FindBarFn<HorzScaleItem>, candlestickStyle: CandlestickStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): CandlesticksColorerStyle => {
+			Candlestick: (findBar: FindBarFn, candlestickStyle: CandlestickStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): CandlesticksColorerStyle => {
 				const upColor = candlestickStyle.upColor;
 				const downColor = candlestickStyle.downColor;
 				const borderUpColor = candlestickStyle.borderUpColor;
@@ -120,7 +120,7 @@ export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements IS
 				const wickUpColor = candlestickStyle.wickUpColor;
 				const wickDownColor = candlestickStyle.wickDownColor;
 
-				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Candlestick', HorzScaleItem>;
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Candlestick'>;
 				const isUp = ensure(currentBar.value[PlotRowValueIndex.Open]) <= ensure(currentBar.value[PlotRowValueIndex.Close]);
 
 				return {
@@ -130,8 +130,8 @@ export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements IS
 				};
 			},
 			// eslint-disable-next-line @typescript-eslint/naming-convention
-			Area: (findBar: FindBarFn<HorzScaleItem>, areaStyle: AreaStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): AreaBarColorerStyle => {
-				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Area', HorzScaleItem>;
+			Area: (findBar: FindBarFn, areaStyle: AreaStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): AreaBarColorerStyle => {
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Area'>;
 				return {
 					barColor: currentBar.lineColor ?? areaStyle.lineColor,
 					lineColor: currentBar.lineColor ?? areaStyle.lineColor,
@@ -140,8 +140,8 @@ export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements IS
 				};
 			},
 			// eslint-disable-next-line @typescript-eslint/naming-convention
-			Baseline: (findBar: FindBarFn<HorzScaleItem>, baselineStyle: BaselineStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): BaselineBarColorerStyle => {
-				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Baseline', HorzScaleItem>;
+			Baseline: (findBar: FindBarFn, baselineStyle: BaselineStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BaselineBarColorerStyle => {
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Baseline'>;
 				const isAboveBaseline = currentBar.value[PlotRowValueIndex.Close] >= baselineStyle.baseValue.price;
 
 				return {
@@ -155,8 +155,8 @@ export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements IS
 				};
 			},
 			// eslint-disable-next-line @typescript-eslint/naming-convention
-			Line: (findBar: FindBarFn<HorzScaleItem>, lineStyle: LineStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): LineBarColorerStyle => {
-				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Line', HorzScaleItem>;
+			Line: (findBar: FindBarFn, lineStyle: LineStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): LineBarColorerStyle => {
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Line'>;
 
 				return {
 					barColor: currentBar.color ?? lineStyle.color,
@@ -164,8 +164,8 @@ export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements IS
 				};
 			},
 			// eslint-disable-next-line @typescript-eslint/naming-convention
-			Histogram: (findBar: FindBarFn<HorzScaleItem>, histogramStyle: HistogramStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): HistogramBarColorerStyle => {
-				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Histogram', HorzScaleItem>;
+			Histogram: (findBar: FindBarFn, histogramStyle: HistogramStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): HistogramBarColorerStyle => {
+				const currentBar = ensureNotNull(findBar(barIndex, precomputedBars)) as SeriesPlotRow<'Histogram'>;
 				return {
 					barColor: currentBar.color ?? histogramStyle.color,
 				};
@@ -175,13 +175,13 @@ export class SeriesBarColorer<T extends SeriesType, HorzScaleItem> implements IS
 		this._styleGetter = this._barStyleFnMap[series.seriesType()];
 	}
 
-	public barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): BarStylesMap[T] {
+	public barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BarStylesMap[T] {
 		// precomputedBars: {value: [Array BarValues], previousValue: [Array BarValues] | undefined}
 		// Used to avoid binary search if bars are already known
 		return this._styleGetter(this._findBar, this._series.options(), barIndex, precomputedBars);
 	}
 
-	private _findBar = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars<HorzScaleItem>): SeriesPlotRow<T, HorzScaleItem> | null => {
+	private _findBar = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): SeriesPlotRow<T> | null => {
 		if (precomputedBars !== undefined) {
 			return precomputedBars.value;
 		}
diff --git a/src/model/series-data.ts b/src/model/series-data.ts
index d8a8991b6d..f2f41ad7b4 100644
--- a/src/model/series-data.ts
+++ b/src/model/series-data.ts
@@ -2,17 +2,17 @@ import { PlotRow } from './plot-data';
 import { PlotList } from './plot-list';
 import { SeriesType } from './series-options';
 
-export interface LinePlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
+export interface LinePlotRow extends PlotRow {
 	readonly color?: string;
 }
 
-export interface AreaPlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
+export interface AreaPlotRow extends PlotRow {
 	lineColor?: string;
 	topColor?: string;
 	bottomColor?: string;
 }
 
-export interface BaselinePlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
+export interface BaselinePlotRow extends PlotRow {
 	topFillColor1?: string;
 	topFillColor2?: string;
 	topLineColor?: string;
@@ -21,32 +21,32 @@ export interface BaselinePlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
 	bottomLineColor?: string;
 }
 
-export interface HistogramPlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
+export interface HistogramPlotRow extends PlotRow {
 	readonly color?: string;
 }
 
-export interface BarPlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
+export interface BarPlotRow extends PlotRow {
 	readonly color?: string;
 }
 
-export interface CandlestickPlotRow<HorzScaleItem> extends PlotRow<HorzScaleItem> {
+export interface CandlestickPlotRow extends PlotRow {
 	readonly color?: string;
 	readonly borderColor?: string;
 	readonly wickColor?: string;
 }
 
-export interface SeriesPlotRowTypeAtTypeMap<HorzScaleItem> {
-	Bar: BarPlotRow<HorzScaleItem>;
-	Candlestick: CandlestickPlotRow<HorzScaleItem>;
-	Area: AreaPlotRow<HorzScaleItem>;
-	Baseline: BaselinePlotRow<HorzScaleItem>;
-	Line: LinePlotRow<HorzScaleItem>;
-	Histogram: HistogramPlotRow<HorzScaleItem>;
+export interface SeriesPlotRowTypeAtTypeMap {
+	Bar: BarPlotRow;
+	Candlestick: CandlestickPlotRow;
+	Area: AreaPlotRow;
+	Baseline: BaselinePlotRow;
+	Line: LinePlotRow;
+	Histogram: HistogramPlotRow;
 }
 
-export type SeriesPlotRow<T extends SeriesType, HorzScaleItem> = SeriesPlotRowTypeAtTypeMap<HorzScaleItem>[T];
-export type SeriesPlotList<T extends SeriesType, HorzScaleItem> = PlotList<HorzScaleItem, SeriesPlotRow<T, HorzScaleItem>>;
+export type SeriesPlotRow<T extends SeriesType> = SeriesPlotRowTypeAtTypeMap[T];
+export type SeriesPlotList<T extends SeriesType> = PlotList<SeriesPlotRow<T>>;
 
-export function createSeriesPlotList<T extends SeriesType, HorzScaleItem>(): SeriesPlotList<T, HorzScaleItem> {
-	return new PlotList<HorzScaleItem, SeriesPlotRow<T, HorzScaleItem>>();
+export function createSeriesPlotList<T extends SeriesType>(): SeriesPlotList<T> {
+	return new PlotList<SeriesPlotRow<T>>();
 }
diff --git a/src/model/series-markers.ts b/src/model/series-markers.ts
index b18a7e6aa3..71fa296ab0 100644
--- a/src/model/series-markers.ts
+++ b/src/model/series-markers.ts
@@ -1,5 +1,3 @@
-import { Time } from './horz-scale-behavior-time/types';
-
 /**
  * Represents the position of a series marker relative to a bar.
  */
@@ -13,7 +11,7 @@ export type SeriesMarkerShape = 'circle' | 'square' | 'arrowUp' | 'arrowDown';
 /**
  * Represents a series marker.
  */
-export interface SeriesMarker<TimeType, HorzScaleItem = Time> {
+export interface SeriesMarker<TimeType> {
 	/**
 	 * The time of the marker.
 	 */
@@ -48,9 +46,9 @@ export interface SeriesMarker<TimeType, HorzScaleItem = Time> {
 	/**
 	 * @internal
 	 */
-	originalTime: HorzScaleItem;
+	originalTime: unknown;
 }
 
-export interface InternalSeriesMarker<TimeType, HorzScaleItem> extends SeriesMarker<TimeType, HorzScaleItem> {
+export interface InternalSeriesMarker<TimeType> extends SeriesMarker<TimeType> {
 	internalId: number;
 }
diff --git a/src/model/series.ts b/src/model/series.ts
index a21a2950af..114ac7428a 100644
--- a/src/model/series.ts
+++ b/src/model/series.ts
@@ -25,7 +25,7 @@ import { SeriesPriceAxisView } from '../views/price-axis/series-price-axis-view'
 
 import { AutoscaleInfoImpl } from './autoscale-info-impl';
 import { BarPrice, BarPrices } from './bar';
-import { ChartModel } from './chart-model';
+import { IChartModelBase } from './chart-model';
 import { Coordinate } from './coordinate';
 import { CustomPriceLine } from './custom-price-line';
 import { isDefaultPriceScale } from './default-price-scale';
@@ -96,21 +96,21 @@ export type SeriesOptionsInternal<T extends SeriesType = SeriesType> = SeriesOpt
 export type SeriesPartialOptionsInternal<T extends SeriesType = SeriesType> = SeriesPartialOptionsMap[T];
 
 export interface ISeries<T extends SeriesType> extends IPriceDataSource {
-	bars(): SeriesPlotList<T, unknown>;
+	bars(): SeriesPlotList<T>;
 	visible(): boolean;
 	options(): Readonly<SeriesOptionsMap[T]>;
 	title(): string;
 	priceScale(): PriceScale;
 	lastValueData(globalLast: boolean): LastValueDataResult;
-	indexedMarkers(): InternalSeriesMarker<TimePointIndex, unknown>[];
+	indexedMarkers(): InternalSeriesMarker<TimePointIndex>[];
 	barColorer(): ISeriesBarColorer<T>;
 	markerDataAtIndex(index: TimePointIndex): MarkerData | null;
 	dataAt(time: TimePointIndex): SeriesDataAtTypeMap[SeriesType] | null;
 }
 
-export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource implements IDestroyable, ISeries<SeriesType> {
+export class Series<T extends SeriesType> extends PriceDataSource implements IDestroyable, ISeries<SeriesType> {
 	private readonly _seriesType: T;
-	private _data: SeriesPlotList<T, HorzScaleItem> = createSeriesPlotList<T, HorzScaleItem>();
+	private _data: SeriesPlotList<T> = createSeriesPlotList<T>();
 	private readonly _priceAxisViews: IPriceAxisView[];
 	private readonly _panePriceAxisView: PanePriceAxisView;
 	private _formatter!: IPriceFormatter;
@@ -119,14 +119,14 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 	private readonly _baseHorizontalLineView: SeriesHorizontalBaseLinePaneView = new SeriesHorizontalBaseLinePaneView(this);
 	private _paneView!: IUpdatablePaneView;
 	private readonly _lastPriceAnimationPaneView: SeriesLastPriceAnimationPaneView | null = null;
-	private _barColorerCache: SeriesBarColorer<T, HorzScaleItem> | null = null;
+	private _barColorerCache: SeriesBarColorer<T> | null = null;
 	private readonly _options: SeriesOptionsInternal<T>;
-	private _markers: readonly SeriesMarker<InternalHorzScaleItem, HorzScaleItem>[] = [];
-	private _indexedMarkers: InternalSeriesMarker<TimePointIndex, HorzScaleItem>[] = [];
+	private _markers: readonly SeriesMarker<InternalHorzScaleItem>[] = [];
+	private _indexedMarkers: InternalSeriesMarker<TimePointIndex>[] = [];
 	private _markersPaneView!: SeriesMarkersPaneView;
 	private _animationTimeoutId: TimerId | null = null;
 
-	public constructor(model: ChartModel<HorzScaleItem>, options: SeriesOptionsInternal<T>, seriesType: T) {
+	public constructor(model: IChartModelBase, options: SeriesOptionsInternal<T>, seriesType: T) {
 		super(model);
 		this._options = options;
 		this._seriesType = seriesType;
@@ -137,7 +137,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		this._panePriceAxisView = new PanePriceAxisView(priceAxisView, this, model);
 
 		if (seriesType === 'Area' || seriesType === 'Line' || seriesType === 'Baseline') {
-			this._lastPriceAnimationPaneView = new SeriesLastPriceAnimationPaneView(this as Series<'Area', HorzScaleItem> | Series<'Line', HorzScaleItem> | Series<'Baseline', HorzScaleItem>);
+			this._lastPriceAnimationPaneView = new SeriesLastPriceAnimationPaneView(this as Series<'Area'> | Series<'Line'> | Series<'Baseline'>);
 		}
 
 		this._recreateFormatter();
@@ -172,7 +172,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 
 		// find range of bars inside range
 		// TODO: make it more optimal
-		let bar: SeriesPlotRow<T, HorzScaleItem> | null;
+		let bar: SeriesPlotRow<T> | null;
 		let lastIndex: TimePointIndex;
 		if (globalLast) {
 			const lastBar = this._data.last();
@@ -212,7 +212,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		};
 	}
 
-	public barColorer(): SeriesBarColorer<T, HorzScaleItem> {
+	public barColorer(): SeriesBarColorer<T> {
 		if (this._barColorerCache !== null) {
 			return this._barColorerCache;
 		}
@@ -252,7 +252,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		this._paneView.update('options');
 	}
 
-	public setData(data: readonly SeriesPlotRow<T, HorzScaleItem>[], updateInfo?: SeriesUpdateInfo): void {
+	public setData(data: readonly SeriesPlotRow<T>[], updateInfo?: SeriesUpdateInfo): void {
 		this._data.setData(data);
 
 		this._recalculateMarkers();
@@ -275,7 +275,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		this.model().lightUpdate();
 	}
 
-	public setMarkers(data: readonly SeriesMarker<InternalHorzScaleItem, HorzScaleItem>[]): void {
+	public setMarkers(data: readonly SeriesMarker<InternalHorzScaleItem>[]): void {
 		this._markers = data;
 		this._recalculateMarkers();
 		const sourcePane = this.model().paneForSource(this);
@@ -286,11 +286,11 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		this.model().lightUpdate();
 	}
 
-	public markers(): readonly SeriesMarker<InternalHorzScaleItem, HorzScaleItem>[] {
+	public markers(): readonly SeriesMarker<InternalHorzScaleItem>[] {
 		return this._markers;
 	}
 
-	public indexedMarkers(): InternalSeriesMarker<TimePointIndex, HorzScaleItem>[] {
+	public indexedMarkers(): InternalSeriesMarker<TimePointIndex>[] {
 		return this._indexedMarkers;
 	}
 
@@ -325,7 +325,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		};
 	}
 
-	public firstBar(): SeriesPlotRow<T, HorzScaleItem> | null {
+	public firstBar(): SeriesPlotRow<T> | null {
 		const visibleBars = this.model().timeScale().visibleStrictRange();
 		if (visibleBars === null) {
 			return null;
@@ -335,7 +335,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 		return this._data.search(startTimePoint, MismatchDirection.NearestRight);
 	}
 
-	public bars(): SeriesPlotList<T, HorzScaleItem> {
+	public bars(): SeriesPlotList<T> {
 		return this._data;
 	}
 
@@ -599,7 +599,7 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 
 		const firstDataIndex = ensureNotNull(this._data.firstIndex());
 
-		this._indexedMarkers = this._markers.map<InternalSeriesMarker<TimePointIndex, HorzScaleItem>>((marker: SeriesMarker<InternalHorzScaleItem, HorzScaleItem>, index: number) => {
+		this._indexedMarkers = this._markers.map<InternalSeriesMarker<TimePointIndex>>((marker: SeriesMarker<InternalHorzScaleItem>, index: number) => {
 			// the first find index on the time scale (across all series)
 			const timePointIndex = ensureNotNull(timeScale.timeToIndex(marker.time, true));
 
@@ -625,32 +625,32 @@ export class Series<T extends SeriesType, HorzScaleItem> extends PriceDataSource
 
 		switch (this._seriesType) {
 			case 'Bar': {
-				this._paneView = new SeriesBarsPaneView(this as Series<'Bar', HorzScaleItem>, this.model());
+				this._paneView = new SeriesBarsPaneView(this as Series<'Bar'>, this.model());
 				break;
 			}
 
 			case 'Candlestick': {
-				this._paneView = new SeriesCandlesticksPaneView(this as Series<'Candlestick', HorzScaleItem>, this.model());
+				this._paneView = new SeriesCandlesticksPaneView(this as Series<'Candlestick'>, this.model());
 				break;
 			}
 
 			case 'Line': {
-				this._paneView = new SeriesLinePaneView(this as Series<'Line', HorzScaleItem>, this.model());
+				this._paneView = new SeriesLinePaneView(this as Series<'Line'>, this.model());
 				break;
 			}
 
 			case 'Area': {
-				this._paneView = new SeriesAreaPaneView(this as Series<'Area', HorzScaleItem>, this.model());
+				this._paneView = new SeriesAreaPaneView(this as Series<'Area'>, this.model());
 				break;
 			}
 
 			case 'Baseline': {
-				this._paneView = new SeriesBaselinePaneView(this as Series<'Baseline', HorzScaleItem>, this.model());
+				this._paneView = new SeriesBaselinePaneView(this as Series<'Baseline'>, this.model());
 				break;
 			}
 
 			case 'Histogram': {
-				this._paneView = new SeriesHistogramPaneView(this as Series<'Histogram', HorzScaleItem>, this.model());
+				this._paneView = new SeriesHistogramPaneView(this as Series<'Histogram'>, this.model());
 				break;
 			}
 
diff --git a/src/model/sort-sources.ts b/src/model/sort-sources.ts
index 1d9152c7d6..79b8b47eae 100644
--- a/src/model/sort-sources.ts
+++ b/src/model/sort-sources.ts
@@ -1,4 +1,5 @@
 import { ensureNotNull } from '../helpers/assertions';
+
 import { ZOrdered } from './idata-source';
 
 export function sortSources<T extends ZOrdered>(sources: readonly T[]): T[] {
diff --git a/src/model/tick-marks.ts b/src/model/tick-marks.ts
index 425d3035a7..2dde92f07e 100644
--- a/src/model/tick-marks.ts
+++ b/src/model/tick-marks.ts
@@ -7,7 +7,7 @@ import { TickMarkWeightValue, TimePointIndex, TimeScalePoint } from './time-data
 /**
  * Tick mark for the horizontal scale.
  */
-export interface TickMark<HorzScaleItem> {
+export interface TickMark {
 	/** Index */
 	index: TimePointIndex;
 	/** Time / Coordinate */
@@ -15,17 +15,17 @@ export interface TickMark<HorzScaleItem> {
 	/** Weight of the tick mark */
 	weight: TickMarkWeightValue;
 	/** Original value for the `time` property */
-	originalTime: HorzScaleItem;
+	originalTime: unknown;
 }
 
-interface MarksCache<HorzScaleItem> {
+interface MarksCache {
 	maxIndexesPerMark: number;
-	marks: readonly TickMark<HorzScaleItem>[];
+	marks: readonly TickMark[];
 }
 
 export class TickMarks<HorzScaleItem> {
-	private _marksByWeight: Map<TickMarkWeightValue, TickMark<HorzScaleItem>[]> = new Map();
-	private _cache: MarksCache<HorzScaleItem> | null = null;
+	private _marksByWeight: Map<TickMarkWeightValue, TickMark[]> = new Map();
+	private _cache: MarksCache | null = null;
 	private _uniformDistribution: boolean = false;
 
 	public setUniformDistribution(val: boolean): void {
@@ -33,7 +33,7 @@ export class TickMarks<HorzScaleItem> {
 		this._cache = null;
 	}
 
-	public setTimeScalePoints(newPoints: readonly TimeScalePoint<HorzScaleItem>[], firstChangedPointIndex: number): void {
+	public setTimeScalePoints(newPoints: readonly TimeScalePoint[], firstChangedPointIndex: number): void {
 		this._removeMarksSinceIndex(firstChangedPointIndex);
 
 		this._cache = null;
@@ -55,7 +55,7 @@ export class TickMarks<HorzScaleItem> {
 		}
 	}
 
-	public build(spacing: number, maxWidth: number): readonly TickMark<HorzScaleItem>[] {
+	public build(spacing: number, maxWidth: number): readonly TickMark[] {
 		const maxIndexesPerMark = Math.ceil(maxWidth / spacing);
 		if (this._cache === null || this._cache.maxIndexesPerMark !== maxIndexesPerMark) {
 			this._cache = {
@@ -75,12 +75,12 @@ export class TickMarks<HorzScaleItem> {
 
 		const weightsToClear: TickMarkWeightValue[] = [];
 
-		this._marksByWeight.forEach((marks: TickMark<HorzScaleItem>[], timeWeight: TickMarkWeightValue) => {
+		this._marksByWeight.forEach((marks: TickMark[], timeWeight: TickMarkWeightValue) => {
 			if (sinceIndex <= marks[0].index) {
 				weightsToClear.push(timeWeight);
 			} else {
 				marks.splice(
-					lowerbound(marks, sinceIndex, (tm: TickMark<HorzScaleItem>) => tm.index < sinceIndex),
+					lowerbound(marks, sinceIndex, (tm: TickMark) => tm.index < sinceIndex),
 					Infinity
 				);
 			}
@@ -91,8 +91,8 @@ export class TickMarks<HorzScaleItem> {
 		}
 	}
 
-	private _buildMarksImpl(maxIndexesPerMark: number): readonly TickMark<HorzScaleItem>[] {
-		let marks: TickMark<HorzScaleItem>[] = [];
+	private _buildMarksImpl(maxIndexesPerMark: number): readonly TickMark[] {
+		let marks: TickMark[] = [];
 
 		for (const weight of Array.from(this._marksByWeight.keys()).sort((a: number, b: number) => b - a)) {
 			if (!this._marksByWeight.get(weight)) {
diff --git a/src/model/time-data.ts b/src/model/time-data.ts
index 5c199af3e0..7b8d71ed43 100644
--- a/src/model/time-data.ts
+++ b/src/model/time-data.ts
@@ -13,13 +13,13 @@ export type TickMarkWeightValue = Nominal<number, 'TickMarkWeightValue'>;
 /**
  * Represents a point on the time scale
  */
-export interface TimeScalePoint<HorzScaleItem> {
+export interface TimeScalePoint {
 	/** Weight of the point */
 	readonly timeWeight: TickMarkWeightValue;
 	/** Time of the point */
 	readonly time: InternalHorzScaleItem;
 	/** Original time for the point */
-	readonly originalTime: HorzScaleItem;
+	readonly originalTime: unknown;
 }
 
 /**
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index cfe850406f..8978d2f3f7 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -179,8 +179,8 @@ export interface ITimeScale {
 	rightOffset(): number;
 
 	indexesToCoordinates<T extends TimedValue>(points: T[], visibleRange?: SeriesItemsIndexesRange): void;
-	indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint<unknown> | null;
-	formatDateTime(timeScalePoint: TimeScalePoint<unknown>): string;
+	indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint | null;
+	formatDateTime(timeScalePoint: TimeScalePoint): string;
 	coordinateToIndex(x: Coordinate): TimePointIndex;
 
 	options(): Readonly<HorzScaleOptions>;
@@ -194,7 +194,7 @@ export class TimeScale<HorzScaleItem> implements ITimeScale {
 	private _width: number = 0;
 	private _baseIndexOrNull: TimePointIndex | null = null;
 	private _rightOffset: number;
-	private _points: readonly TimeScalePoint<HorzScaleItem>[] = [];
+	private _points: readonly TimeScalePoint[] = [];
 	private _barSpacing: number;
 	private _scrollStartPoint: Coordinate | null = null;
 	private _scaleStartPoint: Coordinate | null = null;
@@ -277,7 +277,7 @@ export class TimeScale<HorzScaleItem> implements ITimeScale {
 		return this._points[index]?.time ?? null;
 	}
 
-	public indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint<HorzScaleItem> | null {
+	public indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint | null {
 		return this._points[index] ?? null;
 	}
 
@@ -292,7 +292,7 @@ export class TimeScale<HorzScaleItem> implements ITimeScale {
 			return findNearest ? this._points.length - 1 as TimePointIndex : null;
 		}
 
-		const index = lowerbound(this._points, this._horzScaleBehavior.key(time), (a: TimeScalePoint<HorzScaleItem>, b: InternalHorzScaleItemKey) => this._horzScaleBehavior.key(a.time) < b);
+		const index = lowerbound(this._points, this._horzScaleBehavior.key(time), (a: TimeScalePoint, b: InternalHorzScaleItemKey) => this._horzScaleBehavior.key(a.time) < b);
 
 		if (this._horzScaleBehavior.key(time) < this._horzScaleBehavior.key(this._points[index].time)) {
 			return findNearest ? index as TimePointIndex : null;
@@ -671,7 +671,7 @@ export class TimeScale<HorzScaleItem> implements ITimeScale {
 		});
 	}
 
-	public update(newPoints: readonly TimeScalePoint<HorzScaleItem>[], firstChangedPointIndex: number): void {
+	public update(newPoints: readonly TimeScalePoint[], firstChangedPointIndex: number): void {
 		this._visibleRangeInvalidated = true;
 
 		this._points = newPoints;
@@ -727,9 +727,9 @@ export class TimeScale<HorzScaleItem> implements ITimeScale {
 		this.setVisibleRange(barRange);
 	}
 
-	public formatDateTime(timeScalePoint: TimeScalePoint<HorzScaleItem>): string {
+	public formatDateTime(timeScalePoint: TimeScalePoint): string {
 		if (this._localizationOptions.timeFormatter !== undefined) {
-			return this._localizationOptions.timeFormatter(timeScalePoint.originalTime as unknown as HorzScaleItem);
+			return this._localizationOptions.timeFormatter(timeScalePoint.originalTime as HorzScaleItem);
 		}
 
 		return this._horzScaleBehavior.formatHorzItem(timeScalePoint.time);
@@ -878,11 +878,11 @@ export class TimeScale<HorzScaleItem> implements ITimeScale {
 		this._commonTransitionStartState = null;
 	}
 
-	private _formatLabel(tickMark: TickMark<HorzScaleItem>): string {
+	private _formatLabel(tickMark: TickMark): string {
 		let formatter = this._formattedByWeight.get(tickMark.weight);
 		if (formatter === undefined) {
 			formatter = new FormattedLabelsCache(
-				(mark: TickMark<HorzScaleItem>) => {
+				(mark: TickMark) => {
 					return this._formatLabelImpl(mark);
 				},
 				this._horzScaleBehavior);
@@ -893,7 +893,7 @@ export class TimeScale<HorzScaleItem> implements ITimeScale {
 		return formatter.format(tickMark);
 	}
 
-	private _formatLabelImpl(tickMark: TickMark<HorzScaleItem>): string {
+	private _formatLabelImpl(tickMark: TickMark): string {
 		return this._horzScaleBehavior.formatTickmark(tickMark, this._localizationOptions);
 	}
 
diff --git a/src/views/pane/bars-pane-view-base.ts b/src/views/pane/bars-pane-view-base.ts
index 9645dd6a01..29ec5923e0 100644
--- a/src/views/pane/bars-pane-view-base.ts
+++ b/src/views/pane/bars-pane-view-base.ts
@@ -25,9 +25,9 @@ export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick'
 		priceScale.barPricesToCoordinates(this._items, firstValue, undefinedIfNull(this._itemsVisibleRange));
 	}
 
-	protected abstract _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType, unknown>, colorer: ISeriesBarColorer<TSeriesType>): ItemType;
+	protected abstract _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType>, colorer: ISeriesBarColorer<TSeriesType>): ItemType;
 
-	protected _createDefaultItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType, unknown>, colorer: ISeriesBarColorer<TSeriesType>): BarCandlestickItemBase {
+	protected _createDefaultItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType>, colorer: ISeriesBarColorer<TSeriesType>): BarCandlestickItemBase {
 		return {
 			time: time,
 			open: bar.value[PlotRowValueIndex.Open] as BarPrice,
@@ -45,6 +45,6 @@ export abstract class BarsPaneViewBase<TSeriesType extends 'Bar' | 'Candlestick'
 	protected _fillRawPoints(): void {
 		const colorer = this._series.barColorer();
 
-		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType, unknown>) => this._createRawItem(row.index, row, colorer));
+		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType>) => this._createRawItem(row.index, row, colorer));
 	}
 }
diff --git a/src/views/pane/bars-pane-view.ts b/src/views/pane/bars-pane-view.ts
index 37f85cfebb..ea09df028c 100644
--- a/src/views/pane/bars-pane-view.ts
+++ b/src/views/pane/bars-pane-view.ts
@@ -12,7 +12,7 @@ import { BarsPaneViewBase } from './bars-pane-view-base';
 export class SeriesBarsPaneView extends BarsPaneViewBase<'Bar', BarItem, PaneRendererBars> {
 	protected readonly _renderer: PaneRendererBars = new PaneRendererBars();
 
-	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<SeriesType, unknown>, colorer: SeriesBarColorer<'Bar', unknown>): BarItem {
+	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<SeriesType>, colorer: SeriesBarColorer<'Bar'>): BarItem {
 		return {
 			...this._createDefaultItem(time, bar, colorer),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/candlesticks-pane-view.ts b/src/views/pane/candlesticks-pane-view.ts
index 12c52cf721..f17f10454c 100644
--- a/src/views/pane/candlesticks-pane-view.ts
+++ b/src/views/pane/candlesticks-pane-view.ts
@@ -11,7 +11,7 @@ import { BarsPaneViewBase } from './bars-pane-view-base';
 export class SeriesCandlesticksPaneView extends BarsPaneViewBase<'Candlestick', CandlestickItem, PaneRendererCandlesticks> {
 	protected readonly _renderer: PaneRendererCandlesticks = new PaneRendererCandlesticks();
 
-	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<'Candlestick', unknown>, colorer: SeriesBarColorer<'Candlestick', unknown>): CandlestickItem {
+	protected _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<'Candlestick'>, colorer: SeriesBarColorer<'Candlestick'>): CandlestickItem {
 		return {
 			...this._createDefaultItem(time, bar, colorer),
 			...colorer.barStyle(time),
diff --git a/src/views/pane/line-pane-view-base.ts b/src/views/pane/line-pane-view-base.ts
index 51a8467ef0..3e5f82ce08 100644
--- a/src/views/pane/line-pane-view-base.ts
+++ b/src/views/pane/line-pane-view-base.ts
@@ -41,7 +41,7 @@ export abstract class LinePaneViewBase<
 
 	protected _fillRawPoints(): void {
 		const colorer = this._series.barColorer();
-		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType, unknown>) => {
+		this._items = this._series.bars().rows().map((row: SeriesPlotRow<TSeriesType>) => {
 			const value = row.value[PlotRowValueIndex.Close] as BarPrice;
 			return this._createRawItem(row.index, value, colorer);
 		});
diff --git a/src/views/pane/series-markers-pane-view.ts b/src/views/pane/series-markers-pane-view.ts
index 738f146ca5..0a03bd820b 100644
--- a/src/views/pane/series-markers-pane-view.ts
+++ b/src/views/pane/series-markers-pane-view.ts
@@ -36,7 +36,7 @@ interface Offsets {
 // eslint-disable-next-line max-params
 function fillSizeAndY(
 	rendererItem: SeriesMarkerRendererDataItem,
-	marker: InternalSeriesMarker<TimePointIndex, unknown>,
+	marker: InternalSeriesMarker<TimePointIndex>,
 	seriesData: BarPrices | BarPrice,
 	offsets: Offsets,
 	textHeight: number,
@@ -155,7 +155,7 @@ export class SeriesMarkersPaneView implements IUpdatablePaneView {
 		const timeScale = this._model.timeScale();
 		const seriesMarkers = this._series.indexedMarkers();
 		if (this._dataInvalidated) {
-			this._data.items = seriesMarkers.map<SeriesMarkerRendererDataItem>((marker: InternalSeriesMarker<TimePointIndex, unknown>) => ({
+			this._data.items = seriesMarkers.map<SeriesMarkerRendererDataItem>((marker: InternalSeriesMarker<TimePointIndex>) => ({
 				time: marker.time,
 				x: 0 as Coordinate,
 				y: 0 as Coordinate,
diff --git a/tests/unittests/data-layer.spec.ts b/tests/unittests/data-layer.spec.ts
index 274bd6c19f..cda24220be 100644
--- a/tests/unittests/data-layer.spec.ts
+++ b/tests/unittests/data-layer.spec.ts
@@ -16,14 +16,14 @@ import { TimePointIndex } from '../../src/model/time-data';
 
 chai.use(chaiExclude);
 
-function createSeriesMock<T extends SeriesType = SeriesType>(seriesType?: T): Series<T, Time> {
+function createSeriesMock<T extends SeriesType = SeriesType>(seriesType?: T): Series<T> {
 	const data = new PlotList();
 
 	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 	return {
 		bars: () => data,
 		seriesType: () => seriesType || 'Line',
-	} as Series<T, Time>;
+	} as Series<T>;
 }
 
 // just for tests
@@ -53,7 +53,7 @@ describe('DataLayer', () => {
 		]);
 		expect(updateResult1.timeScale.firstChangedPointIndex).to.be.equal(0);
 		expect(updateResult1.series.size).to.be.equal(1);
-		updateResult1.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
+		updateResult1.series.forEach((updatePacket: SeriesChanges, series: Series<SeriesType>) => {
 			expect(series).to.be.equal(series1);
 			expect(updatePacket.data.length).to.be.equal(2);
 
@@ -73,7 +73,7 @@ describe('DataLayer', () => {
 		]);
 		expect(updateResult2.timeScale.firstChangedPointIndex).to.be.equal(1);
 		expect(updateResult2.series.size).to.be.equal(2);
-		updateResult2.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
+		updateResult2.series.forEach((updatePacket: SeriesChanges, series: Series<SeriesType>) => {
 			if (series === series1) {
 				expect(updatePacket.data.length).to.be.equal(2);
 
@@ -256,7 +256,7 @@ describe('DataLayer', () => {
 		expect(updateResult1.timeScale.points).to.be.equal(undefined);
 		expect(updateResult1.timeScale.firstChangedPointIndex).to.be.equal(undefined);
 		expect(updateResult1.series.size).to.be.equal(1);
-		updateResult1.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
+		updateResult1.series.forEach((updatePacket: SeriesChanges, series: Series<SeriesType>) => {
 			expect(series).to.be.equal(series1);
 			expect(updatePacket.data).excludingEvery(['value', 'originalTime']).to.have.deep.members([
 				{ index: 0, time: { timestamp: 1000 } },
@@ -270,7 +270,7 @@ describe('DataLayer', () => {
 		expect(updateResult2.timeScale.points).to.be.equal(undefined);
 		expect(updateResult2.timeScale.firstChangedPointIndex).to.be.equal(undefined);
 		expect(updateResult2.series.size).to.be.equal(1);
-		updateResult2.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
+		updateResult2.series.forEach((updatePacket: SeriesChanges, series: Series<SeriesType>) => {
 			expect(series).to.be.equal(series2);
 			expect(updatePacket.data).excludingEvery(['value', 'originalTime']).to.have.deep.members([
 				{ index: 1, time: { timestamp: 2000 } },
@@ -301,7 +301,7 @@ describe('DataLayer', () => {
 		]);
 		expect(updateResult.timeScale.firstChangedPointIndex).to.be.equal(2);
 		expect(updateResult.series.size).to.be.equal(2);
-		updateResult.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
+		updateResult.series.forEach((updatePacket: SeriesChanges, series: Series<SeriesType>) => {
 			if (series === series1) {
 				expect(updatePacket.data.length).to.be.equal(2);
 
@@ -356,7 +356,7 @@ describe('DataLayer', () => {
 			{ time: timePoint2, timeWeight: 50, originalTime: { day: 2, month: 10, year: 2019 } },
 		]);
 		expect(updateResult1.series.size).to.be.equal(1);
-		updateResult1.series.forEach((updatePacket: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
+		updateResult1.series.forEach((updatePacket: SeriesChanges, series: Series<SeriesType>) => {
 			expect(series).to.be.equal(series);
 			expect(updatePacket.data.length).to.be.equal(2);
 
@@ -668,7 +668,7 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(1);
 
-			const seriesUpdate = updateResult.series.get(series) as SeriesChanges<Time>;
+			const seriesUpdate = updateResult.series.get(series) as SeriesChanges;
 			expect(seriesUpdate).not.to.be.equal(undefined);
 			expect(seriesUpdate.data.length).to.be.equal(2);
 
@@ -701,7 +701,7 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(1);
 
-			const seriesUpdate = updateResult.series.get(series) as SeriesChanges<Time>;
+			const seriesUpdate = updateResult.series.get(series) as SeriesChanges;
 			expect(seriesUpdate).not.to.be.equal(undefined);
 			expect(seriesUpdate.data.length).to.be.equal(2);
 
@@ -731,7 +731,7 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(1);
 
-			const seriesUpdate = updateResult.series.get(series) as SeriesChanges<Time>;
+			const seriesUpdate = updateResult.series.get(series) as SeriesChanges;
 			expect(seriesUpdate).not.to.be.equal(undefined);
 
 			expect(seriesUpdate.data).excludingEvery(['value', 'originalTime']).to.have.deep.members([
@@ -760,7 +760,7 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(1);
 
-			const seriesUpdate = updateResult.series.get(series) as SeriesChanges<Time>;
+			const seriesUpdate = updateResult.series.get(series) as SeriesChanges;
 			expect(seriesUpdate).not.to.be.equal(undefined);
 			expect(seriesUpdate.data.length).to.be.equal(2);
 
@@ -801,7 +801,7 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(2);
 
-			updateResult.series.forEach((seriesUpdate: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
+			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series<SeriesType>) => {
 				expect(seriesUpdate.data.length).to.be.equal(2);
 
 				if (series === series1) {
@@ -855,7 +855,7 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(2);
 
-			updateResult.series.forEach((seriesUpdate: SeriesChanges<Time>, series: Series<SeriesType, Time>) => {
+			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series<SeriesType>) => {
 				expect(seriesUpdate.data.length).to.be.equal(2);
 
 				if (series === series1) {
diff --git a/tests/unittests/get-series-data-creator.spec.ts b/tests/unittests/get-series-data-creator.spec.ts
index 26272f995b..6c054b8ef6 100644
--- a/tests/unittests/get-series-data-creator.spec.ts
+++ b/tests/unittests/get-series-data-creator.spec.ts
@@ -2,27 +2,27 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { getSeriesDataCreator } from '../../src/api/get-series-data-creator';
-import { Time, UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
+import { UTCTimestamp } from '../../src/model/horz-scale-behavior-time/types';
 import { InternalHorzScaleItem } from '../../src/model/ihorz-scale-behavior';
 import { PlotRow } from '../../src/model/plot-data';
 import { AreaPlotRow, BarPlotRow, BaselinePlotRow, CandlestickPlotRow, HistogramPlotRow, LinePlotRow } from '../../src/model/series-data';
 import { TimePointIndex } from '../../src/model/time-data';
 
-const plotRow: PlotRow<Time> = {
+const plotRow: PlotRow = {
 	index: 0 as TimePointIndex,
 	time: { timestamp: 1649931070 as UTCTimestamp } as unknown as InternalHorzScaleItem,
 	value: [1, 2, 3, 4],
 	originalTime: 1649931070 as UTCTimestamp,
 };
 
-const linePlotRows: LinePlotRow<Time>[] = [
+const linePlotRows: LinePlotRow[] = [
 	{
 		...plotRow,
 		color: '#FF0000',
 	},
 	plotRow,
 ];
-const areaPlotRows: AreaPlotRow<Time>[] = [
+const areaPlotRows: AreaPlotRow[] = [
 	{
 		...plotRow,
 		lineColor: '#FF0000',
@@ -31,7 +31,7 @@ const areaPlotRows: AreaPlotRow<Time>[] = [
 	},
 	plotRow,
 ];
-const baselinePlotRows: BaselinePlotRow<Time>[] = [
+const baselinePlotRows: BaselinePlotRow[] = [
 	{
 		...plotRow,
 		topFillColor1: '#000001',
@@ -43,21 +43,21 @@ const baselinePlotRows: BaselinePlotRow<Time>[] = [
 	},
 	plotRow,
 ];
-const histogramPlotRow: HistogramPlotRow<Time>[] = [
+const histogramPlotRow: HistogramPlotRow[] = [
 	{
 		...plotRow,
 		color: '#00FF00',
 	},
 	plotRow,
 ];
-const barPlotRow: BarPlotRow<Time>[] = [
+const barPlotRow: BarPlotRow[] = [
 	{
 		...plotRow,
 		color: '#0000FF',
 	},
 	plotRow,
 ];
-const candlestickPlotRows: CandlestickPlotRow<Time>[] = [
+const candlestickPlotRows: CandlestickPlotRow[] = [
 	{
 		...plotRow,
 		color: '#0000FF',
diff --git a/tests/unittests/plot-list.spec.ts b/tests/unittests/plot-list.spec.ts
index 6686637d63..5c86d767d5 100644
--- a/tests/unittests/plot-list.spec.ts
+++ b/tests/unittests/plot-list.spec.ts
@@ -12,12 +12,12 @@ function timePoint(val: number): TimePoint {
 	return { timestamp: val as UTCTimestamp };
 }
 
-function plotRow(index: TimePointIndex, time: TimePoint, value: PlotRowValue): PlotRow<TimePoint> {
+function plotRow(index: TimePointIndex, time: TimePoint, value: PlotRowValue): PlotRow {
 	return { index, time: time as unknown as InternalHorzScaleItem, value, originalTime: time };
 }
 
 describe('PlotList', () => {
-	let p: PlotList<TimePoint>;
+	let p: PlotList;
 
 	beforeEach(() => {
 		p = new PlotList();
@@ -132,7 +132,7 @@ describe('PlotList', () => {
 	});
 
 	describe('minMaxOnRangeByPlotFunction and minMaxOnRangeByPlotFunctionCached', () => {
-		let pl: PlotList<TimePoint>;
+		let pl: PlotList;
 
 		beforeEach(() => {
 			pl = new PlotList();
diff --git a/tests/unittests/time-scale.spec.ts b/tests/unittests/time-scale.spec.ts
index e715e4927b..144c321fc0 100644
--- a/tests/unittests/time-scale.spec.ts
+++ b/tests/unittests/time-scale.spec.ts
@@ -20,7 +20,7 @@ function chartModelMock(): ChartModel<Time> {
 }
 
 function tsUpdate(to: number): Parameters<TimeScale<Time>['update']> {
-	const points: TimeScalePoint<Time>[] = [];
+	const points: TimeScalePoint[] = [];
 
 	const startIndex = 0;
 	for (let i = startIndex; i <= to; ++i) {

From 16890a9f8b769c9d1b29596c0d93a7a65ea79a6e Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 4 Jul 2023 18:20:54 +0300
Subject: [PATCH 22/23] Fixed time typings

---
 src/api/series-api.ts                         | 20 +++++++------------
 src/api/time-scale-api.ts                     | 14 ++++++-------
 src/index.ts                                  |  2 +-
 .../horz-scale-behavior-time.ts               | 14 +++++--------
 src/model/ihorz-scale-behavior.ts             |  7 -------
 src/model/series-markers.ts                   | 14 +++++++++++++
 src/model/time-data.ts                        |  2 +-
 src/model/time-scale.ts                       |  7 ++++---
 .../test-cases/chart/horizontal-scale.js      |  4 ----
 .../graphics/test-cases/api/series-markers.js | 18 +++++++++++++++--
 .../test-cases/horizontal-price-scale.js      |  4 ----
 11 files changed, 55 insertions(+), 51 deletions(-)

diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index a2bcb64ca1..077e2b6e58 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -16,7 +16,7 @@ import { CreatePriceLineOptions, PriceLineOptions } from '../model/price-line-op
 import { RangeImpl } from '../model/range-impl';
 import { Series } from '../model/series';
 import { SeriesPlotRow } from '../model/series-data';
-import { SeriesMarker } from '../model/series-markers';
+import { convertSeriesMarker, SeriesMarker } from '../model/series-markers';
 import {
 	SeriesOptionsMap,
 	SeriesPartialOptionsMap,
@@ -137,8 +137,8 @@ export class SeriesApi<
 		if (dataFirstBarInRange !== null && dataLastBarInRange !== null) {
 			// result.from = dataFirstBarInRange.time.businessDay || dataFirstBarInRange.time.timestamp;
 			// result.to = dataLastBarInRange.time.businessDay || dataLastBarInRange.time.timestamp;
-			result.from = this._horzScaleBehavior.convertInternalToHorzItem(dataFirstBarInRange.time);
-			result.to = this._horzScaleBehavior.convertInternalToHorzItem(dataLastBarInRange.time);
+			result.from = dataFirstBarInRange.originalTime as HorzScaleItem;
+			result.to = dataLastBarInRange.originalTime as HorzScaleItem;
 		}
 
 		return result;
@@ -187,21 +187,15 @@ export class SeriesApi<
 	public setMarkers(data: SeriesMarker<HorzScaleItem>[]): void {
 		checkItemsAreOrdered(data, this._horzScaleBehavior, true);
 
-		const convertedMarkers = data.map((marker: SeriesMarker<HorzScaleItem>) => ({
-			...marker as Omit<SeriesMarker<HorzScaleItem>, 'time' | 'originalTime'>,
-			originalTime: marker.time,
-			time: this._horzScaleBehavior.convertHorzItemToInternal(marker.time),
-		}));
+		const convertedMarkers = data.map((marker: SeriesMarker<HorzScaleItem>) =>
+			convertSeriesMarker<HorzScaleItem, InternalHorzScaleItem>(marker, this._horzScaleBehavior.convertHorzItemToInternal(marker.time), marker.time)
+		);
 		this._series.setMarkers(convertedMarkers);
 	}
 
 	public markers(): SeriesMarker<HorzScaleItem>[] {
 		return this._series.markers().map<SeriesMarker<HorzScaleItem>>((internalItem: SeriesMarker<InternalHorzScaleItem>) => {
-			const { originalTime, time, ...item } = internalItem;
-			return {
-				time: originalTime as HorzScaleItem,
-				...item as Omit<SeriesMarker<InternalHorzScaleItem>, 'time' | 'originalTIme'>,
-			};
+			return convertSeriesMarker<InternalHorzScaleItem, HorzScaleItem>(internalItem, internalItem.originalTime as HorzScaleItem, undefined);
 		});
 	}
 
diff --git a/src/api/time-scale-api.ts b/src/api/time-scale-api.ts
index 7ca99182d1..1778402f06 100644
--- a/src/api/time-scale-api.ts
+++ b/src/api/time-scale-api.ts
@@ -9,8 +9,8 @@ import { clone, DeepPartial } from '../helpers/strict-type-checks';
 
 import { ChartModel } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
-import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
-import { Logical, LogicalRange, Range, TimePointIndex, TimePointsRange } from '../model/time-data';
+import { IHorzScaleBehavior, InternalHorzScaleItem } from '../model/ihorz-scale-behavior';
+import { Logical, LogicalRange, Range, TimePointIndex } from '../model/time-data';
 import { HorzScaleOptions, TimeScale } from '../model/time-scale';
 
 import {
@@ -78,13 +78,13 @@ export class TimeScaleApi<HorzScaleItem> implements ITimeScaleApi<HorzScaleItem>
 		}
 
 		return {
-			from: this._horzScaleBehavior.convertInternalToHorzItem(timeRange.from),
-			to: this._horzScaleBehavior.convertInternalToHorzItem(timeRange.to),
+			from: timeRange.from.originalTime as HorzScaleItem,
+			to: timeRange.to.originalTime as HorzScaleItem,
 		};
 	}
 
 	public setVisibleRange(range: Range<HorzScaleItem>): void {
-		const convertedRange: TimePointsRange = {
+		const convertedRange: Range<InternalHorzScaleItem> = {
 			from: this._horzScaleBehavior.convertHorzItemToInternal(range.from),
 			to: this._horzScaleBehavior.convertHorzItemToInternal(range.to),
 		};
@@ -149,12 +149,12 @@ export class TimeScaleApi<HorzScaleItem> implements ITimeScaleApi<HorzScaleItem>
 	public coordinateToTime(x: number): HorzScaleItem | null {
 		const timeScale = this._model.timeScale();
 		const timePointIndex = timeScale.coordinateToIndex(x as Coordinate);
-		const timePoint = timeScale.indexToTime(timePointIndex);
+		const timePoint = timeScale.indexToTimeScalePoint(timePointIndex);
 		if (timePoint === null) {
 			return null;
 		}
 
-		return this._horzScaleBehavior.convertInternalToHorzItem(timePoint);
+		return timePoint.originalTime as HorzScaleItem;
 	}
 
 	public width(): number {
diff --git a/src/index.ts b/src/index.ts
index 6cbd8c5fb1..8d697ac2f6 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -19,7 +19,7 @@ export const customSeriesDefaultOptions: CustomSeriesOptions = {
 	...customStyleDefaults,
 };
 
-export { createChart } from './api/create-chart';
+export { createChart, createChartEx } from './api/create-chart';
 
 /**
  * Returns the current version as a string. For example `'3.3.0'`.
diff --git a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
index 7e1771510f..d053aaf38a 100644
--- a/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
+++ b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
@@ -21,18 +21,19 @@ import { BusinessDay, isBusinessDay, isUTCTimestamp, TickMarkType, TickMarkWeigh
 type TimeConverter = (time: Time) => InternalHorzScaleItem;
 
 function businessDayConverter(time: Time): InternalHorzScaleItem {
+	let businessDay = time;
 	if (isString(time)) {
-		time = stringToBusinessDay(time);
+		businessDay = stringToBusinessDay(time);
 	}
-	if (!isBusinessDay(time)) {
+	if (!isBusinessDay(businessDay)) {
 		throw new Error('time must be of type BusinessDay');
 	}
 
-	const date = new Date(Date.UTC(time.year, time.month - 1, time.day, 0, 0, 0, 0));
+	const date = new Date(Date.UTC(businessDay.year, businessDay.month - 1, businessDay.day, 0, 0, 0, 0));
 
 	return {
 		timestamp: Math.round(date.getTime() / 1000) as UTCTimestamp,
-		businessDay: time,
+		businessDay,
 	} as unknown as InternalHorzScaleItem;
 }
 
@@ -181,11 +182,6 @@ export class HorzScaleBehaviorTime implements IHorzScaleBehavior<Time> {
 		return ensureNotNull(selectTimeConverter(data));
 	}
 
-	public convertInternalToHorzItem(item: InternalHorzScaleItem): Time {
-		const tp = item as unknown as TimePoint;
-		return tp.businessDay ?? tp.timestamp;
-	}
-
 	public key(item: InternalHorzScaleItem | Time): InternalHorzScaleItemKey {
 		// eslint-disable-next-line no-restricted-syntax
 		if (typeof item === 'object' && 'timestamp' in item) {
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
index f43be98953..228ad34977 100644
--- a/src/model/ihorz-scale-behavior.ts
+++ b/src/model/ihorz-scale-behavior.ts
@@ -61,13 +61,6 @@ export interface IHorzScaleBehavior<HorzScaleItem> {
 	 * @returns InternalHorzScaleItem
 	 */
 	convertHorzItemToInternal(item: HorzScaleItem): InternalHorzScaleItem;
-	/**
-	 * Convert an internal horizontal item into a horizontal scale item.
-	 *
-	 * @param item - item to be converted
-	 * @returns HorzScaleItem
-	 */
-	convertInternalToHorzItem(item: InternalHorzScaleItem): HorzScaleItem;
 	/**
 	 * Creates and returns a converter for changing series data into internal horizontal scale items.
 	 *
diff --git a/src/model/series-markers.ts b/src/model/series-markers.ts
index 71fa296ab0..eb334a5ca9 100644
--- a/src/model/series-markers.ts
+++ b/src/model/series-markers.ts
@@ -52,3 +52,17 @@ export interface SeriesMarker<TimeType> {
 export interface InternalSeriesMarker<TimeType> extends SeriesMarker<TimeType> {
 	internalId: number;
 }
+
+export function convertSeriesMarker<InTimeType, OutTimeType>(sm: SeriesMarker<InTimeType>, newTime: OutTimeType, originalTime?: unknown): SeriesMarker<OutTimeType> {
+	const { time: inTime, originalTime: inOriginalTime, ...values } = sm;
+	/* eslint-disable @typescript-eslint/consistent-type-assertions */
+	const res = {
+		time: newTime,
+		...values,
+	} as SeriesMarker<OutTimeType>;
+	/* eslint-enable @typescript-eslint/consistent-type-assertions */
+	if (originalTime !== undefined) {
+		res.originalTime = originalTime;
+	}
+	return res;
+}
diff --git a/src/model/time-data.ts b/src/model/time-data.ts
index 7b8d71ed43..b4d9607b44 100644
--- a/src/model/time-data.ts
+++ b/src/model/time-data.ts
@@ -36,7 +36,7 @@ export interface Range<T> {
 	to: T;
 }
 
-export type TimePointsRange = Range<InternalHorzScaleItem>;
+export type TimePointsRange = Range<Omit<TimeScalePoint, 'timeWeight'>>;
 
 /**
  * Index for a point on the horizontal (time) scale.
diff --git a/src/model/time-scale.ts b/src/model/time-scale.ts
index 8978d2f3f7..848be880b2 100644
--- a/src/model/time-scale.ts
+++ b/src/model/time-scale.ts
@@ -16,6 +16,7 @@ import { TickMark, TickMarks } from './tick-marks';
 import {
 	Logical,
 	LogicalRange,
+	Range,
 	SeriesItemsIndexesRange,
 	TickMarkWeightValue,
 	TimedValue,
@@ -342,12 +343,12 @@ export class TimeScale<HorzScaleItem> implements ITimeScale {
 		const lastIndex = ensureNotNull(this._lastIndex());
 
 		return {
-			from: ensureNotNull(this.indexToTime(Math.max(firstIndex, from) as TimePointIndex)),
-			to: ensureNotNull(this.indexToTime(Math.min(lastIndex, to) as TimePointIndex)),
+			from: ensureNotNull(this.indexToTimeScalePoint(Math.max(firstIndex, from) as TimePointIndex)),
+			to: ensureNotNull(this.indexToTimeScalePoint(Math.min(lastIndex, to) as TimePointIndex)),
 		};
 	}
 
-	public logicalRangeForTimeRange(range: TimePointsRange): LogicalRange {
+	public logicalRangeForTimeRange(range: Range<InternalHorzScaleItem>): LogicalRange {
 		return {
 			from: ensureNotNull(this.timeToIndex(range.from, true)) as number as Logical,
 			to: ensureNotNull(this.timeToIndex(range.to, true)) as number as Logical,
diff --git a/tests/e2e/coverage/test-cases/chart/horizontal-scale.js b/tests/e2e/coverage/test-cases/chart/horizontal-scale.js
index edabc00696..7264ff113a 100644
--- a/tests/e2e/coverage/test-cases/chart/horizontal-scale.js
+++ b/tests/e2e/coverage/test-cases/chart/horizontal-scale.js
@@ -11,10 +11,6 @@ class HorzScaleBehaviorPrice {
 		return price => price;
 	}
 
-	convertInternalToHorzItem(item) {
-		return item;
-	}
-
 	key(item) {
 		return item;
 	}
diff --git a/tests/e2e/graphics/test-cases/api/series-markers.js b/tests/e2e/graphics/test-cases/api/series-markers.js
index cb849df6ec..ac0992eea2 100644
--- a/tests/e2e/graphics/test-cases/api/series-markers.js
+++ b/tests/e2e/graphics/test-cases/api/series-markers.js
@@ -1,5 +1,19 @@
+function reorderField(obj) {
+	const keys = Object.keys(obj);
+	keys.sort();
+	const res = {};
+	for (const key of keys) {
+		res[key] = obj[key];
+	}
+	return res;
+}
+
+function reorderFieldInArray(arr) {
+	return arr.map(reorderField);
+}
+
 function compare(markers, seriesApiMarkers) {
-	return JSON.stringify(markers) === JSON.stringify(seriesApiMarkers);
+	return JSON.stringify(reorderFieldInArray(markers)) === JSON.stringify(reorderFieldInArray(seriesApiMarkers));
 }
 
 function runTestCase(container) {
@@ -34,5 +48,5 @@ function runTestCase(container) {
 		},
 	});
 
-	console.assert(compare(markers, seriesApiMarkers), `series.markers() should return exactly the same that was provided to series.setMarkers()\n${JSON.stringify(seriesApiMarkers)}`);
+	console.assert(compare(markers, seriesApiMarkers), `series.markers() should return exactly the same that was provided to series.setMarkers()\n${JSON.stringify(seriesApiMarkers)}\n${JSON.stringify(markers)}`);
 }
diff --git a/tests/e2e/graphics/test-cases/horizontal-price-scale.js b/tests/e2e/graphics/test-cases/horizontal-price-scale.js
index 0ee32dc4fd..597bc721f8 100644
--- a/tests/e2e/graphics/test-cases/horizontal-price-scale.js
+++ b/tests/e2e/graphics/test-cases/horizontal-price-scale.js
@@ -11,10 +11,6 @@ class HorzScaleBehaviorPrice {
 		return price => price;
 	}
 
-	convertInternalToHorzItem(item) {
-		return item;
-	}
-
 	key(item) {
 		return item;
 	}

From 5e6320e0c84320254e02b7053eebdd2cdcefec05 Mon Sep 17 00:00:00 2001
From: Eugene Korobko <ekorobko@tradingview.com>
Date: Tue, 15 Aug 2023 12:21:21 +0300
Subject: [PATCH 23/23] Updated sizes limits

---
 .size-limit.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.size-limit.js b/.size-limit.js
index b9e58ab0d0..91cdcda788 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -4,21 +4,21 @@ module.exports = [
 	{
 		name: 'CJS',
 		path: 'dist/lightweight-charts.production.cjs',
-		limit: '47.07 KB',
+		limit: '47.58 KB',
 	},
 	{
 		name: 'ESM',
 		path: 'dist/lightweight-charts.production.mjs',
-		limit: '47.01 KB',
+		limit: '47.53 KB',
 	},
 	{
 		name: 'Standalone-ESM',
 		path: 'dist/lightweight-charts.standalone.production.mjs',
-		limit: '48.70 KB',
+		limit: '49.25 KB',
 	},
 	{
 		name: 'Standalone',
 		path: 'dist/lightweight-charts.standalone.production.js',
-		limit: '48.74 KB',
+		limit: '49.3 KB',
 	},
 ];