@pipsend/charts 1.3.1 → 2.0.1

package/dist/typings.d.ts

@@ -15,6 +15,18 @@ declare abstract class DrawingToolBase implements IDrawingTool {
 	private _generateId;
 	get id(): string;
 	get type(): string;
+	/**
+	 * Lets a tool hand the base its own options object, once, in the constructor.
+	 *
+	 * Every tool keeps a typed bag of its own (`_trendOptions`, `_circleOptions`…)
+	 * that the base knows nothing about. Registering the reference here means
+	 * `applyOptions` and `options` work for all of them without each tool
+	 * repeating the same merge.
+	 */
+	protected _registerOptions(options: Record<string, unknown>): void;
+	protected _ownOptions: Record<string, unknown> | null;
+	/** The options in effect, for a configuration dialog to read. */
+	options(): Record<string, unknown>;
 	applyOptions(options: Partial<DrawingToolOptions>): void;
 	show(): void;
 	hide(): void;
@@ -248,6 +260,44 @@ export declare class CircleTool extends DrawingToolBase {
 	protected _update(): void;
 	remove(): void;
 }
+/**
+ * A horizontal and a vertical line crossing at one point.
+ *
+ * Both lines move together — the tool marks a moment at a price, not two
+ * independent levels — so it has a single anchor and drags as one.
+ */
+export declare class CrossLineTool extends DrawingToolBase {
+	private _crossOptions;
+	private _primitive;
+	private _repaint;
+	private _paneView;
+	private _isSelected;
+	private _isHovered;
+	private _isDragging;
+	private _grab;
+	private _moveStartTime;
+	private _moveStartPrice;
+	constructor(context: DrawingContext, options: CrossLineToolOptions);
+	private _createPrimitive;
+	private _requestUpdate;
+	protected _update(): void;
+	private _coordinates;
+	drawToCanvas(ctx: CanvasRenderingContext2D, horizontalPixelRatio: number, verticalPixelRatio: number): void;
+	private _hitTestPrimitive;
+	hitTest(x: number, y: number): boolean;
+	hitTestEndpoint(x: number, y: number): "line" | null;
+	startDrag(_target: "line", grab: DragAnchor): void;
+	updateDrag(time: Time, price: number): void;
+	stopDrag(): void;
+	setColor(color: string): void;
+	color(): string;
+	setSelected(selected: boolean): void;
+	isSelected(): boolean;
+	setHovered(hovered: boolean): void;
+	isHovered(): boolean;
+	remove(): void;
+	protected _serializeShape(): SerializedDrawingTool;
+}
 /**
  * A price line that can be dragged and clicked.
  *
@@ -523,6 +573,15 @@ export declare class FibonacciCalculator {
 		ratio: number;
 		label: string;
 	}>;
+	/**
+	 * The ratios as plain numbers.
+	 *
+	 * Read here, in the module that declares the level literals, rather than by
+	 * the caller: two anonymous `{ ratio, label }` types get different mangled
+	 * names at build time, so a `.ratio` read from elsewhere comes back
+	 * undefined.
+	 */
+	getRatioValues(): number[];
 	/**
 	 * Use standard ratios
 	 */
@@ -630,10 +689,6 @@ export declare class FibonacciFanTool extends DrawingToolBase {
 	protected _update(): void;
 	remove(): void;
 }
-/**
- * Fibonacci Retracement Tool - Herramienta para dibujar niveles de Fibonacci
- * Muestra niveles estándar: 0%, 23.6%, 38.2%, 50%, 61.8%, 78.6%, 100%
- */
 export declare class FibonacciTool extends DrawingToolBase {
 	private _fibOptions;
 	private _calculator;
@@ -672,6 +727,13 @@ export declare class FibonacciTool extends DrawingToolBase {
 	stopDrag(): void;
 	updateDrag(time: Time, price: number): void;
 	hitTestEndpoint(x: number, y: number): "point1" | "point2" | null;
+	/**
+	 * Merge options into the live tool. Same shape as the indicators', so the
+	 * configuration dialog does not need to know what it is talking to.
+	 */
+	applyOptions(options: Partial<FibonacciToolOptions>): void;
+	/** The options currently in effect, with the levels actually in use. */
+	options(): Record<string, unknown>;
 	setColor(color: string): void;
 	color(): string;
 	setSelected(selected: boolean): void;
@@ -752,6 +814,8 @@ export declare class HorizontalLineTool extends DrawingToolBase {
 	constructor(context: DrawingContext, options: HorizontalLineToolOptions);
 	private _createPrimitive;
 	private _createPaneView;
+	/** Where the line starts, in CSS pixels. Zero unless it is a ray. */
+	private _startX;
 	drawToCanvas(ctx: CanvasRenderingContext2D, horizontalPixelRatio: number, verticalPixelRatio: number): void;
 	private _drawLabel;
 	setColor(color: string): void;
@@ -818,6 +882,178 @@ export declare class InteractiveLineManager {
 	 */
 	isCreating(): boolean;
 }
+/**
+ * Two parallel lines marking a trend and its channel.
+ *
+ * Drawn in three clicks: the first two set the base line, the third sets how
+ * far the parallel copy sits from it. The width is kept **in price**, not in
+ * pixels, so the channel keeps its meaning when the scale changes — a pixel
+ * offset would widen and narrow as you zoom.
+ */
+export declare class ParallelChannelTool extends DrawingToolBase {
+	private _channelOptions;
+	private _primitive;
+	private _repaint;
+	private _paneView;
+	private _isSelected;
+	private _isHovered;
+	private _isDragging;
+	private _dragTarget;
+	private _grab;
+	private _moveStart;
+	private _isComplete;
+	private _clickCount;
+	private _previewPoint;
+	private _clickHandler;
+	private _moveHandler;
+	constructor(context: DrawingContext, options: ParallelChannelToolOptions);
+	private _createPrimitive;
+	private _requestUpdate;
+	protected _update(): void;
+	private _startDrawing;
+	private _finish;
+	private _stopDrawing;
+	/** Price of the base line at a given time, extrapolated beyond its points. */
+	private _priceOnBaseLine;
+	/** The two lines in pixels, or null while there is not enough to draw. */
+	private _lines;
+	drawToCanvas(ctx: CanvasRenderingContext2D, horizontalPixelRatio: number, verticalPixelRatio: number): void;
+	private _drawHandle;
+	private _rgba;
+	private _hitTestPrimitive;
+	private _distanceToSegment;
+	hitTest(x: number, y: number): boolean;
+	hitTestEndpoint(x: number, y: number): ChannelPart | null;
+	startDrag(target: ChannelPart, grab: DragAnchor): void;
+	updateDrag(time: Time, price: number): void;
+	stopDrag(): void;
+	setColor(color: string): void;
+	color(): string;
+	setSelected(selected: boolean): void;
+	isSelected(): boolean;
+	setHovered(hovered: boolean): void;
+	isHovered(): boolean;
+	remove(): void;
+	protected _serializeShape(): SerializedDrawingTool;
+}
+/**
+ * Andrews pitchfork: three prongs opening from a pivot.
+ *
+ * The median runs from the pivot through the midpoint of the other two points;
+ * the outer prongs run parallel to it, one through each. All three are
+ * projected to the right edge, which is the whole point — the fork is a
+ * forecast, not a measurement of what already happened.
+ */
+export declare class PitchforkTool extends DrawingToolBase {
+	private _forkOptions;
+	private _primitive;
+	private _repaint;
+	private _paneView;
+	private _isSelected;
+	private _isHovered;
+	private _isDragging;
+	private _dragTarget;
+	private _grab;
+	private _moveStart;
+	private _isComplete;
+	private _clickCount;
+	private _previewPoint;
+	private _clickHandler;
+	private _moveHandler;
+	constructor(context: DrawingContext, options: PitchforkToolOptions);
+	private _createPrimitive;
+	private _requestUpdate;
+	protected _update(): void;
+	private _startDrawing;
+	private _finish;
+	private _stopDrawing;
+	private _screenPoint;
+	/**
+	 * The three prongs in pixels, each already projected to the right edge.
+	 */
+	private _prongs;
+	drawToCanvas(ctx: CanvasRenderingContext2D, horizontalPixelRatio: number, verticalPixelRatio: number): void;
+	/** While fewer than three points exist, only what is known is drawn. */
+	private _drawSkeleton;
+	private _drawHandle;
+	private _rgba;
+	private _hitTestPrimitive;
+	private _distanceToSegment;
+	hitTest(x: number, y: number): boolean;
+	hitTestEndpoint(x: number, y: number): PitchforkPart | null;
+	startDrag(target: PitchforkPart, grab: DragAnchor): void;
+	updateDrag(time: Time, price: number): void;
+	stopDrag(): void;
+	setColor(color: string): void;
+	color(): string;
+	setSelected(selected: boolean): void;
+	isSelected(): boolean;
+	setHovered(hovered: boolean): void;
+	isHovered(): boolean;
+	remove(): void;
+	protected _serializeShape(): SerializedDrawingTool;
+}
+/**
+ * A closed shape of any number of corners.
+ *
+ * Unlike the two-point tools it is drawn over several clicks: each one adds a
+ * corner, and the shape closes when you click the first corner again or press
+ * Enter. Three corners make a triangle, which is why there is no separate tool
+ * for one.
+ */
+export declare class PolygonTool extends DrawingToolBase {
+	private _polygonOptions;
+	private _points;
+	private _primitive;
+	private _repaint;
+	private _paneView;
+	private _isSelected;
+	private _isHovered;
+	private _isDragging;
+	private _dragTarget;
+	private _grab;
+	private _moveStartPoints;
+	private _isComplete;
+	private _previewPoint;
+	private _clickHandler;
+	private _moveHandler;
+	private _keyHandler;
+	/** How close to the first corner a click has to land to close the shape. */
+	private static readonly _CLOSE_TOLERANCE;
+	constructor(context: DrawingContext, options: PolygonToolOptions);
+	private _createPrimitive;
+	private _requestUpdate;
+	protected _update(): void;
+	private _startDrawing;
+	private _isNearFirstPoint;
+	private _finish;
+	private _stopDrawing;
+	/** The corners in pixels, plus the preview corner while still drawing. */
+	private _screenPoints;
+	private _toScreen;
+	drawToCanvas(ctx: CanvasRenderingContext2D, horizontalPixelRatio: number, verticalPixelRatio: number): void;
+	/** The corners themselves, without the preview one. */
+	private _screenCorners;
+	private _drawHandle;
+	private _rgba;
+	private _hitTestPrimitive;
+	hitTest(x: number, y: number): boolean;
+	/** Index of the corner under the pointer, or null. */
+	hitTestEndpoint(x: number, y: number): number | null;
+	startDrag(target: number | "shape", grab: DragAnchor): void;
+	updateDrag(time: Time, price: number): void;
+	stopDrag(): void;
+	setColor(color: string): void;
+	color(): string;
+	setSelected(selected: boolean): void;
+	isSelected(): boolean;
+	setHovered(hovered: boolean): void;
+	isHovered(): boolean;
+	/** The corners, for callers that need the shape rather than its picture. */
+	points(): readonly PolygonVertex[];
+	remove(): void;
+	protected _serializeShape(): SerializedDrawingTool;
+}
 export declare class PositionCalculator {
 	private _pipConfig;
 	constructor(pipConfig: PipConfig);
@@ -1099,6 +1335,12 @@ export declare class RulerTool extends DrawingToolBase {
 	private _createPaneView;
 	private _initializeInteractiveMode;
 	drawToCanvas(ctx: CanvasRenderingContext2D, horizontalPixelRatio: number, verticalPixelRatio: number): void;
+	/**
+	 * Marks the span on the axis being measured: a price range gets horizontal
+	 * caps at each level, a date range vertical ones at each moment. Without
+	 * them a diagonal line between two points reads as a trend line.
+	 */
+	private _drawBracket;
 	private _drawEndpoint;
 	private _drawPreview;
 	private _drawLabel;
@@ -1221,7 +1463,17 @@ export declare class TradingSessionsIndicator {
 	private _isTimeInSession;
 	private _getUTCHour;
 	private _clearSessionBoxes;
-	updateOptions(options: Partial<TradingSessionsOptions>): void;
+	/**
+	 * Merge options into the running indicator and repaint.
+	 *
+	 * The repaint is unconditional on purpose: the disabled branch only drops the
+	 * boxes from the model, and `_updateSessionHighlights` bails out early when
+	 * there is no visible range or no data. Without it, either path leaves the
+	 * boxes it just cleared on screen until something else happens to redraw.
+	 */
+	applyOptions(options: Partial<TradingSessionsOptions>): void;
+	/** The options currently in effect, defaults included. */
+	options(): Required<TradingSessionsOptions>;
 	enable(): void;
 	disable(): void;
 	remove(): void;
@@ -1248,6 +1500,24 @@ export declare class TrendLineTool extends DrawingToolBase {
 	private _initializeInteractiveMode;
 	private _createPrimitive;
 	private _createPaneView;
+	/**
+	 * The segment actually drawn, in CSS pixels, extensions included.
+	 *
+	 * Drawing and hit-testing have to agree on this: with the geometry inlined in
+	 * the renderer, a ray was painted across the chart but only pickable between
+	 * its two handles.
+	 */
+	private _drawnSegment;
+	/**
+	 * The level the axis label reports: where the line is at its right-hand end.
+	 * For a ray that is the chart edge, which is the level it is acting as
+	 * support or resistance at right now.
+	 *
+	 * A steep ray leaves the visible range long before the edge, and a label
+	 * outside the scale is simply not drawn — so it falls back to the handle,
+	 * which is always somewhere the user put it.
+	 */
+	private _labelPrice;
 	drawToCanvas(ctx: CanvasRenderingContext2D, horizontalPixelRatio: number, verticalPixelRatio: number): void;
 	private _drawPreview;
 	private _drawEndpoint;
@@ -1331,11 +1601,17 @@ export declare class VolumeProfileIndicator {
 	addVolumeData(time: Time, volume: number): void;
 	private _calculateProfile;
 	getProfileData(): VolumeProfileData | null;
-	updateOptions(options: Partial<VolumeProfileOptions>): void;
+	/**
+	 * Merge options into the running indicator and repaint. `_calculateProfile`
+	 * returns early without redrawing when there is no data yet, so the repaint
+	 * is asked for here rather than left to it.
+	 */
+	applyOptions(options: Partial<VolumeProfileOptions>): void;
 	remove(): void;
 	getChart(): IChartApi;
 	getSeries(): ISeriesApi<SeriesType>;
-	getOptions(): Required<VolumeProfileOptions>;
+	/** The options currently in effect, defaults included. */
+	options(): Required<VolumeProfileOptions>;
 	private _requestUpdate;
 }
 export declare const DEFAULT_SESSIONS: TradingSession[];
@@ -1547,98 +1823,253 @@ export declare enum TrackingModeExitMode {
 	 */
 	OnNextTap = 1
 }
+/**
+ * Average Directional Index, with the +DI/-DI pair it is read against.
+ *
+ * ADX measures how strong a trend is without saying which way it goes; the
+ * directional lines say which side is in control. All three are bounded to
+ * 0-100, so the pane is pinned to that range.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - ADX configuration
+ * @returns The three series, plus live control over the options
+ */
+export declare function applyADX(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: ADXOptions): IndicatorRuntime<ADXOptions> & {
+	adx: ISeriesApi<"Line">;
+	plusDI: ISeriesApi<"Line">;
+	minusDI: ISeriesApi<"Line">;
+};
 /**
  * Apply ATR (Average True Range) indicator to a series
  * @param series - Source series
  * @param chart - Chart instance
  * @param options - ATR configuration
- * @returns The ATR line series
+ * @returns The ATR line series, plus live control over its options
  */
-export declare function applyATR(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: ATROptions): {
+export declare function applyATR(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: ATROptions): IndicatorRuntime<ATROptions> & {
 	series: ISeriesApi<"Line">;
-	remove(): void;
 };
 /**
  * Apply Bollinger Bands indicator to a series
  * @param series - Source series
  * @param chart - Chart instance
  * @param options - Bollinger Bands configuration
- * @returns Object with upper, middle, and lower band series
+ * @returns The three band series, plus live control over the options
  */
-export declare function applyBollingerBands(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: BollingerBandsOptions): {
+export declare function applyBollingerBands(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: BollingerBandsOptions): IndicatorRuntime<BollingerBandsOptions> & {
+	upper: ISeriesApi<"Line">;
+	middle: ISeriesApi<"Line">;
+	lower: ISeriesApi<"Line">;
+};
+/**
+ * Commodity Channel Index.
+ *
+ * Unlike RSI or the stochastic it is not bounded, so the pane is left to
+ * autoscale; the ±100 levels are what give it a frame of reference.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - CCI configuration
+ * @returns The CCI line series, plus live control over its options
+ */
+export declare function applyCCI(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: CCIOptions): IndicatorRuntime<CCIOptions> & {
+	series: ISeriesApi<"Line">;
+};
+/**
+ * Donchian Channels: the highest high and lowest low of the last N bars.
+ *
+ * The bands are the breakout levels themselves, so unlike Bollinger or Keltner
+ * they are flat until price makes a new extreme.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - Donchian configuration
+ * @returns The three band series, plus live control over the options
+ */
+export declare function applyDonchianChannels(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: DonchianOptions): IndicatorRuntime<DonchianOptions> & {
 	upper: ISeriesApi<"Line">;
 	middle: ISeriesApi<"Line">;
 	lower: ISeriesApi<"Line">;
-	remove(): void;
 };
 /**
  * Apply EMA (Exponential Moving Average) indicator to a series
  * @param series - Source series to calculate EMA from
  * @param chart - Chart instance
  * @param options - EMA configuration options
- * @returns The EMA line series
+ * @returns The EMA line series, plus live control over its options
  */
-export declare function applyEMA(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: EMAOptions): {
+export declare function applyEMA(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: EMAOptions): IndicatorRuntime<EMAOptions> & {
 	series: ISeriesApi<"Line">;
-	remove(): void;
+};
+/**
+ * Ichimoku Kinko Hyo.
+ *
+ * Five lines, two of which are projected `displacement` bars into the future
+ * and one pushed the same distance into the past. The area between the two
+ * leading spans — the cloud — is filled by a primitive, since the engine draws
+ * lines but nothing between them.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - Ichimoku configuration
+ * @returns The five line series, plus live control over the options
+ */
+export declare function applyIchimoku(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: IchimokuOptions): IndicatorRuntime<IchimokuOptions> & {
+	conversion: ISeriesApi<"Line">;
+	base: ISeriesApi<"Line">;
+	spanA: ISeriesApi<"Line">;
+	spanB: ISeriesApi<"Line">;
+	lagging: ISeriesApi<"Line">;
+};
+/**
+ * Keltner Channels: an EMA with bands a multiple of the ATR away.
+ *
+ * Reads like Bollinger but the width follows the true range rather than the
+ * standard deviation, so gaps widen it where Bollinger would ignore them.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - Keltner configuration
+ * @returns The three band series, plus live control over the options
+ */
+export declare function applyKeltnerChannels(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: KeltnerOptions): IndicatorRuntime<KeltnerOptions> & {
+	upper: ISeriesApi<"Line">;
+	middle: ISeriesApi<"Line">;
+	lower: ISeriesApi<"Line">;
 };
 /**
  * Apply MACD indicator to a series
  * @param series - Source series
  * @param chart - Chart instance
  * @param options - MACD configuration
- * @returns Object with macd, signal, and histogram series
+ * @returns The three series, plus live control over the options
  */
-export declare function applyMACD(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: MACDOptions): {
+export declare function applyMACD(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: MACDOptions): IndicatorRuntime<MACDOptions> & {
 	macd: ISeriesApi<"Line">;
 	signal: ISeriesApi<"Line">;
 	histogram: ISeriesApi<"Histogram">;
-	remove(): void;
+};
+/**
+ * Money Flow Index — an RSI weighted by volume.
+ *
+ * Needs volumes: feed them with `setSeriesVolumes` before adding it, or it has
+ * nothing to weigh and draws nothing.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - MFI configuration
+ * @returns The MFI line series, plus live control over its options
+ */
+export declare function applyMFI(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: MFIOptions): IndicatorRuntime<MFIOptions> & {
+	series: ISeriesApi<"Line">;
 };
 /**
  * Apply OBV (On-Balance Volume) indicator to a series
  * @param series - Source series
  * @param chart - Chart instance
  * @param options - OBV configuration
- * @returns The OBV line series
+ * @returns The OBV line series, plus live control over its options
  */
-export declare function applyOBV(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: OBVOptions): {
+export declare function applyOBV(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: OBVOptions): IndicatorRuntime<OBVOptions> & {
+	series: ISeriesApi<"Line">;
+};
+/**
+ * Parabolic SAR: a dot per bar marking where the current trend would reverse.
+ *
+ * Drawn as a line series with the line hidden and its point markers on — the
+ * dots are the indicator, and joining them would draw a shape that means
+ * nothing, least of all across a trend flip.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - SAR configuration
+ * @returns The dot series, plus live control over the options
+ */
+export declare function applyParabolicSAR(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: ParabolicSAROptions): IndicatorRuntime<ParabolicSAROptions> & {
 	series: ISeriesApi<"Line">;
-	remove(): void;
+};
+/**
+ * Classic (floor trader) pivot points.
+ *
+ * Each session's levels come from the previous session's high, low and close,
+ * so they are flat for the whole session and step when a new one starts. The
+ * first session has nothing behind it and is left blank rather than drawn from
+ * its own — incomplete — range.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - Pivot configuration
+ * @returns The level series, plus live control over the options
+ */
+export declare function applyPivotPoints(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: PivotPointsOptions): IndicatorRuntime<PivotPointsOptions> & {
+	pivot: ISeriesApi<"Line">;
+	resistances: ISeriesApi<"Line">[];
+	supports: ISeriesApi<"Line">[];
 };
 /**
  * Apply RSI indicator to a series
  * @param series - Source series to calculate RSI from
  * @param chart - Chart instance to add the indicator to
  * @param options - RSI configuration options
- * @returns The RSI line series
+ * @returns The RSI line series, plus live control over its options
  */
-export declare function applyRSI(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: RSIOptions): {
+export declare function applyRSI(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: RSIOptions): IndicatorRuntime<RSIOptions> & {
 	series: ISeriesApi<"Line">;
-	remove(): void;
 };
 /**
  * Apply SMA (Simple Moving Average) indicator to a series
  * @param series - Source series to calculate SMA from
  * @param chart - Chart instance
  * @param options - SMA configuration options
- * @returns The SMA line series
+ * @returns The SMA line series, plus live control over its options
  */
-export declare function applySMA(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: SMAOptions): {
+export declare function applySMA(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: SMAOptions): IndicatorRuntime<SMAOptions> & {
 	series: ISeriesApi<"Line">;
-	remove(): void;
 };
 /**
  * Apply Stochastic Oscillator indicator to a series
  * @param series - Source series
  * @param chart - Chart instance
  * @param options - Stochastic configuration
- * @returns Object with %K and %D line series
+ * @returns The %K and %D series, plus live control over the options
  */
-export declare function applyStochastic(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: StochasticOptions): {
+export declare function applyStochastic(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: StochasticOptions): IndicatorRuntime<StochasticOptions> & {
 	k: ISeriesApi<"Line">;
 	d: ISeriesApi<"Line">;
-	remove(): void;
+};
+/**
+ * SuperTrend: an ATR band that follows price and flips side on a close through
+ * it, drawn below price in an uptrend and above it in a downtrend.
+ *
+ * The bands only ever tighten while the trend holds — that ratchet is what
+ * makes it a trailing stop rather than a pair of envelopes.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - SuperTrend configuration
+ * @returns The trend line, plus live control over the options
+ */
+export declare function applySuperTrend(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: SuperTrendOptions): IndicatorRuntime<SuperTrendOptions> & {
+	series: ISeriesApi<"Line">;
+};
+/**
+ * Volume Weighted Average Price, restarted every session.
+ *
+ * Needs volumes: feed them with `setSeriesVolumes` first, or it has nothing to
+ * weigh. The optional bands are the standard deviation of price around the
+ * running average, which is what makes VWAP readable as a range rather than a
+ * single line.
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - VWAP configuration
+ * @returns The average and its bands, plus live control over the options
+ */
+export declare function applyVWAP(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: VWAPOptions): IndicatorRuntime<VWAPOptions> & {
+	series: ISeriesApi<"Line">;
+	upper: ISeriesApi<"Line">;
+	lower: ISeriesApi<"Line">;
 };
 /**
  * Apply Volume indicator to a series
@@ -1646,22 +2077,34 @@ export declare function applyStochastic(series: ISeriesApi<SeriesType>, chart: I
  * @param series - Source series to sync with
  * @param chart - Chart instance
  * @param options - Volume configuration
- * @returns The Volume histogram series
+ * @returns The Volume histogram series, plus live control over its options
  */
-export declare function applyVolume(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: VolumeOptions): {
+export declare function applyVolume(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: VolumeOptions): IndicatorRuntime<VolumeOptions> & {
 	series: ISeriesApi<"Histogram">;
-	remove(): void;
 };
 /**
  * Apply WMA (Weighted Moving Average) indicator to a series
  * @param series - Source series to calculate WMA from
  * @param chart - Chart instance
  * @param options - WMA configuration options
- * @returns The WMA line series
+ * @returns The WMA line series, plus live control over its options
  */
-export declare function applyWMA(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: WMAOptions): {
+export declare function applyWMA(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: WMAOptions): IndicatorRuntime<WMAOptions> & {
+	series: ISeriesApi<"Line">;
+};
+/**
+ * Williams %R.
+ *
+ * Runs from -100 to 0 — inverted against the stochastic it mirrors — so the
+ * pane is pinned to that range and overbought sits at the top (-20).
+ *
+ * @param series - Source series
+ * @param chart - Chart instance
+ * @param options - Williams %R configuration
+ * @returns The %R line series, plus live control over its options
+ */
+export declare function applyWilliamsR(series: ISeriesApi<SeriesType>, chart: IChartApi, options?: WilliamsROptions): IndicatorRuntime<WilliamsROptions> & {
 	series: ISeriesApi<"Line">;
-	remove(): void;
 };
 /**
  * Automatically calculate pip configuration based on price
@@ -1696,6 +2139,7 @@ export declare function createChart(container: string | HTMLElement, options?: D
  */
 export declare function createChartEx<HorzScaleItem, THorzScaleBehavior extends IHorzScaleBehavior<HorzScaleItem>>(container: string | HTMLElement, horzScaleBehavior: THorzScaleBehavior, options?: DeepPartial<ReturnType<THorzScaleBehavior["options"]>>): IChartApiBase<HorzScaleItem>;
 export declare function createCircleTool(context: DrawingContext, options: CircleToolOptions): CircleTool;
+export declare function createCrossLineTool(context: DrawingContext, options: CrossLineToolOptions): CrossLineTool;
 export declare function createFibonacciExtensionTool(context: DrawingContext, options: FibonacciExtensionOptions): FibonacciExtensionTool;
 export declare function createFibonacciFanTool(context: DrawingContext, options: FibonacciFanToolOptions): FibonacciFanTool;
 /**
@@ -1757,6 +2201,9 @@ export declare function createInteractiveLineManager(chart: IChartApi, series: I
  * @returns An instance of IChartApiBase configured for price-based horizontal scaling.
  */
 export declare function createOptionsChart(container: string | HTMLElement, options?: DeepPartial<PriceChartOptions>): IChartApiBase<number>;
+export declare function createParallelChannelTool(context: DrawingContext, options: ParallelChannelToolOptions): ParallelChannelTool;
+export declare function createPitchforkTool(context: DrawingContext, options: PitchforkToolOptions): PitchforkTool;
+export declare function createPolygonTool(context: DrawingContext, options: PolygonToolOptions): PolygonTool;
 /**
  * Crea un gestor de marcadores de posiciones de trading
  *
@@ -1993,23 +2440,8 @@ export declare function isBusinessDay(time: Time): time is BusinessDay;
  * @returns `true` if `time` is a {@link UTCTimestamp} number, false otherwise.
  */
 export declare function isUTCTimestamp(time: Time): time is UTCTimestamp;
-/**
- * Set volume data for OBV calculation
- * @param series - The candlestick series
- * @param data - Array with volume field
- */
-export declare function setOBVVolumeData(series: ISeriesApi<SeriesType>, data: any[]): void;
-/**
- * Set volume data for a series
- * Call this function when you set data to your candlestick series
- * @param series - The candlestick series
- * @param data - Array with volume field
- * @example
- * const data = [{time: '2024-01-01', open: 100, high: 105, low: 99, close: 103, volume: 1000000}, ...];
- * candleSeries.setData(data);
- * setVolumeData(candleSeries, data); // Store volume for indicators
- */
-export declare function setVolumeData(series: ISeriesApi<SeriesType>, data: any[]): void;
+/** Replaces the volumes known for a series. */
+export declare function setSeriesVolumes(series: ISeriesApi<SeriesType>, data: readonly any[]): void;
 export declare function setVolumeProfileData(indicator: VolumeProfileIndicator, data: Array<{
 	time: Time;
 	volume: number;
@@ -2022,11 +2454,28 @@ export declare function timeFromCoordinate(chart: IChartApi, series: ISeriesApi<
  * Returns the current version as a string. For example `'1.0.0'`.
  */
 export declare function version(): string;
+export interface ADXOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	period?: number;
+	colorADX?: string;
+	colorPlusDI?: string;
+	colorMinusDI?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+	/** Trend-strength threshold drawn across the pane. Null hides it. */
+	threshold?: number | null;
+	levelColor?: string;
+	/** Whether the two directional lines are drawn alongside the ADX. */
+	showDI?: boolean;
+}
 export interface ATROptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	period?: number;
 	color?: string;
+	lineWidth?: number;
 }
 /**
  * Structure describing a single item of data for area series
@@ -2449,13 +2898,15 @@ export interface BaselineStyleOptions {
 	lastPriceAnimation: LastPriceAnimationMode;
 }
 export interface BollingerBandsOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	period?: number;
 	stdDev?: number;
 	colorUpper?: string;
 	colorMiddle?: string;
 	colorLower?: string;
+	/** Width of the outer bands. The middle band is drawn one step thicker. */
+	lineWidth?: number;
 }
 export interface BrushPoint {
 	time: Time;
@@ -2495,6 +2946,19 @@ export interface BusinessDay {
 	 */
 	day: number;
 }
+export interface CCIOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	period?: number;
+	color?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+	/** Reference levels drawn across the pane. Null hides one. */
+	overbought?: number | null;
+	oversold?: number | null;
+	levelColor?: string;
+}
 /**
  * Structure describing a single item of data for candlestick series
  */
@@ -2707,6 +3171,17 @@ export interface ControllableLine {
 	cancelDrag(): void;
 	click(): void;
 }
+export interface CrossLineToolOptions extends DrawingToolOptions {
+	time?: Time;
+	price?: number;
+	lineColor?: string;
+	lineWidth?: number;
+	lineStyle?: "solid" | "dashed" | "dotted";
+	/** Show the level on the price axis. */
+	showPriceLabel?: boolean;
+	onUpdate?: () => void;
+	onRemove?: () => void;
+}
 /** Structure describing a crosshair line (vertical or horizontal) */
 export interface CrosshairLineOptions {
 	/**
@@ -2827,6 +3302,19 @@ export interface CustomStyleOptions {
 	 */
 	color: string;
 }
+export interface DonchianOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	period?: number;
+	colorUpper?: string;
+	colorMiddle?: string;
+	colorLower?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+	/** Whether the midline between the two extremes is drawn. */
+	showMiddle?: boolean;
+}
 /**
  * Pointer position captured when a drag gesture starts. Whole-object moves are
  * computed as an offset from this anchor, so the object keeps its position
@@ -2920,10 +3408,15 @@ export interface DrawingUtils {
 	readonly setLineStyle: (ctx: CanvasRenderingContext2D, lineStyle: LineStyle) => void;
 }
 export interface EMAOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	period?: number;
 	color?: string;
+	lineWidth?: number;
+	/** Which price of each bar to compute from. Defaults to the close. */
+	source?: IndicatorSource;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
 }
 export interface FibonacciExtensionLevel {
 	level: number;
@@ -2990,6 +3483,15 @@ export interface FibonacciToolOptions extends DrawingToolOptions {
 	point2Time?: Time;
 	point2Price?: number;
 	useExtended?: boolean;
+	/**
+	 * The levels to draw, as plain ratios. Overrides `useExtended`, which only
+	 * picks between two fixed sets — traders keep their own, and dropping the
+	 * ones they do not read is half the point of the tool.
+	 *
+	 * Numbers rather than `{ ratio, label }` objects on purpose: these cross the
+	 * boundary to the app, and the build-time mangler renames object keys.
+	 */
+	levels?: number[];
 	interactive?: boolean;
 	lineColor?: string;
 	lineWidth?: number;
@@ -3139,11 +3641,18 @@ export interface HistogramStyleOptions {
 export interface HorizontalLineToolOptions extends DrawingToolOptions {
 	price?: number;
 	interactive?: boolean;
+	/**
+	 * Where the line starts. Left undefined it spans the whole chart; set, the
+	 * line only runs from there to the right edge — a horizontal ray.
+	 */
+	startTime?: Time;
 	lineColor?: string;
 	lineWidth?: number;
 	lineStyle?: "solid" | "dashed" | "dotted";
 	showLabel?: boolean;
 	labelText?: string;
+	/** Show the level on the price axis. */
+	showPriceLabel?: boolean;
 	onUpdate?: () => void;
 	onRemove?: () => void;
 }
@@ -4781,6 +5290,29 @@ export interface IYieldCurveChartApi extends Omit<IChartApiBase<number>, "addSer
 	 */
 	addSeries<T extends YieldCurveSeriesType>(definition: SeriesDefinition<T>, options?: SeriesPartialOptionsMap[T], paneIndex?: number): ISeriesApi<T, number, WhitespaceData<number> | LineData<number>>;
 }
+export interface IchimokuOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	/** Period of the conversion line (Tenkan-sen). */
+	conversionPeriod?: number;
+	/** Period of the base line (Kijun-sen). */
+	basePeriod?: number;
+	/** Period of the second leading span (Senkou Span B). */
+	spanBPeriod?: number;
+	/** How far the cloud is projected forward and the lagging span pushed back. */
+	displacement?: number;
+	colorConversion?: string;
+	colorBase?: string;
+	colorSpanA?: string;
+	colorSpanB?: string;
+	colorLagging?: string;
+	cloudBullishColor?: string;
+	cloudBearishColor?: string;
+	cloudOpacity?: number;
+	showCloud?: boolean;
+	showLagging?: boolean;
+	lineWidth?: number;
+}
 export interface ImageWatermarkOptions {
 	/**
 	 * Maximum width for the image watermark.
@@ -4809,6 +5341,48 @@ export interface ImageWatermarkOptions {
 	 */
 	alpha: number;
 }
+/**
+ * What every indicator returns. Options can be changed on a live indicator, so
+ * a chart never has to drop and rebuild one to restyle it or move its period.
+ *
+ * `TOptions` is the indicator's own public options interface, with defaults
+ * already resolved: `options()` always answers with a complete set.
+ */
+export interface IndicatorRuntime<TOptions extends object> {
+	/**
+	 * Remove the indicator: drops its series and stops listening to the source.
+	 * Without this the subscription outlives the indicator and keeps writing to
+	 * a series that no longer exists.
+	 */
+	remove(): void;
+	/** Force a full recalculation. */
+	recalculate(): void;
+	/**
+	 * Merge options into the running indicator. Style-only changes restyle the
+	 * series; anything listed in `recomputeOn` also recalculates. `paneIndex` is
+	 * fixed at creation and ignored here.
+	 */
+	applyOptions(next: Partial<TOptions>): void;
+	/** The options currently in effect, defaults included. */
+	options(): TOptions;
+}
+export interface KeltnerOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	/** Period of the exponential moving average at the centre. */
+	period?: number;
+	/** Period of the average true range that sets the width. */
+	atrPeriod?: number;
+	/** How many ATRs the bands sit from the centre. */
+	multiplier?: number;
+	source?: IndicatorSource;
+	colorUpper?: string;
+	colorMiddle?: string;
+	colorLower?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+}
 /**
  * Represents options for enabling or disabling kinetic scrolling with mouse and touch gestures.
  */
@@ -5105,14 +5679,29 @@ export interface LocalizationOptionsBase {
 	tickmarksPercentageFormatter?: TickmarksPercentageFormatterFn;
 }
 export interface MACDOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	fastPeriod?: number;
 	slowPeriod?: number;
 	signalPeriod?: number;
 	colorMACD?: string;
 	colorSignal?: string;
-	colorHistogram?: string;
+	colorHistogramUp?: string;
+	colorHistogramDown?: string;
+	lineWidth?: number;
+}
+export interface MFIOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	period?: number;
+	color?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+	/** Reference levels drawn across the pane. Null hides one. */
+	overbought?: number | null;
+	oversold?: number | null;
+	levelColor?: string;
 }
 /**
  * Represents a mouse event.
@@ -5159,9 +5748,10 @@ export interface MouseEventParams<HorzScaleItem = Time> {
 	sourceEvent?: TouchMouseEventData;
 }
 export interface OBVOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	color?: string;
+	lineWidth?: number;
 	data?: any[];
 }
 /**
@@ -5231,6 +5821,37 @@ export interface PaneSize {
 	/** Width of the Chart Pane (pixels) */
 	width: number;
 }
+export interface ParabolicSAROptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	/** Acceleration factor the trend starts with. */
+	step?: number;
+	/** Ceiling the acceleration factor is capped at. */
+	maxStep?: number;
+	colorUp?: string;
+	colorDown?: string;
+	/** Radius of each dot, in pixels. */
+	dotSize?: number;
+}
+export interface ParallelChannelToolOptions extends DrawingToolOptions {
+	point1Time?: Time;
+	point1Price?: number;
+	point2Time?: Time;
+	point2Price?: number;
+	/** Distance to the parallel line, in price. Signed: negative sits below. */
+	channelWidth?: number;
+	interactive?: boolean;
+	lineColor?: string;
+	lineWidth?: number;
+	lineStyle?: "solid" | "dashed" | "dotted";
+	fillColor?: string;
+	fillOpacity?: number;
+	extendRight?: boolean;
+	showPriceLabel?: boolean;
+	onUpdate?: () => void;
+	onRemove?: () => void;
+	onComplete?: () => void;
+}
 /**
  * Position Calculator - Cálculos de P&L, pips, R:R para trading
  */
@@ -5238,6 +5859,39 @@ export interface PipConfig {
 	pipValue: number;
 	decimals: number;
 }
+export interface PitchforkToolOptions extends DrawingToolOptions {
+	/** The pivot the fork opens from. */
+	pivotTime?: Time;
+	pivotPrice?: number;
+	/** The two points whose midpoint the median line runs through. */
+	upperTime?: Time;
+	upperPrice?: number;
+	lowerTime?: Time;
+	lowerPrice?: number;
+	interactive?: boolean;
+	lineColor?: string;
+	lineWidth?: number;
+	lineStyle?: "solid" | "dashed" | "dotted";
+	fillColor?: string;
+	fillOpacity?: number;
+	onUpdate?: () => void;
+	onRemove?: () => void;
+	onComplete?: () => void;
+}
+export interface PivotPointsOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	/** Session the levels are derived from. */
+	pivotPeriod?: SessionPeriod;
+	/** How many support/resistance pairs to draw, from 1 to 3. */
+	levels?: number;
+	colorPivot?: string;
+	colorResistance?: string;
+	colorSupport?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+}
 /**
  * Represents a point on the chart.
  */
@@ -5251,6 +5905,22 @@ export interface Point {
 	 */
 	readonly y: Coordinate;
 }
+export interface PolygonToolOptions extends DrawingToolOptions {
+	points?: PolygonVertex[];
+	interactive?: boolean;
+	fillColor?: string;
+	fillOpacity?: number;
+	borderColor?: string;
+	borderWidth?: number;
+	borderStyle?: "solid" | "dashed" | "dotted";
+	onUpdate?: () => void;
+	onRemove?: () => void;
+	onComplete?: () => void;
+}
+export interface PolygonVertex {
+	time: Time;
+	price: number;
+}
 /**
  * Opciones para el gestor de posiciones
  */
@@ -5621,10 +6291,19 @@ export interface PrimitiveHoveredItem {
 	isBackground?: boolean;
 }
 export interface RSIOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	period?: number;
 	color?: string;
+	lineWidth?: number;
+	/** Which price of each bar to compute from. Defaults to the close. */
+	source?: IndicatorSource;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+	/** Reference level drawn across the pane. Set to null to hide it. */
+	overbought?: number | null;
+	oversold?: number | null;
+	levelColor?: string;
 }
 export interface RectangleToolOptions extends DrawingToolOptions {
 	time1?: Time;
@@ -5667,6 +6346,12 @@ export interface RulerToolOptions extends DrawingToolOptions {
 	symbol?: string;
 	pipConfig?: PipConfig;
 	interactive?: boolean;
+	/**
+	 * Which axis the measurement is about. Both by default; a price range only
+	 * reports the move, a date range only the elapsed bars, and each draws a
+	 * bracket across the axis it ignores so the reading is unambiguous.
+	 */
+	measure?: "both" | "price" | "time";
 	lineColor?: string;
 	lineWidth?: number;
 	showLabel?: boolean;
@@ -5678,11 +6363,15 @@ export interface RulerToolOptions extends DrawingToolOptions {
 	onRemove?: () => void;
 }
 export interface SMAOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	period?: number;
 	color?: string;
 	lineWidth?: number;
+	/** Which price of each bar to compute from. Defaults to the close. */
+	source?: IndicatorSource;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
 }
 /**
  * Serialized drawing tool data — plain JSON-safe object
@@ -6151,12 +6840,30 @@ export interface SolidColor {
 	color: string;
 }
 export interface StochasticOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	kPeriod?: number;
 	dPeriod?: number;
 	colorK?: string;
 	colorD?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+	/** Reference level drawn across the pane. Set to null to hide it. */
+	overbought?: number | null;
+	oversold?: number | null;
+	levelColor?: string;
+}
+export interface SuperTrendOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	/** Period of the average true range the bands are built from. */
+	period?: number;
+	/** How many ATRs the bands sit from the median price. */
+	multiplier?: number;
+	colorUp?: string;
+	colorDown?: string;
+	lineWidth?: number;
 }
 export interface TextToolOptions extends DrawingToolOptions {
 	time?: Time;
@@ -6460,6 +7167,8 @@ export interface TrendLineToolOptions extends DrawingToolOptions {
 	lineStyle?: "solid" | "dashed" | "dotted";
 	extendLeft?: boolean;
 	extendRight?: boolean;
+	/** Show the line's current level on the price axis. */
+	showPriceLabel?: boolean;
 	onUpdate?: () => void;
 	onRemove?: () => void;
 }
@@ -6484,6 +7193,19 @@ export interface UpDownMarkersPluginOptions {
 	 */
 	updateVisibilityDuration: number;
 }
+export interface VWAPOptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	/** Session the average restarts on. */
+	anchorPeriod?: SessionPeriod;
+	color?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+	/** Standard-deviation bands around the average. 0 hides them. */
+	bandMultiplier?: number;
+	bandColor?: string;
+}
 /**
  * Represents a vertical gradient of two colors.
  */
@@ -6513,13 +7235,15 @@ export interface VerticalLineToolOptions extends DrawingToolOptions {
 	onRemove?: () => void;
 }
 export interface VolumeOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	colorUp?: string;
 	colorDown?: string;
 }
 export interface VolumeProfileData {
 	bins: PriceVolumeBin[];
+	/** Price span each bin covers, so a bin can be drawn as tall as its band. */
+	binSize: number;
 	poc: number;
 	valueAreaHigh: number;
 	valueAreaLow: number;
@@ -6534,14 +7258,20 @@ export interface VolumeProfileOptions {
 	pocColor?: string;
 	valueAreaColor?: string;
 	opacity?: number;
+	/** Width of the histogram in pixels, capped at a fifth of the chart. */
 	width?: number;
 	position?: "left" | "right";
 }
 export interface WMAOptions {
-	/** Pane the indicator is drawn in. Defaults to its historical value. */
+	/** Pane the indicator is drawn in. Fixed at creation. */
 	paneIndex?: number;
 	period?: number;
 	color?: string;
+	lineWidth?: number;
+	/** Which price of each bar to compute from. Defaults to the close. */
+	source?: IndicatorSource;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
 }
 /**
  * Represents a whitespace data item, which is a data point without a value.
@@ -6570,6 +7300,19 @@ export interface WhitespaceData<HorzScaleItem = Time> {
 	 */
 	customValues?: Record<string, unknown>;
 }
+export interface WilliamsROptions {
+	/** Pane the indicator is drawn in. Fixed at creation. */
+	paneIndex?: number;
+	period?: number;
+	color?: string;
+	lineWidth?: number;
+	/** 0 solid, 1 dotted, 2 dashed, 3 large dashed, 4 sparse dotted. */
+	lineStyle?: number;
+	/** Reference levels drawn across the pane. Null hides one. */
+	overbought?: number | null;
+	oversold?: number | null;
+	levelColor?: string;
+}
 /**
  * Extended chart options that include yield curve specific options.
  * This interface combines the standard chart options with yield curve options.
@@ -6671,6 +7414,7 @@ export type CandlestickSeriesOptions = SeriesOptions<CandlestickStyleOptions>;
  * Represents candlestick series options where all properties are optional.
  */
 export type CandlestickSeriesPartialOptions = SeriesPartialOptions<CandlestickStyleOptions>;
+export type ChannelPart = "point1" | "point2" | "width" | "body";
 /**
  * Structure describing options of the chart with time points at the horizontal scale. Series options are to be set separately
  */
@@ -6761,6 +7505,8 @@ export type IPanePrimitive<HorzScaleItem = Time> = IPanePrimitiveBase<PaneAttach
  */
 export type ISeriesPrimitive<HorzScaleItem = Time> = ISeriesPrimitiveBase<SeriesAttachedParameter<HorzScaleItem, SeriesType>>;
 export type ITextWatermarkPluginApi<T> = PrimitiveHasApplyOptions<IPanePrimitiveWrapper<T, TextWatermarkOptions>>;
+/** Which price of each bar an indicator is computed from. */
+export type IndicatorSource = "close" | "open" | "high" | "low" | "hl2" | "hlc3" | "ohlc4";
 /**
  * Internal Horizontal Scale Item
  */
@@ -6843,6 +7589,7 @@ export type OverlayPriceScaleOptions = Omit<PriceScaleOptions, "visible" | "auto
  * A function used to format a percentage value as a string.
  */
 export type PercentageFormatterFn = (percentageValue: number) => string;
+export type PitchforkPart = "pivot" | "upper" | "lower" | "body";
 /**
  * Tipo de posición de trading
  */
@@ -6937,6 +7684,8 @@ export type SeriesPartialOptions<T> = DeepPartial<T & SeriesOptionsCommon>;
  * @see {@link SeriesOptionsMap}
  */
 export type SeriesType = keyof SeriesOptionsMap;
+/** How a series is cut into sessions. */
+export type SessionPeriod = "daily" | "weekly" | "monthly";
 /**
  * A custom function used to handle changes to the time scale's size.
  */