oakscriptjs 0.8.2 → 0.9.0

package/dist/esm/script/index.d.ts

@@ -0,0 +1,987 @@
+/**
+ * @fileoverview PineScript-style script API — write an indicator as a flat
+ * script instead of the explicit calculate() convention.
+ *
+ * ```typescript
+ * import { indicator, input, plot, ta } from 'oakscriptjs/script';
+ *
+ * indicator('My SMA', { overlay: true });
+ * const length = input.int(20, 'Length', { minval: 1 });
+ * const src = input.source('close', 'Source');
+ * plot(ta.sma(src, length), 'SMA', { color: '#2962FF' });
+ * ```
+ *
+ * Execution model: the host calls {@link executeScript} with the script body,
+ * the bars and the current input values. Declaration calls (indicator, input.*,
+ * plot, hline, fill, alertcondition) run as the body executes and are collected
+ * into a {@link ScriptRunResult}: the declarative configs (inputConfig,
+ * plotConfig, hlineConfig, fillConfig) plus an IndicatorResult with the plot
+ * data. Re-running the body with new bars or inputs is PineScript's
+ * recalculation model.
+ *
+ * `input.*` is idempotent like PineScript: it declares the input AND returns
+ * its current value (the host-supplied override, else the default).
+ *
+ * The OHLCV builtins (open/high/low/close/volume/hl2/hlc3/ohlc4/hlcc4) are
+ * Series bound to a module-level BarData that the host swaps per run, so
+ * derived Series memoize between identical runs and recompute when the bars
+ * version bumps.
+ *
+ * One script executes at a time (module-level context) — hosts that run many
+ * scripts must serialize executions, which a Web Worker does naturally.
+ *
+ * @module script
+ */
+import type { Bar } from '../types/index.js';
+import type { ArrowData, BarColorData, IndicatorResult, MarkerData, MarkerLocation, MarkerSize, ShapeStyle, TimeValue } from '../types/metadata.js';
+import type { ArrowConfig, BarColorConfig, FillConfig, HLineConfig, InputConfig, PlotConfig, ShapeConfig } from '../runtime/types.js';
+import { BarData, Series } from '../runtime/series.js';
+import * as taSeries from '../ta-series.js';
+import * as colorCore from '../color/index.js';
+import { isNA, nz } from '../utils/index.js';
+import * as lineCore from '../line/index.js';
+import * as labelCore from '../label/index.js';
+import * as boxCore from '../box/index.js';
+import * as linefillCore from '../linefill/index.js';
+import * as polylineCore from '../polyline/index.js';
+import * as chartPointCore from '../chartpoint/index.js';
+import * as mathCore from '../math/index.js';
+import * as timeframeCore from '../timeframe/index.js';
+import { type SessionSpec } from '../session/calendar.js';
+import type { ChartPoint } from '../types/index.js';
+import { STRATEGY_CONSTANTS, type StrategyCloseAllOptions, type StrategyCloseOptions, type StrategyDirection, type StrategyEngine, type StrategyEntryOptions, type StrategyExitOptions, type StrategyNumberVariable, type StrategyOptions, type StrategyProperties, type StrategyRiskDirection, type StrategyRiskValueType, type StrategyTextVariable, type StrategyTrade } from '../strategy/index.js';
+/** Everything one run of a script produced. */
+export interface ScriptRunResult {
+    metadata: {
+        title: string;
+        shortTitle?: string;
+        overlay: boolean;
+        precision?: number;
+        format?: string;
+    };
+    inputConfig: InputConfig[];
+    plotConfig: PlotConfig[];
+    hlineConfig: HLineConfig[];
+    fillConfig: FillConfig[];
+    shapeConfig: ShapeConfig[];
+    arrowConfig: ArrowConfig[];
+    barColorConfig: BarColorConfig[];
+    defaultInputs: Record<string, unknown>;
+    alertConfig: AlertConditionConfig[];
+    /** Strategy properties (declared values, else the PineScript defaults) when the script declares strategy(). */
+    strategyConfig?: StrategyProperties;
+    /** The renderable output (plots keyed by plotConfig ids, plot-pair fills). */
+    result: IndicatorResult & {
+        alerts?: AlertState[];
+    };
+}
+export interface AlertConditionConfig {
+    id: string;
+    title: string;
+    message?: string;
+}
+/** Per-run alert evaluation: whether the condition is true on the last bar. */
+export interface AlertState {
+    id: string;
+    title: string;
+    message?: string;
+    triggered: boolean;
+}
+/** Handle returned by plot()/hline() so fill() can reference them. */
+export interface PlotHandle {
+    id: string;
+    kind: 'plot' | 'hline';
+}
+/** What the host passes to its strategy engine factory when the script declares strategy(). */
+export interface StrategySetup {
+    properties: StrategyProperties;
+    bars: readonly Bar[];
+    chart: Readonly<ChartContext>;
+}
+export interface ScriptOptions {
+    /** Creates the order engine of a strategy script; called by strategy(). */
+    strategyEngine?: (setup: StrategySetup) => StrategyEngine;
+}
+/**
+ * Runs a script body against `bars` with the given input overrides and
+ * collects everything it declared. `chart` describes the bars (chart timeframe,
+ * exchange time zone, session type) for the PineScript values that depend on them. `options.strategyEngine`
+ * supplies the order engine of strategy scripts. This is the host-side entry — editor
+ * panels, workers and tests call it; scripts never do.
+ */
+export declare function executeScript(body: () => void, barsInput: Bar[], inputs?: Record<string, unknown>, chart?: ChartContext, options?: ScriptOptions): ScriptRunResult;
+export interface IndicatorOptions {
+    shorttitle?: string;
+    overlay?: boolean;
+    precision?: number;
+    format?: string;
+    /** Lines kept before the oldest are deleted (default 50; PineScript keeps up to 5 more). */
+    max_lines_count?: number;
+    /** Labels kept before the oldest are deleted (default 50). */
+    max_labels_count?: number;
+    /** Boxes kept before the oldest are deleted (default 50). */
+    max_boxes_count?: number;
+    /** Polylines kept before the oldest are deleted (default 50). */
+    max_polylines_count?: number;
+}
+/** PineScript `indicator()` — declares the script's metadata. */
+export declare function indicator(title: string, options?: IndicatorOptions): void;
+/** Options of every `input.*` kind (PineScript `group`, `inline`, `tooltip`, `confirm`, `display`). */
+export interface InputOptions {
+    group?: string;
+    inline?: string;
+    tooltip?: string;
+    confirm?: boolean;
+    display?: InputConfig['display'];
+}
+export interface NumericInputOptions extends InputOptions {
+    minval?: number;
+    maxval?: number;
+    step?: number;
+}
+export interface StringInputOptions extends InputOptions {
+    options?: string[];
+}
+/** PineScript `input.*` — declares an input AND returns its current value. */
+export declare const input: {
+    int(defval: number, title?: string, opts?: NumericInputOptions): number;
+    float(defval: number, title?: string, opts?: NumericInputOptions): number;
+    bool(defval: boolean, title?: string, opts?: InputOptions): boolean;
+    string(defval: string, title?: string, opts?: StringInputOptions): string;
+    color(defval: string, title?: string, opts?: InputOptions): string;
+    /** Declares a source input and returns it as a Series. */
+    source(defval?: string, title?: string, opts?: InputOptions): Series;
+    /** Timeframe string ("60", "1D", "W"). As in PineScript, "" means the chart timeframe. */
+    timeframe(defval: string, title?: string, opts?: StringInputOptions): string;
+    /** Session string ("0930-1600", "0930-1600:23456"). */
+    session(defval: string, title?: string, opts?: StringInputOptions): string;
+    /** Date and time as a UNIX time in milliseconds, e.g. `input.time(timestamp('2024-01-01'), 'Start')`. */
+    time(defval: number, title?: string, opts?: InputOptions): number;
+};
+export declare const open: Series;
+export declare const high: Series;
+export declare const low: Series;
+export declare const close: Series;
+export declare const volume: Series;
+export declare const hl2: Series;
+export declare const hlc3: Series;
+export declare const ohlc4: Series;
+export declare const hlcc4: Series;
+/** ta.* with the chart-implicit (bars-first) functions bound to the context,
+ *  so scripts call them like PineScript: `ta.tr(true)`, `ta.atr(14)`. */
+export declare const ta: {
+    tr: (handleNa?: boolean) => Series;
+    atr: (length: number) => Series;
+    sar: (start?: number, inc?: number, max?: number) => Series;
+    wpr: (length?: number) => Series;
+    supertrend: (factor: number, atrLength: number) => [Series, Series];
+    dmi: (diLength: number, adxSmoothing: number) => [Series, Series, Series];
+    kc: (source: Series, length: number, mult: number, useTrueRange?: boolean) => [Series, Series, Series];
+    kcw: (source: Series, length?: number, mult?: number, useTrueRange?: boolean) => Series;
+    ichimoku: (conversionPeriods: number, basePeriods: number, laggingSpan2Periods: number, displacement: number) => [Series, Series, Series, Series, Series];
+    /** `ta.highest(source, length)` or `ta.highest(length)` (source = high). */
+    highest: (sourceOrLength: Series | number, length?: number) => Series;
+    /** `ta.lowest(source, length)` or `ta.lowest(length)` (source = low). */
+    lowest: (sourceOrLength: Series | number, length?: number) => Series;
+    /** `ta.highestbars(source, length)` or `ta.highestbars(length)` (source = high); offsets are 0 or negative. */
+    highestbars: (sourceOrLength: Series | number, length?: number) => Series;
+    /** `ta.lowestbars(source, length)` or `ta.lowestbars(length)` (source = low); offsets are 0 or negative. */
+    lowestbars: (sourceOrLength: Series | number, length?: number) => Series;
+    /** `ta.vwap(source, anchor?, stdev_mult?)` with the chart volume; the default anchor is a new trading
+     *  day (`timeframe.change("1D")`), which needs the chart context (timeframe, time zone, session). */
+    vwap: {
+        (source: Series, anchor?: Series): Series;
+        (source: Series, anchor: Series | undefined, stdev_mult: number): [Series, Series, Series];
+    };
+    /** `ta.mfi(source, length)` with the chart volume (PineScript takes 2 arguments). */
+    mfi: (source: Series, length: number) => Series;
+    /** `ta.pivothigh(source, leftbars, rightbars)` or `ta.pivothigh(leftbars, rightbars)` (source = high).
+     *  The value appears `rightbars` bars after the pivot bar, as in PineScript. */
+    pivothigh: (sourceOrLeft: Series | number, leftOrRight: number, rightbars?: number) => Series;
+    /** `ta.pivotlow(source, leftbars, rightbars)` or `ta.pivotlow(leftbars, rightbars)` (source = low). */
+    pivotlow: (sourceOrLeft: Series | number, leftOrRight: number, rightbars?: number) => Series;
+    obv: Series;
+    pvt: Series;
+    accdist: Series;
+    nvi: Series;
+    pvi: Series;
+    iii: Series;
+    wad: Series;
+    wvad: Series;
+    sma(source: Series, length: number): Series;
+    ema(source: Series, length: number): Series;
+    wma(source: Series, length: number): Series;
+    rma(source: Series, length: number): Series;
+    rsi(source: Series, length: number): Series;
+    macd(source: Series, fastLength: number, slowLength: number, signalLength: number): [Series, Series, Series];
+    bb(source: Series, length: number, mult: number): [Series, Series, Series];
+    stdev(source: Series, length: number, biased?: boolean): Series;
+    stoch(source: Series, high: Series, low: Series, length: number): Series;
+    crossover(source1: Series, source2: Series | number): Series;
+    crossunder(source1: Series, source2: Series | number): Series;
+    cross(source1: Series, source2: Series | number): Series;
+    change(source: Series, length?: number): Series;
+    mom(source: Series, length: number): Series;
+    roc(source: Series, length: number): Series;
+    rising(source: Series, length: number): Series;
+    falling(source: Series, length: number): Series;
+    cum(source: Series): Series;
+    vwapBands(source: Series, volume: Series, anchor: Series | undefined, stdev_mult: number): [Series, Series, Series];
+    vwma(source: Series, length: number, volume: Series): Series;
+    linreg(source: Series, length: number, offset?: number): Series;
+    alma(source: Series, length?: number, offset?: number, sigma?: number, floor?: boolean): Series;
+    zigzag(bars: Bar[], deviation?: number, depth?: number, backstep?: number): [Series, Series, Series];
+    cci(source: Series, length: number): Series;
+    dev(source: Series, length: number): Series;
+    variance(source: Series, length: number, biased?: boolean): Series;
+    median(source: Series, length: number): Series;
+    swma(source: Series): Series;
+    correlation(source1: Series, source2: Series, length: number): Series;
+    percentrank(source: Series, length: number): Series;
+    hma(source: Series, length: number): Series;
+    barssince(condition: Series): Series;
+    valuewhen(condition: Series, source: Series, occurrence: number): Series;
+    tsi(source: Series, shortLength: number, longLength: number): Series;
+    cmo(source: Series, length: number): Series;
+    bbw(source: Series, length: number, mult: number): Series;
+    range(source: Series, length: number): Series;
+    max(source: Series): Series;
+    min(source: Series): Series;
+    cog(source: Series, length?: number): Series;
+    mode(source: Series, length: number): Series;
+    percentile_linear_interpolation(source: Series, length: number, percentage: number): Series;
+    percentile_nearest_rank(source: Series, length: number, percentage: number): Series;
+    rci(source: Series, length: number): Series;
+    ta: {
+        sma: typeof taSeries.sma;
+        ema: typeof taSeries.ema;
+        wma: typeof taSeries.wma;
+        vwma: typeof taSeries.vwma;
+        rma: typeof taSeries.rma;
+        rsi: typeof taSeries.rsi;
+        macd: typeof taSeries.macd;
+        bb: typeof taSeries.bb;
+        stdev: typeof taSeries.stdev;
+        atr: typeof taSeries.atr;
+        tr: typeof taSeries.tr;
+        stoch: typeof taSeries.stoch;
+        crossover: typeof taSeries.crossover;
+        crossunder: typeof taSeries.crossunder;
+        cross: typeof taSeries.cross;
+        change: typeof taSeries.change;
+        mom: typeof taSeries.mom;
+        roc: typeof taSeries.roc;
+        highest: typeof taSeries.highest;
+        lowest: typeof taSeries.lowest;
+        rising: typeof taSeries.rising;
+        falling: typeof taSeries.falling;
+        cum: typeof taSeries.cum;
+        supertrend: typeof taSeries.supertrend;
+        vwap: typeof taSeries.vwap;
+        ichimoku: typeof taSeries.ichimoku;
+        linreg: typeof taSeries.linreg;
+        alma: typeof taSeries.alma;
+        zigzag: typeof taSeries.zigzag;
+        cci: typeof taSeries.cci;
+        sar: typeof taSeries.sar;
+        dev: typeof taSeries.dev;
+        variance: typeof taSeries.variance;
+        median: typeof taSeries.median;
+        swma: typeof taSeries.swma;
+        correlation: typeof taSeries.correlation;
+        percentrank: typeof taSeries.percentrank;
+        mfi: typeof taSeries.mfi;
+        hma: typeof taSeries.hma;
+        pivothigh: typeof taSeries.pivothigh;
+        pivotlow: typeof taSeries.pivotlow;
+        barssince: typeof taSeries.barssince;
+        valuewhen: typeof taSeries.valuewhen;
+        dmi: typeof taSeries.dmi;
+        tsi: typeof taSeries.tsi;
+        cmo: typeof taSeries.cmo;
+        kc: typeof taSeries.kc;
+        bbw: typeof taSeries.bbw;
+        wpr: typeof taSeries.wpr;
+        kcw: typeof taSeries.kcw;
+        range: typeof taSeries.range;
+        highestbars: typeof taSeries.highestbars;
+        lowestbars: typeof taSeries.lowestbars;
+        max: typeof taSeries.max;
+        min: typeof taSeries.min;
+        vwapBands: typeof taSeries.vwapBands;
+        obv: typeof taSeries.obv;
+        pvt: typeof taSeries.pvt;
+        accdist: typeof taSeries.accdist;
+        nvi: typeof taSeries.nvi;
+        pvi: typeof taSeries.pvi;
+        iii: typeof taSeries.iii;
+        wad: typeof taSeries.wad;
+        wvad: typeof taSeries.wvad;
+        cog: typeof taSeries.cog;
+        mode: typeof taSeries.mode;
+        percentile_linear_interpolation: typeof taSeries.percentile_linear_interpolation;
+        percentile_nearest_rank: typeof taSeries.percentile_nearest_rank;
+        rci: typeof taSeries.rci;
+    };
+};
+/** PineScript `fixnan(source)`: each `na` value becomes the previous non-`na` value.
+ *  Accepts a Series or a per-bar color array (`undefined` = `na`, as returned by `color.when`). */
+export declare function fixnan(source: Series): Series;
+export declare function fixnan(source: Array<string | undefined>): Array<string | undefined>;
+/** Per-bar color selection: truthy → colorTrue, else colorFalse.
+ *  colorFalse may be omitted (PineScript `na`): those bars get no color,
+ *  which bgcolor()/barcolor() skip. */
+declare function colorWhen(cond: Series, colorTrue: string, colorFalse: string): string[];
+declare function colorWhen(cond: Series, colorTrue: string, colorFalse?: string): Array<string | undefined>;
+/** color.* plus `when` — per-bar conditional colors for plot()/fill()/bgcolor()/barcolor(). */
+export declare const color: {
+    new: typeof colorCore.new_color;
+    when: typeof colorWhen;
+    rgb(red: import("../index.js").simple_int, green: import("../index.js").simple_int, blue: import("../index.js").simple_int, transp?: import("../index.js").simple_float): string;
+    from_hex(hex: string, transp?: import("../index.js").simple_float): string;
+    new_color(baseColor: import("../types/index.js").color, transp: import("../index.js").simple_float): string;
+    r(clr: import("../types/index.js").color): import("../index.js").int;
+    g(clr: import("../types/index.js").color): import("../index.js").int;
+    b(clr: import("../types/index.js").color): import("../index.js").int;
+    t(clr: import("../types/index.js").color): import("../index.js").float;
+    from_gradient(value: import("../index.js").float, bottom_value: import("../index.js").float, top_value: import("../index.js").float, bottom_color: import("../types/index.js").color, top_color: import("../types/index.js").color): string;
+    aqua: "#00BCD4";
+    black: "#363A45";
+    blue: "#2962FF";
+    fuchsia: "#E040FB";
+    gray: "#787B86";
+    green: "#4CAF50";
+    lime: "#00E676";
+    maroon: "#880E4F";
+    navy: "#311B92";
+    olive: "#808000";
+    orange: "#FF9800";
+    purple: "#9C27B0";
+    red: "#F23645";
+    silver: "#B2B5BE";
+    teal: "#089981";
+    white: "#FFFFFF";
+    yellow: "#FDD835";
+};
+export interface ScriptPlotOptions {
+    /** Static color, or a per-bar color array from color.when(). */
+    color?: string | string[];
+    linewidth?: number;
+    style?: PlotConfig['style'];
+    /** Line style (PineScript `linestyle`); default solid. A constant or an input value, not per bar. */
+    linestyle?: PlotConfig['linestyle'];
+    display?: PlotConfig['display'];
+    histbase?: number;
+    /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+    force_overlay?: boolean;
+}
+/** PineScript `plot()` — declares the plot and supplies its data in one call. */
+declare function plotImpl(series: Series, title?: string, options?: ScriptPlotOptions): PlotHandle;
+/**
+ * PineScript `plot()`, with the `plot.style_*` and `plot.linestyle_*` constants:
+ * `plot(src, 'Level', { style: plot.style_stepline, linestyle: plot.linestyle_dashed })`.
+ */
+export declare const plot: typeof plotImpl & {
+    readonly style_line: "line";
+    readonly style_linebr: "linebr";
+    readonly style_stepline: "stepline";
+    readonly style_steplinebr: "steplinebr";
+    readonly style_stepline_diamond: "stepline_diamond";
+    readonly style_histogram: "histogram";
+    readonly style_columns: "columns";
+    readonly style_area: "area";
+    readonly style_areabr: "areabr";
+    readonly style_circles: "circles";
+    readonly style_cross: "cross";
+    readonly linestyle_solid: "solid";
+    readonly linestyle_dotted: "dotted";
+    readonly linestyle_dashed: "dashed";
+};
+export interface ScriptHLineOptions {
+    color?: string;
+    /** Line style; default dashed (PineScript). */
+    linestyle?: HLineConfig['linestyle'];
+    linewidth?: number;
+}
+/** PineScript `hline()` — a static horizontal level. Default line style: dashed (PineScript). */
+declare function hlineImpl(price: number, title?: string, options?: ScriptHLineOptions): PlotHandle;
+/** PineScript `hline()`, with the `hline.style_*` constants: `hline(0, 'Zero', { linestyle: hline.style_dotted })`. */
+export declare const hline: typeof hlineImpl & {
+    readonly style_solid: "solid";
+    readonly style_dotted: "dotted";
+    readonly style_dashed: "dashed";
+};
+export interface ScriptFillOptions {
+    /** Static color, or a per-bar color array from color.when(). */
+    color?: string | string[];
+    title?: string;
+}
+/** A fill colour argument: a colour, na (null / undefined), or a per-bar array from color.when(). */
+export type ScriptFillColor = string | null | undefined | Array<string | null | undefined>;
+/** A gradient value argument: a number or a Series. */
+export type ScriptFillValue = number | Series;
+/**
+ * PineScript `fill()`, with the three PineScript overloads (positional arguments), for two plots or two hlines:
+ * - `fill(p1, p2, color?, title?, ...)`
+ * - `fill(p1, p2, top_value, bottom_value, top_color, bottom_color, title?, ...)`: gradient fill; values and colours
+ *   can change per bar (a Series / a color.when() array)
+ * - `fill(p1, p2, { color, title })`: options object (oakscriptjs form, kept for existing scripts)
+ * Arguments that change only how the chart shows the fill (`editable`, `show_last`, `fillgaps`, `display`) are
+ * accepted and not used.
+ */
+export declare function fill(a: PlotHandle, b: PlotHandle, options?: ScriptFillOptions): void;
+export declare function fill(a: PlotHandle, b: PlotHandle, color: ScriptFillColor, title?: string, ...rest: unknown[]): void;
+export declare function fill(a: PlotHandle, b: PlotHandle, top_value: ScriptFillValue, bottom_value: ScriptFillValue, top_color: ScriptFillColor, bottom_color: ScriptFillColor, title?: string, ...rest: unknown[]): void;
+export interface PlotShapeOptions {
+    style?: ShapeStyle;
+    location?: MarkerLocation;
+    color?: string;
+    text?: string;
+    textcolor?: string;
+    size?: MarkerSize;
+    /** Display offset in bars (marker shown at bar i + offset). */
+    offset?: number;
+    /** Hover tooltip (extension over PineScript, for label.new-style ports). */
+    tooltip?: string;
+    /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+    force_overlay?: boolean;
+}
+export interface PlotCharOptions extends Omit<PlotShapeOptions, 'style'> {
+    char?: string;
+}
+/** PineScript `plotshape()` — a marker on each bar where the condition holds. */
+export declare function plotshape(condition: Series, title?: string, options?: PlotShapeOptions): void;
+/** PineScript `plotchar()` — a character marker on each bar where the condition holds. */
+export declare function plotchar(condition: Series, title?: string, options?: PlotCharOptions): void;
+export interface PlotArrowOptions {
+    /** Color of the up arrows: a color or a per-bar array (default #00FF00, PineScript). */
+    colorup?: string | Array<string | undefined>;
+    /** Color of the down arrows: a color or a per-bar array (default #FF0000, PineScript). */
+    colordown?: string | Array<string | undefined>;
+    /** Display offset in bars (arrow shown at bar i + offset). */
+    offset?: number;
+    /** Minimal arrow height in pixels (default 5). */
+    minheight?: number;
+    /** Maximal arrow height in pixels (default 100). */
+    maxheight?: number;
+    display?: ArrowConfig['display'];
+    /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+    force_overlay?: boolean;
+}
+/**
+ * PineScript `plotarrow()` — an up arrow below the bar for a positive value, a down arrow above the bar for a
+ * negative value, nothing for 0 / na. The arrows go to `result.arrows` (value and color per bar), the declaration to
+ * `arrowConfig`; the renderer scales the height with the absolute value between minheight and maxheight.
+ */
+export declare function plotarrow(series: Series, title?: string, options?: PlotArrowOptions): void;
+/**
+ * PineScript `bgcolor()` — per-bar background color. `force_overlay: true` colors the main chart pane even when the
+ * script is not an overlay.
+ */
+export declare function bgcolor(colors: string | Array<string | undefined>, options?: {
+    offset?: number;
+    title?: string;
+    force_overlay?: boolean;
+}): void;
+/** PineScript `barcolor()` — per-bar candle color override. */
+export declare function barcolor(colors: string | Array<string | undefined>, options?: {
+    title?: string;
+}): void;
+/**
+ * The scalar view of one bar handed to an {@link eachBar} callback.
+ * All fields are plain numbers, so native JS operators work.
+ */
+export interface BarContext {
+    /** Bar index (PineScript bar_index). */
+    readonly i: number;
+    /** Total number of bars. */
+    readonly n: number;
+    /** Time of the current bar. */
+    readonly time: number;
+    readonly open: number;
+    readonly high: number;
+    readonly low: number;
+    readonly close: number;
+    readonly volume: number;
+    /** Value of any Series at the current bar minus `offset` (PineScript src[offset]). */
+    get(src: Series, offset?: number): number;
+    /** This block's own previous output (PineScript self-reference, offset >= 1). */
+    prev(offset?: number): number;
+}
+/**
+ * Runs the callback once per bar, in order, and collects the returned values
+ * into a Series. This is the escape hatch for PineScript logic the vectorized
+ * model cannot express:
+ *
+ * - `var x = 0` / `x := ...` → a plain `let` variable captured by the closure
+ * - per-bar `if` / `for` / `while` → native JS statements
+ * - `src[k]` → `c.get(src, k)`; self-reference → `c.prev()`
+ *
+ * Returning a boolean collects 1/0; returning nothing collects na (NaN).
+ *
+ * ```typescript
+ * let dir = 0;                          // var dir = 0
+ * const trend = eachBar((c) => {
+ *   if (c.close > c.get(close, 1)) dir = 1;   // dir := 1
+ *   else if (c.close < c.get(close, 1)) dir = -1;
+ *   return dir;
+ * });
+ * ```
+ */
+export declare function eachBar(fn: (c: BarContext) => number | boolean | void): Series;
+/**
+ * Runs the strategy logic once per bar, in order, like {@link eachBar}. On each bar the engine first
+ * fills the pending orders (`processBar`), then the callback runs at the bar close (order calls,
+ * `strategy.*` variables), then `processClose` runs. A script has one strategy.eachBar() per run.
+ * The callback's return values are collected into a Series, as with eachBar().
+ */
+declare function strategyEachBar(fn: (c: BarContext) => number | boolean | void): Series;
+/** Numeric `strategy.*` variables, read from the engine (current bar inside strategy.eachBar()). */
+export type StrategyNumberVariables = {
+    readonly [K in StrategyNumberVariable]: number;
+};
+/** Text `strategy.*` variables, read from the engine. */
+export type StrategyTextVariables = {
+    readonly [K in StrategyTextVariable]: string;
+};
+/** PineScript `strategy`: the `strategy()` declaration and the `strategy.*` namespace. */
+export type StrategyApi = ((title: string, options?: StrategyOptions) => void) & typeof STRATEGY_CONSTANTS & StrategyNumberVariables & StrategyTextVariables & {
+    eachBar: typeof strategyEachBar;
+    entry(id: string, direction: StrategyDirection, options?: StrategyEntryOptions): void;
+    order(id: string, direction: StrategyDirection, options?: StrategyEntryOptions): void;
+    exit(id: string, options?: StrategyExitOptions): void;
+    close(id: string, options?: StrategyCloseOptions): void;
+    close_all(options?: StrategyCloseAllOptions): void;
+    cancel(id: string): void;
+    cancel_all(): void;
+    /** PineScript `strategy.opentrades.*(index)`: open trade `index` (0 = oldest), undefined when it does not exist. */
+    opentrade(index: number): StrategyTrade | undefined;
+    /** PineScript `strategy.closedtrades.*(index)`: closed trade `index` (0 = oldest), undefined when it does not exist. */
+    closedtrade(index: number): StrategyTrade | undefined;
+    default_entry_qty(fill_price: number): number;
+    risk: {
+        allow_entry_in(direction: StrategyRiskDirection): void;
+        max_cons_loss_days(count: number, alert_message?: string): void;
+        max_drawdown(value: number, type: StrategyRiskValueType, alert_message?: string): void;
+        max_intraday_filled_orders(count: number, alert_message?: string): void;
+        max_intraday_loss(value: number, type: StrategyRiskValueType, alert_message?: string): void;
+        max_position_size(contracts: number): void;
+    };
+};
+/**
+ * PineScript `strategy`: call it to declare a strategy, and use its members as the `strategy.*` namespace.
+ * OakScriptJS does not fill orders: the host passes an engine in `executeScript(..., { strategyEngine })`,
+ * and the order calls and `strategy.*` variables are forwarded to it.
+ *
+ * ```typescript
+ * strategy('MA Cross', { initial_capital: 10000, default_qty_type: strategy.percent_of_equity, default_qty_value: 100 });
+ * const up = ta.crossover(ta.sma(close, 9), ta.sma(close, 21));
+ * strategy.eachBar((c) => {
+ *   if (c.get(up) && strategy.position_size === 0) {
+ *     strategy.entry('L', strategy.long);
+ *     strategy.exit('X', { from_entry: 'L', stop: c.close * 0.95, limit: c.close * 1.15 });
+ *   }
+ * });
+ * ```
+ */
+export declare const strategy: StrategyApi;
+/**
+ * What the caller knows about the loaded bars. PineScript reads these values from the chart and
+ * the symbol; nothing is fetched here. A script that needs a value the caller did not give throws.
+ */
+export interface ChartContext {
+    /** Chart timeframe: "5", "60", "1D", "1W"... (PineScript `timeframe.period`) */
+    timeframe?: string;
+    /** Exchange time zone: "America/New_York", "Etc/UTC"... (PineScript `syminfo.timezone`) */
+    timezone?: string;
+    /** Session type of the bars (PineScript `syminfo.session`); default "regular" */
+    sessionType?: 'regular' | 'extended';
+    /**
+     * Session of the loaded bars in the symbol session format: hours ("0930-1600", "1700-1600", "24x7"),
+     * corrections (early closes, days off) and holidays. Needed by `time(tf)`, `time_close`,
+     * `timeframe.change`, `time_tradingday`, `session.*` and the default anchor of `ta.vwap`.
+     */
+    session?: SessionSpec | string;
+    /** Regular trading hours when the bars include extended hours (default: `session`); holidays default to `session`'s */
+    regularSession?: SessionSpec | string;
+    /** Chart symbol as PineScript `syminfo.tickerid` (e.g. "NASDAQ:AAPL"); needed by `request.security(syminfo.tickerid, ...)` */
+    tickerid?: string;
+    /** Unit of `Bar.time`: 's' (default, as lightweight-charts) or 'ms'. PineScript times are in ms. */
+    timeUnit?: 's' | 'ms';
+    /** Minimum price move of the symbol (PineScript `syminfo.mintick`), e.g. 0.01; used by `math.round_to_mintick` */
+    mintick?: number;
+    /** Currency value of one point of price move for one contract (PineScript `syminfo.pointvalue`); 1 for stocks */
+    pointvalue?: number;
+    /** Smallest tradable quantity (PineScript `syminfo.mincontract`); 1 for whole shares */
+    mincontract?: number;
+    /**
+     * The last bar is closed (`barstate.isconfirmed` on the last bar). Default false: PineScript treats the last bar
+     * of the data as not confirmed until the data feed closes it.
+     */
+    lastBarConfirmed?: boolean;
+    /** The last bar receives live updates (`barstate.isrealtime`); default false (a calculation on history). */
+    realtime?: boolean;
+    /** On a realtime last bar: this run is the first update of the bar (`barstate.isnew`); default true. */
+    lastBarNew?: boolean;
+}
+/**
+ * PineScript `timeframe.*`: the chart timeframe variables (from the chart context), and
+ * `in_seconds(timeframe?)`, `from_seconds(seconds)`.
+ */
+export declare const timeframe: {
+    period: string;
+    main_period: string;
+    multiplier: number;
+    isintraday: boolean;
+    isdaily: boolean;
+    isweekly: boolean;
+    ismonthly: boolean;
+    isminutes: boolean;
+    isseconds: boolean;
+    isticks: boolean;
+    isdwm: boolean;
+    /** PineScript `timeframe.change(tf)`: 1 on bars that open a new `tf` period (0 on the first bar). */
+    change(tf: string): Series;
+    /** Seconds in `timeframe`; without it (or with "") the chart timeframe, as in PineScript. */
+    in_seconds(tf?: string): number;
+    from_seconds(seconds: import("../index.js").int): import("../index.js").simple_string;
+    info(timeframe: import("../index.js").simple_string): timeframeCore.TimeframeInfo;
+};
+/**
+ * PineScript `syminfo.timezone`, `syminfo.tickerid`, `syminfo.session` (session type), `syminfo.mintick`,
+ * `syminfo.pointvalue` and `syminfo.mincontract`, from the chart context.
+ */
+export declare const syminfo: {
+    readonly mintick: number;
+    readonly pointvalue: number;
+    readonly mincontract: number;
+    readonly timezone: string;
+    readonly tickerid: string;
+    readonly session: string;
+};
+/** A calendar function: `(time, timezone?)` on a UNIX time or on a Series of times. */
+interface CalendarFunction {
+    (time: number, timezone?: string): number;
+    (time: Series, timezone?: string): Series;
+}
+/** PineScript `year(time, timezone?)`; the default time zone is the exchange time zone. */
+export declare const year: CalendarFunction;
+/** PineScript `month(time, timezone?)`; the default time zone is the exchange time zone. */
+export declare const month: CalendarFunction;
+/** PineScript `weekofyear(time, timezone?)`; the default time zone is the exchange time zone. */
+export declare const weekofyear: CalendarFunction;
+/** PineScript `dayofmonth(time, timezone?)`; the default time zone is the exchange time zone. */
+export declare const dayofmonth: CalendarFunction;
+/** PineScript `dayofweek(time, timezone?)`; the default time zone is the exchange time zone. */
+export declare const dayofweek: CalendarFunction;
+/** PineScript `hour(time, timezone?)`; the default time zone is the exchange time zone. */
+export declare const hour: CalendarFunction;
+/** PineScript `minute(time, timezone?)`; the default time zone is the exchange time zone. */
+export declare const minute: CalendarFunction;
+/** PineScript `second(time, timezone?)`; the default time zone is the exchange time zone. */
+export declare const second: CalendarFunction;
+/**
+ * PineScript `timestamp`: date string (GMT+0 by default), `(timezone, year, month, day, ...)`, or
+ * `(year, month, day, ...)` in the exchange time zone.
+ */
+export declare function timestamp(dateString: string): number;
+export declare function timestamp(timezone: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number): number;
+export declare function timestamp(year: number, month: number, day: number, hour?: number, minute?: number, second?: number): number;
+/** Session test of PineScript `time(timeframe, session, timezone)`; the default time zone is the exchange time zone. */
+export declare function inSession(time: number, session: string, timezone?: string): boolean;
+/** PineScript `str.*`; `format_time` and the dates of `format` use the exchange time zone by default. */
+export declare const str: {
+    format_time(time: number, format?: string, timezone?: string): string;
+    format(pattern: string, ...args: unknown[]): string;
+    length(str: import("../index.js").simple_string): import("../index.js").int;
+    tostring(value: any, format?: import("../index.js").simple_string): string;
+    tonumber(str: import("../index.js").simple_string): import("../index.js").float | null;
+    substring(str: import("../index.js").simple_string, begin: import("../index.js").simple_int, end?: import("../index.js").simple_int): string;
+    upper(str: import("../index.js").simple_string): string;
+    lower(str: import("../index.js").simple_string): string;
+    contains(source: import("../index.js").simple_string, str: import("../index.js").simple_string): import("../index.js").bool;
+    pos(source: import("../index.js").simple_string, str: import("../index.js").simple_string): import("../index.js").int;
+    replace(source: import("../index.js").simple_string, target: import("../index.js").simple_string, replacement: import("../index.js").simple_string, occurrence?: import("../index.js").simple_int): string;
+    replace_all(source: import("../index.js").simple_string, target: import("../index.js").simple_string, replacement: import("../index.js").simple_string): string;
+    split(str: import("../index.js").simple_string, separator: import("../index.js").simple_string): string[];
+    concat(...strings: import("../index.js").simple_string[]): string;
+    startswith(source: import("../index.js").simple_string, str: import("../index.js").simple_string): import("../index.js").bool;
+    endswith(source: import("../index.js").simple_string, str: import("../index.js").simple_string): import("../index.js").bool;
+    charAt(str: import("../index.js").simple_string, pos: import("../index.js").simple_int): string;
+    trim(str: import("../index.js").simple_string): string;
+    trimLeft(str: import("../index.js").simple_string): string;
+    trimRight(str: import("../index.js").simple_string): string;
+    match(source: import("../index.js").simple_string, regex: import("../index.js").simple_string): import("../index.js").bool;
+    repeat(source: import("../index.js").simple_string, count: import("../index.js").simple_int, separator?: import("../index.js").simple_string): string | null;
+};
+declare function timeFunction(tf?: string, session?: string, timezone?: string): Series;
+declare function timeCloseFunction(tf?: string, session?: string, timezone?: string): Series;
+/**
+ * PineScript `time`: the bar open time in ms (a Series), and `time(timeframe?, session?, timezone?)`:
+ * the open time of the `timeframe` period that contains the bar, `na` outside `session`.
+ */
+export declare const time: Series & typeof timeFunction;
+/**
+ * PineScript `time_close`: the bar close time in ms (a Series), and `time_close(timeframe?, session?, timezone?)`.
+ * Needs the chart timeframe and session.
+ */
+export declare const time_close: Series & typeof timeCloseFunction;
+/** PineScript `time_tradingday`: 00:00 UTC of the trading day of each bar, in ms. */
+export declare const time_tradingday: Series;
+/**
+ * PineScript `barstate.*` (1 / 0 per bar). All bars but the last are confirmed history bars. The last bar is
+ * confirmed only when the host says so (`ChartContext.lastBarConfirmed`, e.g. the closing update of a realtime
+ * bar), and is a realtime bar only when it receives live updates (`ChartContext.realtime`); without live updates
+ * it is a history bar, as in PineScript.
+ * `islastconfirmedhistory` is the last bar when it is confirmed and not realtime, else the bar before it.
+ */
+export declare const barstate: {
+    readonly isfirst: Series;
+    readonly islast: Series;
+    readonly isconfirmed: Series;
+    readonly isrealtime: Series;
+    readonly ishistory: Series;
+    readonly isnew: Series;
+    readonly islastconfirmedhistory: Series;
+};
+/**
+ * PineScript `session.*` (1 / 0 per bar) and the constants `session.regular` / `session.extended`.
+ * First and last bars are per session period; market / pre / post market use the regular hours.
+ */
+export declare const session: {
+    regular: string;
+    extended: string;
+    readonly isfirstbar: Series;
+    readonly islastbar: Series;
+    readonly ismarket: Series;
+    readonly ispremarket: Series;
+    readonly ispostmarket: Series;
+    readonly isfirstbar_regular: Series;
+    readonly islastbar_regular: Series;
+};
+/** PineScript `barmerge.*` constants of `request.security`. */
+export declare const barmerge: {
+    readonly gaps_on: "gaps_on";
+    readonly gaps_off: "gaps_off";
+    readonly lookahead_on: "lookahead_on";
+    readonly lookahead_off: "lookahead_off";
+};
+/** PineScript `ticker.heikinashi(symbol)` / `ticker.standard(symbol)` for the chart symbol. */
+export declare const ticker: {
+    heikinashi(symbol: string): string;
+    standard(symbol: string): string;
+};
+/** What an expression of `request.security` may return. */
+export type SecurityValue = Series | number | boolean | Array<Series | number | boolean>;
+/**
+ * PineScript `request.security` for the chart symbol (`syminfo.tickerid`, `""`, `ticker.heikinashi(...)`,
+ * `ticker.standard(...)`) and a timeframe equal to or higher than the chart's. The higher-timeframe bars are
+ * built by grouping the chart bars, and `expression` runs on them (its `ta.*` calls, tuples and `timeframe.*`
+ * see the higher timeframe). Other symbols need external data and throw; a lower timeframe throws.
+ *
+ * PineScript rules: lookahead off shows a period's value from the
+ * bar that completes it; lookahead on from its first bar; gaps on keeps only the bar where the value appears.
+ * Built bars can differ from the exchange's bars (official open / close, volume).
+ */
+declare function security<T extends SecurityValue>(symbol: string, timeframe: string, expression: () => T, gaps?: string, lookahead?: string): T extends unknown[] ? Series[] : Series;
+/** PineScript `request.*`: `security` for the chart symbol (issue #101). */
+export declare const request: {
+    security: typeof security;
+};
+/** PineScript `line.*`; `line.all` lists the live lines in creation order. */
+export declare const line: {
+    all: import("../index.js").Line[];
+    new_line(first_point: ChartPoint, second_point: ChartPoint, xloc?: "bar_index" | "bar_time", extend?: "none" | "left" | "right" | "both", lineColor?: import("../types/index.js").color, style?: "solid" | "dotted" | "dashed" | "arrow_left" | "arrow_right" | "arrow_both", width?: number, force_overlay?: boolean): import("../index.js").Line;
+    new_line(x1: number, y1: number, x2: number, y2: number, xloc?: "bar_index" | "bar_time", extend?: "none" | "left" | "right" | "both", lineColor?: import("../types/index.js").color, style?: "solid" | "dotted" | "dashed" | "arrow_left" | "arrow_right" | "arrow_both", width?: number, force_overlay?: boolean): import("../index.js").Line;
+    get_price(id: import("../index.js").Line, x: number): number;
+    get_x1(id: import("../index.js").Line): number;
+    get_x2(id: import("../index.js").Line): number;
+    get_y1(id: import("../index.js").Line): number;
+    get_y2(id: import("../index.js").Line): number;
+    copy(id: import("../index.js").Line): import("../index.js").Line;
+    set_x1(id: import("../index.js").Line, x: number): import("../index.js").Line;
+    set_x2(id: import("../index.js").Line, x: number): import("../index.js").Line;
+    set_y1(id: import("../index.js").Line, y: number): import("../index.js").Line;
+    set_y2(id: import("../index.js").Line, y: number): import("../index.js").Line;
+    set_xy1(id: import("../index.js").Line, x: number, y: number): import("../index.js").Line;
+    set_xy2(id: import("../index.js").Line, x: number, y: number): import("../index.js").Line;
+    set_xloc(id: import("../index.js").Line, x1: number, x2: number, xloc: "bar_index" | "bar_time"): import("../index.js").Line;
+    set_extend(id: import("../index.js").Line, extend: "none" | "left" | "right" | "both"): import("../index.js").Line;
+    set_color(id: import("../index.js").Line, lineColor: import("../types/index.js").color): import("../index.js").Line;
+    set_style(id: import("../index.js").Line, style: "solid" | "dotted" | "dashed" | "arrow_left" | "arrow_right" | "arrow_both"): import("../index.js").Line;
+    set_width(id: import("../index.js").Line, width: number): import("../index.js").Line;
+    delete_line(id: import("../index.js").Line): void;
+    set_first_point(id: import("../index.js").Line, point: ChartPoint): import("../index.js").Line;
+    set_second_point(id: import("../index.js").Line, point: ChartPoint): import("../index.js").Line;
+    new: typeof lineCore.new_line;
+    delete: typeof lineCore.delete_line;
+};
+/** PineScript `label.*`; `label.all` lists the live labels in creation order. */
+export declare const label: {
+    all: import("../index.js").Label[];
+    new_label(point: ChartPoint, text?: string, xloc?: "bar_index" | "bar_time", yloc?: "price" | "abovebar" | "belowbar", labelColor?: import("../types/index.js").color, style?: "none" | "xcross" | "cross" | "triangleup" | "triangledown" | "flag" | "circle" | "arrowup" | "arrowdown" | "label_up" | "label_down" | "label_left" | "label_right" | "label_lower_left" | "label_lower_right" | "label_upper_left" | "label_upper_right" | "label_center" | "square" | "diamond" | "text_outline", textcolor?: import("../types/index.js").color, size?: string | number, textalign?: "left" | "center" | "right", tooltip?: string, text_font_family?: "default" | "monospace", force_overlay?: boolean, text_formatting?: number): import("../index.js").Label;
+    new_label(x: number, y: number, text?: string, xloc?: "bar_index" | "bar_time", yloc?: "price" | "abovebar" | "belowbar", labelColor?: import("../types/index.js").color, style?: "none" | "xcross" | "cross" | "triangleup" | "triangledown" | "flag" | "circle" | "arrowup" | "arrowdown" | "label_up" | "label_down" | "label_left" | "label_right" | "label_lower_left" | "label_lower_right" | "label_upper_left" | "label_upper_right" | "label_center" | "square" | "diamond" | "text_outline", textcolor?: import("../types/index.js").color, size?: string | number, textalign?: "left" | "center" | "right", tooltip?: string, text_font_family?: "default" | "monospace", force_overlay?: boolean, text_formatting?: number): import("../index.js").Label;
+    get_x(id: import("../index.js").Label): number;
+    get_y(id: import("../index.js").Label): number;
+    get_text(id: import("../index.js").Label): string | undefined;
+    copy(id: import("../index.js").Label): import("../index.js").Label;
+    set_x(id: import("../index.js").Label, x: number): import("../index.js").Label;
+    set_y(id: import("../index.js").Label, y: number): import("../index.js").Label;
+    set_xy(id: import("../index.js").Label, x: number, y: number): import("../index.js").Label;
+    set_xloc(id: import("../index.js").Label, x: number, xloc: "bar_index" | "bar_time"): import("../index.js").Label;
+    set_yloc(id: import("../index.js").Label, yloc: "price" | "abovebar" | "belowbar"): import("../index.js").Label;
+    set_text(id: import("../index.js").Label, text: string): import("../index.js").Label;
+    set_tooltip(id: import("../index.js").Label, tooltip: string): import("../index.js").Label;
+    set_color(id: import("../index.js").Label, labelColor: import("../types/index.js").color): import("../index.js").Label;
+    set_textcolor(id: import("../index.js").Label, textColor: import("../types/index.js").color): import("../index.js").Label;
+    set_style(id: import("../index.js").Label, style: "none" | "xcross" | "cross" | "triangleup" | "triangledown" | "flag" | "circle" | "arrowup" | "arrowdown" | "label_up" | "label_down" | "label_left" | "label_right" | "label_lower_left" | "label_lower_right" | "label_upper_left" | "label_upper_right" | "label_center" | "square" | "diamond" | "text_outline"): import("../index.js").Label;
+    set_size(id: import("../index.js").Label, size: string | number): import("../index.js").Label;
+    set_textalign(id: import("../index.js").Label, align: "left" | "center" | "right"): import("../index.js").Label;
+    set_text_font_family(id: import("../index.js").Label, font: "default" | "monospace"): import("../index.js").Label;
+    delete_label(id: import("../index.js").Label): void;
+    set_point(id: import("../index.js").Label, point: ChartPoint): import("../index.js").Label;
+    set_text_formatting(id: import("../index.js").Label, formatting: number): import("../index.js").Label;
+    new: typeof labelCore.new_label;
+    delete: typeof labelCore.delete_label;
+};
+/** PineScript `box.*`; `box.all` lists the live boxes in creation order. */
+export declare const box: {
+    all: import("../index.js").Box[];
+    new_box(top_left: ChartPoint, bottom_right: ChartPoint, border_color?: import("../types/index.js").color, border_width?: number, border_style?: "solid" | "dotted" | "dashed", extend?: "none" | "left" | "right" | "both", xloc?: "bar_index" | "bar_time", bgcolor?: import("../types/index.js").color, text?: string, text_size?: string | number, text_color?: import("../types/index.js").color, text_halign?: "left" | "center" | "right", text_valign?: "top" | "center" | "bottom", text_wrap?: "none" | "auto", text_font_family?: "default" | "monospace", force_overlay?: boolean, text_formatting?: number): import("../index.js").Box;
+    new_box(left: number, top: number, right: number, bottom: number, border_color?: import("../types/index.js").color, border_width?: number, border_style?: "solid" | "dotted" | "dashed", extend?: "none" | "left" | "right" | "both", xloc?: "bar_index" | "bar_time", bgcolor?: import("../types/index.js").color, text?: string, text_size?: string | number, text_color?: import("../types/index.js").color, text_halign?: "left" | "center" | "right", text_valign?: "top" | "center" | "bottom", text_wrap?: "none" | "auto", text_font_family?: "default" | "monospace", force_overlay?: boolean, text_formatting?: number): import("../index.js").Box;
+    get_left(id: import("../index.js").Box): number;
+    get_right(id: import("../index.js").Box): number;
+    get_top(id: import("../index.js").Box): number;
+    get_bottom(id: import("../index.js").Box): number;
+    copy(id: import("../index.js").Box): import("../index.js").Box;
+    set_left(id: import("../index.js").Box, left: number): import("../index.js").Box;
+    set_right(id: import("../index.js").Box, right: number): import("../index.js").Box;
+    set_top(id: import("../index.js").Box, top: number): import("../index.js").Box;
+    set_bottom(id: import("../index.js").Box, bottom: number): import("../index.js").Box;
+    set_lefttop(id: import("../index.js").Box, left: number, top: number): import("../index.js").Box;
+    set_rightbottom(id: import("../index.js").Box, right: number, bottom: number): import("../index.js").Box;
+    set_xloc(id: import("../index.js").Box, left: number, right: number, xloc: "bar_index" | "bar_time"): import("../index.js").Box;
+    set_extend(id: import("../index.js").Box, extend: "none" | "left" | "right" | "both"): import("../index.js").Box;
+    set_border_color(id: import("../index.js").Box, borderColor: import("../types/index.js").color): import("../index.js").Box;
+    set_border_width(id: import("../index.js").Box, width: number): import("../index.js").Box;
+    set_border_style(id: import("../index.js").Box, style: "solid" | "dotted" | "dashed"): import("../index.js").Box;
+    set_bgcolor(id: import("../index.js").Box, bgColor: import("../types/index.js").color): import("../index.js").Box;
+    set_text(id: import("../index.js").Box, text: string): import("../index.js").Box;
+    set_text_color(id: import("../index.js").Box, textColor: import("../types/index.js").color): import("../index.js").Box;
+    set_text_size(id: import("../index.js").Box, size: string | number): import("../index.js").Box;
+    set_text_halign(id: import("../index.js").Box, align: "left" | "center" | "right"): import("../index.js").Box;
+    set_text_valign(id: import("../index.js").Box, align: "top" | "center" | "bottom"): import("../index.js").Box;
+    set_text_wrap(id: import("../index.js").Box, wrap: "none" | "auto"): import("../index.js").Box;
+    set_text_font_family(id: import("../index.js").Box, font: "default" | "monospace"): import("../index.js").Box;
+    delete_box(id: import("../index.js").Box): void;
+    set_top_left_point(id: import("../index.js").Box, point: ChartPoint): import("../index.js").Box;
+    set_bottom_right_point(id: import("../index.js").Box, point: ChartPoint): import("../index.js").Box;
+    set_text_formatting(id: import("../index.js").Box, formatting: number): import("../index.js").Box;
+    new: typeof boxCore.new_box;
+    delete: typeof boxCore.delete_box;
+};
+/** PineScript `linefill.*`; `linefill.all` lists the live linefills in creation order. */
+export declare const linefill: {
+    all: import("../index.js").Linefill[];
+    new_linefill(line1: import("../index.js").Line, line2: import("../index.js").Line, fillColor?: import("../types/index.js").color): import("../index.js").Linefill;
+    get_line1(id: import("../index.js").Linefill): import("../index.js").Line;
+    get_line2(id: import("../index.js").Linefill): import("../index.js").Line;
+    set_color(id: import("../index.js").Linefill, fillColor: import("../types/index.js").color): import("../index.js").Linefill;
+    delete_linefill(id: import("../index.js").Linefill): void;
+    new: typeof linefillCore.new_linefill;
+    delete: typeof linefillCore.delete_linefill;
+};
+/** PineScript `polyline.*`; `polyline.all` lists the live polylines in creation order. */
+export declare const polyline: {
+    all: polylineCore.Polyline[];
+    new_polyline(points: ChartPoint[], curved?: boolean, closed?: boolean, xloc?: "bar_index" | "bar_time", line_color?: import("../types/index.js").color, fill_color?: import("../types/index.js").color | null, line_style?: "solid" | "dotted" | "dashed", line_width?: number, force_overlay?: boolean): polylineCore.Polyline;
+    delete_polyline(id: polylineCore.Polyline): void;
+    get_all(): readonly polylineCore.Polyline[];
+    clear_all(): void;
+    reset_id_counter(): void;
+    new: typeof polylineCore.new_polyline;
+    delete: typeof polylineCore.delete_polyline;
+};
+/** PineScript `text.format_*` constants. */
+export declare const text: {
+    format_none: 0;
+    format_bold: 1;
+    format_italic: 2;
+};
+/**
+ * PineScript `chart.point.*`. `chart.point.now(price?)` is the point of the current bar
+ * (index, time, and `price`, default the close), so it runs inside eachBar().
+ */
+export declare const chart: {
+    point: {
+        now(price?: number): ChartPoint;
+        new_point(time: number | null, index: number | null, price: number): ChartPoint;
+        from_time(time: number, price: number): ChartPoint;
+        from_index(index: number, price: number): ChartPoint;
+        copy(point: ChartPoint): ChartPoint;
+        new: typeof chartPointCore.new_point;
+    };
+};
+/** Wraps a plain value array (e.g. a side output accumulated inside eachBar)
+ *  into a Series aligned with the current bars. */
+export declare function seriesOf(values: number[]): Series;
+/** PineScript `alertcondition()` — collected for the host's alert engine. */
+export declare function alertcondition(condition: Series, title: string, message?: string): void;
+export { Series, BarData, isNA as na, nz };
+export { STRATEGY_DEFAULTS } from '../strategy/index.js';
+export type { StrategyCloseAllOptions, StrategyCloseOptions, StrategyCommissionType, StrategyDirection, StrategyEngine, StrategyEntryOptions, StrategyExitOptions, StrategyNumberVariable, StrategyOcaType, StrategyOptions, StrategyProperties, StrategyQtyType, StrategyRiskDirection, StrategyRiskRule, StrategyRiskValueType, StrategyTextVariable, StrategyTrade, StrategyVariable, } from '../strategy/index.js';
+/** PineScript `math.*`; `math.round_to_mintick(x)` uses `syminfo.mintick` of the chart context. */
+export declare const math: {
+    round_to_mintick: typeof mathCore.round_to_mintick;
+    abs(value: Series): Series;
+    abs(value: import("../index.js").float): import("../index.js").float;
+    ceil(value: Series): Series;
+    ceil(value: import("../index.js").float): import("../index.js").int;
+    floor(value: Series): Series;
+    floor(value: import("../index.js").float): import("../index.js").int;
+    round(value: Series, precision?: import("../index.js").int): Series;
+    round(value: import("../index.js").float, precision?: import("../index.js").int): import("../index.js").float;
+    max(...values: (import("../index.js").float | Series)[]): import("../index.js").float | Series;
+    min(...values: (import("../index.js").float | Series)[]): import("../index.js").float | Series;
+    avg(...values: (import("../index.js").float | Series)[]): import("../index.js").float | Series;
+    sum(source: Series, length: import("../index.js").simple_int): Series;
+    sum(source: import("../index.js").series_float, length: import("../index.js").simple_int): import("../index.js").series_float;
+    sqrt(value: Series): Series;
+    sqrt(value: import("../index.js").float): import("../index.js").float;
+    pow(base: Series, exponent: import("../index.js").float): Series;
+    pow(base: import("../index.js").float, exponent: Series): Series;
+    pow(base: Series, exponent: Series): Series;
+    pow(base: import("../index.js").float, exponent: import("../index.js").float): import("../index.js").float;
+    exp(value: Series): Series;
+    exp(value: import("../index.js").float): import("../index.js").float;
+    log(value: Series): Series;
+    log(value: import("../index.js").float): import("../index.js").float;
+    log10(value: Series): Series;
+    log10(value: import("../index.js").float): import("../index.js").float;
+    sin(value: Series): Series;
+    sin(value: import("../index.js").float): import("../index.js").float;
+    cos(value: Series): Series;
+    cos(value: import("../index.js").float): import("../index.js").float;
+    tan(value: Series): Series;
+    tan(value: import("../index.js").float): import("../index.js").float;
+    asin(value: Series): Series;
+    asin(value: import("../index.js").float): import("../index.js").float;
+    acos(value: Series): Series;
+    acos(value: import("../index.js").float): import("../index.js").float;
+    atan(value: Series): Series;
+    atan(value: import("../index.js").float): import("../index.js").float;
+    toradians(degrees: Series): Series;
+    toradians(degrees: import("../index.js").float): import("../index.js").float;
+    todegrees(radians: Series): Series;
+    todegrees(radians: import("../index.js").float): import("../index.js").float;
+    random(min?: import("../index.js").float, max?: import("../index.js").float, _seed?: import("../index.js").int): import("../index.js").float;
+    sign(value: Series): Series;
+    sign(value: import("../index.js").float): import("../index.js").int;
+    pi: number;
+    e: number;
+    phi: 1.618033988749895;
+    rphi: 0.618033988749895;
+};
+export * as compare from '../compare/index.js';
+export type { Bar, IndicatorResult, TimeValue, InputConfig, PlotConfig, HLineConfig, FillConfig, ShapeConfig, ArrowConfig, BarColorConfig, MarkerData, ArrowData, BarColorData, MarkerLocation, MarkerSize, ShapeStyle, };
+//# sourceMappingURL=index.d.ts.map