openpinescript 0.0.0-stage → 0.1.0

package/dist/types/runtime/v1/stdlib/ta.d.ts

@@ -0,0 +1,409 @@
+import { Context } from "../context.js";
+/**
+ * Simple Moving Average
+ * @returns series float
+ */
+export declare function sma(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Exponential Moving Average
+ * @returns series float
+ */
+export declare function ema(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Rolling Moving Average (Used in RSI)
+ * @returns series float
+ */
+export declare function rma(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Weighted Moving Average
+ * @returns series float
+ */
+export declare function wma(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Volume Weighted Moving Average
+ * @returns series float
+ */
+export declare function vwma(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Symmetrically Weighted Moving Average
+ * @returns series float
+ */
+export declare function swma(ctx: Context, sourceInput: any): number;
+/**
+ * TRIX Oscillator
+ * @returns series float
+ */
+export declare function trix(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Relative Strength Index
+ * @returns series float
+ */
+export declare function rsi(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Calculates MACD
+ * @returns [series float, series float, series float]
+ */
+export declare function macd(ctx: Context, sourceInput: any, fastLenInput: any, slowLenInput: any, sigLenInput: any): [number, number, number];
+/**
+ * Momentum
+ * @returns series float
+ */
+export declare function mom(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Bollinger Bands
+ * @returns [series float, series float, series float]
+ */
+export declare function bb(ctx: Context, sourceInput: any, lengthInput: any, multInput: any): [number, number, number];
+/**
+ * Commodity Channel Index
+ * @returns series float
+ */
+export declare function cci(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * Cross
+ * @returns bool
+ */
+export declare function cross(ctx: Context, xInput: any, yInput: any): boolean;
+/**
+ * Crossover
+ * @returns bool
+ */
+export declare function crossover(ctx: Context, xInput: any, yInput: any): boolean;
+/**
+ * Crossunder
+ * @returns bool
+ */
+export declare function crossunder(ctx: Context, xInput: any, yInput: any): boolean;
+/**
+ * Highest value in window.
+ *
+ * Pine has TWO forms: `highest(source, length)` and `highest(length)`, where the
+ * one-argument form defaults its source to `high`. The short form is the one
+ * published breakout strategies actually use (`highest(enter_fast)`), and
+ * without it `length` arrived undefined and every bar was NaN.
+ *
+ * @returns series float
+ */
+export declare function highest(ctx: Context, source: any, length?: any): number;
+/**
+ * Lowest value in window.
+ *
+ * As with highest(), the one-argument form `lowest(length)` defaults its source
+ * to `low`.
+ *
+ * @returns series float
+ */
+export declare function lowest(ctx: Context, source: any, length?: any): number;
+/**
+ * Offset to highest value
+ * @returns series int
+ */
+export declare function highestbars(ctx: Context, source: any, length?: any): number;
+/**
+ * Offset to lowest value
+ * @returns series int
+ */
+export declare function lowestbars(ctx: Context, source: any, length?: any): number;
+/**
+ * Stochastic
+ * @returns series float
+ */
+export declare function stoch(ctx: Context, sourceInput: any, highInput: any, lowInput: any, lengthInput: any): number;
+/**
+ * valuewhen: Returns the value of 'source' when 'condition' was true on the nth occurrence.
+ * @returns series float
+ */
+export declare function valuewhen(ctx: Context, conditionInput: any, sourceInput: any, occurrenceInput: any): number;
+/**
+ * barssince: Returns the number of bars since the condition last evaluated to true.
+ * @returns series int
+ */
+export declare function barssince(ctx: Context, conditionInput: any): number;
+/**
+ * atr: Average True Range (requires contextual high/low/close data)
+ * @returns series float
+ */
+export declare function atr(ctx: Context, lengthInput: any): number;
+/**
+ * `ta.vwap(source)` — Volume Weighted Average Price.
+ *
+ * The accumulation restarts at the beginning of every SESSION; it is not
+ * cumulative over the chart. That is the whole character of the indicator, and
+ * getting it wrong is invisible on a short export and badly wrong on a long
+ * one — the old sessionless version drifted further from TradingView the more
+ * history it was given.
+ *
+ * On a daily or higher timeframe every bar is its own session, so this returns
+ * `source` unchanged. That is not a degenerate case to work around: TradingView
+ * does the same, exactly, on all 2,475 daily bars of
+ * conformance/v5/golden/harness_state.BTCUSDT.1D.log. VWAP is an intraday
+ * indicator, and on a daily chart there is nothing for it to average.
+ *
+ * ../sessions.ts owns the boundary, shared with `session.isfirstbar`.
+ *
+ * @returns series float
+ */
+export declare function vwap(ctx: Context, sourceInput: any, anchor?: any, stdev_mult?: any): number | number[];
+/**
+ * linreg: Linear Regression Curve
+ * @returns series float
+ */
+export declare function linreg(ctx: Context, sourceInput: any, lengthInput: any, offsetInput?: any): number;
+/**
+ * `ta.sar(start, inc, max)` — Parabolic SAR.
+ *
+ * This follows the `pine_sar` reference implementation published alongside
+ * `ta.sar` in TradingView's Pine Script reference manual, step for step. It is
+ * not the textbook Wilder algorithm, and the differences are not cosmetic —
+ * each of the four below moved the output on real data, and all four together
+ * reproduce TradingView's own values on 2,475 BTCUSDT daily bars to 1e-6 with
+ * no exceptions (conformance/v5/golden/harness_state.BTCUSDT.1D.log):
+ *
+ *   - It returns `na` on bar 0 and SEEDS on bar 1, using `close > close[1]` to
+ *     pick the initial direction. A bar-0 seed puts every later value one bar
+ *     early for the whole chart.
+ *   - The parabola advances BEFORE the stop is tested, so the reversal test
+ *     sees this bar's advanced stop rather than the previous bar's.
+ *   - On reversal the new stop is `max(high, maxMin)` (or `min(low, maxMin)`),
+ *     which can pick the CURRENT bar's extreme rather than the trend's.
+ *   - The acceleration factor and extreme point are frozen on the bar a trend
+ *     begins — `isFirstTrendBar` — so a reversal bar never also bumps `af`.
+ *
+ * The closing clamp keeps the stop out of the previous two bars' range. Note
+ * it is `low[1]`/`low[2]`, NOT Wilder's `low`/`low[1]`: clamping against the
+ * current bar suppresses reversals TradingView takes (it first diverged at bar
+ * 263 of that export).
+ *
+ * @returns series float
+ */
+export declare function sar(ctx: Context, startInput: any, incInput: any, maxInput: any): number;
+/**
+ * cum: Cumulative sum of source over all bars.
+ * @returns series float
+ */
+export declare function cum(ctx: Context, sourceInput: any): number;
+/**
+ * roc: Rate of Change. 100 * (source - source[length]) / source[length]
+ * @returns series float
+ */
+export declare function roc(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * change: Difference between current value and value N bars ago.
+ * @returns series float
+ */
+export declare function change(ctx: Context, sourceInput: any, lengthInput?: any): number;
+/**
+ * falling: True if source has been falling (decreasing) for `length` consecutive bars.
+ * @returns series bool
+ */
+export declare function falling(ctx: Context, sourceInput: any, lengthInput: any): boolean;
+/**
+ * rising: True if source has been rising (increasing) for `length` consecutive bars.
+ * @returns series bool
+ */
+export declare function rising(ctx: Context, sourceInput: any, lengthInput: any): boolean;
+/**
+ * dev: Deviation. Mean absolute deviation of source over length bars.
+ * @returns series float
+ */
+export declare function dev(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * variance: Variance of source over length bars.
+ * @returns series float
+ */
+export declare function variance(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * stdev: Standard Deviation of source over length bars.
+ * @returns series float
+ */
+export declare function stdev(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * correlation: Pearson correlation coefficient between two series over length bars.
+ * @returns series float
+ */
+export declare function correlation(ctx: Context, source1Input: any, source2Input: any, lengthInput: any): number;
+/**
+ * percentrank: Percent rank. Percentage of past `length` values that are <= current value.
+ * @returns series float
+ */
+export declare function percentrank(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * wpr: Williams %R
+ * @returns series float
+ */
+export declare function wpr(ctx: Context, lengthInput: any): number;
+/**
+ * mfi: Money Flow Index
+ * @returns series float
+ */
+export declare function mfi(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * alma: Arnaud Legoux Moving Average
+ * @returns series float
+ */
+export declare function alma(ctx: Context, sourceInput: any, lengthInput: any, offsetInput?: any, sigmaInput?: any): number;
+/**
+ * cog: Center of Gravity oscillator
+ * @returns series float
+ */
+export declare function cog(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * tsi: True Strength Index
+ * @returns series float
+ */
+export declare function tsi(ctx: Context, sourceInput: any, longLenInput: any, shortLenInput: any): number;
+/**
+ * pivothigh: Pivot High. Returns the value of the pivot high point, NaN otherwise.
+ * Looks for a high that is higher than `leftbars` bars to the left and `rightbars` bars to the right.
+ * @returns series float
+ */
+export declare function pivothigh(ctx: Context, sourceInput: any, leftbarsInput: any, rightbarsInput: any): number;
+/**
+ * pivotlow: Pivot Low. Returns the value of the pivot low point, NaN otherwise.
+ * @returns series float
+ */
+export declare function pivotlow(ctx: Context, sourceInput: any, leftbarsInput: any, rightbarsInput: any): number;
+/**
+ * `tr` / `ta.tr` — True Range, as a VARIABLE.
+ *
+ * A getter, because a script reads it by name:
+ *
+ *     trBalance := trBalance + sign(tr - tr[_i])
+ *
+ * is TradingView's own `v4-debugging-11`, and `tr` there is a series, not a
+ * function. Registered without `@getter` it emitted the FUNCTION OBJECT, so
+ * `tr - tr[5]` was arithmetic on a function and every bar of the plot was na —
+ * with no diagnostic, because a built-in that exists is not an undeclared read.
+ *
+ * The one-argument call form `ta.tr(handle_na)` is a separate question. Nothing
+ * in the manual or the release notes states what `handle_na` does, and no
+ * script in the corpus passes it, so no parameter is offered rather than one
+ * that guesses.
+ *
+ * @getter
+ * @returns {series float} The bar's true range.
+ */
+export declare function tr(ctx: Context): number;
+/**
+ * sum: Rolling sum of source over length bars. (Equivalent to sma * length.)
+ * @returns series float
+ */
+export declare function sum(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * fixnan: Replaces NaN with the last non-NaN value (per call site).
+ * @returns series float
+ */
+export declare function fixnan(ctx: Context, xInput: any): number;
+/**
+ * percentile_nearest_rank: the value at `percentage` percentile of the last
+ * `length` values, using the nearest-rank method (no interpolation).
+ *
+ * Nearest rank is `ceil(P/100 * N)` over the ASCENDING sample, so the result is
+ * always one of the observed values — which is what distinguishes it from
+ * percentile_linear_interpolation.
+ *
+ * @returns series float
+ */
+export declare function percentile_nearest_rank(ctx: Context, sourceInput: any, lengthInput: any, percentageInput: any): number;
+/**
+ * percentile_linear_interpolation: the value at `percentage` percentile of the
+ * last `length` values, interpolating between the two straddling samples.
+ *
+ * @returns series float
+ */
+export declare function percentile_linear_interpolation(ctx: Context, sourceInput: any, lengthInput: any, percentageInput: any): number;
+/**
+ * bbw: Bollinger Bands Width — the bands' span as a fraction of the basis.
+ *
+ *   (basis + mult*stdev - (basis - mult*stdev)) / basis  =  2*mult*stdev / sma
+ *
+ * @returns series float
+ */
+export declare function bbw(ctx: Context, sourceInput: any, lengthInput: any, multInput: any): number;
+/**
+ * kc: Keltner Channels — [basis, upper, lower].
+ *
+ * The basis is an EMA of the source; the band width is an EMA of the bar's
+ * range. `useTrueRange` chooses which range: the true range (the default, and
+ * what makes the channel gap-aware) or the plain high-low span.
+ *
+ * @returns [float, float, float]
+ */
+export declare function kc(ctx: Context, sourceInput: any, lengthInput: any, multInput: any, useTrueRangeInput?: any): [number, number, number];
+/**
+ * kcw: Keltner Channels Width — the channel span over its basis.
+ * @returns series float
+ */
+export declare function kcw(ctx: Context, sourceInput: any, lengthInput: any, multInput: any, useTrueRangeInput?: any): number;
+/**
+ * hma: Hull Moving Average.
+ *
+ *   wma(2 * wma(src, len/2) - wma(src, len), round(sqrt(len)))
+ *
+ * The doubled short WMA minus the long one is what removes the lag; the final
+ * smoothing over sqrt(len) is what removes the noise that leaves behind.
+ *
+ * @returns series float
+ */
+export declare function hma(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * cmo: Chande Momentum Oscillator.
+ *
+ *   100 * (sum(gains) - sum(losses)) / (sum(gains) + sum(losses))
+ *
+ * Unlike RSI, the sums are plain rolling sums rather than Wilder-smoothed, so
+ * the result reacts faster and swings the full -100..100.
+ *
+ * @returns series float
+ */
+export declare function cmo(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * dmi: Directional Movement Index — [+DI, -DI, ADX].
+ *
+ * Transcribed from the reference implementation in TradingView's v5 manual
+ * rather than from a textbook: the +DM/-DM tie-breaks ("strictly greater than
+ * the other AND positive") and the zero-sum guard in ADX are exactly where
+ * published variants disagree with each other.
+ *
+ * @returns [float, float, float]
+ */
+export declare function dmi(ctx: Context, diLengthInput: any, adxSmoothingInput: any): [number, number, number];
+/**
+ * supertrend: [supertrend, direction].
+ *
+ * `direction` is -1 while the trend is up (the line sits below price) and 1
+ * while it is down. That sign convention is TradingView's and reads backwards
+ * to most people, so it is worth stating: a script testing `direction < 0` is
+ * testing for an UPTREND.
+ *
+ * The bands RATCHET — each one may only tighten toward price until price
+ * crosses it — which is the whole behaviour of the indicator and the reason it
+ * cannot be composed from the smoothers alone.
+ *
+ * @returns [float, float]
+ */
+export declare function supertrend(ctx: Context, factorInput: any, atrPeriodInput: any): [number, number];
+/**
+ * range: the span of `source` over `length` bars — highest minus lowest.
+ * @returns series float
+ */
+export declare function range(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * median: the middle value of the last `length` samples.
+ *
+ * `na` until the window is full, matching every other windowed function here —
+ * a median over three of the twenty bars requested is not a median over twenty.
+ *
+ * @returns series float
+ */
+export declare function median(ctx: Context, sourceInput: any, lengthInput: any): number;
+/**
+ * mode: the most frequent value of the last `length` samples.
+ *
+ * Ties go to the SMALLEST value, which is what TradingView documents. Without
+ * that rule the answer would depend on iteration order, and two runs of the
+ * same script could differ.
+ *
+ * @returns series float
+ */
+export declare function mode(ctx: Context, sourceInput: any, lengthInput: any): number;

package/dist/types/runtime/v1/stdlib/time.d.ts

@@ -0,0 +1,158 @@
+import { Context } from "../context.js";
+/**
+ * `timestamp(...)` — a UNIX timestamp in milliseconds, in all three spellings.
+ *
+ * SOURCING. TradingView's `v5-concepts-time-20` demonstrates every one, and
+ * annotates each with the zone it is read in:
+ *
+ *     timestamp("2021-01-01")                          // "in the UTC+0 time zone"
+ *     timestamp(2021, 1, 1, 0, 0)                      // "in the exchange time zone"
+ *     timestamp("America/New_York", 2021, 1, 1, 0, 0)  // in the named zone
+ *     timestamp("UTC0", 2021, 1, 1, 0, 0)              // in "UTC0" (UTC+0)
+ *
+ * ── What this used to be ────────────────────────────────────────────────────
+ *
+ * Only the middle one, and always in UTC. The date-STRING form returned
+ * `Date.UTC(Number("2021-01-01"), …)` — NaN — so `input.time(timestamp(
+ * "2021-01-01"))` was `na` and every plot gated on it drew nothing. The
+ * timezone form had no parameter to bind to, so the zone was dropped and the
+ * answer came back in UTC, silently off by up to half a day.
+ *
+ * Declared at top level, not as a member of the `time` object: Pine spells this
+ * as a global `timestamp(...)`, and the registry generator only hoists top-level
+ * exports to unprefixed keys. As an object member it generated
+ * "time.timestamp", which no Pine source can reach.
+ *
+ * The parameters are named for BOTH shapes, because the keyword form has to
+ * bind: `timestamp(timezone = "UTC+4", year = 2021, …)` and
+ * `timestamp(year = 2021, …)` are the same function. Which shape a positional
+ * call is in is decided by whether the first argument is a string.
+ *
+ * @returns {number} UNIX timestamp in milliseconds, or na.
+ */
+export declare function timestamp(ctx: Context, timezone?: any, year?: any, month?: any, day?: any, hour?: any, minute?: any, second?: any, dateString?: any): number;
+/**
+ * `year` / `year(time, timezone)` — the four-digit year.
+ * @getter
+ * @returns {series int} The year of `time` in `timezone`.
+ */
+export declare function year(ctx: Context, time?: any, timezone?: any): number;
+/**
+ * `month` / `month(time, timezone)` — 1 for January, 12 for December.
+ * @getter
+ * @returns {series int} The month of `time` in `timezone`.
+ */
+export declare function month(ctx: Context, time?: any, timezone?: any): number;
+/**
+ * `dayofmonth` / `dayofmonth(time, timezone)` — 1 to 31.
+ * @getter
+ * @returns {series int} The day of the month of `time` in `timezone`.
+ */
+export declare function dayofmonth(ctx: Context, time?: any, timezone?: any): number;
+/**
+ * `dayofweek` / `dayofweek(time, timezone)` — Sunday is 1, Saturday is 7.
+ * @getter
+ * @returns {series int} The day of the week of `time` in `timezone`.
+ */
+export declare function dayofweek(ctx: Context, time?: any, timezone?: any): number;
+/**
+ * `hour` / `hour(time, timezone)` — 0 to 23.
+ * @getter
+ * @returns {series int} The hour of `time` in `timezone`.
+ */
+export declare function hour(ctx: Context, time?: any, timezone?: any): number;
+/**
+ * `minute` / `minute(time, timezone)` — 0 to 59.
+ * @getter
+ * @returns {series int} The minute of `time` in `timezone`.
+ */
+export declare function minute(ctx: Context, time?: any, timezone?: any): number;
+/**
+ * `second` / `second(time, timezone)` — 0 to 59.
+ * @getter
+ * @returns {series int} The second of `time` in `timezone`.
+ */
+export declare function second(ctx: Context, time?: any, timezone?: any): number;
+/**
+ * `weekofyear` / `weekofyear(time, timezone)` — the ISO week, 1 to 53.
+ * @getter
+ * @returns {series int} The week of the year of `time` in `timezone`.
+ */
+export declare function weekofyear(ctx: Context, time?: any, timezone?: any): number;
+/**
+ * `time(resolution)` / `time(resolution, session)`.
+ *
+ * With one argument, the current bar's UNIX time. With a session, the bar's
+ * time when it falls INSIDE that session and `na` otherwise — which is how
+ * pre-v4 scripts express "only trade the cash session".
+ *
+ * TIMEZONE. The session window, and its day mask, are evaluated in the
+ * `timezone` argument when one is given, otherwise in the symbol's exchange
+ * timezone (`ctx.timezone`, which a host sets with `Session.setChart`; "UTC"
+ * until it does). Evidence: TradingView's Pine Logs for the ICT Silver Bullet
+ * script (conformance/v5/parity/harness_ict_silver_bullet.BTCUSDT.5.csv) show
+ * "0300-0400" in "America/New_York" opening at 07:00 UTC on 2026-10-05 (EDT,
+ * UTC-4); evaluated in UTC it opened at 03:00. Daylight saving follows the
+ * zone, so the same window opens at 08:00 UTC in winter. An unknown zone name
+ * reads as UTC, as for `hour()` and the other calendar accessors.
+ *
+ * The `resolution` argument is accepted and ignored: honouring it means
+ * re-aggregating the chart into that timeframe, which is the same missing
+ * engine that blocks `heikinashi()`.
+ *
+ * ⚠ THE DEFAULT SESSION IS NOT APPLIED. Omitting `session` returns the bar
+ * time unfiltered. TradingView instead applies the SYMBOL's session, and the
+ * v4 → v5 guide records its literal fallback widening from `"23456"` (Mon-Fri)
+ * to `"1234567"` (Sun-Sat) — a difference this engine therefore does not model.
+ *
+ * Applying either literal was tried and reverted. It needs the same exchange
+ * calendar the timezone note above is missing, and Mon-Fri broke a published
+ * script in the corpus outright: sunday.pine marks Sunday opens by testing
+ * `dayofweek(time('D'))`, and a weekday mask makes that `na` on every bar it
+ * exists to find. See the note in transpiler/common/profiles/index.ts.
+ *
+ * @returns {series float} The bar's UNIX time in ms, or na.
+ */
+export declare function time(ctx: any, _resolution?: any, session?: any, timezone?: any, bars_back?: any, timeframe_bars_back?: any): number;
+/**
+ * `time_close(resolution, session, timezone)` — the bar's CLOSING time.
+ *
+ * Added in Pine v4. Where `time` is the instant a bar opened, this is the
+ * instant it closes, which is what a script needs to place a drawing at the
+ * right-hand edge of the current bar rather than its left.
+ *
+ * It is derived from the chart's resolution rather than read from the data,
+ * because the closing time of the bar being evaluated is the OPENING time of a
+ * bar that has not arrived yet — on the last bar there is no next bar to read.
+ *
+ * `session` filters exactly as it does for `time()`, in the same timezone
+ * (the `timezone` argument, else the exchange's).
+ *
+ * Marked `@getter` because Pine documents it as "both a variable and a
+ * function": bare `time_close` must read as the current bar's closing time,
+ * while `time_close("D")` still resolves through the ordinary call path. `time`
+ * itself does not need the tag only because the runtime binds an `opsv2_time`
+ * SERIES into the sandbox for the bare form to find; there is no such series
+ * here, and without the tag `plot(time_close)` plotted the function object,
+ * which reads as `na`.
+ *
+ * @getter
+ * @returns {series float} The bar's closing UNIX time in ms, or na.
+ */
+export declare function time_close(ctx: any, resolution?: any, session?: any, timezone?: any, bars_back?: any, timeframe_bars_back?: any): number;
+/**
+ * `time_tradingday` — the start of the trading day the bar belongs to.
+ *
+ * Added in Pine v4 (February 2021): "the beginning time of the trading day the
+ * current bar belongs to". The v5 manual states it as the 00:00 UTC start of
+ * the last trading day in the bar's final session.
+ *
+ * With no exchange calendar this is UTC midnight of the bar's own day — exact
+ * for a symbol whose session does not straddle midnight, and shifted for one
+ * that does. Same limitation, and same remedy, as the rest of this file:
+ * supply bar timestamps already shifted to the exchange timezone.
+ *
+ * @getter
+ * @returns {series float} UNIX time of the trading day's start, in ms.
+ */
+export declare function time_tradingday(ctx: any): number;

package/dist/types/runtime/v1/stdlib/trades.d.ts

@@ -0,0 +1,108 @@
+/**
+ * `strategy.opentrades.*` and `strategy.closedtrades.*` — the trade inspectors.
+ *
+ * SOURCING. From the manual's strategies page, these are indexed accessors:
+ * `strategy.opentrades.entry_price(trade_num)` "returns the entry price of the
+ * open trade at `trade_num`", and the `closedtrades` family answers the same
+ * questions about trades that have already been closed. Trade numbers are
+ * ZERO-BASED and count from the oldest.
+ *
+ * ── Why this is a file of its own ───────────────────────────────────────────
+ *
+ * `strategy.opentrades` is BOTH a number — how many trades are open — and the
+ * root of these functions. `runtime/v1/stdlib/strategy.ts` is a namespace
+ * module, so its exported `function opentrades(ctx)` already claims that key,
+ * and TypeScript will not let one name be a function and an object literal in
+ * one file.
+ *
+ * So the sub-members are declared here, in a non-namespace file whose exported
+ * object is called `strategy`. The generator reads the object literal and emits
+ * `strategy.opentrades.entry_price`; `createStdlib` then attaches those members
+ * onto the getter function, which is the merge it already does for `log.info`
+ * beside a flat `log`.
+ *
+ * ── What is a trade ─────────────────────────────────────────────────────────
+ *
+ * An open trade is one filled entry not yet fully closed (see ../openTrades),
+ * so `strategy.opentrades` is the length of the list these functions index. A
+ * partial close shrinks the oldest entry's size; it does not add a trade.
+ * The excursions (`max_drawdown`, `max_runup`) are tracked for the position as
+ * a whole, and every open trade reports that figure.
+ */
+import { Context } from "../context.js";
+export declare const strategy: {
+    opentrades: {
+        /** The entry price of the open trade at `trade_num`. */
+        entry_price: (ctx: Context, trade_num?: any) => number;
+        /** The bar index on which the open trade at `trade_num` was entered. */
+        entry_bar_index: (ctx: Context, trade_num?: any) => number;
+        /** The order id that opened the trade at `trade_num`. */
+        entry_id: (ctx: Context, trade_num?: any) => any;
+        /** The trade's UNREALISED profit, in the strategy's currency. */
+        profit: (ctx: Context, trade_num?: any) => number;
+        /** The trade's direction as a signed size: positive long, negative short. */
+        size: (ctx: Context, trade_num?: any) => number;
+        /** The open position's largest adverse and favourable excursions so far. */
+        max_drawdown: (ctx: Context, trade_num?: any) => number;
+        max_runup: (ctx: Context, trade_num?: any) => number;
+        /** Unrealised result as a percentage of the entry value. */
+        profit_percent: (ctx: Context, trade_num?: any) => number;
+        /** When the open trade began, UNIX ms. */
+        entry_time: (ctx: Context, trade_num?: any) => number;
+        /** Entry commission paid on the open trade. */
+        commission: (ctx: Context, trade_num?: any) => number;
+        /** The entry order's comment, which this engine does not record: na. */
+        entry_comment: (_ctx: Context, _trade_num?: any) => any;
+    };
+    closedtrades: {
+        /**
+         * v6: the index of the oldest closed trade that has not been trimmed —
+         * "0, representing the actual first trade in the simulation" until the
+         * strategy has more than 9000. A v6-only name; see renames6.ts.
+         * @getter
+         */
+        first_index: (ctx: Context) => number;
+        /** The entry price of the closed trade at `trade_num`. */
+        entry_price: (ctx: Context, trade_num?: any) => number;
+        /** The exit price of the closed trade at `trade_num`. */
+        exit_price: (ctx: Context, trade_num?: any) => number;
+        /**
+         * The order id that opened the closed trade at `trade_num`. `id` is the
+         * CLOSING order's name, which is what this returned until TradingView's
+         * log showed "L" where it read "Exit XL1".
+         */
+        entry_id: (ctx: Context, trade_num?: any) => any;
+        /**
+         * The id of the order that closed the trade at `trade_num`, or na when
+         * there is no such trade — the string "NaN" passed `na()` as a value.
+         */
+        exit_id: (ctx: Context, trade_num?: any) => any;
+        /** The comment of the order that closed the trade, or na when it had none. */
+        exit_comment: (ctx: Context, trade_num?: any) => any;
+        /** Commission paid on the trade's entry and exit, in the account currency. */
+        commission: (ctx: Context, trade_num?: any) => number;
+        /** The bar index the closed trade was entered on. */
+        entry_bar_index: (ctx: Context, trade_num?: any) => number;
+        /** The bar index the closed trade was exited on. */
+        exit_bar_index: (ctx: Context, trade_num?: any) => number;
+        /** The trade's REALISED profit, in the strategy's currency. */
+        profit: (ctx: Context, trade_num?: any) => number;
+        /** The trade's size as a signed number: positive long, negative short. */
+        size: (ctx: Context, trade_num?: any) => number;
+        /** The largest adverse excursion while the trade was open, in money. */
+        max_drawdown: (ctx: Context, trade_num?: any) => number;
+        /** The largest favourable excursion, in money. */
+        max_runup: (ctx: Context, trade_num?: any) => number;
+        /** The drawdown as a percentage of the trade's entry value. */
+        max_drawdown_percent: (ctx: Context, trade_num?: any) => number;
+        /** The run-up as a percentage of the trade's entry value. */
+        max_runup_percent: (ctx: Context, trade_num?: any) => number;
+        /** The trade's result as a percentage of its entry value. */
+        profit_percent: (ctx: Context, trade_num?: any) => number;
+        /** When the trade opened and closed, UNIX ms. */
+        entry_time: (ctx: Context, trade_num?: any) => number;
+        exit_time: (ctx: Context, trade_num?: any) => number;
+        /** The entry order's comment, which this engine does not record: na. */
+        entry_comment: (_ctx: Context, _trade_num?: any) => any;
+    };
+};