/**!
* lightweight-charts-react-components v2.5.0
*
* This source code is licensed under the MIT license found in the
* LICENSE.md file in the root directory of this source tree.
*
* @license MIT
*/

import { ChartOptions } from 'lightweight-charts';
import { ChartOptionsImpl } from 'lightweight-charts';
import { DeepPartial } from 'lightweight-charts';
import type { DependencyList } from 'react';
import type { ForwardedRef } from 'react';
import type { ForwardRefExoticComponent } from 'react';
import { IChartApi } from 'lightweight-charts';
import { IChartApiBase } from 'lightweight-charts';
import type { ICustomSeriesPaneView } from 'lightweight-charts';
import { IHorzScaleBehavior } from 'lightweight-charts';
import type { IImageWatermarkPluginApi } from 'lightweight-charts';
import type { ImageWatermarkOptions } from 'lightweight-charts';
import type { IPaneApi } from 'lightweight-charts';
import type { IPanePrimitive } from 'lightweight-charts';
import type { IPriceLine } from 'lightweight-charts';
import type { IPriceScaleApi } from 'lightweight-charts';
import type { IRange } from 'lightweight-charts';
import type { ISeriesApi } from 'lightweight-charts';
import type { ISeriesMarkersPluginApi } from 'lightweight-charts';
import type { ISeriesPrimitive } from 'lightweight-charts';
import type { ITextWatermarkPluginApi } from 'lightweight-charts';
import type { ITimeScaleApi } from 'lightweight-charts';
import { IYieldCurveChartApi } from 'lightweight-charts';
import type { JSX } from 'react';
import type { LogicalRangeChangeEventHandler } from 'lightweight-charts';
import { MouseEventHandler } from 'lightweight-charts';
import { PriceChartOptions } from 'lightweight-charts';
import type { PriceLineOptions } from 'lightweight-charts';
import type { PriceScaleOptions as PriceScaleOptions_2 } from 'lightweight-charts';
import type { ReactElement } from 'react';
import type { ReactNode } from 'react';
import type { RefAttributes } from 'react';
import type { SeriesDataItemTypeMap } from 'lightweight-charts';
import type { SeriesMarker } from 'lightweight-charts';
import type { SeriesMarkersOptions } from 'lightweight-charts';
import type { SeriesPartialOptionsMap } from 'lightweight-charts';
import type { SeriesType } from 'lightweight-charts';
import type { SizeChangeEventHandler } from 'lightweight-charts';
import type { TextWatermarkOptions } from 'lightweight-charts';
import { Time } from 'lightweight-charts';
import type { TimeRangeChangeEventHandler } from 'lightweight-charts';
import type { TimeScaleOptions as TimeScaleOptions_2 } from 'lightweight-charts';
import { YieldCurveChartOptions } from 'lightweight-charts';

/**
 * AreaSeries component that can be used to create an area series in a chart.
 *
 * @param props - The properties for the area series.
 * @param ref - The ref to access the area series API.
 * @returns A React component that renders the area series.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/series | Series documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/series-types#area | TradingView documentation for area series}
 * @example
 * ```tsx
 * <AreaSeries
 *  data={[
 *    { time: '2021-01-01', value: 100 },
 *    { time: '2021-01-02', value: 200 }
 *  ]}
 *  options={{}}
 * />
 * ```
 */
export declare const AreaSeries: SeriesForwardRefComponent<"Area">;

/**
 * BarSeries component that can be used to create a bar series in a chart.
 *
 * @param props - The properties for the bar series.
 * @param ref - The ref to access the bar series API.
 * @returns A React component that renders the bar series.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/series | Series documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/series-types#bar | TradingView documentation for bar series}
 * @example
 * ```tsx
 * <BarSeries
 *  data={[
 *    { time: '2021-01-01', open: 100, high: 110, low: 90, close: 105 },
 *    { time: '2021-01-02', open: 105, high: 115, low: 95, close: 110 }
 *  ]}
 *  options={{}}
 * />
 * ```
 */
export declare const BarSeries: SeriesForwardRefComponent<"Bar">;

/**
 * BaselineSeries component that can be used to create a baseline series in a chart.
 *
 * @param props - The properties for the baseline series.
 * @param ref - The ref to access the baseline series API.
 * @returns A React component that renders the baseline series.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/series | Series documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/series-types#baseline | TradingView documentation for baseline series}
 * @example
 * ```tsx
 * <BaselineSeries
 *  data={[
 *    { time: '2021-01-01', value: 100 },
 *    { time: '2021-01-02', value: 200 }
 *  ]}
 *  options={{}}
 * />
 * ```
 */
export declare const BaselineSeries: SeriesForwardRefComponent<"Baseline">;

/**
 * CandlestickSeries component that can be used to create a candlestick series in a chart.
 *
 * @param props - The properties for the candlestick series.
 * @param ref - The ref to access the candlestick series API.
 * @returns A React component that renders the candlestick series.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/series | Series documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/series-types#candlestick | TradingView documentation for candlestick series}
 * @example
 * ```tsx
 * <CandlestickSeries
 *  data={[
 *    { time: '2021-01-01', open: 100, high: 110, low: 90, close: 105 },
 *    { time: '2021-01-02', open: 105, high: 115, low: 95, close: 110 }
 *  ]}
 *  options={{}}
 * />
 * ```
 */
export declare const CandlestickSeries: SeriesForwardRefComponent<"Candlestick">;

/**
 * Chart component that can be used to create a chart.
 *
 * @param props - The properties for the chart.
 * @param ref - The ref to access the chart API.
 * @returns A React component that renders the chart.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/chart | Chart documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/chart-types | TradingView documentation for charts}
 * @example
 * ```tsx
 * <Chart>
 *   <Pane stretchFactor={2}>
 *     ...
 *   </Pane>
 * </Chart>
 * ```
 */
export declare const Chart: ForwardRefExoticComponent<ChartProps & RefAttributes<HTMLDivElement>>;

/**
 * Common chart API surface used by the React wrapper.
 */
declare type ChartApiInstance<HorzScaleItem = Time> = Pick<IChartApiBase<HorzScaleItem>, "applyOptions" | "remove" | "subscribeClick" | "unsubscribeClick" | "subscribeCrosshairMove" | "unsubscribeCrosshairMove" | "subscribeDblClick" | "unsubscribeDblClick">;

/**
 * Chart API reference type that can be used to access the chart plugin API.
 */
export declare type ChartApiRef<HorzScaleItem = Time, TChartApi extends ChartApiInstance<HorzScaleItem> = ChartApiInstance<HorzScaleItem>> = {
    /**
     * Internal reference to the chart API instance.
     */
    _chart: TChartApi | null;
    /**
     * Function to get the chart API instance.
     */
    api: () => TChartApi | null;
    /**
     * Function to initialize the chart API instance.
     */
    init: () => TChartApi | null;
    /**
     * Function to clear the chart API instance.
     */
    clear: () => void;
};

/**
 * Chart component props.
 */
export declare type ChartProps = GenericChartProps<Time, IChartApi, ChartOptions>;

/**
 * CustomChart component that can be used to create a chart with a custom horizontal scale behavior.
 *
 * @param props - The properties for the custom chart.
 * @param ref - The ref to access the chart container.
 * @returns A React component that renders the custom chart.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/chart | Chart documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/chart-types#custom-horizontal-scale-chart | TradingView documentation for custom horizontal scale charts}
 * @example
 * ```tsx
 * <CustomChart horzScaleBehavior={new (defaultHorzScaleBehavior())()}>
 *   <LineSeries data={[{ time: "2025-01-01", value: 100 }]} />
 * </CustomChart>
 * ```
 */
export declare const CustomChart: CustomChartForwardRefComponent;

declare type CustomChartForwardRefComponent = (<HorzScaleItem, THorzScaleBehavior extends IHorzScaleBehavior<HorzScaleItem>>(props: CustomChartProps<HorzScaleItem, THorzScaleBehavior> & RefAttributes<HTMLDivElement>) => JSX.Element) & {
    displayName: string;
};

/**
 * CustomChart component props.
 */
export declare type CustomChartProps<HorzScaleItem = Time, THorzScaleBehavior extends IHorzScaleBehavior<HorzScaleItem> = IHorzScaleBehavior<HorzScaleItem>> = GenericChartProps<HorzScaleItem, IChartApiBase<HorzScaleItem>, ReturnType<THorzScaleBehavior["options"]>> & {
    /**
     * Horizontal scale behavior instance passed to `createChartEx`.
     */
    horzScaleBehavior: THorzScaleBehavior;
};

/**
 * CustomSeries component that can be used to create a custom series in a chart.
 *
 * @param props - The properties for the custom series.
 * @param ref - The ref to access the custom series API.
 * @returns A React component that renders the custom series.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/series | Series documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/series-types#custom-series-plugins | TradingView documentation for custom series}
 * @example
 * ```tsx
 * <CustomSeries
 *  data={[
 *    { time: '2021-01-01', value: 100 },
 *    { time: '2021-01-02', value: 200 }
 *  ]}
 *  options={{}}
 *  plugin={{}}
 * />
 * ```
 */
export declare const CustomSeries: SeriesForwardRefComponent<"Custom">;

/**
 * Unique properties for the custom series component.
 */
declare type CustomSeriesUniqueProps<HorzScaleItem = Time> = {
    /**
     * Custom pane view plugin instance that can be used to render custom series.
     */
    plugin?: ICustomSeriesPaneView<HorzScaleItem>;
};

/**
 * Generic chart component props.
 */
export declare type GenericChartProps<HorzScaleItem = Time, TChartApi extends ChartApiInstance<HorzScaleItem> = ChartApiInstance<HorzScaleItem>, TOptions extends ChartOptionsImpl<HorzScaleItem> = ChartOptionsImpl<HorzScaleItem>> = {
    /**
     * Children of the chart component.
     */
    children?: ReactNode;
    /**
     * The props for the container element on which the chart will be rendered.
     * The wrapper sets `aria-hidden` to `true` by default because Lightweight Charts
     * renders layout tables internally; override it explicitly if you provide your own
     * accessible labelling strategy.
     */
    containerProps?: JSX.IntrinsicElements["div"];
    /**
     * Callback function that is called when the chart is clicked.
     */
    onClick?: MouseEventHandler<HorzScaleItem>;
    /**
     * Callback function that is called when the crosshair moves.
     */
    onCrosshairMove?: MouseEventHandler<HorzScaleItem>;
    /**
     * Callback function that is called when the chart is initialized.
     */
    onInit?: (chart: TChartApi) => void;
    /**
     * Options for the chart.
     */
    options?: DeepPartial<TOptions>;
    /**
     * Callback function that is called when the chart is double-clicked.
     */
    onDblClick?: MouseEventHandler<HorzScaleItem>;
};

declare type GenericMarkersComponent = (<HorzScaleItem = Time>(props: MarkersProps<HorzScaleItem> & {
    ref?: ForwardedRef<MarkersApiRef<HorzScaleItem>>;
}) => JSX.Element | null) & {
    displayName: string;
};

declare type GenericPaneComponent = (<HorzScaleItem = Time>(props: PaneProps & {
    ref?: ForwardedRef<PaneApiRef<HorzScaleItem>>;
}) => JSX.Element) & {
    displayName: string;
};

declare type GenericPanePrimitiveComponent = (<HorzScaleItem = Time>(props: PanePrimitiveProps<HorzScaleItem> & {
    ref?: ForwardedRef<PanePrimitiveApiRef<HorzScaleItem>>;
}) => ReturnType<typeof PanePrimitiveRenderFunction>) & {
    displayName: string;
};

declare type GenericSeriesPrimitiveComponent = (<T extends SeriesType, HorzScaleItem = Time>(props: SeriesPrimitiveProps<T, HorzScaleItem> & {
    ref?: ForwardedRef<SeriesPrimitiveApiRef<HorzScaleItem>>;
}) => ReturnType<typeof SeriesPrimitiveRenderFunction>) & {
    displayName: string;
};

declare type GenericTimeScaleComponent = (<HorzScaleItem = Time>(props: TimeScaleProps<HorzScaleItem> & {
    ref?: ForwardedRef<TimeScaleApiRef<HorzScaleItem>>;
}) => JSX.Element) & {
    displayName: string;
};

/**
 * HistogramSeries component that can be used to create a histogram series in a chart.
 *
 * @param props - The properties for the histogram series.
 * @param ref - The ref to access the histogram series API.
 * @returns A React component that renders the histogram series.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/series | Series documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/series-types#histogram | TradingView documentation for histogram series}
 * @example
 * ```tsx
 * <HistogramSeries
 *  data={[
 *    { time: '2021-01-01', value: 100 },
 *    { time: '2021-01-02', value: 200 }
 *  ]}
 *  options={{}}
 * />
 * ```
 */
export declare const HistogramSeries: SeriesForwardRefComponent<"Histogram">;

/**
 * Unique properties for the image watermark component.
 */
export declare type ImageWatermarkProps = {
    src: string;
} & DeepPartial<ImageWatermarkOptions>;

/**
 * Pane context that provides access to the pane API and readiness state.
 */
export declare interface IPaneContext<HorzScaleItem = Time> {
    /**
     * Reference to the pane API.
     */
    paneApiRef?: PaneApiRef<HorzScaleItem>;
    /**
     * Readiness state of the pane component.
     */
    isReady: boolean;
}

/**
 * LineSeries component that can be used to create a line series in a chart.
 *
 * @param props - The properties for the line series.
 * @param ref - The ref to access the line series API.
 * @returns A React component that renders the line series.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/series | Series documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/series-types#line | TradingView documentation for line series}
 * @example
 * ```tsx
 * <LineSeries
 *  data={[
 *    { time: '2021-01-01', value: 100 },
 *    { time: '2021-01-02', value: 200 }
 *  ]}
 *  options={{}}
 * />
 * ```
 */
export declare const LineSeries: SeriesForwardRefComponent<"Line">;

/**
 * Markers component that can be used to add markers to a chart pane.
 *
 * @param props - The properties for the markers.
 * @param ref - The ref to access the markers API.
 * @returns A React component that renders the markers.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/markers | Documentation for Markers}
 * @see {@link https://tradingview.github.io/lightweight-charts/tutorials/how_to/series-markers | TradingView documentation for markers}
 * @example
 * ```tsx
 * <Markers
 *  markers={[
 *    { time: 1622548800, position: "aboveBar", color: "red", shape: "arrowUp" },
 *    { time: 1622548800, position: "belowBar", color: "green", shape: "arrowDown" },
 *  ]}
 * />
 * ```
 */
export declare const Markers: GenericMarkersComponent;

/**
 * Markers API reference type that can be used to access the series markers plugin API.
 */
export declare type MarkersApiRef<HorzScaleItem = Time> = {
    /**
     * Internal reference to the series markers API instance.
     */
    _markers: ISeriesMarkersPluginApi<HorzScaleItem> | null;
    /**
     * Function to get the series markers API instance.
     */
    api: () => ISeriesMarkersPluginApi<HorzScaleItem> | null;
    /**
     * Function to initialize the series markers API instance.
     */
    init: () => ISeriesMarkersPluginApi<HorzScaleItem> | null;
    /**
     * Function to clear the series markers API instance.
     */
    clear: () => void;
};

/**
 * Markers component properties that can be used to create a series markers component.
 */
export declare type MarkersProps<HorzScaleItem = Time> = {
    /**
     * List of markers to be displayed on the series.
     */
    markers: SeriesMarker<HorzScaleItem>[];
    /**
     * Options for the markers.
     */
    options?: DeepPartial<SeriesMarkersOptions>;
    /**
     * Whether markers should update reactively when marker list changes.
     */
    reactive?: boolean;
};

/**
 * OptionsChart component that can be used to create a price-based horizontal scale chart.
 *
 * @param props - The properties for the options chart.
 * @param ref - The ref to access the chart container.
 * @returns A React component that renders the options chart.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/chart | Chart documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/chart-types#options-chart-price-based | TradingView documentation for options charts}
 * @example
 * ```tsx
 * <OptionsChart>
 *   <LineSeries data={[{ time: 95, value: 1.2 }, { time: 100, value: 2.8 }]} />
 * </OptionsChart>
 * ```
 */
export declare const OptionsChart: ForwardRefExoticComponent<OptionsChartProps & RefAttributes<HTMLDivElement>>;

/**
 * OptionsChart component props.
 */
export declare type OptionsChartProps = GenericChartProps<number, IChartApiBase<number>, PriceChartOptions>;

/**
 * Pane component that can be used to create a pane in a chart.
 *
 * @param props - The properties for the pane.
 * @param ref - The ref to access the pane API.
 * @returns A React component that renders the pane.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/panes | Panes documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/panes | TradingView documentation for panes}
 * @example
 * ```tsx
 * <Pane stretchFactor={2}>
 * ...
 * </Pane>
 * ```
 */
export declare const Pane: GenericPaneComponent;

/**
 * Pane API reference type that can be used to access the pane plugin API.
 */
export declare type PaneApiRef<HorzScaleItem = Time> = {
    /**
     * Reference to the pane API.
     */
    _pane: IPaneApi<HorzScaleItem> | null;
    /**
     * Function to get the pane API.
     */
    api: () => IPaneApi<HorzScaleItem> | null;
    /**
     * Function to initialize the pane API.
     */
    init: () => IPaneApi<HorzScaleItem> | null;
    /**
     * Function to clear the pane API.
     */
    clear: () => void;
};

/**
 * PanePrimitive component that can be used to create a primitive on a pane.
 *
 * @param props - The properties for the pane primitive.
 * @param ref - The ref to access the pane primitive API.
 * @returns A React component that renders the pane primitive.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/pane-primitives | Pane primitives documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/plugins/pane-primitives | TradingView documentation for pane primitive}
 * @example
 * ```tsx
 * <Pane>
 *   <PanePrimitive render={({ chart, pane }) => new MyPanePrimitive(chart, pane)} />
 * </Pane>
 * ```
 */
export declare const PanePrimitive: GenericPanePrimitiveComponent;

/**
 * Pane primitive API reference type that can be used to access the pane primitive plugin API.
 */
export declare type PanePrimitiveApiRef<HorzScaleItem = Time> = ReactivePrimitiveApiRef<IPanePrimitive<HorzScaleItem>>;

/**
 * Pane primitive properties that can be used to create a pane primitive.
 */
export declare type PanePrimitiveProps<HorzScaleItem = Time> = ReactivePrimitiveProps<IPanePrimitive<HorzScaleItem>, RenderPanePrimitive<HorzScaleItem>>;

declare const PanePrimitiveRenderFunction: <HorzScaleItem = Time>(props: PanePrimitiveProps<HorzScaleItem>, ref: ForwardedRef<PanePrimitiveApiRef<HorzScaleItem>>) => JSX.Element | null;

/**
 * Pane component props.
 */
export declare type PaneProps = {
    /**
     * Children of the pane component.
     */
    children?: ReactNode;
    /**
     * Stretch factor for the pane, which determines how much space the pane should take relative to other panes.
     */
    stretchFactor?: number;
};

/**
 * PriceLine component that can be used to add a price line to a chart pane.
 *
 * @param props - The properties for the price line.
 * @param ref - The ref to access the price line API.
 * @returns A React component that renders the price line.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/price-lines | Price Lines documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/tutorials/how_to/price-line | TradingView documentation for price lines}
 * @example
 * ```tsx
 * <PriceLine price={100} options={{}} />
 * ```
 */
export declare const PriceLine: ForwardRefExoticComponent<PriceLineProps & RefAttributes<PriceLineApiRef>>;

/**
 * PriceLine API reference type that can be used to access the price line plugin API.
 */
export declare type PriceLineApiRef = {
    /**
     * Reference to the price line API.
     */
    _priceLine: IPriceLine | null;
    /**
     * Function to get the price line API.
     */
    api: () => IPriceLine | null;
    /**
     * Function to initialize the price line API.
     */
    init: () => IPriceLine | null;
    /**
     * Function to clear the price line API.
     */
    clear: () => void;
};

/**
 * PriceLine component props.
 */
export declare type PriceLineProps = {
    /**
     * The price at which the price line should be drawn.
     */
    price: number;
    /**
     * Options for the price line.
     */
    options?: Omit<Partial<PriceLineOptions>, "price">;
};

/**
 * PriceScale component that can be used to create/customize price scale in a chart.
 *
 * @param props - The properties for the price scale.
 * @param ref - The ref to access the price scale API.
 * @returns A React component that renders the price scale.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/price-scale | Price Scale documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/price-scale | TradingView documentation for price scale}
 * @example
 * ```tsx
 * <PriceScale id="right" options={{}} />
 * ```
 */
export declare const PriceScale: ForwardRefExoticComponent<PriceScaleProps & RefAttributes<PriceScaleApiRef>>;

/**
 * Price scale API reference type that can be used to access the price scale plugin API.
 */
export declare type PriceScaleApiRef = {
    /**
     * Reference to the price scale API.
     */
    _priceScale: IPriceScaleApi | null;
    /**
     * Function to get the price scale API.
     */
    api: () => IPriceScaleApi | null;
    /**
     * Function to initialize the price scale API.
     */
    init: () => IPriceScaleApi | null;
    /**
     * Function to set the ID of the price scale.
     */
    setId: (id: string) => void;
    /**
     * Function to clear the price scale API.
     */
    clear: () => void;
};

declare type PriceScaleOptions = DeepPartial<PriceScaleOptions_2>;

/**
 * PriceScale component props.
 */
export declare type PriceScaleProps = {
    /**
     * Options for the price scale.
     */
    options?: PriceScaleOptions;
    /**
     * The ID of the price scale.
     */
    id: string;
};

/**
 * Shared API reference shape for reactive primitives.
 */
declare type ReactivePrimitiveApiRef<TPrimitive> = {
    /**
     * Internal reference to the primitive API instance.
     */
    _primitive: TPrimitive | null;
    /**
     * Function to get the primitive API instance.
     */
    api(): TPrimitive | null;
    /**
     * Function to initialize the primitive API instance.
     */
    init(): TPrimitive | null;
    /**
     * Function to clear the primitive API instance.
     */
    clear(): void;
};

declare type ReactivePrimitiveProps<TPrimitive, TRender> = {
    render: TRender;
    plugin?: never;
} | {
    plugin: TPrimitive;
    render?: never;
};

/**
 * Render function type for pane primitives.
 */
export declare type RenderPanePrimitive<HorzScaleItem = Time> = ({ chart, pane, }: {
    chart: IChartApiBase<HorzScaleItem>;
    pane: IPaneApi<HorzScaleItem>;
}) => IPanePrimitive<HorzScaleItem>;

/**
 * Render function type for series primitives.
 */
export declare type RenderPrimitive<T extends SeriesType = SeriesType, HorzScaleItem = Time> = ({ chart, series, }: {
    chart: IChartApiBase<HorzScaleItem>;
    series: ISeriesApi<T, HorzScaleItem>;
}) => ISeriesPrimitive<HorzScaleItem>;

/**
 * Series API reference type that can be used to access the series plugin API.
 */
export declare type SeriesApiRef<T extends SeriesType, HorzScaleItem = Time> = {
    /**
     * Internal reference to the series API instance.
     */
    _series: ISeriesApi<T, HorzScaleItem> | null;
    /**
     * Function to get the series API instance.
     */
    api: () => ISeriesApi<T, HorzScaleItem> | null;
    /**
     * Function to initialize the series API instance.
     */
    init: () => ISeriesApi<T, HorzScaleItem> | null;
    /**
     * Function to clear the series API instance.
     */
    clear: () => void;
};

/**
 * Forward ref component type for a series component.
 */
declare type SeriesForwardRefComponent<T extends SeriesType> = (<HorzScaleItem = Time>(props: SeriesProps<T, HorzScaleItem> & RefAttributes<SeriesApiRef<T, HorzScaleItem>>) => ReactElement | null) & {
    displayName?: string;
};

/**
 * Series options that can be used to customize the appearance and behavior of a series.
 */
export declare type SeriesOptions<T extends SeriesType> = SeriesPartialOptionsMap[T];

declare type SeriesParameters<T extends SeriesType, HorzScaleItem = Time> = {
    data: SeriesDataItemTypeMap<HorzScaleItem>[T][];
    reactive?: boolean;
    options?: SeriesOptions<T>;
    seriesOrder?: ReturnType<ISeriesApi<T>["seriesOrder"]>;
    /**
     * If true, the series will replace its data on every update.
     * If false, it will try to apply incremental updates to the existing series when possible,
     * which can be useful for performance.
     *
     * @see {@link https://tradingview.github.io/lightweight-charts/docs#updating-the-data-in-a-series | TradingView documentation for updating series data}
     */
    alwaysReplaceData?: boolean;
} & (T extends "Custom" ? CustomSeriesUniqueProps<HorzScaleItem> : {});

/**
 * SeriesPrimitive component that can be used to create a primitive on series.
 *
 * @param props - The properties for the series primitive.
 * @param ref - The ref to access the series primitive API.
 * @returns A React component that renders the series primitive.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/series-primitives | Series primitives documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/plugins/series-primitives | TradingView documentation for series primitive}
 * @example
 * ```tsx
 * <SeriesPrimitive render={{}} />
 * <SeriesPrimitive plugin={{}} />
 * ```
 */
export declare const SeriesPrimitive: GenericSeriesPrimitiveComponent;

/**
 * Series primitive API reference type that can be used to access the series primitive plugin API.
 */
export declare type SeriesPrimitiveApiRef<HorzScaleItem = Time> = ReactivePrimitiveApiRef<ISeriesPrimitive<HorzScaleItem>>;

/**
 * Series primitive properties that can be used to create a series primitive.
 */
export declare type SeriesPrimitiveProps<T extends SeriesType = SeriesType, HorzScaleItem = Time> = ReactivePrimitiveProps<ISeriesPrimitive<HorzScaleItem>, RenderPrimitive<T, HorzScaleItem>>;

declare const SeriesPrimitiveRenderFunction: <T extends SeriesType, HorzScaleItem = Time>(props: SeriesPrimitiveProps<T, HorzScaleItem>, ref: ForwardedRef<SeriesPrimitiveApiRef<HorzScaleItem>>) => JSX.Element | null;

/**
 * Series component properties that can be used to create a series of a specific type.
 */
export declare type SeriesProps<T extends SeriesType, HorzScaleItem = Time> = Omit<SeriesTemplateProps<T, HorzScaleItem>, "type">;

/**
 * Properties of a series template component that can be used to create a series of a specific type.
 */
declare type SeriesTemplateProps<T extends SeriesType, HorzScaleItem = Time> = {
    type: T;
    children?: ReactNode;
} & SeriesParameters<T, HorzScaleItem>;

/**
 * Unique properties for the text watermark component.
 */
export declare type TextWatermarkProps = DeepPartial<TextWatermarkOptions>;

/**
 * TimeScale component that can be used to create/customize time scale in a chart.
 *
 * @param props - The properties for the time scale.
 * @param ref - The ref to access the time scale API.
 * @returns A React component that renders the time scale.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/time-scale | Time Scale documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/time-scale | TradingView documentation for time scale}
 * @example
 * ```tsx
 * <TimeScale
 *   visibleRange={{ from: 0, to: 100 }}
 *   onVisibleTimeRangeChange={() => {}}
 * />
 * ```
 */
export declare const TimeScale: GenericTimeScaleComponent;

/**
 * Time scale API reference type that can be used to access the time scale plugin API.
 */
export declare type TimeScaleApiRef<HorzScaleItem = Time> = {
    /**
     * Reference to the time scale API.
     */
    _timeScale: ITimeScaleApi<HorzScaleItem> | null;
    /**
     * Function to get the time scale API.
     */
    api: () => ITimeScaleApi<HorzScaleItem> | null;
    /**
     * Function to initialize the time scale API.
     */
    init: () => ITimeScaleApi<HorzScaleItem> | null;
    /**
     * Function to clear the time scale API.
     */
    clear: () => void;
};

/**
 * TimeScaleFitContentTrigger component that triggers a fit content operation on the time scale.
 *
 * @param props - The properties for the time scale fit content trigger.
 * @returns A React component that triggers a fit content operation on the time scale.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/time-scale-fit-content-trigger | Time Scale Fit Content Trigger documentation}
 * @example
 * ```tsx
 * <TimeScaleFitContentTrigger deps={[...]} />
 * ```
 */
export declare const TimeScaleFitContentTrigger: ({ deps, }: TimeScaleFitContentTriggerProps) => JSX.Element | null;

/**
 * TimeScaleFitContentTriggerProps component props.
 */
export declare type TimeScaleFitContentTriggerProps = {
    /**
     * List of dependencies that trigger the time scale to fit content.
     */
    deps: DependencyList;
};

declare type TimeScaleOptions = DeepPartial<TimeScaleOptions_2>;

/**
 * Props for the TimeScale component that controls chart time scale behavior.
 *
 * Use this component to configure how the chart's visible time/logical range is initialized
 * and updated, and to react to time scale updates via event handlers.
 */
export declare type TimeScaleProps<HorzScaleItem = Time> = {
    /**
     * Callback for when the visible time range changes.
     */
    onVisibleTimeRangeChange?: TimeRangeChangeEventHandler<HorzScaleItem>;
    /**
     * Callback for when the visible logical range changes.
     */
    onVisibleLogicalRangeChange?: LogicalRangeChangeEventHandler;
    /**
     * Callback for when the size of the time scale changes.
     */
    onSizeChange?: SizeChangeEventHandler;
    /**
     * The visible time range for the time scale.
     */
    visibleRange?: IRange<HorzScaleItem>;
    /**
     * The visible logical range for the time scale.
     */
    visibleLogicalRange?: IRange<number>;
    /**
     * Options for the time scale.
     */
    options?: TimeScaleOptions;
    /**
     * Children of the time scale component.
     */
    children?: ReactNode;
};

/**
 * Watermark API reference type that can be used to access the watermark plugin API.
 */
export declare type WatermarkApiRef<T extends WatermarkType, HorzScaleItem = Time> = T extends "text" ? {
    _watermark: ITextWatermarkPluginApi<HorzScaleItem> | null;
    api: () => ITextWatermarkPluginApi<HorzScaleItem> | null;
    init: () => ITextWatermarkPluginApi<HorzScaleItem> | null;
    clear: () => void;
} : {
    _watermark: IImageWatermarkPluginApi<HorzScaleItem> | null;
    api: () => IImageWatermarkPluginApi<HorzScaleItem> | null;
    init: () => IImageWatermarkPluginApi<HorzScaleItem> | null;
    clear: () => void;
};

/**
 * Watermark component that can be used to add an image watermark to a chart pane.
 *
 * @param props - The properties for the image watermark.
 * @param ref - The ref to access the watermark API.
 * @returns A React component that renders the image watermark.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/watermarks | Watermarks documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/tutorials/how_to/watermark | TradingView documentation for watermarks}
 * @example
 * ```tsx
 * <WatermarkImage
 *  src="data:image/svg+xml;base64,..."
 *  alpha={0.5}
 *  padding={20}
 * />
 * ```
 */
export declare const WatermarkImage: ForwardRefExoticComponent<ImageWatermarkProps & RefAttributes<WatermarkApiRef<"image">>>;

/**
 * Watermark component that can be used to add a text or image watermark to a chart pane.
 *
 * @param props - The properties for the watermark.
 * @param ref - The ref to access the watermark API.
 * @returns A React component that renders the watermark.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/watermarks | Watermarks documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/tutorials/how_to/watermark | TradingView documentation for watermarks}
 * @example
 * ```tsx
 * <WatermarkText
 *  lines={[
 *    { text: "Your chart name", color: "blue", fontSize: 24 },
 *    { text: "Some other text", color: "pink", fontSize: 16 },
 *  ]}
 *  horzAlign="center"
 * />
 * ```
 */
export declare const WatermarkText: ForwardRefExoticComponent<TextWatermarkProps & RefAttributes<WatermarkApiRef<"text">>>;

/**
 * Watermark types supported by the library.
 * - `text`: A text watermark.
 * - `image`: An image watermark.
 */
export declare type WatermarkType = "text" | "image";

/**
 * YieldCurveChart component that can be used to create a yield curve chart.
 *
 * @param props - The properties for the yield curve chart.
 * @param ref - The ref to access the chart container.
 * @returns A React component that renders the yield curve chart.
 * @see {@link https://ukorvl.github.io/lightweight-charts-react-components/docs/chart | Chart documentation}
 * @see {@link https://tradingview.github.io/lightweight-charts/docs/chart-types#yield-curve-chart | TradingView documentation for yield curve charts}
 * @example
 * ```tsx
 * <YieldCurveChart>
 *   <LineSeries data={[{ time: 1, value: 5.2 }, { time: 12, value: 4.7 }]} />
 * </YieldCurveChart>
 * ```
 */
export declare const YieldCurveChart: ForwardRefExoticComponent<YieldCurveChartProps & RefAttributes<HTMLDivElement>>;

/**
 * YieldCurveChart component props.
 */
export declare type YieldCurveChartProps = GenericChartProps<number, IYieldCurveChartApi, YieldCurveChartOptions>;

export { }