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',
 	},
 ];
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 e90d11a269..a586a1ade1 100644
--- a/src/api/chart-api.ts
+++ b/src/api/chart-api.ts
@@ -5,8 +5,11 @@ 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 { ChartOptionsImpl, ChartOptionsInternal } from '../model/chart-model';
+import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap, WhitespaceData } from '../model/data-consumer';
+import { DataLayer, DataUpdateResponse, SeriesChanges } from '../model/data-layer';
 import { CustomData, ICustomSeriesPaneView } from '../model/icustom-series';
+import { IHorzScaleBehavior } from '../model/ihorz-scale-behavior';
 import { Series } from '../model/series';
 import { SeriesPlotRow } from '../model/series-data';
 import {
@@ -28,12 +31,10 @@ import {
 	SeriesStyleOptionsMap,
 	SeriesType,
 } from '../model/series-options';
-import { Logical, Time } from '../model/time-data';
+import { Logical } from '../model/time-data';
 
-import { DataUpdatesConsumer, isFulfilledData, SeriesDataItemTypeMap, WhitespaceData } from './data-consumer';
-import { DataLayer, DataUpdateResponse, SeriesChanges } from './data-layer';
 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';
@@ -62,7 +63,7 @@ function patchPriceFormat(priceFormat?: DeepPartial<PriceFormat>): void {
 	}
 }
 
-function migrateHandleScaleScrollOptions(options: DeepPartial<ChartOptions>): void {
+function migrateHandleScaleScrollOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsImpl<HorzScaleItem>>): void {
 	if (isBoolean(options.handleScale)) {
 		const handleScale = options.handleScale;
 		options.handleScale = {
@@ -104,32 +105,36 @@ function migrateHandleScaleScrollOptions(options: DeepPartial<ChartOptions>): vo
 	}
 }
 
-function toInternalOptions(options: DeepPartial<ChartOptions>): DeepPartial<ChartOptionsInternal> {
+function toInternalOptions<HorzScaleItem>(options: DeepPartial<ChartOptionsImpl<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<IChartApiBase<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 IChartApiBase<HorzScaleItem>, DataUpdatesConsumer<SeriesType, HorzScaleItem> {
+	private _chartWidget: ChartWidget<HorzScaleItem>;
+	private _dataLayer: DataLayer<HorzScaleItem>;
+	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> = new Delegate();
-	private readonly _dblClickedDelegate: Delegate<MouseEventParams> = new Delegate();
-	private readonly _crosshairMovedDelegate: Delegate<MouseEventParams> = new Delegate();
+	private readonly _clickedDelegate: Delegate<MouseEventParams<HorzScaleItem>> = new Delegate();
+	private readonly _dblClickedDelegate: 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<ChartOptionsImpl<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) => {
@@ -157,7 +162,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 {
@@ -188,13 +193,13 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 	}
 
 	public addCustomSeries<
-		TData extends CustomData,
+		TData extends CustomData<HorzScaleItem>,
 		TOptions extends CustomSeriesOptions,
 		TPartialOptions extends CustomSeriesPartialOptions = SeriesPartialOptions<TOptions>
 	>(
-		customPaneView: ICustomSeriesPaneView<TData, TOptions>,
+		customPaneView: ICustomSeriesPaneView<HorzScaleItem, TData, TOptions>,
 		options?: SeriesPartialOptions<TOptions>
-	): ISeriesApi<'Custom', TData, TOptions, TPartialOptions> {
+	): ISeriesApi<'Custom', HorzScaleItem, TData, TOptions, TPartialOptions> {
 		const paneView = ensure(customPaneView);
 		const defaults = {
 			...customStyleDefaults,
@@ -208,33 +213,33 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 		);
 	}
 
-	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);
@@ -247,52 +252,52 @@ 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>, 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>, 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 subscribeDblClick(handler: MouseEventHandler): void {
-		this._dblClickedDelegate.subscribe(handler);
+	public subscribeCrosshairMove(handler: MouseEventHandler<HorzScaleItem>): void {
+		this._crosshairMovedDelegate.subscribe(handler);
 	}
 
-	public unsubscribeDblClick(handler: MouseEventHandler): void {
-		this._dblClickedDelegate.unsubscribe(handler);
+	public unsubscribeCrosshairMove(handler: MouseEventHandler<HorzScaleItem>): void {
+		this._crosshairMovedDelegate.unsubscribe(handler);
 	}
 
-	public subscribeCrosshairMove(handler: MouseEventHandler): void {
-		this._crosshairMovedDelegate.subscribe(handler);
+	public subscribeDblClick(handler: MouseEventHandler<HorzScaleItem>): void {
+		this._dblClickedDelegate.subscribe(handler);
 	}
 
-	public unsubscribeCrosshairMove(handler: MouseEventHandler): void {
-		this._crosshairMovedDelegate.unsubscribe(handler);
+	public unsubscribeDblClick(handler: MouseEventHandler<HorzScaleItem>): void {
+		this._dblClickedDelegate.unsubscribe(handler);
 	}
 
 	public priceScale(priceScaleId: string): IPriceScaleApi {
 		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<ChartOptionsImpl<HorzScaleItem>>): void {
 		this._chartWidget.applyOptions(toInternalOptions(options));
 	}
 
-	public options(): Readonly<ChartOptions> {
-		return this._chartWidget.options() as Readonly<ChartOptions>;
+	public options(): Readonly<ChartOptionsImpl<HorzScaleItem>> {
+		return this._chartWidget.options() as Readonly<ChartOptionsImpl<HorzScaleItem>>;
 	}
 
 	public takeScreenshot(): HTMLCanvasElement {
@@ -309,21 +314,21 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 
 	private _addSeriesImpl<
 		TSeries extends SeriesType,
-		TData extends WhitespaceData = SeriesDataItemTypeMap[TSeries],
+		TData extends WhitespaceData<HorzScaleItem> = SeriesDataItemTypeMap<HorzScaleItem>[TSeries],
 		TOptions extends SeriesOptionsMap[TSeries] = SeriesOptionsMap[TSeries],
 		TPartialOptions extends SeriesPartialOptionsMap[TSeries] = SeriesPartialOptionsMap[TSeries]
 	>(
 		type: TSeries,
 		styleDefaults: SeriesStyleOptionsMap[TSeries],
 		options: SeriesPartialOptionsMap[TSeries] = {},
-		customPaneView?: ICustomSeriesPaneView
-	): ISeriesApi<TSeries, TData, TOptions, TPartialOptions> {
+		customPaneView?: ICustomSeriesPaneView<HorzScaleItem>
+	): ISeriesApi<TSeries, HorzScaleItem, TData, TOptions, TPartialOptions> {
 		patchPriceFormat(options.priceFormat);
 
 		const strictOptions = merge(clone(seriesOptionsDefaults), clone(styleDefaults), options) as SeriesOptionsMap[TSeries];
 		const series = this._chartWidget.model().createSeries(type, strictOptions, customPaneView);
 
-		const res = new SeriesApi<TSeries, TData, TOptions, TPartialOptions>(series, this, this, this);
+		const res = new SeriesApi<TSeries, HorzScaleItem, TData, TOptions, TPartialOptions>(series, this, this, this, this._horzScaleBehavior);
 		this._seriesMap.set(res, series);
 		this._seriesMapReversed.set(series, res);
 
@@ -334,20 +339,20 @@ export class ChartApi implements IChartApi, DataUpdatesConsumer<SeriesType> {
 		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, series: Series<SeriesType>) => series.setData(value.data, value.info));
 
 		model.recalculateAllPanes();
 	}
 
-	private _mapSeriesToApi(series: Series): ISeriesApi<SeriesType> {
+	private _mapSeriesToApi(series: Series<SeriesType>): 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) => {
+	private _convertMouseParams(param: MouseEventParamsImpl): MouseEventParams<HorzScaleItem> {
+		const seriesData: MouseEventParams<HorzScaleItem>['seriesData'] = new Map();
+		param.seriesData.forEach((plotRow: SeriesPlotRow<SeriesType>, series: Series<SeriesType>) => {
 			const seriesType = series.seriesType();
-			const data = getSeriesDataCreator(seriesType)(plotRow);
+			const data = getSeriesDataCreator<SeriesType, HorzScaleItem>(seriesType)(plotRow);
 			if (seriesType !== 'Custom') {
 				assert(isFulfilledData(data));
 			} else {
@@ -360,7 +365,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.originalTime as HorzScaleItem,
 			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..0f0cf3f68e 100644
--- a/src/api/create-chart.ts
+++ b/src/api/create-chart.ts
@@ -1,19 +1,31 @@
 import { assert } from '../helpers/assertions';
 import { DeepPartial, isString } from '../helpers/strict-type-checks';
 
-import { ChartOptions } from '../model/chart-model';
+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 { 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.
+ * 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
  */
-export function createChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions>): IChartApi {
+export function createChartEx<HorzScaleItem, THorzScaleBehavior extends IHorzScaleBehavior<HorzScaleItem>>(
+	container: string | HTMLElement,
+	horzScaleBehavior: THorzScaleBehavior,
+	options?: DeepPartial<ReturnType<THorzScaleBehavior['options']>>
+): IChartApiBase<HorzScaleItem> {
 	let htmlElement: HTMLElement;
 	if (isString(container)) {
 		const element = document.getElementById(container);
@@ -23,5 +35,39 @@ 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;
+}
+
+/**
+ * Structure describing options of the chart with time points at the horizontal scale. Series options are to be set separately
+ */
+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;
+}
+
+/**
+ * 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.
+ * @returns An interface to the created chart
+ */
+export function createChart(container: string | HTMLElement, options?: DeepPartial<ChartOptions>): IChartApi {
+	return createChartEx<Time, HorzScaleBehaviorTime>(
+		container,
+		new HorzScaleBehaviorTime(),
+		HorzScaleBehaviorTime.applyDefaults(options)
+	);
 }
diff --git a/src/api/get-series-data-creator.ts b/src/api/get-series-data-creator.ts
index 55f6f2873b..86f89e49ed 100644
--- a/src/api/get-series-data-creator.ts
+++ b/src/api/get-series-data-creator.ts
@@ -1,3 +1,13 @@
+import {
+	AreaData,
+	BarData,
+	BaselineData,
+	CandlestickData,
+	LineData,
+	OhlcData,
+	SeriesDataItemTypeMap,
+	SingleValueData,
+} from '../model/data-consumer';
 import { CustomData } from '../model/icustom-series';
 import { PlotRow, PlotRowValueIndex } from '../model/plot-data';
 import {
@@ -10,27 +20,15 @@ import {
 	SeriesPlotRow,
 } from '../model/series-data';
 import { SeriesType } from '../model/series-options';
-import { Time } from '../model/time-data';
-
-import {
-	AreaData,
-	BarData,
-	BaselineData,
-	CandlestickData,
-	LineData,
-	OhlcData,
-	SeriesDataItemTypeMap,
-	SingleValueData,
-} from './data-consumer';
 
-type SeriesPlotRowToDataMap = {
-	[T in keyof SeriesDataItemTypeMap]: (plotRow: SeriesPlotRow<T>) => SeriesDataItemTypeMap[T];
+type SeriesPlotRowToDataMap<HorzScaleItem> = {
+	[T in keyof SeriesDataItemTypeMap]: (plotRow: SeriesPlotRow<T>) => SeriesDataItemTypeMap<HorzScaleItem>[T];
 };
 
-function singleValueData(plotRow: PlotRow): SingleValueData {
-	const data: SingleValueData = {
+function singleValueData<HorzScaleItem>(plotRow: PlotRow): SingleValueData<HorzScaleItem> {
+	const data: SingleValueData<HorzScaleItem> = {
 		value: plotRow.value[PlotRowValueIndex.Close],
-		time: plotRow.originalTime as unknown as Time,
+		time: plotRow.originalTime as HorzScaleItem,
 	};
 	if (plotRow.customValues !== undefined) {
 		data.customValues = plotRow.customValues;
@@ -38,8 +36,8 @@ function singleValueData(plotRow: PlotRow): SingleValueData {
 	return data;
 }
 
-function lineData(plotRow: LinePlotRow): LineData {
-	const result: LineData = singleValueData(plotRow);
+function lineData<HorzScaleItem>(plotRow: LinePlotRow): LineData<HorzScaleItem> {
+	const result: LineData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.color !== undefined) {
 		result.color = plotRow.color;
@@ -48,8 +46,8 @@ function lineData(plotRow: LinePlotRow): LineData {
 	return result;
 }
 
-function areaData(plotRow: AreaPlotRow): AreaData {
-	const result: AreaData = singleValueData(plotRow);
+function areaData<HorzScaleItem>(plotRow: AreaPlotRow): AreaData<HorzScaleItem> {
+	const result: AreaData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.lineColor !== undefined) {
 		result.lineColor = plotRow.lineColor;
@@ -66,8 +64,8 @@ function areaData(plotRow: AreaPlotRow): AreaData {
 	return result;
 }
 
-function baselineData(plotRow: BaselinePlotRow): BaselineData {
-	const result: BaselineData = singleValueData(plotRow);
+function baselineData<HorzScaleItem>(plotRow: BaselinePlotRow): BaselineData<HorzScaleItem> {
+	const result: BaselineData<HorzScaleItem> = singleValueData(plotRow);
 
 	if (plotRow.topLineColor !== undefined) {
 		result.topLineColor = plotRow.topLineColor;
@@ -96,13 +94,13 @@ function baselineData(plotRow: BaselinePlotRow): BaselineData {
 	return result;
 }
 
-function ohlcData(plotRow: PlotRow): OhlcData {
-	const data: OhlcData = {
+function ohlcData<HorzScaleItem>(plotRow: PlotRow): OhlcData<HorzScaleItem> {
+	const data: OhlcData<HorzScaleItem> = {
 		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 HorzScaleItem,
 	};
 	if (plotRow.customValues !== undefined) {
 		data.customValues = plotRow.customValues;
@@ -110,8 +108,8 @@ function ohlcData(plotRow: PlotRow): OhlcData {
 	return data;
 }
 
-function barData(plotRow: BarPlotRow): BarData {
-	const result: BarData = ohlcData(plotRow);
+function barData<HorzScaleItem>(plotRow: BarPlotRow): BarData<HorzScaleItem> {
+	const result: BarData<HorzScaleItem> = ohlcData<HorzScaleItem>(plotRow);
 
 	if (plotRow.color !== undefined) {
 		result.color = plotRow.color;
@@ -120,8 +118,8 @@ function barData(plotRow: BarPlotRow): BarData {
 	return result;
 }
 
-function candlestickData(plotRow: CandlestickPlotRow): CandlestickData {
-	const result: CandlestickData = ohlcData(plotRow);
+function candlestickData<HorzScaleItem>(plotRow: CandlestickPlotRow): CandlestickData<HorzScaleItem> {
+	const result: CandlestickData<HorzScaleItem> = ohlcData(plotRow);
 	const { color, borderColor, wickColor } = plotRow;
 
 	if (color !== undefined) {
@@ -139,24 +137,23 @@ function candlestickData(plotRow: CandlestickPlotRow): CandlestickData {
 	return result;
 }
 
-function customData(plotRow: CustomPlotRow): CustomData {
-	const time = plotRow.originalTime as unknown as Time;
+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>,
+		Bar: barData<HorzScaleItem>,
+		Candlestick: candlestickData<HorzScaleItem>,
+		Custom: customData<HorzScaleItem>,
+	};
+	return seriesPlotRowToDataMap[seriesType];
+}
+
+function customData<HorzScaleItem>(plotRow: CustomPlotRow): CustomData<HorzScaleItem> {
+	const time = plotRow.originalTime as HorzScaleItem;
 	return {
 		...plotRow.data,
 		time,
 	};
 }
-
-const seriesPlotRowToDataMap: SeriesPlotRowToDataMap = {
-	Area: areaData,
-	Line: lineData,
-	Baseline: baselineData,
-	Histogram: lineData,
-	Bar: barData,
-	Candlestick: candlestickData,
-	Custom: customData,
-};
-
-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
deleted file mode 100644
index 6ccb4ecac8..0000000000
--- a/src/api/get-series-plot-row-creator.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-import { ensureDefined } from '../helpers/assertions';
-
-import { CustomData } from '../model/icustom-series';
-import { PlotRow, PlotRowValue } 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 { AreaData, BarData, BaselineData, CandlestickData, HistogramData, isWhitespaceData, LineData, SeriesDataItemTypeMap, WhitespaceData } from './data-consumer';
-
-function getColoredLineBasedSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: LineData | HistogramData, originalTime: OriginalTime): Mutable<SeriesPlotRow<'Line' | 'Histogram'>> {
-	const val = item.value;
-
-	const res: Mutable<SeriesPlotRow<'Line' | 'Histogram'>> = { index, time, value: [val, val, val, val], originalTime };
-
-	if (item.color !== undefined) {
-		res.color = item.color;
-	}
-
-	return res;
-}
-
-function getAreaSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: AreaData, originalTime: OriginalTime): Mutable<SeriesPlotRow<'Area'>> {
-	const val = item.value;
-
-	const res: Mutable<SeriesPlotRow<'Area'>> = { index, time, value: [val, val, val, val], originalTime };
-
-	if (item.lineColor !== undefined) {
-		res.lineColor = item.lineColor;
-	}
-
-	if (item.topColor !== undefined) {
-		res.topColor = item.topColor;
-	}
-
-	if (item.bottomColor !== undefined) {
-		res.bottomColor = item.bottomColor;
-	}
-
-	return res;
-}
-
-function getBaselineSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: BaselineData, originalTime: OriginalTime): Mutable<SeriesPlotRow<'Baseline'>> {
-	const val = item.value;
-
-	const res: Mutable<SeriesPlotRow<'Baseline'>> = { index, time, value: [val, val, val, val], originalTime };
-
-	if (item.topLineColor !== undefined) {
-		res.topLineColor = item.topLineColor;
-	}
-
-	if (item.bottomLineColor !== undefined) {
-		res.bottomLineColor = item.bottomLineColor;
-	}
-
-	if (item.topFillColor1 !== undefined) {
-		res.topFillColor1 = item.topFillColor1;
-	}
-
-	if (item.topFillColor2 !== undefined) {
-		res.topFillColor2 = item.topFillColor2;
-	}
-
-	if (item.bottomFillColor1 !== undefined) {
-		res.bottomFillColor1 = item.bottomFillColor1;
-	}
-
-	if (item.bottomFillColor2 !== undefined) {
-		res.bottomFillColor2 = item.bottomFillColor2;
-	}
-
-	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 };
-
-	if (item.color !== undefined) {
-		res.color = item.color;
-	}
-
-	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 };
-	if (item.color !== undefined) {
-		res.color = item.color;
-	}
-
-	if (item.borderColor !== undefined) {
-		res.borderColor = item.borderColor;
-	}
-
-	if (item.wickColor !== undefined) {
-		res.wickColor = item.wickColor;
-	}
-
-	return res;
-}
-
-// The returned data is used for scaling the series, and providing the current value for the price scale
-export type CustomDataToPlotRowValueConverter = (item: CustomData | WhitespaceData) => number[];
-
-function getCustomSeriesPlotRow(time: TimePoint, index: TimePointIndex, item: CustomData | WhitespaceData, originalTime: OriginalTime, dataToPlotRow?: CustomDataToPlotRowValueConverter): Mutable<SeriesPlotRow<'Custom'>> {
-	const values = ensureDefined(dataToPlotRow)(item);
-	const max = Math.max(...values);
-	const min = Math.min(...values);
-	const last = values[values.length - 1];
-	const value: PlotRowValue = [last, max, min, last];
-	const { time: excludedTime, color, ...data } = item as CustomData;
-	return { index, time, value, originalTime, data, color };
-}
-
-export type WhitespacePlotRow = Omit<PlotRow, 'value'>;
-
-export function isSeriesPlotRow(row: SeriesPlotRow | WhitespacePlotRow): row is SeriesPlotRow {
-	return (row as Partial<SeriesPlotRow>).value !== undefined;
-}
-
-type SeriesItemValueFnMap = {
-	[T in keyof SeriesDataItemTypeMap]: (time: TimePoint, index: TimePointIndex, item: SeriesDataItemTypeMap[T], originalTime: OriginalTime, dataToPlotRow?: CustomDataToPlotRowValueConverter, customIsWhitespace?: WhitespaceCheck) => Mutable<SeriesPlotRow<T> | WhitespacePlotRow>;
-};
-
-function wrapCustomValues<T extends SeriesPlotRow | WhitespacePlotRow>(plotRow: Mutable<T>, bar: SeriesDataItemTypeMap[SeriesType]): Mutable<T> {
-	if (bar.customValues !== undefined) {
-		plotRow.customValues = bar.customValues;
-	}
-	return plotRow;
-}
-
-export type WhitespaceCheck = (bar: SeriesDataItemTypeMap[SeriesType]) => bar is WhitespaceData;
-function isWhitespaceDataWithCustomCheck(bar: SeriesDataItemTypeMap[SeriesType], customIsWhitespace?: WhitespaceCheck): bar is WhitespaceData {
-	if (customIsWhitespace) {
-		return customIsWhitespace(bar);
-	}
-	return isWhitespaceData(bar);
-}
-
-function wrapWhitespaceData<TSeriesType extends SeriesType>(createPlotRowFn: (typeof getBaselineSeriesPlotRow) | (typeof getBarSeriesPlotRow) | (typeof getCandlestickSeriesPlotRow) | (typeof getCustomSeriesPlotRow)): SeriesItemValueFnMap[TSeriesType] {
-	return (time: TimePoint, index: TimePointIndex, bar: SeriesDataItemTypeMap[SeriesType], originalTime: OriginalTime, dataToPlotRow?: CustomDataToPlotRowValueConverter, customIsWhitespace?: WhitespaceCheck) => {
-		if (isWhitespaceDataWithCustomCheck(bar, customIsWhitespace)) {
-			return wrapCustomValues({ time, index, originalTime }, bar);
-		}
-
-		return wrapCustomValues(createPlotRowFn(time, index, bar, originalTime, dataToPlotRow), bar);
-	};
-}
-
-const seriesPlotRowFnMap: SeriesItemValueFnMap = {
-	Candlestick: wrapWhitespaceData(getCandlestickSeriesPlotRow),
-	Bar: wrapWhitespaceData(getBarSeriesPlotRow),
-	Area: wrapWhitespaceData(getAreaSeriesPlotRow),
-	Baseline: wrapWhitespaceData(getBaselineSeriesPlotRow),
-	Histogram: wrapWhitespaceData(getColoredLineBasedSeriesPlotRow),
-	Line: wrapWhitespaceData(getColoredLineBasedSeriesPlotRow),
-	Custom: wrapWhitespaceData(getCustomSeriesPlotRow),
-};
-
-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 551cf88e47..168c834109 100644
--- a/src/api/ichart-api.ts
+++ b/src/api/ichart-api.ts
@@ -1,6 +1,8 @@
 import { DeepPartial } from '../helpers/strict-type-checks';
 
-import { ChartOptions } from '../model/chart-model';
+import { ChartOptionsImpl } from '../model/chart-model';
+import { BarData, HistogramData, LineData, WhitespaceData } from '../model/data-consumer';
+import { Time } from '../model/horz-scale-behavior-time/types';
 import { CustomData, ICustomSeriesPaneView } from '../model/icustom-series';
 import { Point } from '../model/point';
 import {
@@ -14,10 +16,9 @@ import {
 	SeriesPartialOptions,
 	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, WhitespaceData } from './data-consumer';
 import { IPriceScaleApi } from './iprice-scale-api';
 import { ISeriesApi } from './iseries-api';
 import { ITimeScaleApi } from './itime-scale-api';
@@ -25,13 +26,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
 	 */
@@ -48,11 +49,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 | CustomData>;
+	seriesData: Map<ISeriesApi<SeriesType, HorzScaleItem>, BarData<HorzScaleItem> | LineData<HorzScaleItem> | HistogramData<HorzScaleItem> | CustomData<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.
 	 */
@@ -66,12 +67,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 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.
 	 */
@@ -102,13 +103,13 @@ export interface IChartApi {
 	 * ```
 	 */
 	addCustomSeries<
-		TData extends CustomData,
+		TData extends CustomData<HorzScaleItem>,
 		TOptions extends CustomSeriesOptions,
 		TPartialOptions extends SeriesPartialOptions<TOptions> = SeriesPartialOptions<TOptions>
 	>(
-		customPaneView: ICustomSeriesPaneView<TData, TOptions>,
+		customPaneView: ICustomSeriesPaneView<HorzScaleItem, TData, TOptions>,
 		customOptions?: SeriesPartialOptions<TOptions>
-	): ISeriesApi<'Custom', TData | WhitespaceData, TOptions, TPartialOptions>;
+	): ISeriesApi<'Custom', HorzScaleItem, TData | WhitespaceData<HorzScaleItem>, TOptions, TPartialOptions>;
 
 	/**
 	 * Creates an area series with specified parameters.
@@ -120,7 +121,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.
@@ -132,7 +133,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.
@@ -144,7 +145,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.
@@ -156,7 +157,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.
@@ -168,7 +169,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.
@@ -180,7 +181,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.
@@ -190,7 +191,7 @@ export interface IChartApi {
 	 * chart.removeSeries(series);
 	 * ```
 	 */
-	removeSeries(seriesApi: ISeriesApi<SeriesType>): void;
+	removeSeries(seriesApi: ISeriesApi<SeriesType, HorzScaleItem>): void;
 
 	/**
 	 * Subscribe to the chart click event.
@@ -209,7 +210,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}.
@@ -220,7 +221,7 @@ export interface IChartApi {
 	 * chart.unsubscribeClick(myClickHandler);
 	 * ```
 	 */
-	unsubscribeClick(handler: MouseEventHandler): void;
+	unsubscribeClick(handler: MouseEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Subscribe to the chart double-click event.
@@ -239,7 +240,7 @@ export interface IChartApi {
 	 * chart.subscribeDblClick(myDblClickHandler);
 	 * ```
 	 */
-	subscribeDblClick(handler: MouseEventHandler): void;
+	subscribeDblClick(handler: MouseEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Unsubscribe a handler that was previously subscribed using {@link subscribeDblClick}.
@@ -250,7 +251,7 @@ export interface IChartApi {
 	 * chart.unsubscribeDblClick(myDblClickHandler);
 	 * ```
 	 */
-	unsubscribeDblClick(handler: MouseEventHandler): void;
+	unsubscribeDblClick(handler: MouseEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Subscribe to the crosshair move event.
@@ -269,7 +270,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}.
@@ -280,7 +281,7 @@ export interface IChartApi {
 	 * chart.unsubscribeCrosshairMove(myCrosshairMoveHandler);
 	 * ```
 	 */
-	unsubscribeCrosshairMove(handler: MouseEventHandler): void;
+	unsubscribeCrosshairMove(handler: MouseEventHandler<HorzScaleItem>): void;
 
 	/**
 	 * Returns API to manipulate a price scale.
@@ -295,21 +296,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<ChartOptionsImpl<HorzScaleItem>>): void;
 
 	/**
 	 * Returns currently applied options
 	 *
 	 * @returns Full set of currently applied options, including defaults
 	 */
-	options(): Readonly<ChartOptions>;
+	options(): Readonly<ChartOptionsImpl<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 4dbe85b4c4..a38ac606a9 100644
--- a/src/api/iseries-api.ts
+++ b/src/api/iseries-api.ts
@@ -2,6 +2,8 @@ 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';
@@ -10,9 +12,8 @@ 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';
 import { IPriceScaleApi } from './iprice-scale-api';
 import { ISeriesPrimitive } from './iseries-primitive-api';
@@ -32,7 +33,7 @@ export type DataChangedHandler = (scope: DataChangedScope) => void;
  */
 // 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.
@@ -53,7 +54,8 @@ export interface BarsInfo extends Partial<Range<Time>> {
  */
 export interface ISeriesApi<
 	TSeriesType extends SeriesType,
-	TData = SeriesDataItemTypeMap[TSeriesType],
+	HorzScaleItem = Time,
+	TData = SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType],
 	TOptions = SeriesOptionsMap[TSeriesType],
 	TPartialOptions = SeriesPartialOptionsMap[TSeriesType],
 	> {
@@ -104,7 +106,7 @@ export interface ISeriesApi<
 	 * chart.timeScale().subscribeVisibleLogicalRangeChange(onVisibleLogicalRangeChanged);
 	 * ```
 	 */
-	barsInLogicalRange(range: Range<number>): BarsInfo | null;
+	barsInLogicalRange(range: Range<number>): BarsInfo<HorzScaleItem> | null;
 
 	/**
 	 * Applies new options to the existing series
@@ -267,12 +269,12 @@ export interface ISeriesApi<
 	 * });
 	 * ```
 	 */
-	setMarkers(data: SeriesMarker<Time>[]): void;
+	setMarkers(data: SeriesMarker<HorzScaleItem>[]): void;
 
 	/**
 	 * Returns an array of series markers.
 	 */
-	markers(): SeriesMarker<Time>[];
+	markers(): SeriesMarker<HorzScaleItem>[];
 
 	/**
 	 * Creates a new price line
@@ -324,7 +326,7 @@ export interface ISeriesApi<
 	 *
 	 * @param primitive - any implementation of ISeriesPrimitive interface
 	 */
-	attachPrimitive(primitive: ISeriesPrimitive): void;
+	attachPrimitive(primitive: ISeriesPrimitive<HorzScaleItem>): void;
 
 	/**
 	 * Detaches additional drawing primitive from the series
@@ -332,5 +334,5 @@ export interface ISeriesApi<
 	 * @param primitive - implementation of ISeriesPrimitive interface attached before
 	 * Does nothing if specified primitive was not attached
 	 */
-	detachPrimitive(primitive: ISeriesPrimitive): void;
+	detachPrimitive(primitive: ISeriesPrimitive<HorzScaleItem>): void;
 }
diff --git a/src/api/iseries-primitive-api.ts b/src/api/iseries-primitive-api.ts
index 624fce0cb9..9f1d8a04d6 100644
--- a/src/api/iseries-primitive-api.ts
+++ b/src/api/iseries-primitive-api.ts
@@ -1,7 +1,7 @@
 import { ISeriesPrimitiveBase } from '../model/iseries-primitive';
 import { SeriesOptionsMap, SeriesType } from '../model/series-options';
 
-import { IChartApi } from './ichart-api';
+import { IChartApiBase } from './ichart-api';
 import { ISeriesApi } from './iseries-api';
 
 /**
@@ -9,16 +9,17 @@ import { ISeriesApi } from './iseries-api';
  * a refresh of the chart.
  */
 export interface SeriesAttachedParameter<
+	HorzScaleItem,
 	TSeriesType extends SeriesType = keyof SeriesOptionsMap
 > {
 	/**
 	 * Chart instance.
 	 */
-	chart: IChartApi;
+	chart: IChartApiBase<HorzScaleItem>;
 	/**
 	 * Series to which the Primitive is attached.
 	 */
-	series: ISeriesApi<TSeriesType>;
+	series: ISeriesApi<TSeriesType, HorzScaleItem>;
 	/**
 	 * Request an update (redraw the chart)
 	 */
@@ -28,6 +29,6 @@ export interface SeriesAttachedParameter<
 /**
  * Interface for series primitives. It must be implemented to add some external graphics to series.
  */
-export type ISeriesPrimitive = ISeriesPrimitiveBase<
-	SeriesAttachedParameter<SeriesType>
+export type ISeriesPrimitive<HorzScaleItem> = ISeriesPrimitiveBase<
+	SeriesAttachedParameter<HorzScaleItem, SeriesType>
 >;
diff --git a/src/api/itime-scale-api.ts b/src/api/itime-scale-api.ts
index 24e12901d6..bd25d9f16a 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 { TimeScaleOptions } from '../model/time-scale';
-
-/**
- * Represents a {@link Time} range.
- */
-export type TimeRange = Range<Time>;
+import { Logical, LogicalRange, Range } from '../model/time-data';
+import { HorzScaleOptions } from '../model/time-scale';
 
 /**
  * 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.
@@ -224,12 +219,12 @@ export interface ITimeScaleApi {
 	 *
 	 * @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/chart-options-defaults.ts b/src/api/options/chart-options-defaults.ts
index 9abf077e56..10c003e58f 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..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,
@@ -15,4 +15,5 @@ export const timeScaleOptionsDefaults: TimeScaleOptions = {
 	secondsVisible: true,
 	shiftVisibleRangeOnNewBar: true,
 	ticksVisible: false,
+	uniformDistribution: false,
 };
diff --git a/src/api/price-scale-api.ts b/src/api/price-scale-api.ts
index 4b2d1fc485..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';
@@ -9,10 +9,10 @@ import { PriceScale, PriceScaleOptions } from '../model/price-scale';
 import { IPriceScaleApi } from './iprice-scale-api';
 
 export class PriceScaleApi implements IPriceScaleApi {
-	private _chartWidget: ChartWidget;
+	private _chartWidget: IChartWidgetBase;
 	private readonly _priceScaleId: string;
 
-	public constructor(chartWidget: ChartWidget, priceScaleId: string) {
+	public constructor(chartWidget: IChartWidgetBase, priceScaleId: string) {
 		this._chartWidget = chartWidget;
 		this._priceScaleId = priceScaleId;
 	}
diff --git a/src/api/series-api.ts b/src/api/series-api.ts
index fda9b228b7..077e2b6e58 100644
--- a/src/api/series-api.ts
+++ b/src/api/series-api.ts
@@ -7,27 +7,27 @@ import { clone, merge } from '../helpers/strict-type-checks';
 
 import { BarPrice } from '../model/bar';
 import { Coordinate } from '../model/coordinate';
+import { DataUpdatesConsumer, SeriesDataItemTypeMap, WhitespaceData } from '../model/data-consumer';
+import { checkItemsAreOrdered, checkPriceLineOptions, checkSeriesValuesType } from '../model/data-validators';
+import { IHorzScaleBehavior, InternalHorzScaleItem } from '../model/ihorz-scale-behavior';
 import { ISeriesPrimitiveBase } from '../model/iseries-primitive';
 import { MismatchDirection } from '../model/plot-list';
 import { CreatePriceLineOptions, PriceLineOptions } from '../model/price-line-options';
 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,
 	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, WhitespaceData } from './data-consumer';
-import { convertTime } from './data-layer';
-import { checkItemsAreOrdered, checkPriceLineOptions, checkSeriesValuesType } from './data-validators';
 import { getSeriesDataCreator } from './get-series-data-creator';
-import { type IChartApi } from './ichart-api';
+import { type IChartApiBase } from './ichart-api';
 import { IPriceLine } from './iprice-line';
 import { IPriceScaleApi } from './iprice-scale-api';
 import { BarsInfo, DataChangedHandler, DataChangedScope, ISeriesApi } from './iseries-api';
@@ -37,23 +37,32 @@ import { PriceLine } from './price-line-api';
 
 export class SeriesApi<
 	TSeriesType extends SeriesType,
-	TData extends WhitespaceData = SeriesDataItemTypeMap[TSeriesType],
+	HorzScaleItem,
+	TData extends WhitespaceData<HorzScaleItem> = SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType],
 	TOptions extends SeriesOptionsMap[TSeriesType] = SeriesOptionsMap[TSeriesType],
 	TPartialOptions extends SeriesPartialOptionsMap[TSeriesType] = SeriesPartialOptionsMap[TSeriesType]
 > implements
-		ISeriesApi<TSeriesType, TData, TOptions, TPartialOptions>,
+		ISeriesApi<TSeriesType, HorzScaleItem, TData, TOptions, TPartialOptions>,
 		IDestroyable {
 	protected _series: Series<TSeriesType>;
-	protected _dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType>;
-	protected readonly _chartApi: IChartApi;
+	protected _dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType, HorzScaleItem>;
+	protected readonly _chartApi: IChartApiBase<HorzScaleItem>;
 
-	private readonly _priceScaleApiProvider: IPriceScaleApiProvider;
+	private readonly _priceScaleApiProvider: IPriceScaleApiProvider<HorzScaleItem>;
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
 	private readonly _dataChangedDelegate: Delegate<DataChangedScope> = new Delegate();
 
-	public constructor(series: Series<TSeriesType>, dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType>, priceScaleApiProvider: IPriceScaleApiProvider, chartApi: IChartApi) {
+	public constructor(
+		series: Series<TSeriesType>,
+		dataUpdatesConsumer: DataUpdatesConsumer<TSeriesType, HorzScaleItem>,
+		priceScaleApiProvider: IPriceScaleApiProvider<HorzScaleItem>,
+		chartApi: IChartApiBase<HorzScaleItem>,
+		horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>
+	) {
 		this._series = series;
 		this._dataUpdatesConsumer = dataUpdatesConsumer;
 		this._priceScaleApiProvider = priceScaleApiProvider;
+		this._horzScaleBehavior = horzScaleBehavior;
 		this._chartApi = chartApi;
 	}
 
@@ -82,8 +91,7 @@ export class SeriesApi<
 		return this._series.priceScale().coordinateToPrice(coordinate as Coordinate, firstValue.value);
 	}
 
-	// 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;
 		}
@@ -123,19 +131,21 @@ export class SeriesApi<
 			? 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 = dataFirstBarInRange.originalTime as HorzScaleItem;
+			result.to = dataLastBarInRange.originalTime as HorzScaleItem;
 		}
 
 		return result;
 	}
 
 	public setData(data: TData[]): void {
-		checkItemsAreOrdered(data);
+		checkItemsAreOrdered(data, this._horzScaleBehavior);
 		checkSeriesValuesType(this._series.seriesType(), data);
 
 		this._dataUpdatesConsumer.applyNewData(this._series, data);
@@ -156,7 +166,8 @@ export class SeriesApi<
 			return null;
 		}
 
-		return getSeriesDataCreator(this.seriesType())(data) as TData | null;
+		const creator = getSeriesDataCreator<TSeriesType, HorzScaleItem>(this.seriesType());
+		return creator(data) as TData | null;
 	}
 
 	public data(): readonly TData[] {
@@ -173,24 +184,18 @@ export class SeriesApi<
 		this._dataChangedDelegate.unsubscribe(handler);
 	}
 
-	public setMarkers(data: SeriesMarker<Time>[]): void {
-		checkItemsAreOrdered(data, true);
+	public setMarkers(data: SeriesMarker<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((marker: SeriesMarker<HorzScaleItem>) =>
+			convertSeriesMarker<HorzScaleItem, InternalHorzScaleItem>(marker, this._horzScaleBehavior.convertHorzItemToInternal(marker.time), 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;
-			return {
-				time: originalTime as unknown as Time,
-				...item as Omit<SeriesMarker<TimePoint>, 'time' | 'originalTIme'>,
-			};
+	public markers(): SeriesMarker<HorzScaleItem>[] {
+		return this._series.markers().map<SeriesMarker<HorzScaleItem>>((internalItem: SeriesMarker<InternalHorzScaleItem>) => {
+			return convertSeriesMarker<InternalHorzScaleItem, HorzScaleItem>(internalItem, internalItem.originalTime as HorzScaleItem, undefined);
 		});
 	}
 
@@ -222,7 +227,7 @@ export class SeriesApi<
 		return this._series.seriesType();
 	}
 
-	public attachPrimitive(primitive: ISeriesPrimitive): void {
+	public attachPrimitive(primitive: ISeriesPrimitive<HorzScaleItem>): void {
 		// at this point we cast the generic to unknown because we
 		// don't want the model to know the types of the API (◑_◑)
 		this._series.attachPrimitive(primitive as ISeriesPrimitiveBase<unknown>);
@@ -235,7 +240,7 @@ export class SeriesApi<
 		}
 	}
 
-	public detachPrimitive(primitive: ISeriesPrimitive): void {
+	public detachPrimitive(primitive: ISeriesPrimitive<HorzScaleItem>): void {
 		this._series.detachPrimitive(primitive as ISeriesPrimitiveBase<unknown>);
 		if (primitive.detached) {
 			primitive.detached();
diff --git a/src/api/time-scale-api.ts b/src/api/time-scale-api.ts
index b82cddf83f..1778402f06 100644
--- a/src/api/time-scale-api.ts
+++ b/src/api/time-scale-api.ts
@@ -5,40 +5,43 @@ import { TimeAxisWidget } from '../gui/time-axis-widget';
 import { assert } from '../helpers/assertions';
 import { Delegate } from '../helpers/delegate';
 import { IDestroyable } from '../helpers/idestroyable';
-import { DeepPartial } from '../helpers/strict-type-checks';
+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 { TimeScale, TimeScaleOptions } from '../model/time-scale';
+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 { 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: timeRange.from.originalTime as HorzScaleItem,
+			to: timeRange.to.originalTime as HorzScaleItem,
 		};
 	}
 
-	public setVisibleRange(range: TimeRange): void {
-		const convertedRange: TimePointsRange = {
-			from: convertTime(range.from),
-			to: convertTime(range.to),
+	public setVisibleRange(range: Range<HorzScaleItem>): void {
+		const convertedRange: Range<InternalHorzScaleItem> = {
+			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,15 +146,15 @@ 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);
+		const timePoint = timeScale.indexToTimeScalePoint(timePointIndex);
 		if (timePoint === null) {
 			return null;
 		}
 
-		return timePoint.businessDay ?? timePoint.timestamp;
+		return timePoint.originalTime as HorzScaleItem;
 	}
 
 	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);
 	}
 
@@ -186,13 +189,13 @@ export class TimeScaleApi implements ITimeScaleApi, IDestroyable {
 		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 {
-			...this._timeScale.options(),
+			...clone(this._timeScale.options()),
 			barSpacing: this._timeScale.barSpacing(),
 		};
 	}
diff --git a/src/gui/chart-widget.ts b/src/gui/chart-widget.ts
index 5c78d5068a..dd75b820fd 100644
--- a/src/gui/chart-widget.ts
+++ b/src/gui/chart-widget.ts
@@ -8,9 +8,10 @@ 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 { 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';
 import {
 	InvalidateMask,
 	InvalidationLevel,
@@ -20,21 +21,20 @@ 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;
+	originalTime?: unknown;
 	index?: TimePointIndex;
 	point?: Point;
-	seriesData: Map<Series, SeriesPlotRow>;
-	hoveredSeries?: Series;
+	seriesData: Map<Series<SeriesType>, SeriesPlotRow<SeriesType>>;
+	hoveredSeries?: Series<SeriesType>;
 	hoveredObject?: string;
 	touchMouseEventData?: TouchMouseEventData;
 }
@@ -43,11 +43,19 @@ export type MouseEventParamsImplSupplier = () => MouseEventParamsImpl;
 
 const windowsChrome = isChromiumBased() && isWindows();
 
-export class ChartWidget implements IDestroyable {
-	private readonly _options: ChartOptionsInternal;
+export interface IChartWidgetBase {
+	getPriceAxisWidth(position: DefaultPriceScaleId): number;
+	model(): IChartModelBase;
+	paneWidgets(): PaneWidget[];
+	options(): ChartOptionsInternalBase;
+	setCursorStyle(style: string | null): void;
+}
+
+export class ChartWidget<HorzScaleItem> implements IDestroyable, IChartWidgetBase {
+	private readonly _options: ChartOptionsInternal<HorzScaleItem>;
 	private _paneWidgets: PaneWidget[] = [];
 	// 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,7 +63,7 @@ export class ChartWidget implements IDestroyable {
 	private _rightPriceAxisWidth: number = 0;
 	private _element: HTMLDivElement;
 	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();
@@ -67,9 +75,12 @@ export class ChartWidget implements IDestroyable {
 	private _container: HTMLElement;
 	private _cursorStyleOverride: string | null = null;
 
-	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');
@@ -89,11 +100,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();
@@ -122,11 +134,11 @@ 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;
 	}
 
@@ -134,7 +146,7 @@ export class ChartWidget implements IDestroyable {
 		return this._paneWidgets;
 	}
 
-	public timeAxisWidget(): TimeAxisWidget {
+	public timeAxisWidget(): TimeAxisWidget<HorzScaleItem> {
 		return this._timeAxisWidget;
 	}
 
@@ -215,7 +227,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
@@ -306,7 +318,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;
@@ -738,10 +750,10 @@ export class ChartWidget implements IDestroyable {
 		point: Point | null,
 		event: TouchMouseEventData | null
 	): MouseEventParamsImpl {
-		const seriesData = new Map<Series, SeriesPlotRow>();
+		const seriesData = new Map<Series<SeriesType>, SeriesPlotRow<SeriesType>>();
 		if (index !== null) {
 			const serieses = this._model.serieses();
-			serieses.forEach((s: Series) => {
+			serieses.forEach((s: Series<SeriesType>) => {
 				// TODO: replace with search left
 				const data = s.bars().search(index);
 				if (data !== null) {
@@ -749,7 +761,7 @@ export class ChartWidget implements IDestroyable {
 				}
 			});
 		}
-		let clientTime: OriginalTime | undefined;
+		let clientTime: unknown | undefined;
 		if (index !== null) {
 			const timePoint = this._model.timeScale().indexToTimeScalePoint(index)?.originalTime;
 			if (timePoint !== undefined) {
@@ -768,7 +780,7 @@ export class ChartWidget implements IDestroyable {
 			: undefined;
 
 		return {
-			time: clientTime,
+			originalTime: clientTime,
 			index: index ?? undefined,
 			point: point ?? undefined,
 			hoveredSeries,
@@ -854,6 +866,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..97fd2b16f5 100644
--- a/src/gui/pane-separator.ts
+++ b/src/gui/pane-separator.ts
@@ -1,14 +1,14 @@
 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 implements IDestroyable {
-	private readonly _chartWidget: ChartWidget;
+	private readonly _chartWidget: IChartWidgetBase;
 	private readonly _rowElement: HTMLTableRowElement;
 	private readonly _cell: HTMLTableCellElement;
 	private readonly _handle: HTMLDivElement | null;
@@ -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: 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 78a40cccdb..a72fa70186 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, TrackingModeExitMode } from '../model/chart-model';
+import { IChartModelBase, TrackingModeExitMode } from '../model/chart-model';
 import { Coordinate } from '../model/coordinate';
 import { IDataSource } from '../model/idata-source';
 import { InvalidationLevel } from '../model/invalidate-mask';
@@ -27,7 +27,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 { drawBackground, drawForeground, DrawFunction, drawSourcePaneViews } from './draw-functions';
 import { IPaneViewsGetter } from './ipane-view-getter';
 import { MouseEventHandler, MouseEventHandlerEventBase, MouseEventHandlerMouseEvent, MouseEventHandlers, MouseEventHandlerTouchEvent, Position, TouchMouseEvent } from './mouse-event-handler';
@@ -61,7 +61,7 @@ interface StartScrollPosition extends Point {
 }
 
 export class PaneWidget implements IDestroyable, MouseEventHandlers {
-	private readonly _chart: ChartWidget;
+	private readonly _chart: IChartWidgetBase;
 	private _state: Pane | null;
 	private _size: Size = size({ width: 0, height: 0 });
 	private _leftPriceAxisWidget: PriceAxisWidget | null = null;
@@ -87,7 +87,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 
 	private _isSettingSize: boolean = false;
 
-	public constructor(chart: ChartWidget, state: Pane) {
+	public constructor(chart: IChartWidgetBase, state: Pane) {
 		this._chart = chart;
 
 		this._state = state;
@@ -182,7 +182,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		this.updatePriceAxisWidgetsStates();
 	}
 
-	public chart(): ChartWidget {
+	public chart(): IChartWidgetBase {
 		return this._chart;
 	}
 
@@ -654,7 +654,7 @@ export class PaneWidget implements IDestroyable, MouseEventHandlers {
 		this._initCrosshairPosition = { x: crosshair.appliedX(), y: crosshair.appliedY() };
 	}
 
-	private _model(): ChartModel {
+	private _model(): IChartModelBase {
 		return this._chart.model();
 	}
 
diff --git a/src/gui/price-axis-stub.ts b/src/gui/price-axis-stub.ts
index c141639fe2..83298bebd7 100644
--- a/src/gui/price-axis-stub.ts
+++ b/src/gui/price-axis-stub.ts
@@ -10,7 +10,7 @@ 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';
 
@@ -30,7 +30,7 @@ export class PriceAxisStub implements IDestroyable {
 
 	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider;
 
-	private _options: ChartOptionsInternal;
+	private _options: ChartOptionsBase;
 
 	private _invalidated: boolean = true;
 
@@ -41,7 +41,7 @@ export class PriceAxisStub implements IDestroyable {
 
 	public constructor(
 		side: PriceAxisWidgetSide,
-		options: ChartOptionsInternal,
+		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 d026d23444..a6585c786d 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';
@@ -68,7 +68,7 @@ function buildPriceAxisViewsGetter(
 
 export class PriceAxisWidget implements IDestroyable {
 	private readonly _pane: PaneWidget;
-	private readonly _options: Readonly<ChartOptionsInternal>;
+	private readonly _options: Readonly<ChartOptionsInternalBase>;
 	private readonly _layoutOptions: Readonly<LayoutOptions>;
 	private readonly _rendererOptionsProvider: PriceAxisRendererOptionsProvider;
 	private readonly _isLeft: boolean;
@@ -94,7 +94,7 @@ export class PriceAxisWidget implements IDestroyable {
 	private _sourceTopPaneViews: IPriceAxisViewsGetter;
 	private _sourceBottomPaneViews: IPriceAxisViewsGetter;
 
-	public constructor(pane: PaneWidget, options: Readonly<ChartOptionsInternal>, rendererOptionsProvider: PriceAxisRendererOptionsProvider, 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 078c649f7f..a34fbfb030 100644
--- a/src/gui/time-axis-widget.ts
+++ b/src/gui/time-axis-widget.ts
@@ -16,13 +16,12 @@ 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 { SeriesPrimitivePaneViewZOrder } from '../model/iseries-primitive';
 import { LayoutOptions } from '../model/layout-options';
 import { Pane } from '../model/pane';
 import { TextWidthCache } from '../model/text-width-cache';
-import { TickMarkWeight } from '../model/time-data';
-import { TimeMark } from '../model/time-scale';
 import { IPaneRenderer } from '../renderers/ipane-renderer';
 import { TimeAxisViewRendererOptions } from '../renderers/itime-axis-view-renderer';
 import { IAxisView } from '../views/pane/iaxis-view';
@@ -44,10 +43,6 @@ const enum CursorType {
 	EwResize,
 }
 
-function markWithGreaterWeight(a: TimeMark, b: TimeMark): TimeMark {
-	return a.weight > b.weight ? a : b;
-}
-
 function buildTimeAxisViewsGetter(zOrder: SeriesPrimitivePaneViewZOrder): ITimeAxisViewsGetter {
 	return (source: IDataSource): readonly IAxisView[] => source.timePaneViews?.(zOrder) ?? [];
 }
@@ -55,8 +50,8 @@ const sourcePaneViews = buildTimeAxisViewsGetter('normal');
 const sourceTopPaneViews = buildTimeAxisViewsGetter('top');
 const sourceBottomPaneViews = buildTimeAxisViewsGetter('bottom');
 
-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;
@@ -75,8 +70,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');
@@ -378,13 +376,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();
 
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 0e63ec50d5..8d697ac2f6 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -10,20 +10,16 @@ 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 { isBusinessDay, isUTCTimestamp } from './model/horz-scale-behavior-time/types';
+export { TickMarkType } from './model/horz-scale-behavior-time/types';
 export const customSeriesDefaultOptions: CustomSeriesOptions = {
 	...seriesOptionsDefaults,
 	...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/chart-model.ts b/src/model/chart-model.ts
index 0d81178585..fda1a32534 100644
--- a/src/model/chart-model.ts
+++ b/src/model/chart-model.ts
@@ -15,18 +15,19 @@ import { Crosshair, CrosshairOptions } from './crosshair';
 import { DefaultPriceScaleId, isDefaultPriceScale } from './default-price-scale';
 import { GridOptions } from './grid';
 import { ICustomSeriesPaneView } from './icustom-series';
+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 { 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 { TimeScale, TimeScaleOptions } from './time-scale';
+import { HorzScaleOptions, ITimeScale, TimeScale } from './time-scale';
 import { TouchMouseEventData } from './touch-mouse-event-data';
 import { Watermark, WatermarkOptions } from './watermark';
 
@@ -231,9 +232,9 @@ export interface TrackingModeOptions {
 }
 
 /**
- * Structure describing options of the chart. Series options are to be set separately
+ * Represents common chart options
  */
-export interface ChartOptions {
+export interface ChartOptionsBase {
 	/**
 	 * Width of the chart in pixels
 	 *
@@ -297,7 +298,7 @@ export interface ChartOptions {
 	/**
 	 * 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.
@@ -310,11 +311,6 @@ export interface ChartOptions {
 	 */
 	grid: GridOptions;
 
-	/**
-	 * Localization options.
-	 */
-	localization: LocalizationOptions;
-
 	/**
 	 * Scroll options, or a boolean flag that enables/disables scrolling
 	 */
@@ -335,10 +331,36 @@ export interface ChartOptions {
 	 */
 	trackingMode: TrackingModeOptions;
 
+	/**
+	 * Basic localization options
+	 */
+	localization: LocalizationOptionsBase;
 }
 
-export type ChartOptionsInternal =
-	Omit<ChartOptions, 'handleScroll' | 'handleScale' | 'layout'>
+/**
+ * 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<ChartOptionsImpl<HorzScaleItem>, 'handleScroll' | 'handleScale' | 'layout'>
 	& {
 		/** @public */
 		handleScroll: HandleScrollOptions;
@@ -354,19 +376,74 @@ interface GradientColorsCache {
 	colors: Map<number, string>;
 }
 
-export class ChartModel implements IDestroyable {
-	private readonly _options: ChartOptionsInternal;
+export interface IChartModelBase {
+	applyPriceScaleOptions(priceScaleId: string, options: DeepPartial<PriceScaleOptions>): void;
+	findPriceScale(priceScaleId: string): PriceScaleOnPane | null;
+	options(): Readonly<ChartOptionsInternalBase>;
+	timeScale(): ITimeScale;
+	serieses(): readonly ISeries<SeriesType>[];
+
+	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;
+
+	lightUpdate(): void;
+	fullUpdate(): void;
+
+	backgroundBottomColor(): string;
+	backgroundTopColor(): string;
+	backgroundColorAtYPercentFromTop(percent: number): string;
+
+	paneForSource(source: IPriceDataSource): Pane | null;
+	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;
 
-	private readonly _timeScale: TimeScale;
+	private readonly _timeScale: TimeScale<HorzScaleItem>;
 	private readonly _panes: Pane[] = [];
 	private readonly _crosshair: Crosshair;
 	private readonly _magnet: Magnet;
 	private readonly _watermark: Watermark;
 
-	private _serieses: Series[] = [];
+	private _serieses: Series<SeriesType>[] = [];
 
 	private _width: number = 0;
 	private _hoveredSource: HoveredSource | null = null;
@@ -377,13 +454,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);
@@ -427,11 +507,11 @@ 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));
@@ -494,7 +574,7 @@ export class ChartModel implements IDestroyable {
 		return null;
 	}
 
-	public timeScale(): TimeScale {
+	public timeScale(): TimeScale<HorzScaleItem> {
 		return this._timeScale;
 	}
 
@@ -650,7 +730,7 @@ export class ChartModel implements IDestroyable {
 		this.lightUpdate();
 	}
 
-	public serieses(): readonly Series[] {
+	public serieses(): readonly Series<SeriesType>[] {
 		return this._serieses;
 	}
 
@@ -713,7 +793,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;
 
@@ -766,7 +846,7 @@ export class ChartModel implements IDestroyable {
 		return this._priceScalesOptionsChanged;
 	}
 
-	public createSeries<T extends SeriesType>(seriesType: T, options: SeriesOptionsMap[T], customPaneView?: ICustomSeriesPaneView): Series<T> {
+	public createSeries<T extends SeriesType>(seriesType: T, options: SeriesOptionsMap[T], customPaneView?: ICustomSeriesPaneView<HorzScaleItem>): Series<T> {
 		const pane = this._panes[0];
 		const series = this._createSeries(options, seriesType, pane, customPaneView);
 		this._serieses.push(series);
@@ -781,7 +861,7 @@ export class ChartModel implements IDestroyable {
 		return series;
 	}
 
-	public removeSeries(series: Series): void {
+	public removeSeries(series: Series<SeriesType>): void {
 		const pane = this.paneForSource(series);
 
 		const seriesIndex = this._serieses.indexOf(series);
@@ -794,7 +874,7 @@ export class ChartModel implements IDestroyable {
 		}
 	}
 
-	public moveSeriesToScale(series: Series, targetScaleId: string): void {
+	public moveSeriesToScale(series: Series<SeriesType>, targetScaleId: string): void {
 		const pane = ensureNotNull(this.paneForSource(series));
 		pane.removeDataSource(series);
 
@@ -926,7 +1006,7 @@ export class ChartModel implements IDestroyable {
 		this._panes.forEach((pane: Pane) => pane.grid().paneView().update());
 	}
 
-	private _createSeries<T extends SeriesType>(options: SeriesOptionsInternal<T>, seriesType: T, pane: Pane, customPaneView?: ICustomSeriesPaneView): Series<T> {
+	private _createSeries<T extends SeriesType>(options: SeriesOptionsInternal<T>, seriesType: T, pane: Pane, customPaneView?: ICustomSeriesPaneView<HorzScaleItem>): Series<T> {
 		const series = new Series<T>(this, options, seriesType, pane, customPaneView);
 
 		const targetScaleId = options.priceScaleId !== undefined ? options.priceScaleId : this.defaultVisiblePriceScaleId();
diff --git a/src/model/crosshair.ts b/src/model/crosshair.ts
index 09d3b300f3..f012569e12 100644
--- a/src/model/crosshair.ts
+++ b/src/model/crosshair.ts
@@ -12,13 +12,15 @@ 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 { PriceScale } from './price-scale';
-import { Series } from './series';
-import { TimePoint, TimePointIndex } from './time-data';
+import { ISeries } from './series';
+import { SeriesType } from './series-options';
+import { TimePointIndex } from './time-data';
 
 export interface CrosshairPriceAndCoordinate {
 	price: number;
@@ -26,7 +28,7 @@ export interface CrosshairPriceAndCoordinate {
 }
 
 export interface CrosshairTimeAndCoordinate {
-	time: TimePoint;
+	time: InternalHorzScaleItem;
 	coordinate: number;
 }
 
@@ -127,7 +129,7 @@ export class Crosshair extends DataSource {
 	private _price: number = NaN;
 	private _index: TimePointIndex = 0 as TimePointIndex;
 	private _visible: boolean = true;
-	private readonly _model: ChartModel;
+	private readonly _model: IChartModelBase;
 	private _priceAxisViews: Map<PriceScale, CrosshairPriceAxisView> = new Map();
 	private readonly _timeAxisView: CrosshairTimeAxisView;
 	private readonly _markersPaneView: CrosshairMarksPaneView;
@@ -142,7 +144,7 @@ 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: IChartModelBase, options: CrosshairOptions) {
 		super();
 		this._model = model;
 		this._options = options;
@@ -334,7 +336,7 @@ export class Crosshair extends DataSource {
 
 	private _setIndexToLastSeriesBarIndex(): void {
 		const lastIndexes = this._model.serieses()
-			.map((s: Series) => 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;
diff --git a/src/model/custom-price-line.ts b/src/model/custom-price-line.ts
index 3b75419c9f..3fec202946 100644
--- a/src/model/custom-price-line.ts
+++ b/src/model/custom-price-line.ts
@@ -8,16 +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 {
-	private readonly _series: Series;
+	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, 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/api/data-consumer.ts b/src/model/data-consumer.ts
similarity index 63%
rename from src/api/data-consumer.ts
rename to src/model/data-consumer.ts
index be06064699..f189ebcc82 100644
--- a/src/api/data-consumer.ts
+++ b/src/model/data-consumer.ts
@@ -1,29 +1,7 @@
-import { isNumber, isString } from '../helpers/strict-type-checks';
-
-import { CustomData, CustomSeriesWhitespaceData } from '../model/icustom-series';
-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);
-}
+import { Time } from './horz-scale-behavior-time/types';
+import { CustomData, CustomSeriesWhitespaceData } from './icustom-series';
+import { Series } from './series';
+import { SeriesType } from './series-options';
 
 /**
  * Represents a whitespace data item, which is a data point without a value.
@@ -41,11 +19,11 @@ export function isUTCTimestamp(time: Time): time is UTCTimestamp {
  * ];
  * ```
  */
-export interface WhitespaceData {
+export interface WhitespaceData<HorzScaleItem = Time> {
 	/**
 	 * The time of the data.
 	 */
-	time: Time;
+	time: HorzScaleItem;
 
 	/**
 	 * Additional custom values which will be ignored by the library, but
@@ -57,7 +35,12 @@ export interface WhitespaceData {
 /**
  * A base interface for a data point of single-value series.
  */
-export interface SingleValueData extends WhitespaceData {
+export interface SingleValueData<HorzScaleItem = Time> extends WhitespaceData<HorzScaleItem> {
+	/**
+	 * The time of the data.
+	 */
+	time: HorzScaleItem;
+
 	/**
 	 * Price value of the data.
 	 */
@@ -67,7 +50,7 @@ export interface SingleValueData extends WhitespaceData {
 /**
  * Structure describing a single item of data for line series
  */
-export interface LineData extends SingleValueData {
+export interface LineData<HorzScaleItem = Time> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -77,7 +60,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 = Time> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -87,7 +70,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 = Time> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional line color value for certain data item. If missed, color from options is used
 	 */
@@ -107,7 +90,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 = Time> extends SingleValueData<HorzScaleItem> {
 	/**
 	 * Optional top area top fill color value for certain data item. If missed, color from options is used
 	 */
@@ -142,7 +125,12 @@ export interface BaselineData extends SingleValueData {
 /**
  * Represents a bar with a {@link Time} and open, high, low, and close prices.
  */
-export interface OhlcData extends WhitespaceData {
+export interface OhlcData<HorzScaleItem = Time> extends WhitespaceData<HorzScaleItem> {
+	/**
+	 * The bar time.
+	 */
+	time: HorzScaleItem;
+
 	/**
 	 * The open price.
 	 */
@@ -164,7 +152,7 @@ export interface OhlcData extends WhitespaceData {
 /**
  * Structure describing a single item of data for bar series
  */
-export interface BarData extends OhlcData {
+export interface BarData<HorzScaleItem = Time> extends OhlcData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -174,7 +162,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 = Time> extends OhlcData<HorzScaleItem> {
 	/**
 	 * Optional color value for certain data item. If missed, color from options is used
 	 */
@@ -189,16 +177,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 = Time>(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
 	);
 }
 
@@ -207,38 +195,38 @@ 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 = Time> {
 	/**
 	 * 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>;
 	/**
 	 * The base types of an custom series data.
 	 */
-	Custom: CustomData | CustomSeriesWhitespaceData;
+	Custom: CustomData<HorzScaleItem> | CustomSeriesWhitespaceData<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 = Time> {
+	applyNewData(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): void;
+	updateData(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): void;
 }
diff --git a/src/api/data-layer.ts b/src/model/data-layer.ts
similarity index 64%
rename from src/api/data-layer.ts
rename to src/model/data-layer.ts
index 0ddbfb492c..d665d54e99 100644
--- a/src/api/data-layer.ts
+++ b/src/model/data-layer.ts
@@ -1,113 +1,22 @@
 /// <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 { Mutable } from '../helpers/mutable';
 
-import { Series, SeriesUpdateInfo } from '../model/series';
-import { SeriesPlotRow } from '../model/series-data';
-import { SeriesType } from '../model/series-options';
+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';
+import { SeriesType } from './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;
-
-function businessDayConverter(time: Time): TimePoint {
-	if (!isBusinessDay(time)) {
-		throw new Error('time must be of type BusinessDay');
-	}
+} from './time-data';
 
-	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 type TimedData<HorzScaleItem> = Pick<SeriesDataItemTypeMap<HorzScaleItem>[SeriesType], 'time'>;
 
 export interface TimeScaleChanges {
 	/**
@@ -130,7 +39,7 @@ export interface SeriesChanges {
 	/**
 	 * Data to be merged into series' plot list
 	 */
-	data: readonly SeriesPlotRow[];
+	data: readonly SeriesPlotRow<SeriesType>[];
 	/**
 	 * Additional info about this change
 	 */
@@ -141,7 +50,7 @@ export interface DataUpdateResponse {
 	/**
 	 * 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>, SeriesChanges>;
 
 	/**
 	 * Contains optional time scale points
@@ -151,40 +60,40 @@ export interface DataUpdateResponse {
 
 interface TimePointData {
 	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>, Mutable<SeriesPlotRow<SeriesType> | WhitespacePlotRow>>;
 }
 
-interface InternalTimeScalePoint extends Mutable<TimeScalePoint> {
+export interface InternalTimeScalePoint extends Mutable<TimeScalePoint> {
 	pointData: TimePointData;
 }
 
-function createEmptyTimePointData(timePoint: TimePoint): TimePointData {
+function createEmptyTimePointData(timePoint: InternalHorzScaleItem): TimePointData {
 	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>[] | 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>[] | 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) {
 		return {
 			lastBarUpdatedOrNewBarsAddedToTheRight:
@@ -196,27 +105,43 @@ 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>, SeriesPlotRow<TSeriesType> | WhitespacePlotRow>): HorzScaleItem {
+	let result: HorzScaleItem | undefined;
+	mergedPointData.forEach((v: SeriesPlotRow<TSeriesType> | WhitespacePlotRow) => {
 		if (result === undefined) {
-			result = v.originalTime;
+			result = v.originalTime as HorzScaleItem;
 		}
 	});
 
 	return ensureDefined(result);
 }
 
-export class DataLayer {
+function saveOriginalTime<TSeriesType extends SeriesType, HorzScaleItem>(data: SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>): void {
+	if (data.originalTime === undefined) {
+		data.originalTime = data.time;
+	}
+}
+
+type SeriesDataItemWithOriginalTime<TSeriesType extends SeriesType, HorzScaleItem> = SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType] & {
+	originalTime: HorzScaleItem;
+};
+
+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> = 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[] = [];
 
+	private readonly _horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>;
+
+	public constructor(horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>) {
+		this._horzScaleBehavior = horzScaleBehavior;
+	}
+
 	public destroy(): void {
 		this._pointDataByTimePoint.clear();
 		this._seriesRowsBySeries.clear();
@@ -224,7 +149,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>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType][]): DataUpdateResponse {
 		let needCleanupPoints = this._pointDataByTimePoint.size !== 0;
 
 		let isTimeScaleAffected = false;
@@ -252,23 +177,24 @@ export class DataLayer {
 		let seriesRows: (SeriesPlotRow<TSeriesType> | WhitespacePlotRow)[] = [];
 
 		if (data.length !== 0) {
-			const originalTimes = data.map((d: SeriesDataItemTypeMap[TSeriesType]) => d.time as unknown as OriginalTime);
+			const originalTimes = data.map((d: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]) => d.time);
 
-			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());
 			const dataToPlotRow = series.customSeriesPlotValuesBuilder();
-			const customWhitespaceChecker = series.customSeriesWhitespaceCheck();
+			const customWhitespaceChecker = series.customSeriesWhitespaceCheck<HorzScaleItem>();
 
-			seriesRows = data.map((item: SeriesDataItemTypeMap[TSeriesType], index: number) => {
+			seriesRows = data.map((item: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType], index: number) => {
 				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;
 				}
 
@@ -293,14 +219,14 @@ export class DataLayer {
 			const newTimeScalePoints: InternalTimeScalePoint[] = [];
 			this._pointDataByTimePoint.forEach((pointData: TimePointData) => {
 				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, t2: InternalTimeScalePoint) => this._horzScaleBehavior.key(t1.time) - this._horzScaleBehavior.key(t2.time));
 
 			firstChangedPointIndex = this._replaceTimeScalePoints(newTimeScalePoints);
 		}
@@ -308,26 +234,29 @@ 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>): DataUpdateResponse {
 		return this.setSeriesData(series, []);
 	}
 
-	public updateSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap[TSeriesType]): DataUpdateResponse {
-		const originalTime = data.time as unknown as OriginalTime;
-		convertStringToBusinessDay(data);
+	public updateSeriesData<TSeriesType extends SeriesType>(series: Series<TSeriesType>, data: SeriesDataItemTypeMap<HorzScaleItem>[TSeriesType]): DataUpdateResponse {
+		const extendedData = data as SeriesDataItemWithOriginalTime<TSeriesType, HorzScaleItem>;
+		saveOriginalTime(extendedData);
+		// 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
@@ -336,13 +265,14 @@ 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 dataToPlotRow = series.customSeriesPlotValuesBuilder();
-		const customWhitespaceChecker = series.customSeriesWhitespaceCheck();
-		const plotRow = createPlotRow(time, pointDataAtTime.index, data, originalTime, dataToPlotRow, customWhitespaceChecker);
+		const customWhitespaceChecker = series.customSeriesWhitespaceCheck<HorzScaleItem>();
+		const plotRow = createPlotRow(time, pointDataAtTime.index, data, extendedData.originalTime, dataToPlotRow, customWhitespaceChecker);
+
 		pointDataAtTime.mapping.set(series, plotRow);
 
 		this._updateLastSeriesRow(series, plotRow);
@@ -355,13 +285,13 @@ export class DataLayer {
 		}
 
 		const newPoint: InternalTimeScalePoint = {
-			timeWeight: 0,
+			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, 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
@@ -372,12 +302,12 @@ export class DataLayer {
 			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>, plotRow: SeriesPlotRow<SeriesType> | WhitespacePlotRow): void {
 		let seriesData = this._seriesRowsBySeries.get(series);
 		if (seriesData === undefined) {
 			seriesData = [];
@@ -386,7 +316,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);
 			}
@@ -401,7 +331,7 @@ export class DataLayer {
 		this._seriesLastTimePoint.set(series, plotRow.time);
 	}
 
-	private _setRowsToSeries(series: Series, seriesRows: (SeriesPlotRow | WhitespacePlotRow)[]): 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);
@@ -418,7 +348,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));
 			}
 		}
 	}
@@ -435,7 +365,7 @@ export class DataLayer {
 		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;
 			}
@@ -464,7 +394,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;
 
@@ -479,7 +409,7 @@ export class DataLayer {
 
 		let baseIndex = 0 as TimePointIndex;
 
-		this._seriesRowsBySeries.forEach((data: SeriesPlotRow[]) => {
+		this._seriesRowsBySeries.forEach((data: SeriesPlotRow<SeriesType>[]) => {
 			if (data.length !== 0) {
 				baseIndex = Math.max(baseIndex, data[data.length - 1].index) as TimePointIndex;
 			}
@@ -488,7 +418,7 @@ export class DataLayer {
 		return baseIndex;
 	}
 
-	private _getUpdateResponse(updatedSeries: Series, firstChangedPointIndex: number, info?: SeriesUpdateInfo): DataUpdateResponse {
+	private _getUpdateResponse(updatedSeries: Series<SeriesType>, firstChangedPointIndex: number, info?: SeriesUpdateInfo): DataUpdateResponse {
 		const dataUpdateResponse: DataUpdateResponse = {
 			series: new Map(),
 			timeScale: {
@@ -499,7 +429,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>[], s: Series<SeriesType>) => {
 				dataUpdateResponse.series.set(
 					s,
 					{
@@ -528,12 +458,12 @@ export class DataLayer {
 	}
 }
 
-function assignIndexToPointData(pointData: TimePointData, 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 | WhitespacePlotRow>) => {
+	pointData.mapping.forEach((seriesRow: Mutable<SeriesPlotRow<SeriesType> | WhitespacePlotRow>) => {
 		seriesRow.index = index;
 	});
 }
diff --git a/src/api/data-validators.ts b/src/model/data-validators.ts
similarity index 69%
rename from src/api/data-validators.ts
rename to src/model/data-validators.ts
index d4b56a0066..795c740c44 100644
--- a/src/api/data-validators.ts
+++ b/src/model/data-validators.ts
@@ -1,12 +1,12 @@
-import { assert } from '../helpers/assertions';
+/// <reference types="_build-time-constants" />
 
-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 { assert } from '../helpers/assertions';
 
 import { isFulfilledData, SeriesDataItemTypeMap } from './data-consumer';
-import { convertTime } from './data-layer';
+import { IHorzScaleBehavior } from './ihorz-scale-behavior';
+import { CreatePriceLineOptions } from './price-line-options';
+import { SeriesMarker } from './series-markers';
+import { SeriesType } from './series-options';
 
 export function checkPriceLineOptions(options: CreatePriceLineOptions): void {
 	if (process.env.NODE_ENV === 'production') {
@@ -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(data: readonly (SeriesMarker<Time> | SeriesDataItemTypeMap[SeriesType])[], 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;
 	}
@@ -26,26 +26,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;
 
-export function getChecker(type: SeriesType): Checker {
+export function getChecker<HorzScaleItem>(type: SeriesType): Checker<HorzScaleItem> {
 	switch (type) {
 		case 'Bar':
 		case 'Candlestick':
@@ -62,9 +62,9 @@ export 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;
@@ -100,9 +100,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/model/formatted-labels-cache.ts b/src/model/formatted-labels-cache.ts
index 0e831c3b7f..9119b150e9 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 {
@@ -9,7 +10,7 @@ interface CachedTick {
 
 export type FormatFunction = (tickMark: TickMark) => string;
 
-export class FormattedLabelsCache {
+export class FormattedLabelsCache<HorzScaleItem> {
 	private readonly _format: FormatFunction;
 	private readonly _maxSize: number;
 	private _actualSize: number = 0;
@@ -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, horzScaleBehavior: IHorzScaleBehavior<HorzScaleItem>, size: number = 50) {
 		this._format = format;
+		this._horzScaleBehavior = horzScaleBehavior;
 		this._maxSize = size;
 	}
 
 	public format(tickMark: TickMark): 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/get-series-plot-row-creator.ts b/src/model/get-series-plot-row-creator.ts
new file mode 100644
index 0000000000..0e740b5d04
--- /dev/null
+++ b/src/model/get-series-plot-row-creator.ts
@@ -0,0 +1,166 @@
+import { ensureDefined } from '../helpers/assertions';
+import { Mutable } from '../helpers/mutable';
+
+import { CustomData } from '../model/icustom-series';
+import { PlotRow, PlotRowValue } from '../model/plot-data';
+import { SeriesPlotRow } from '../model/series-data';
+import { SeriesType } from '../model/series-options';
+import { TimePointIndex } from '../model/time-data';
+
+import { AreaData, BarData, BaselineData, CandlestickData, HistogramData, isWhitespaceData, LineData, SeriesDataItemTypeMap, WhitespaceData } from './data-consumer';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
+
+function getColoredLineBasedSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: LineData | HistogramData, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Line' | 'Histogram'>> {
+	const val = item.value;
+
+	const res: Mutable<SeriesPlotRow<'Line' | 'Histogram'>> = { index, time, value: [val, val, val, val], originalTime };
+
+	if (item.color !== undefined) {
+		res.color = item.color;
+	}
+
+	return res;
+}
+
+function getAreaSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: AreaData, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Area'>> {
+	const val = item.value;
+
+	const res: Mutable<SeriesPlotRow<'Area'>> = { index, time, value: [val, val, val, val], originalTime };
+
+	if (item.lineColor !== undefined) {
+		res.lineColor = item.lineColor;
+	}
+
+	if (item.topColor !== undefined) {
+		res.topColor = item.topColor;
+	}
+
+	if (item.bottomColor !== undefined) {
+		res.bottomColor = item.bottomColor;
+	}
+
+	return res;
+}
+
+function getBaselineSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: BaselineData, originalTime: HorzScaleItem): Mutable<SeriesPlotRow<'Baseline'>> {
+	const val = item.value;
+
+	const res: Mutable<SeriesPlotRow<'Baseline'>> = { index, time, value: [val, val, val, val], originalTime };
+
+	if (item.topLineColor !== undefined) {
+		res.topLineColor = item.topLineColor;
+	}
+
+	if (item.bottomLineColor !== undefined) {
+		res.bottomLineColor = item.bottomLineColor;
+	}
+
+	if (item.topFillColor1 !== undefined) {
+		res.topFillColor1 = item.topFillColor1;
+	}
+
+	if (item.topFillColor2 !== undefined) {
+		res.topFillColor2 = item.topFillColor2;
+	}
+
+	if (item.bottomFillColor1 !== undefined) {
+		res.bottomFillColor1 = item.bottomFillColor1;
+	}
+
+	if (item.bottomFillColor2 !== undefined) {
+		res.bottomFillColor2 = item.bottomFillColor2;
+	}
+
+	return res;
+}
+
+function getBarSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: BarData, 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;
+	}
+
+	return res;
+}
+
+function getCandlestickSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: CandlestickData, 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;
+	}
+
+	if (item.borderColor !== undefined) {
+		res.borderColor = item.borderColor;
+	}
+
+	if (item.wickColor !== undefined) {
+		res.wickColor = item.wickColor;
+	}
+
+	return res;
+}
+
+// The returned data is used for scaling the series, and providing the current value for the price scale
+export type CustomDataToPlotRowValueConverter<HorzScaleItem> = (item: CustomData<HorzScaleItem> | WhitespaceData) => number[];
+
+function getCustomSeriesPlotRow<HorzScaleItem>(time: InternalHorzScaleItem, index: TimePointIndex, item: CustomData<HorzScaleItem> | WhitespaceData, originalTime: HorzScaleItem, dataToPlotRow?: CustomDataToPlotRowValueConverter<HorzScaleItem>): Mutable<SeriesPlotRow<'Custom'>> {
+	const values = ensureDefined(dataToPlotRow)(item);
+	const max = Math.max(...values);
+	const min = Math.min(...values);
+	const last = values[values.length - 1];
+	const value: PlotRowValue = [last, max, min, last];
+	const { time: excludedTime, color, ...data } = item as CustomData<HorzScaleItem>;
+	return { index, time, value, originalTime, data, color };
+}
+
+export type WhitespacePlotRow = Omit<PlotRow, 'value'>;
+
+export function isSeriesPlotRow(row: SeriesPlotRow | WhitespacePlotRow): row is SeriesPlotRow {
+	return (row as Partial<SeriesPlotRow>).value !== undefined;
+}
+
+type SeriesItemValueFnMap<HorzScaleItem> = {
+	[T in keyof SeriesDataItemTypeMap]: (time: InternalHorzScaleItem, index: TimePointIndex, item: SeriesDataItemTypeMap<HorzScaleItem>[T], originalTime: HorzScaleItem, dataToPlotRow?: CustomDataToPlotRowValueConverter<HorzScaleItem>, customIsWhitespace?: WhitespaceCheck<HorzScaleItem>) => Mutable<SeriesPlotRow<T> | WhitespacePlotRow>;
+};
+
+function wrapCustomValues<T extends SeriesPlotRow | WhitespacePlotRow, HorzScaleItem>(plotRow: Mutable<T>, bar: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType]): Mutable<T> {
+	if (bar.customValues !== undefined) {
+		plotRow.customValues = bar.customValues;
+	}
+	return plotRow;
+}
+
+export type WhitespaceCheck<HorzScaleItem> = (bar: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType]) => bar is WhitespaceData<HorzScaleItem>;
+
+function isWhitespaceDataWithCustomCheck<HorzScaleItem>(bar: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType], customIsWhitespace?: WhitespaceCheck<HorzScaleItem>): bar is WhitespaceData<HorzScaleItem> {
+	if (customIsWhitespace) {
+		return customIsWhitespace(bar);
+	}
+	return isWhitespaceData(bar);
+}
+
+type GetPlotRowType = (typeof getBaselineSeriesPlotRow) | (typeof getBarSeriesPlotRow) | (typeof getCandlestickSeriesPlotRow) | (typeof getCustomSeriesPlotRow);
+
+function wrapWhitespaceData<TSeriesType extends SeriesType, HorzScaleItem>(createPlotRowFn: GetPlotRowType): SeriesItemValueFnMap<HorzScaleItem>[TSeriesType] {
+	return (time: InternalHorzScaleItem, index: TimePointIndex, bar: SeriesDataItemTypeMap<HorzScaleItem>[SeriesType], originalTime: HorzScaleItem, dataToPlotRow?: CustomDataToPlotRowValueConverter<HorzScaleItem>, customIsWhitespace?: WhitespaceCheck<HorzScaleItem>) => {
+		if (isWhitespaceDataWithCustomCheck(bar, customIsWhitespace)) {
+			return wrapCustomValues({ time, index, originalTime }, bar);
+		}
+
+		return wrapCustomValues<ReturnType<GetPlotRowType>, HorzScaleItem>(createPlotRowFn(time, index, bar, originalTime, dataToPlotRow), bar);
+	};
+}
+
+export function getSeriesPlotRowCreator<TSeriesType extends SeriesType, HorzScaleItem>(seriesType: TSeriesType): SeriesItemValueFnMap<HorzScaleItem>[TSeriesType] {
+	const seriesPlotRowFnMap: SeriesItemValueFnMap<HorzScaleItem> = {
+		Candlestick: wrapWhitespaceData(getCandlestickSeriesPlotRow),
+		Bar: wrapWhitespaceData(getBarSeriesPlotRow),
+		Area: wrapWhitespaceData(getAreaSeriesPlotRow),
+		Baseline: wrapWhitespaceData(getBaselineSeriesPlotRow),
+		Histogram: wrapWhitespaceData(getColoredLineBasedSeriesPlotRow),
+		Line: wrapWhitespaceData(getColoredLineBasedSeriesPlotRow),
+		Custom: wrapWhitespaceData(getCustomSeriesPlotRow),
+	};
+	return seriesPlotRowFnMap[seriesType];
+}
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..d053aaf38a
--- /dev/null
+++ b/src/model/horz-scale-behavior-time/horz-scale-behavior-time.ts
@@ -0,0 +1,265 @@
+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';
+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 } 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';
+
+type TimeConverter = (time: Time) => InternalHorzScaleItem;
+
+function businessDayConverter(time: Time): InternalHorzScaleItem {
+	let businessDay = time;
+	if (isString(time)) {
+		businessDay = stringToBusinessDay(time);
+	}
+	if (!isBusinessDay(businessDay)) {
+		throw new Error('time must be of type BusinessDay');
+	}
+
+	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,
+	} 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) || isString(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;
+
+// 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!: TimeChartOptions;
+
+	public options(): TimeChartOptions {
+		return this._options;
+	}
+
+	public setOptions(options: TimeChartOptions): void {
+		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 key(item: InternalHorzScaleItem | Time): InternalHorzScaleItemKey {
+		// 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));
+		}
+	}
+
+	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, 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 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>[], 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..a2fe524d8a
--- /dev/null
+++ b/src/model/horz-scale-behavior-time/time-based-chart-options.ts
@@ -0,0 +1,26 @@
+import { ChartOptionsImpl } from '../chart-model';
+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 TimeScaleOptions extends HorzScaleOptions {
+	/**
+	 * 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 ChartOptionsImpl<Time> {
+	/**
+	 * Extended time scale options with option to override tickMarkFormatter
+	 */
+	timeScale: TimeScaleOptions;
+}
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 70%
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..fd4513ffc9 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,8 @@
-import { TickMarkWeight, TimeScalePoint } from '../model/time-data';
+import { Mutable } from '../../helpers/mutable';
+
+import { InternalHorzScaleItem } from '../ihorz-scale-behavior';
+import { TickMarkWeightValue, TimeScalePoint } from '../time-data';
+import { TickMarkWeight, TimePoint } from './types';
 
 function hours(count: number): number {
 	return count * 60 * 60 * 1000;
@@ -46,27 +50,31 @@ function weightByTime(currentDate: Date, prevDate: Date): TickMarkWeight {
 	return TickMarkWeight.LessThanSecond;
 }
 
+function cast(t: InternalHorzScaleItem): TimePoint {
+	return t as unknown as TimePoint;
+}
+
 export function fillWeightsForPoints(sortedTimePoints: readonly Mutable<TimeScalePoint>[], 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 +82,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..feba41343b
--- /dev/null
+++ b/src/model/horz-scale-behavior-time/types.ts
@@ -0,0 +1,129 @@
+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.
+	 */
+	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/icustom-series.ts b/src/model/icustom-series.ts
index c2b63ade56..474bdf3e0d 100644
--- a/src/model/icustom-series.ts
+++ b/src/model/icustom-series.ts
@@ -1,17 +1,18 @@
 import { CanvasRenderingTarget2D } from 'fancy-canvas';
 
 import { Coordinate } from './coordinate';
+import { Time } from './horz-scale-behavior-time/types';
 import { CustomSeriesOptions } from './series-options';
-import { Range, Time } from './time-data';
+import { Range } from './time-data';
 
 /**
  * Represents a whitespace data item, which is a data point without a value.
  */
-export interface CustomSeriesWhitespaceData {
+export interface CustomSeriesWhitespaceData<HorzScaleItem> {
 	/**
 	 * The time of the data.
 	 */
-	time: Time;
+	time: HorzScaleItem;
 
 	/**
 	 * Additional custom values which will be ignored by the library, but
@@ -27,7 +28,7 @@ export interface CustomSeriesWhitespaceData {
  * within the interface. It is recommended that you extend this interface with
  * the required data structure.
  */
-export interface CustomData extends CustomSeriesWhitespaceData {
+export interface CustomData<HorzScaleItem = Time> extends CustomSeriesWhitespaceData<HorzScaleItem> {
 	/**
 	 * If defined then this color will be used for the price line and price scale line
 	 * for this specific data item of the custom series.
@@ -35,13 +36,14 @@ export interface CustomData extends CustomSeriesWhitespaceData {
 	color?: string;
 }
 
-export type WhitespaceCheck<TData extends CustomData = CustomData> = (bar: TData | CustomSeriesWhitespaceData) => bar is CustomSeriesWhitespaceData;
+export type WhitespaceCheck<HorzScaleItem, TData extends CustomData<HorzScaleItem> = CustomData<HorzScaleItem>> = (bar: TData | CustomSeriesWhitespaceData<HorzScaleItem>) => bar is CustomSeriesWhitespaceData<HorzScaleItem>;
 
 /**
  * Renderer data for an item within the custom series.
  */
 export interface CustomBarItemData<
-	TData extends CustomData = CustomData
+	HorzScaleItem,
+	TData extends CustomData<HorzScaleItem> = CustomData<HorzScaleItem>
 > {
 	/**
 	 * Horizontal coordinate for the item. Measured from the left edge of the pane in pixels.
@@ -66,12 +68,13 @@ export interface CustomBarItemData<
  * for drawing the series data.
  */
 export interface PaneRendererCustomData<
-	TData extends CustomData
+	HorzScaleItem,
+	TData extends CustomData<HorzScaleItem>
 > {
 	/**
 	 * List of all the series' items and their x coordinates.
 	 */
-	bars: readonly CustomBarItemData<TData>[];
+	bars: readonly CustomBarItemData<HorzScaleItem, TData>[];
 	/**
 	 * Spacing between consecutive bars.
 	 */
@@ -126,7 +129,8 @@ export type CustomSeriesPricePlotValues = number[];
  * This interface represents the view for the custom series
  */
 export interface ICustomSeriesPaneView<
-	TData extends CustomData = CustomData,
+	HorzScaleItem = Time,
+	TData extends CustomData<HorzScaleItem> = CustomData<HorzScaleItem>,
 	TSeriesOptions extends CustomSeriesOptions = CustomSeriesOptions
 > {
 	/**
@@ -142,7 +146,7 @@ export interface ICustomSeriesPaneView<
 	 * during the next paint.
 	 */
 	update(
-		data: PaneRendererCustomData<TData>,
+		data: PaneRendererCustomData<HorzScaleItem, TData>,
 		seriesOptions: TSeriesOptions
 	): void;
 
@@ -161,7 +165,7 @@ export interface ICustomSeriesPaneView<
 	 *
 	 * @param data - data point to be tested
 	 */
-	isWhitespace(data: TData | CustomSeriesWhitespaceData): data is CustomSeriesWhitespaceData;
+	isWhitespace(data: TData | CustomSeriesWhitespaceData<HorzScaleItem>): data is CustomSeriesWhitespaceData<HorzScaleItem>;
 
 	/**
 	 * Default options
diff --git a/src/model/idata-source.ts b/src/model/idata-source.ts
index c16b53249e..8b34ea0765 100644
--- a/src/model/idata-source.ts
+++ b/src/model/idata-source.ts
@@ -8,6 +8,9 @@ import { PrimitiveHoveredItem, SeriesPrimitivePaneViewZOrder } from './iseries-p
 import { Pane } from './pane';
 import { PriceScale } from './price-scale';
 
+export interface ZOrdered {
+	zorder(): number | null;
+}
 /**
  * Prefix meanings:
  * - bottom: Pane views that are painted at the bottom (above background color, below grid lines)
@@ -32,8 +35,7 @@ interface IDataSourcePaneViews extends IPluginPaneViews {
 
 export type DataSourcePaneViewGetterNames = keyof IDataSourcePaneViews;
 
-export interface IDataSource extends IDataSourcePaneViews {
-	zorder(): number | null;
+export interface IDataSource extends IDataSourcePaneViews, ZOrdered {
 	setZorder(value: number): void;
 	priceScale(): PriceScale | null;
 	setPriceScale(scale: PriceScale | null): void;
@@ -41,6 +43,13 @@ export interface IDataSource extends IDataSourcePaneViews {
 	updateAllViews(): void;
 
 	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: Pane): readonly IPaneView[];
 	timeAxisViews(): readonly ITimeAxisView[];
 
 	visible(): boolean;
diff --git a/src/model/ihorz-scale-behavior.ts b/src/model/ihorz-scale-behavior.ts
new file mode 100644
index 0000000000..228ad34977
--- /dev/null
+++ b/src/model/ihorz-scale-behavior.ts
@@ -0,0 +1,122 @@
+import { Mutable } from '../helpers/mutable';
+import { Nominal } from '../helpers/nominal';
+
+import { ChartOptionsImpl } 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';
+
+/**
+ * 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(): 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.
+	 *
+	 * @param options - Chart options to be set
+	 * @returns void
+	 */
+	setOptions(options: ChartOptionsImpl<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;
+	/**
+	 * 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, 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>[], startIndex: number): void;
+}
diff --git a/src/model/iprice-data-source.ts b/src/model/iprice-data-source.ts
index 5407afbf0a..7bdb8c2a5c 100644
--- a/src/model/iprice-data-source.ts
+++ b/src/model/iprice-data-source.ts
@@ -1,20 +1,21 @@
 import { IPriceFormatter } from '../formatters/iprice-formatter';
 
 import { AutoscaleInfoImpl } from './autoscale-info-impl';
-import { ChartModel } from './chart-model';
+import { IChartModelBase } 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 {
 	firstValue(): FirstValue | null;
 	formatter(): IPriceFormatter;
 	priceLineColor(lastBarColor: string): string;
-	model(): ChartModel;
 	minMove(): number;
 	autoscaleInfo(startTimePoint: TimePointIndex, endTimePoint: TimePointIndex): AutoscaleInfoImpl | null;
+	model(): IChartModelBase;
 }
diff --git a/src/model/localization-options.ts b/src/model/localization-options.ts
index 7a78db853a..5f4bd450f0 100644
--- a/src/model/localization-options.ts
+++ b/src/model/localization-options.ts
@@ -1,15 +1,15 @@
+import { Time } from './horz-scale-behavior-time/types';
 import { PercentageFormatterFn, 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> = (time: HorzScaleItem) => string;
 
 /**
- * Represents options for formatting dates, times, and prices according to a locale.
+ * Represents basic localization options
  */
-export interface LocalizationOptions {
+export interface LocalizationOptionsBase {
 	/**
 	 * Current locale used to format dates. Uses the browser's language settings by default.
 	 *
@@ -32,13 +32,19 @@ export interface LocalizationOptions {
 	 * @defaultValue `undefined`
 	 */
 	percentageFormatter?: PercentageFormatterFn;
+}
+
+/**
+ * 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.
 	 *
 	 * @defaultValue `undefined`
 	 */
-	timeFormatter?: TimeFormatterFn;
+	timeFormatter?: TimeFormatterFn<HorzScaleItem>;
 
 	/**
 	 * Date formatting string.
diff --git a/src/model/magnet.ts b/src/model/magnet.ts
index 85b267a5f0..5f136891c2 100644
--- a/src/model/magnet.ts
+++ b/src/model/magnet.ts
@@ -5,7 +5,8 @@ import { CrosshairMode, CrosshairOptions } from './crosshair';
 import { IPriceDataSource } from './iprice-data-source';
 import { Pane } 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 {
@@ -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 ISeries<SeriesType>[] = pane.dataSources().filter(
+			((ds: IPriceDataSource) => (ds instanceof Series<SeriesType>)) as (ds: IPriceDataSource) => ds is Series<SeriesType>);
 
 		const candidates = serieses.reduce(
-			(acc: Coordinate[], series: Series) => {
+			(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 7e591a28bf..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, ChartOptions, 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;
 
@@ -22,8 +22,8 @@ interface MinMaxOrderInfo {
 }
 
 export class Pane implements IDestroyable {
-	private readonly _timeScale: TimeScale;
-	private readonly _model: ChartModel;
+	private readonly _timeScale: ITimeScale;
+	private readonly _model: IChartModelBase;
 	private readonly _grid: Grid;
 
 	private _dataSources: IPriceDataSource[] = [];
@@ -39,7 +39,7 @@ export class Pane implements IDestroyable {
 	private _leftPriceScale: PriceScale;
 	private _rightPriceScale: PriceScale;
 
-	public constructor(timeScale: TimeScale, model: ChartModel) {
+	public constructor(timeScale: ITimeScale, model: IChartModelBase) {
 		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<ChartOptionsBase>): void {
 		if (options.leftPriceScale) {
 			this._leftPriceScale.applyOptions(options.leftPriceScale);
 		}
@@ -115,7 +115,7 @@ export class Pane implements IDestroyable {
 		this._stretchFactor = factor;
 	}
 
-	public model(): ChartModel {
+	public model(): IChartModelBase {
 		return this._model;
 	}
 
@@ -321,7 +321,7 @@ export class Pane implements IDestroyable {
 
 	public orderedSources(): readonly IPriceDataSource[] {
 		if (this._cachedOrderedSources === null) {
-			this._cachedOrderedSources = sortSources(this._dataSources);
+			this._cachedOrderedSources = sortSources<IPriceDataSource>(this._dataSources);
 		}
 
 		return this._cachedOrderedSources;
diff --git a/src/model/plot-data.ts b/src/model/plot-data.ts
index 8e7aa98ac5..1a5a0e822b 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
@@ -19,8 +20,8 @@ export type PlotRowValue = [
 
 export interface PlotRow {
 	readonly index: TimePointIndex;
-	readonly time: TimePoint;
+	readonly time: InternalHorzScaleItem;
+	readonly originalTime: unknown;
 	readonly value: PlotRowValue;
-	readonly originalTime: OriginalTime;
 	readonly customValues?: Record<string, unknown>;
 }
diff --git a/src/model/price-data-source.ts b/src/model/price-data-source.ts
index befae6768a..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 extends DataSource implements IPriceDataSource {
-	private readonly _model: ChartModel;
+	private readonly _model: IChartModelBase;
 
-	public constructor(model: ChartModel) {
+	public constructor(model: IChartModelBase) {
 		super();
 		this._model = model;
 	}
 
-	public model(): ChartModel {
+	public model(): IChartModelBase {
 		return this._model;
 	}
 
diff --git a/src/model/price-scale.ts b/src/model/price-scale.ts
index 4099ce593c..66817ca5a4 100644
--- a/src/model/price-scale.ts
+++ b/src/model/price-scale.ts
@@ -11,7 +11,7 @@ import { BarCoordinates, BarPrice, BarPrices } from './bar';
 import { Coordinate } from './coordinate';
 import { FirstValue, IPriceDataSource } from './iprice-data-source';
 import { LayoutOptions } from './layout-options';
-import { LocalizationOptions } from './localization-options';
+import { LocalizationOptionsBase } from './localization-options';
 import { PriceFormatterFn } from './price-formatter-fn';
 import { PriceRangeImpl } from './price-range-impl';
 import {
@@ -198,7 +198,7 @@ export class PriceScale {
 	private readonly _id: string;
 
 	private readonly _layoutOptions: LayoutOptions;
-	private readonly _localizationOptions: LocalizationOptions;
+	private readonly _localizationOptions: LocalizationOptionsBase;
 	private readonly _options: PriceScaleOptions;
 
 	private _height: number = 0;
@@ -227,7 +227,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: LocalizationOptionsBase) {
 		this._id = id;
 		this._options = options;
 		this._layoutOptions = layoutOptions;
@@ -538,7 +538,7 @@ export class PriceScale {
 			sources.push(ds);
 		}
 
-		sources = sortSources(sources);
+		sources = sortSources<IPriceDataSource>(sources);
 		this._cachedOrderedSources = sources;
 		return this._cachedOrderedSources;
 	}
diff --git a/src/model/series-bar-colorer.ts b/src/model/series-bar-colorer.ts
index 76033f8ce4..bb94648a18 100644
--- a/src/model/series-bar-colorer.ts
+++ b/src/model/series-bar-colorer.ts
@@ -76,7 +76,7 @@ export interface BarStylesMap {
 	Custom: CustomBarColorerStyle;
 }
 
-type FindBarFn = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars) => SeriesPlotRow | null;
+type FindBarFn = (barIndex: TimePointIndex, precomputedBars?: PrecomputedBars) => SeriesPlotRow<SeriesType> | null;
 
 type StyleGetterFn<T extends SeriesType> = (
 	findBar: FindBarFn,
@@ -89,6 +89,10 @@ type BarStylesFnMap = {
 	[T in keyof SeriesOptionsMap]: StyleGetterFn<T>;
 };
 
+export interface ISeriesBarColorer<T extends SeriesType> {
+	barStyle(barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BarStylesMap[T];
+}
+
 const barStyleFnMap: BarStylesFnMap = {
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	Bar: (findBar: FindBarFn, barStyle: BarStyleOptions, barIndex: TimePointIndex, precomputedBars?: PrecomputedBars): BarColorerStyle => {
@@ -172,9 +176,9 @@ const barStyleFnMap: BarStylesFnMap = {
 	},
 };
 
-export class SeriesBarColorer<T extends SeriesType> {
+export class SeriesBarColorer<T extends SeriesType> implements ISeriesBarColorer<T> {
 	private _series: Series<T>;
-	private readonly _styleGetter: typeof barStyleFnMap[T];
+	private readonly _styleGetter: BarStylesFnMap[T];
 
 	public constructor(series: Series<T>) {
 		this._series = series;
diff --git a/src/model/series-data.ts b/src/model/series-data.ts
index 733bb26b2f..12f5cd886b 100644
--- a/src/model/series-data.ts
+++ b/src/model/series-data.ts
@@ -54,6 +54,6 @@ export interface SeriesPlotRowTypeAtTypeMap {
 export type SeriesPlotRow<T extends SeriesType = SeriesType> = SeriesPlotRowTypeAtTypeMap[T];
 export type SeriesPlotList<T extends SeriesType = SeriesType> = PlotList<SeriesPlotRow<T>>;
 
-export function createSeriesPlotList<T extends SeriesType = SeriesType>(): SeriesPlotList<T> {
+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 9b3b7d073f..eb334a5ca9 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.
  */
@@ -48,9 +46,23 @@ export interface SeriesMarker<TimeType> {
 	/**
 	 * @internal
 	 */
-	originalTime: OriginalTime;
+	originalTime: unknown;
 }
 
-export interface InternalSeriesMarker<TimeType> extends Omit<SeriesMarker<TimeType>, 'originalTime'> {
+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/series-primitive-wrapper.ts b/src/model/series-primitive-wrapper.ts
index 84935cf1a4..d8ad2362d2 100644
--- a/src/model/series-primitive-wrapper.ts
+++ b/src/model/series-primitive-wrapper.ts
@@ -19,9 +19,9 @@ import {
 } from './iseries-primitive';
 import { PriceScale } from './price-scale';
 import { Series } from './series';
-import { AutoscaleInfo } from './series-options';
+import { AutoscaleInfo, SeriesType } from './series-options';
 import { Logical, TimePointIndex } from './time-data';
-import { TimeScale } from './time-scale';
+import { ITimeScale } from './time-scale';
 
 class SeriesPrimitiveRendererWrapper implements IPaneRenderer {
 	private readonly _baseRenderer: ISeriesPrimitivePaneRenderer;
@@ -101,10 +101,10 @@ function getAxisViewData(baseView: ISeriesPrimitiveAxisView): AxisViewData {
 
 class SeriesPrimitiveTimeAxisViewWrapper implements ITimeAxisView {
 	private readonly _baseView: ISeriesPrimitiveAxisView;
-	private readonly _timeScale: TimeScale;
+	private readonly _timeScale: ITimeScale;
 	private readonly _renderer: TimeAxisViewRenderer = new TimeAxisViewRenderer();
 
-	public constructor(baseView: ISeriesPrimitiveAxisView, timeScale: TimeScale) {
+	public constructor(baseView: ISeriesPrimitiveAxisView, timeScale: ITimeScale) {
 		this._baseView = baseView;
 		this._timeScale = timeScale;
 	}
@@ -152,14 +152,14 @@ class SeriesPrimitivePriceAxisViewWrapper extends PriceAxisView {
 
 export class SeriesPrimitiveWrapper<TSeriesAttachedParameters = unknown> {
 	private readonly _primitive: ISeriesPrimitiveBase<TSeriesAttachedParameters>;
-	private readonly _series: Series;
+	private readonly _series: Series<SeriesType>;
 	private _paneViewsCache: RendererCache<readonly ISeriesPrimitivePaneView[], readonly SeriesPrimitivePaneViewWrapper[]> | null = null;
 	private _timeAxisViewsCache: RendererCache<readonly ISeriesPrimitiveAxisView[], readonly SeriesPrimitiveTimeAxisViewWrapper[]> | null = null;
 	private _priceAxisViewsCache: RendererCache<readonly ISeriesPrimitiveAxisView[], readonly SeriesPrimitivePriceAxisViewWrapper[]> | null = null;
 	private _priceAxisPaneViewsCache: RendererCache<readonly ISeriesPrimitivePaneView[], readonly SeriesPrimitivePaneViewWrapper[]> | null = null;
 	private _timeAxisPaneViewsCache: RendererCache<readonly ISeriesPrimitivePaneView[], readonly SeriesPrimitivePaneViewWrapper[]> | null = null;
 
-	public constructor(primitive: ISeriesPrimitiveBase<TSeriesAttachedParameters>, series: Series) {
+	public constructor(primitive: ISeriesPrimitiveBase<TSeriesAttachedParameters>, series: Series<SeriesType>) {
 		this._primitive = primitive;
 		this._series = series;
 	}
diff --git a/src/model/series.ts b/src/model/series.ts
index 69d2623d78..22a235b1ec 100644
--- a/src/model/series.ts
+++ b/src/model/series.ts
@@ -27,12 +27,13 @@ import { ITimeAxisView } from '../views/time-axis/itime-axis-view';
 
 import { AutoscaleInfoImpl, AutoScaleMargins } 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';
 import { CustomData, CustomSeriesWhitespaceData, ICustomSeriesPaneView, WhitespaceCheck } from './icustom-series';
-import { FirstValue } from './iprice-data-source';
+import { InternalHorzScaleItem } from './ihorz-scale-behavior';
+import { FirstValue, IPriceDataSource } from './iprice-data-source';
 import { ISeriesPrimitiveBase, PrimitiveHoveredItem, SeriesPrimitivePaneViewZOrder } from './iseries-primitive';
 import { Pane } from './pane';
 import { PlotRowValueIndex } from './plot-data';
@@ -41,7 +42,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 {
@@ -54,7 +55,7 @@ import {
 	SeriesType,
 } from './series-options';
 import { ISeriesPrimitivePaneViewWrapper, SeriesPrimitiveWrapper } from './series-primitive-wrapper';
-import { TimePoint, TimePointIndex } from './time-data';
+import { TimePointIndex } from './time-data';
 
 type PrimitivePaneViewExtractor = (wrapper: SeriesPrimitiveWrapper) => readonly ISeriesPrimitivePaneViewWrapper[];
 function extractPrimitivePaneViews(
@@ -83,7 +84,7 @@ function primitiveTimePaneViewsExtractor(wrapper: SeriesPrimitiveWrapper): reado
 	return wrapper.timeAxisPaneViews();
 }
 
-type CustomDataToPlotRowValueConverter = (item: CustomData | CustomSeriesWhitespaceData) => number[];
+type CustomDataToPlotRowValueConverter<HorzScaleItem> = (item: CustomData<HorzScaleItem> | CustomSeriesWhitespaceData<HorzScaleItem>) => number[];
 
 export interface LastValueDataResultWithoutData {
 	noData: true;
@@ -129,9 +130,22 @@ 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 interface ISeries<T extends SeriesType> extends IPriceDataSource {
+	bars(): SeriesPlotList<T>;
+	visible(): boolean;
+	options(): Readonly<SeriesOptionsMap[T]>;
+	title(): string;
+	priceScale(): PriceScale;
+	lastValueData(globalLast: boolean): LastValueDataResult;
+	indexedMarkers(): InternalSeriesMarker<TimePointIndex>[];
+	barColorer(): ISeriesBarColorer<T>;
+	markerDataAtIndex(index: TimePointIndex): MarkerData | null;
+	dataAt(time: TimePointIndex): SeriesDataAtTypeMap[SeriesType] | null;
+}
+
+export class Series<T extends SeriesType> extends PriceDataSource implements IDestroyable, ISeries<SeriesType> {
 	private readonly _seriesType: T;
-	private _data: SeriesPlotList<T> = createSeriesPlotList();
+	private _data: SeriesPlotList<T> = createSeriesPlotList<T>();
 	private readonly _priceAxisViews: IPriceAxisView[];
 	private readonly _panePriceAxisView: PanePriceAxisView;
 	private _formatter!: IPriceFormatter;
@@ -142,13 +156,13 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 	private readonly _lastPriceAnimationPaneView: SeriesLastPriceAnimationPaneView | null = null;
 	private _barColorerCache: SeriesBarColorer<T> | null = null;
 	private readonly _options: SeriesOptionsInternal<T>;
-	private _markers: readonly SeriesMarker<TimePoint>[] = [];
+	private _markers: readonly SeriesMarker<InternalHorzScaleItem>[] = [];
 	private _indexedMarkers: InternalSeriesMarker<TimePointIndex>[] = [];
 	private _markersPaneView!: SeriesMarkersPaneView;
 	private _animationTimeoutId: TimerId | null = null;
 	private _primitives: SeriesPrimitiveWrapper[] = [];
 
-	public constructor(model: ChartModel, options: SeriesOptionsInternal<T>, seriesType: T, pane?: Pane, customPaneView?: ICustomSeriesPaneView) {
+	public constructor(model: IChartModelBase, options: SeriesOptionsInternal<T>, seriesType: T, pane?: Pane, customPaneView?: ICustomSeriesPaneView<unknown>) {
 		super(model);
 		this._options = options;
 		this._seriesType = seriesType;
@@ -297,7 +311,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>[]): void {
 		this._markers = data;
 		this._recalculateMarkers();
 		const sourcePane = this.model().paneForSource(this);
@@ -308,7 +322,7 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		this.model().lightUpdate();
 	}
 
-	public markers(): readonly SeriesMarker<TimePoint>[] {
+	public markers(): readonly SeriesMarker<InternalHorzScaleItem>[] {
 		return this._markers;
 	}
 
@@ -549,20 +563,20 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 		this._primitives = this._primitives.filter((wrapper: SeriesPrimitiveWrapper) => wrapper.primitive() !== source);
 	}
 
-	public customSeriesPlotValuesBuilder(): CustomDataToPlotRowValueConverter | undefined {
+	public customSeriesPlotValuesBuilder(): CustomDataToPlotRowValueConverter<unknown> | undefined {
 		if (this._paneView instanceof SeriesCustomPaneView === false) {
 			return undefined;
 		}
-		return (data: CustomData | CustomSeriesWhitespaceData) => {
+		return (data: CustomData<unknown> | CustomSeriesWhitespaceData<unknown>) => {
 			return (this._paneView as SeriesCustomPaneView).priceValueBuilder(data);
 		};
 	}
 
-	public customSeriesWhitespaceCheck(): WhitespaceCheck | undefined {
+	public customSeriesWhitespaceCheck<HorzScaleItem>(): WhitespaceCheck<HorzScaleItem> | undefined {
 		if (this._paneView instanceof SeriesCustomPaneView === false) {
 			return undefined;
 		}
-		return (data: CustomData | CustomSeriesWhitespaceData): data is CustomSeriesWhitespaceData => {
+		return (data: CustomData<HorzScaleItem> | CustomSeriesWhitespaceData<HorzScaleItem>): data is CustomSeriesWhitespaceData<HorzScaleItem> => {
 			return (this._paneView as SeriesCustomPaneView).isWhitespace(data);
 		};
 	}
@@ -704,7 +718,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>>((marker: SeriesMarker<InternalHorzScaleItem>, index: number) => {
 			// the first find index on the time scale (across all series)
 			const timePointIndex = ensureNotNull(timeScale.timeToIndex(marker.time, true));
 
@@ -720,11 +734,12 @@ export class Series<T extends SeriesType = SeriesType> extends PriceDataSource i
 				internalId: index,
 				text: marker.text,
 				size: marker.size,
+				originalTime: marker.originalTime,
 			};
 		});
 	}
 
-	private _recreatePaneViews(customPaneView?: ICustomSeriesPaneView): void {
+	private _recreatePaneViews(customPaneView?: ICustomSeriesPaneView<unknown>): void {
 		this._markersPaneView = new SeriesMarkersPaneView(this, this.model());
 
 		switch (this._seriesType) {
diff --git a/src/model/sort-sources.ts b/src/model/sort-sources.ts
index 28bf853e2b..79b8b47eae 100644
--- a/src/model/sort-sources.ts
+++ b/src/model/sort-sources.ts
@@ -1,9 +1,9 @@
 import { ensureNotNull } from '../helpers/assertions';
 
-import { IDataSource } from './idata-source';
+import { ZOrdered } from './idata-source';
 
-export function sortSources<T extends IDataSource>(sources: readonly T[]): T[] {
-	return sources.slice().sort((s1: IDataSource, s2: IDataSource) => {
+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/tick-marks.ts b/src/model/tick-marks.ts
index 2549d849b0..2dde92f07e 100644
--- a/src/model/tick-marks.ts
+++ b/src/model/tick-marks.ts
@@ -1,13 +1,21 @@
 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';
 
+/**
+ * Tick mark for the horizontal scale.
+ */
 export interface TickMark {
+	/** Index */
 	index: TimePointIndex;
-	time: TimePoint;
-	weight: TickMarkWeight;
-	originalTime: OriginalTime;
+	/** Time / Coordinate */
+	time: InternalHorzScaleItem;
+	/** Weight of the tick mark */
+	weight: TickMarkWeightValue;
+	/** Original value for the `time` property */
+	originalTime: unknown;
 }
 
 interface MarksCache {
@@ -15,9 +23,15 @@ interface MarksCache {
 	marks: readonly TickMark[];
 }
 
-export class TickMarks {
-	private _marksByWeight: Map<TickMarkWeight, TickMark[]> = new Map();
+export class TickMarks<HorzScaleItem> {
+	private _marksByWeight: Map<TickMarkWeightValue, TickMark[]> = new Map();
 	private _cache: MarksCache | null = null;
+	private _uniformDistribution: boolean = false;
+
+	public setUniformDistribution(val: boolean): void {
+		this._uniformDistribution = val;
+		this._cache = null;
+	}
 
 	public setTimeScalePoints(newPoints: readonly TimeScalePoint[], firstChangedPointIndex: number): void {
 		this._removeMarksSinceIndex(firstChangedPointIndex);
@@ -59,9 +73,9 @@ export class TickMarks {
 			return;
 		}
 
-		const weightsToClear: TickMarkWeight[] = [];
+		const weightsToClear: TickMarkWeightValue[] = [];
 
-		this._marksByWeight.forEach((marks: TickMark[], timeWeight: number) => {
+		this._marksByWeight.forEach((marks: TickMark[], timeWeight: TickMarkWeightValue) => {
 			if (sinceIndex <= marks[0].index) {
 				weightsToClear.push(timeWeight);
 			} else {
@@ -120,6 +134,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..b4d9607b44 100644
--- a/src/model/time-data.ts
+++ b/src/model/time-data.ts
@@ -2,95 +2,24 @@ 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
- * ```
+ * Weight of the tick mark. @see TickMarkWeight enum
  */
-export type Time = UTCTimestamp | BusinessDay | string;
-
-export type OriginalTime = Nominal<unknown, 'OriginalTime'>;
-
-export interface TimePoint {
-	timestamp: UTCTimestamp;
-	businessDay?: BusinessDay;
-}
+export type TickMarkWeightValue = Nominal<number, 'TickMarkWeightValue'>;
 
 /**
- * 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.
+ * Represents a point on the time scale
  */
-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 interface TimeScalePoint {
-	readonly timeWeight: TickMarkWeight;
-	readonly time: TimePoint;
-	readonly originalTime: OriginalTime;
+	/** Weight of the point */
+	readonly timeWeight: TickMarkWeightValue;
+	/** Time of the point */
+	readonly time: InternalHorzScaleItem;
+	/** Original time for the point */
+	readonly originalTime: unknown;
 }
 
 /**
@@ -107,8 +36,11 @@ export interface Range<T> {
 	to: T;
 }
 
-export type TimePointsRange = Range<TimePoint>;
+export type TimePointsRange = Range<Omit<TimeScalePoint, 'timeWeight'>>;
 
+/**
+ * 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 d40e7f9a5f..848be880b2 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,23 +7,22 @@ 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';
 import {
 	Logical,
 	LogicalRange,
+	Range,
 	SeriesItemsIndexesRange,
-	TickMarkWeight,
-	Time,
+	TickMarkWeightValue,
 	TimedValue,
-	TimePoint,
 	TimePointIndex,
 	TimePointsRange,
 	TimeScalePoint,
-	UTCTimestamp,
 } from './time-data';
 import { TimeScaleVisibleRange } from './time-scale-visible-range';
 
@@ -41,63 +37,28 @@ 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: TickMarkWeight;
+	/** Weight of the time mark */
+	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.
  */
-export interface TimeScaleOptions {
+export interface HorzScaleOptions {
 	/**
 	 * The margin space in bars from the right side of the chart.
 	 *
@@ -191,27 +152,45 @@ 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;
+
+	/**
+	 * 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;
 }
 
-export class TimeScale {
-	private readonly _options: TimeScaleOptions;
-	private readonly _model: ChartModel;
-	private readonly _localizationOptions: LocalizationOptions;
+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;
+	rightOffset(): number;
+
+	indexesToCoordinates<T extends TimedValue>(points: T[], visibleRange?: SeriesItemsIndexesRange): void;
+	indexToTimeScalePoint(index: TimePointIndex): TimeScalePoint | null;
+	formatDateTime(timeScalePoint: TimeScalePoint): string;
+	coordinateToIndex(x: Coordinate): TimePointIndex;
+
+	options(): Readonly<HorzScaleOptions>;
+}
 
-	private _dateTimeFormatter!: DateFormatter | DateTimeFormatter;
+export class TimeScale<HorzScaleItem> implements ITimeScale {
+	private readonly _options: HorzScaleOptions;
+	private readonly _model: ChartModel<HorzScaleItem>;
+	private readonly _localizationOptions: LocalizationOptions<HorzScaleItem>;
 
 	private _width: number = 0;
 	private _baseIndexOrNull: TimePointIndex | null = null;
@@ -220,8 +199,8 @@ export class TimeScale {
 	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 +214,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: HorzScaleOptions, 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> {
+	public options(): Readonly<HorzScaleOptions> {
 		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<HorzScaleOptions>, localizationOptions?: DeepPartial<LocalizationOptions<HorzScaleItem>>): void {
 		merge(this._options, options);
 
 		if (this._options.fixLeftEdge) {
@@ -289,7 +274,7 @@ export class TimeScale {
 		this._optionsApplied.fire();
 	}
 
-	public indexToTime(index: TimePointIndex): TimePoint | null {
+	public indexToTime(index: TimePointIndex): InternalHorzScaleItem | null {
 		return this._points[index]?.time ?? null;
 	}
 
@@ -297,20 +282,20 @@ export class TimeScale {
 		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, 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,12 +343,12 @@ 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.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,
@@ -745,10 +730,10 @@ export class TimeScale {
 
 	public formatDateTime(timeScalePoint: TimeScalePoint): string {
 		if (this._localizationOptions.timeFormatter !== undefined) {
-			return this._localizationOptions.timeFormatter(timeScalePoint.originalTime as unknown as Time);
+			return this._localizationOptions.timeFormatter(timeScalePoint.originalTime as HorzScaleItem);
 		}
 
-		return this._dateTimeFormatter.format(new Date(timeScalePoint.time.timestamp * 1000));
+		return this._horzScaleBehavior.formatHorzItem(timeScalePoint.time);
 	}
 
 	private _isAllScalingAndScrollingDisabled(): boolean {
@@ -897,9 +882,11 @@ export class TimeScale {
 	private _formatLabel(tickMark: TickMark): 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) => {
+					return this._formatLabelImpl(mark);
+				},
+				this._horzScaleBehavior);
 
 			this._formattedByWeight.set(tickMark.weight, formatter);
 		}
@@ -908,20 +895,7 @@ export class TimeScale {
 	}
 
 	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);
+		return this._horzScaleBehavior.formatTickmark(tickMark, this._localizationOptions);
 	}
 
 	private _setVisibleRange(newVisibleRange: TimeScaleVisibleRange): void {
@@ -950,18 +924,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 +957,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..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. */
@@ -69,7 +69,7 @@ export class Watermark extends DataSource {
 	private readonly _paneView: WatermarkPaneView;
 	private readonly _options: WatermarkOptions;
 
-	public constructor(model: ChartModel, options: WatermarkOptions) {
+	public constructor(model: IChartModelBase, options: WatermarkOptions) {
 		super();
 		this._options = options;
 		this._paneView = new WatermarkPaneView(this);
diff --git a/src/renderers/price-axis-renderer-options-provider.ts b/src/renderers/price-axis-renderer-options-provider.ts
index cd8aeb4117..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';
 
@@ -10,7 +10,7 @@ const enum RendererConstants {
 }
 
 export class PriceAxisRendererOptionsProvider {
-	private readonly _chartModel: ChartModel;
+	private readonly _chartModel: IChartModelBase;
 
 	private readonly _rendererOptions: PriceAxisViewRendererOptions = {
 		borderSize: RendererConstants.BorderSize,
@@ -27,7 +27,7 @@ export class PriceAxisRendererOptionsProvider {
 		baselineOffset: 0,
 	};
 
-	public constructor(chartModel: ChartModel) {
+	public constructor(chartModel: IChartModelBase) {
 		this._chartModel = chartModel;
 	}
 
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];
-};
diff --git a/src/views/pane/area-pane-view.ts b/src/views/pane/area-pane-view.ts
index 27daba1b38..f7c6b55177 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';
@@ -14,12 +14,12 @@ export class SeriesAreaPaneView extends LinePaneViewBase<'Area', AreaFillItem &
 	private readonly _areaRenderer: PaneRendererArea = new PaneRendererArea();
 	private readonly _lineRenderer: PaneRendererLine = new PaneRendererLine();
 
-	public constructor(series: Series<'Area'>, model: ChartModel) {
+	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'>): 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 07a8fc317a..29ec5923e0 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> extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer> {
-	public constructor(series: Series<TSeriesType>, model: ChartModel) {
+	public constructor(series: ISeries<TSeriesType>, model: IChartModelBase) {
 		super(series, model, false);
 	}
 
-	protected _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale, 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, colorer: SeriesBarColorer<TSeriesType>): ItemType;
+	protected abstract _createRawItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType>, colorer: ISeriesBarColorer<TSeriesType>): ItemType;
 
-	protected _createDefaultItem(time: TimePointIndex, bar: SeriesPlotRow, colorer: SeriesBarColorer<TSeriesType>): BarCandlestickItemBase {
+	protected _createDefaultItem(time: TimePointIndex, bar: SeriesPlotRow<TSeriesType>, colorer: ISeriesBarColorer<TSeriesType>): BarCandlestickItemBase {
 		return {
 			time: time,
 			open: bar.value[PlotRowValueIndex.Open] as BarPrice,
diff --git a/src/views/pane/bars-pane-view.ts b/src/views/pane/bars-pane-view.ts
index 9938415186..ea09df028c 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,
@@ -11,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, colorer: SeriesBarColorer<'Bar'>): 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/baseline-pane-view.ts b/src/views/pane/baseline-pane-view.ts
index d86499c49f..4a7c45250b 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';
@@ -14,12 +14,12 @@ export class SeriesBaselinePaneView extends LinePaneViewBase<'Baseline', Baselin
 	private readonly _baselineAreaRenderer: PaneRendererBaselineArea = new PaneRendererBaselineArea();
 	private readonly _baselineLineRenderer: PaneRendererBaselineLine = new PaneRendererBaselineLine();
 
-	public constructor(series: Series<'Baseline'>, model: ChartModel) {
+	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'>): 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 6b4c2ce3e4..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, colorer: SeriesBarColorer<'Candlestick'>): 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/crosshair-marks-pane-view.ts b/src/views/pane/crosshair-marks-pane-view.ts
index 8a307d9027..63bc43b250 100644
--- a/src/views/pane/crosshair-marks-pane-view.ts
+++ b/src/views/pane/crosshair-marks-pane-view.ts
@@ -1,10 +1,11 @@
 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';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
@@ -31,14 +32,14 @@ function createEmptyMarkerData(): MarksRendererData {
 const rangeForSinglePoint: SeriesItemsIndexesRange = { from: 0, to: 1 };
 
 export class CrosshairMarksPaneView implements IUpdatablePaneView {
-	private readonly _chartModel: ChartModel;
+	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, crosshair: Crosshair) {
+	public constructor(chartModel: IChartModelBase, crosshair: Crosshair) {
 		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: ISeries<SeriesType>, index: number) => {
 			const data = this._markersData[index];
 			const seriesData = s.markerDataAtIndex(timePointIndex);
 
diff --git a/src/views/pane/custom-pane-view.ts b/src/views/pane/custom-pane-view.ts
index c48e152688..88a5caf571 100644
--- a/src/views/pane/custom-pane-view.ts
+++ b/src/views/pane/custom-pane-view.ts
@@ -2,7 +2,7 @@ import { CanvasRenderingTarget2D } from 'fancy-canvas';
 
 import { undefinedIfNull } from '../../helpers/strict-type-checks';
 
-import { ChartModel } from '../../model/chart-model';
+import { IChartModelBase } from '../../model/chart-model';
 import { Coordinate } from '../../model/coordinate';
 import {
 	CustomBarItemData,
@@ -17,7 +17,7 @@ import { PriceScale } from '../../model/price-scale';
 import { Series } from '../../model/series';
 import { SeriesPlotRow } from '../../model/series-data';
 import { TimedValue } 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';
@@ -55,12 +55,12 @@ export class SeriesCustomPaneView extends SeriesPaneViewBase<
 	CustomSeriesPaneRendererWrapper
 > {
 	protected readonly _renderer: CustomSeriesPaneRendererWrapper;
-	private readonly _paneView: ICustomSeriesPaneView;
+	private readonly _paneView: ICustomSeriesPaneView<unknown>;
 
 	public constructor(
 		series: Series<'Custom'>,
-		model: ChartModel,
-		paneView: ICustomSeriesPaneView
+		model: IChartModelBase,
+		paneView: ICustomSeriesPaneView<unknown>
 	) {
 		super(series, model, false);
 		this._paneView = paneView;
@@ -76,11 +76,11 @@ export class SeriesCustomPaneView extends SeriesPaneViewBase<
 		);
 	}
 
-	public priceValueBuilder(plotRow: CustomData | CustomSeriesWhitespaceData): CustomSeriesPricePlotValues {
+	public priceValueBuilder(plotRow: CustomData<unknown> | CustomSeriesWhitespaceData<unknown>): CustomSeriesPricePlotValues {
 		return this._paneView.priceValueBuilder(plotRow);
 	}
 
-	public isWhitespace(data: CustomData | CustomSeriesWhitespaceData): data is CustomSeriesWhitespaceData {
+	public isWhitespace(data: CustomData<unknown> | CustomSeriesWhitespaceData<unknown>): data is CustomSeriesWhitespaceData<unknown> {
 		return this._paneView.isWhitespace(data);
 	}
 
@@ -101,7 +101,7 @@ export class SeriesCustomPaneView extends SeriesPaneViewBase<
 
 	protected override _convertToCoordinates(
 		priceScale: PriceScale,
-		timeScale: TimeScale
+		timeScale: ITimeScale
 	): void {
 		timeScale.indexesToCoordinates(
 			this._items,
@@ -112,7 +112,7 @@ export class SeriesCustomPaneView extends SeriesPaneViewBase<
 	protected _prepareRendererData(): void {
 		this._paneView.update(
 			{
-				bars: this._items.map(unwrapItemData) as CustomBarItemData[],
+				bars: this._items.map(unwrapItemData) as CustomBarItemData<unknown>[],
 				barSpacing: this._model.timeScale().barSpacing(),
 				visibleRange: this._itemsVisibleRange,
 			},
diff --git a/src/views/pane/custom-price-line-pane-view.ts b/src/views/pane/custom-price-line-pane-view.ts
index 81423d6faa..4b501ecd5a 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 { ISeries } 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;
 
-	public constructor(series: Series, priceLine: CustomPriceLine) {
+	public constructor(series: ISeries<SeriesType>, priceLine: CustomPriceLine) {
 		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..06a2f96614 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 implements IUpdatablePaneView {
 				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);
diff --git a/src/views/pane/histogram-pane-view.ts b/src/views/pane/histogram-pane-view.ts
index 54d11417b5..b6ea4336f3 100644
--- a/src/views/pane/histogram-pane-view.ts
+++ b/src/views/pane/histogram-pane-view.ts
@@ -1,7 +1,7 @@
 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';
 
@@ -10,7 +10,7 @@ import { LinePaneViewBase } from './line-pane-view-base';
 export class SeriesHistogramPaneView extends LinePaneViewBase<'Histogram', HistogramItem, PaneRendererHistogram> {
 	protected readonly _renderer: PaneRendererHistogram = new PaneRendererHistogram();
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Histogram'>): 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 f5d1312f51..3e5f82ce08 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';
@@ -19,16 +19,16 @@ export abstract class LinePaneViewBase<
 	ItemType extends PricedValue & TimedValue,
 	TRenderer extends IPaneRenderer
 > extends SeriesPaneViewBase<TSeriesType, ItemType, TRenderer> {
-	public constructor(series: Series<TSeriesType>, model: ChartModel) {
+	public constructor(series: ISeries<TSeriesType>, model: IChartModelBase) {
 		super(series, model, true);
 	}
 
-	protected _convertToCoordinates(priceScale: PriceScale, timeScale: TimeScale, 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>): ItemType;
+	protected abstract _createRawItem(time: TimePointIndex, price: BarPrice, colorer: ISeriesBarColorer<TSeriesType>): ItemType;
 
 	protected _createRawItemBase(time: TimePointIndex, price: BarPrice): PricedValue & TimedValue {
 		return {
diff --git a/src/views/pane/line-pane-view.ts b/src/views/pane/line-pane-view.ts
index 2c72f14f65..d15a3387dc 100644
--- a/src/views/pane/line-pane-view.ts
+++ b/src/views/pane/line-pane-view.ts
@@ -1,5 +1,5 @@
 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';
 
@@ -8,7 +8,7 @@ import { LinePaneViewBase } from './line-pane-view-base';
 export class SeriesLinePaneView extends LinePaneViewBase<'Line', LineStrokeItem, PaneRendererLine> {
 	protected readonly _renderer: PaneRendererLine = new PaneRendererLine();
 
-	protected _createRawItem(time: TimePointIndex, price: BarPrice, colorer: SeriesBarColorer<'Line'>): 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 bf262d508b..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';
@@ -42,11 +42,11 @@ export class PanePriceAxisView implements IPaneView {
 	private _priceAxisView: IPriceAxisView;
 	private readonly _textWidthCache: TextWidthCache;
 	private readonly _dataSource: IPriceDataSource;
-	private readonly _chartModel: ChartModel;
+	private readonly _chartModel: IChartModelBase;
 	private readonly _renderer: PanePriceAxisViewRenderer;
 	private _fontSize: number;
 
-	public constructor(priceAxisView: IPriceAxisView, dataSource: IPriceDataSource, chartModel: ChartModel) {
+	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 b544baea0e..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,11 +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 extends SeriesHorizontalLinePaneView {
 	// eslint-disable-next-line no-useless-constructor
-	public constructor(series: Series) {
+	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 7f4cbb5890..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,7 @@
-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';
 import { IPaneRenderer } from '../../renderers/ipane-renderer';
@@ -16,12 +17,12 @@ export abstract class SeriesHorizontalLinePaneView implements IPaneView {
 		visible: false,
 	};
 
-	protected readonly _series: Series;
-	protected readonly _model: ChartModel;
+	protected readonly _series: ISeries<SeriesType>;
+	protected readonly _model: IChartModelBase;
 	protected readonly _lineRenderer: HorizontalLineRenderer = new HorizontalLineRenderer();
 	private _invalidated: boolean = true;
 
-	protected constructor(series: Series) {
+	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 1bb7367c69..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';
@@ -120,7 +120,7 @@ function animationData(durationSinceStart: number, lineColor: string): Animation
 }
 
 export class SeriesLastPriceAnimationPaneView implements IUpdatablePaneView {
-	private readonly _series: Series<'Area'> | Series<'Line'> | Series<'Baseline'>;
+	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 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: 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 13017d75e6..0a03bd820b 100644
--- a/src/views/pane/series-markers-pane-view.ts
+++ b/src/views/pane/series-markers-pane-view.ts
@@ -3,13 +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,
@@ -41,7 +42,7 @@ function fillSizeAndY(
 	textHeight: number,
 	shapeMargin: number,
 	priceScale: PriceScale,
-	timeScale: TimeScale,
+	timeScale: ITimeScale,
 	firstValue: number
 ): void {
 	const inBarPrice = isNumber(seriesData) ? seriesData : seriesData.close;
@@ -84,8 +85,8 @@ function fillSizeAndY(
 }
 
 export class SeriesMarkersPaneView implements IUpdatablePaneView {
-	private readonly _series: Series;
-	private readonly _model: ChartModel;
+	private readonly _series: ISeries<SeriesType>;
+	private readonly _model: IChartModelBase;
 	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: ISeries<SeriesType>, model: IChartModelBase) {
 		this._series = series;
 		this._model = model;
 		this._data = {
diff --git a/src/views/pane/series-pane-view-base.ts b/src/views/pane/series-pane-view-base.ts
index e944858c7a..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> implements IUpdatablePaneView {
-	protected readonly _series: Series<TSeriesType>;
-	protected readonly _model: ChartModel;
+	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>, model: ChartModel, 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, 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 302aa4b484..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 { PriceLineSource } from '../../model/series-options';
+import { ISeries } from '../../model/series';
+import { PriceLineSource, SeriesType } from '../../model/series-options';
 
 import { SeriesHorizontalLinePaneView } from './series-horizontal-line-pane-view';
 
 export class SeriesPriceLinePaneView extends SeriesHorizontalLinePaneView {
 	// eslint-disable-next-line no-useless-constructor
-	public constructor(series: Series) {
+	public constructor(series: ISeries<SeriesType>) {
 		super(series);
 	}
 
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..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,8 @@
 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,
 	PriceAxisViewRendererData,
@@ -10,10 +11,10 @@ import {
 import { PriceAxisView } from './price-axis-view';
 
 export class CustomPriceLinePriceAxisView extends PriceAxisView {
-	private readonly _series: Series;
+	private readonly _series: ISeries<SeriesType>;
 	private readonly _priceLine: CustomPriceLine;
 
-	public constructor(series: Series, priceLine: CustomPriceLine) {
+	public constructor(series: ISeries<SeriesType>, priceLine: CustomPriceLine) {
 		super();
 		this._series = series;
 		this._priceLine = priceLine;
diff --git a/src/views/price-axis/series-price-axis-view.ts b/src/views/price-axis/series-price-axis-view.ts
index c8a3474275..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 { PriceAxisLastValueMode } from '../../model/series-options';
+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 extends PriceAxisView {
-	private readonly _source: Series;
+	private readonly _source: ISeries<SeriesType>;
 
-	public constructor(source: Series) {
+	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 7ba1b23745..9cd17d4057 100644
--- a/src/views/time-axis/crosshair-time-axis-view.ts
+++ b/src/views/time-axis/crosshair-time-axis-view.ts
@@ -1,7 +1,7 @@
 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';
 
@@ -10,7 +10,7 @@ import { ITimeAxisView } from './itime-axis-view';
 export class CrosshairTimeAxisView implements ITimeAxisView {
 	private _invalidated: boolean = true;
 	private readonly _crosshair: Crosshair;
-	private readonly _model: ChartModel;
+	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 implements ITimeAxisView {
 		tickVisible: true,
 	};
 
-	public constructor(crosshair: Crosshair, model: ChartModel, valueProvider: TimeAndCoordinateProvider) {
+	public constructor(crosshair: Crosshair, model: IChartModelBase, valueProvider: TimeAndCoordinateProvider) {
 		this._crosshair = crosshair;
 		this._model = model;
 		this._valueProvider = valueProvider;
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..7264ff113a
--- /dev/null
+++ b/tests/e2e/coverage/test-cases/chart/horizontal-scale.js
@@ -0,0 +1,99 @@
+function markWithGreaterWeight(a, b) {
+	return a.weight > b.weight ? a : b;
+}
+
+class HorzScaleBehaviorPrice {
+	options() {}
+	setOptions() {}
+	preprocessData() {}
+	updateFormatter() {}
+	createConverterToInternalObj() {
+		return price => price;
+	}
+
+	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/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>;
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
new file mode 100644
index 0000000000..597bc721f8
--- /dev/null
+++ b/tests/e2e/graphics/test-cases/horizontal-price-scale.js
@@ -0,0 +1,89 @@
+function markWithGreaterWeight(a, b) {
+	return a.weight > b.weight ? a : b;
+}
+
+class HorzScaleBehaviorPrice {
+	options() {}
+	setOptions() {}
+	preprocessData() {}
+	updateFormatter() {}
+	createConverterToInternalObj() {
+		return price => price;
+	}
+
+	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);
+}
diff --git a/tests/type-checks/plugins.ts b/tests/type-checks/plugins.ts
index fab06e294a..07338cb4cd 100644
--- a/tests/type-checks/plugins.ts
+++ b/tests/type-checks/plugins.ts
@@ -1,8 +1,8 @@
 import { createChart, customSeriesDefaultOptions } from '../../src';
-import { CandlestickData, WhitespaceData } from '../../src/api/data-consumer';
+import { CandlestickData, WhitespaceData } from '../../src/model/data-consumer';
+import { Time } from '../../src/model/horz-scale-behavior-time/types';
 import { CustomData, CustomSeriesPricePlotValues, ICustomSeriesPaneRenderer, ICustomSeriesPaneView, PaneRendererCustomData } from '../../src/model/icustom-series';
 import { CustomSeriesOptions } from '../../src/model/series-options';
-import { Time } from '../../src/model/time-data';
 
 interface WhiskerBoxSeriesOptions extends CustomSeriesOptions {
 	whiskerColor: string;
@@ -31,7 +31,7 @@ interface WhiskerData extends CustomData {
 }
 
 class WhiskerBoxSeries<TData extends WhiskerData>
-	implements ICustomSeriesPaneView<TData, WhiskerBoxSeriesOptions> {
+	implements ICustomSeriesPaneView<Time, TData, WhiskerBoxSeriesOptions> {
 	public priceValueBuilder(plotRow: TData): CustomSeriesPricePlotValues {
 		return [];
 	}
@@ -46,7 +46,7 @@ class WhiskerBoxSeries<TData extends WhiskerData>
 	}
 
 	public update(
-		data: PaneRendererCustomData<TData>,
+		data: PaneRendererCustomData<Time, TData>,
 		options: WhiskerBoxSeriesOptions
 	): void {}
 
diff --git a/tests/unittests/data-layer.spec.ts b/tests/unittests/data-layer.spec.ts
index c3ab5ac4b1..7dc3b6f269 100644
--- a/tests/unittests/data-layer.spec.ts
+++ b/tests/unittests/data-layer.spec.ts
@@ -3,14 +3,16 @@ 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 { ensureDefined } from '../../src/helpers/assertions';
+import { BarData, HistogramData, LineData, WhitespaceData } from '../../src/model/data-consumer';
+import { DataLayer, SeriesChanges } from '../../src/model/data-layer';
+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 { BusinessDay, Time, TimePoint, TimePointIndex, UTCTimestamp } from '../../src/model/time-data';
+import { TimePointIndex } from '../../src/model/time-data';
 
 chai.use(chaiExclude);
 
@@ -27,17 +29,19 @@ function createSeriesMock<T extends SeriesType = SeriesType>(seriesType?: T): Se
 }
 
 // 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();
@@ -51,14 +55,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, series: Series<SeriesType>) => {
 			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)]);
@@ -71,7 +75,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, series: Series<SeriesType>) => {
 			if (series === series1) {
 				expect(updatePacket.data.length).to.be.equal(2);
 
@@ -89,7 +93,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();
@@ -114,7 +118,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();
@@ -159,7 +163,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();
@@ -183,7 +187,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();
@@ -239,7 +243,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();
@@ -254,7 +258,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, series: Series<SeriesType>) => {
 			expect(series).to.be.equal(series1);
 			expect(updatePacket.data).excludingEvery(['value', 'originalTime']).to.have.deep.members([
 				{ index: 0, time: { timestamp: 1000 } },
@@ -268,7 +272,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, series: Series<SeriesType>) => {
 			expect(series).to.be.equal(series2);
 			expect(updatePacket.data).excludingEvery(['value', 'originalTime']).to.have.deep.members([
 				{ index: 1, time: { timestamp: 2000 } },
@@ -278,7 +282,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();
@@ -299,7 +303,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, series: Series<SeriesType>) => {
 			if (series === series1) {
 				expect(updatePacket.data.length).to.be.equal(2);
 
@@ -324,7 +328,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 };
@@ -354,26 +358,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, series: Series<SeriesType>) => {
 			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)))
@@ -400,10 +404,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,
@@ -423,7 +427,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));
 
@@ -436,7 +440,7 @@ describe('DataLayer', () => {
 			return res;
 		}
 
-		const dataLayer = new DataLayer();
+		const dataLayer = new DataLayer<Time>(behavior);
 		const series1 = createSeriesMock();
 		const series2 = createSeriesMock();
 		const data1 = generateData();
@@ -478,7 +482,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();
 
@@ -500,7 +504,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,
@@ -544,7 +548,7 @@ describe('DataLayer', () => {
 		];
 
 		it('single series', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 			const series = createSeriesMock();
 
 			dataLayer.setSeriesData(series, data);
@@ -556,7 +560,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++) {
@@ -580,7 +584,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) {
@@ -592,7 +596,7 @@ describe('DataLayer', () => {
 		}
 
 		it('remove first series', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series1 = createSeriesMock();
 			const series2 = createSeriesMock();
@@ -617,7 +621,7 @@ describe('DataLayer', () => {
 		});
 
 		it('remove second series', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series1 = createSeriesMock();
 			const series2 = createSeriesMock();
@@ -644,7 +648,7 @@ describe('DataLayer', () => {
 
 	describe('customValues', () => {
 		it('should be able to store customValues in a data 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();
@@ -660,12 +664,12 @@ describe('DataLayer', () => {
 				},
 			]);
 
-			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series) => {
+			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series<SeriesType>) => {
 				expect(seriesUpdate.data.length).to.be.equal(2);
 
 				if (series === series1) {
 					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);
 					expect(seriesUpdate.data[1].customValues).to.not.be.equal(undefined);
 					expect(seriesUpdate.data[1].customValues).to.deep.equal(
 						{ testValue: 1234, testString: 'abc' }
@@ -675,7 +679,7 @@ describe('DataLayer', () => {
 		});
 
 		it('should be able to remove customValues from 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();
@@ -692,19 +696,19 @@ describe('DataLayer', () => {
 
 			// change the last point of the first series
 			const updateResult = dataLayer.updateSeriesData(series1, dataItemAt(4000 as UTCTimestamp));
-			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series) => {
+			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series<SeriesType>) => {
 				expect(seriesUpdate.data.length).to.be.equal(2);
 
 				if (series === series1) {
 					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);
 					expect(seriesUpdate.data[1].customValues).to.be.equal(undefined);
 				}
 			});
 		});
 
 		it('should be able to replace data including customValues with whitespace', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series = createSeriesMock();
 
@@ -732,19 +736,19 @@ describe('DataLayer', () => {
 			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);
 
 			// Update the last item from whitespace back to a normal data item (without customValue)
 			const updateResultTwo = dataLayer.updateSeriesData(series, dataItemAt(5000 as UTCTimestamp));
-			updateResultTwo.series.forEach((seriesUpdateTwo: SeriesChanges, updatedSeries: Series) => {
+			updateResultTwo.series.forEach((seriesUpdateTwo: SeriesChanges, updatedSeries: Series<SeriesType>) => {
 				expect(seriesUpdateTwo.data.length).to.be.equal(3);
 
 				if (updatedSeries === series) {
 					expect(seriesUpdateTwo.data[2].index).to.be.equal(2 as TimePointIndex);
-					expect(seriesUpdateTwo.data[2].time.timestamp).to.be.equal(5000 as UTCTimestamp);
+					expect((seriesUpdateTwo.data[2].time as unknown as TimePoint).timestamp).to.be.equal(5000 as UTCTimestamp);
 					expect(seriesUpdateTwo.data[2].customValues).to.be.equal(undefined);
 				}
 			});
@@ -753,7 +757,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();
 
@@ -780,14 +784,14 @@ describe('DataLayer', () => {
 			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();
 
@@ -813,14 +817,14 @@ describe('DataLayer', () => {
 			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();
 
@@ -849,7 +853,7 @@ describe('DataLayer', () => {
 		});
 
 		it('should allow to replace bar with whitespace', () => {
-			const dataLayer = new DataLayer();
+			const dataLayer = new DataLayer<Time>(behavior);
 
 			const series = createSeriesMock();
 
@@ -872,14 +876,14 @@ describe('DataLayer', () => {
 			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();
@@ -908,27 +912,27 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(2);
 
-			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series) => {
+			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series<SeriesType>) => {
 				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();
@@ -962,21 +966,21 @@ describe('DataLayer', () => {
 
 			expect(updateResult.series.size).to.be.equal(2);
 
-			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series) => {
+			updateResult.series.forEach((seriesUpdate: SeriesChanges, series: Series<SeriesType>) => {
 				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/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 {
diff --git a/tests/unittests/get-series-data-creator.spec.ts b/tests/unittests/get-series-data-creator.spec.ts
index db0c975b2d..6c054b8ef6 100644
--- a/tests/unittests/get-series-data-creator.spec.ts
+++ b/tests/unittests/get-series-data-creator.spec.ts
@@ -2,15 +2,17 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { getSeriesDataCreator } from '../../src/api/get-series-data-creator';
+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 { OriginalTime, TimePointIndex, UTCTimestamp } from '../../src/model/time-data';
+import { TimePointIndex } from '../../src/model/time-data';
 
 const plotRow: PlotRow = {
 	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[] = [
diff --git a/tests/unittests/get-series-plot-row-creator.spec.ts b/tests/unittests/get-series-plot-row-creator.spec.ts
index 18d55fd935..379b1db5f0 100644
--- a/tests/unittests/get-series-plot-row-creator.spec.ts
+++ b/tests/unittests/get-series-plot-row-creator.spec.ts
@@ -1,32 +1,34 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
-import { getSeriesPlotRowCreator } from '../../src/api/get-series-plot-row-creator';
-import { OriginalTime, TimePointIndex, UTCTimestamp } from '../../src/model/time-data';
+import { getSeriesPlotRowCreator } from '../../src/model/get-series-plot-row-creator';
+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..5c86d767d5 100644
--- a/tests/unittests/plot-list.spec.ts
+++ b/tests/unittests/plot-list.spec.ts
@@ -2,16 +2,18 @@ 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 };
+	return { index, time: time as unknown as InternalHorzScaleItem, value, originalTime: time };
 }
 
 describe('PlotList', () => {
diff --git a/tests/unittests/time-scale.spec.ts b/tests/unittests/time-scale.spec.ts
index 6004a58aeb..144c321fc0 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']> {
+function tsUpdate(to: number): Parameters<TimeScale<Time>['update']> {
 	const points: TimeScalePoint[] = [];
 
 	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);
 		});
 	});
 });
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"
+        }
+	]
+}
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).