openpinescript 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,314 @@
+import type { Context } from "../context.js";
+/**
+ * strategy.ts - Backtesting Engine Logic
+ *
+ * Implements: entry, exit, order, close, cancel, pending order matching,
+ * OCA groups (cancel / reduce / none), and strategy.risk.* circuit breakers.
+ */
+export declare const long = "long";
+export declare const short = "short";
+/**
+ * strategy.commission.* — how `commission_value` is interpreted.
+ *
+ *     strategy("X", commission_type=strategy.commission.percent,
+ *                   commission_value=0.1)
+ *
+ * Nested under `strategy`, not a top-level `commission` namespace — that is
+ * where Pine puts it, and a top-level constant would leave
+ * `strategy.commission.percent` undefined at runtime.
+ */
+export declare const commission: {
+    /** A percentage of the position's cash value. */
+    percent: string;
+    /** A fixed amount per contract/share filled. */
+    cash_per_contract: string;
+    /** A fixed amount per order, regardless of size. */
+    cash_per_order: string;
+};
+export declare const direction: {
+    long: string;
+    short: string;
+};
+export declare const oca: {
+    cancel: string;
+    reduce: string;
+    none: string;
+};
+export interface PendingExit {
+    id: string;
+    from_entry: string;
+    qty: number;
+    qty_percent: number;
+    /** Profit target, in PRICE. */
+    limit: number;
+    /** Stop loss, in PRICE. */
+    stop: number;
+    /** Profit target, in TICKS from the entry. */
+    profit: number;
+    /** Stop loss, in TICKS from the entry. */
+    loss: number;
+    /** Trailing-stop activation level, in PRICE. */
+    trail_price: number;
+    /** Trailing-stop activation offset, in TICKS from the entry. */
+    trail_points: number;
+    /** How far behind the extreme the trailing stop follows, in TICKS. */
+    trail_offset: number;
+    /** The best price seen since the trail armed, or NaN while it has not. */
+    trail_peak: number;
+    /** The bar this order was first registered on. See `livesYet`. */
+    placedBar: number;
+    oca_name: string;
+    /** `comment`, and the three that replace it by how the exit filled. */
+    comment?: string;
+    comment_profit?: string;
+    comment_loss?: string;
+    comment_trailing?: string;
+    /**
+     * One unit per TRADE the exit applies to (the trades `from_entry` names, or
+     * every trade): its own price to measure relative levels from, its own
+     * trailing high-water mark, and whether it has filled. A script re-issues the
+     * same `strategy.exit` every bar, and the units survive that. A trade filled
+     * after the last call has no unit until the next call (or, for an entry
+     * that was pending at the call, `arms`).
+     */
+    units?: ExitUnit[];
+    /** Entry ids that had an order pending when the exit was called, and the bar of that first call. */
+    arms?: Record<string, number>;
+}
+/** One trade's share of a `strategy.exit`; see `PendingExit.units`. */
+export interface ExitUnit {
+    /** `OpenEntry.uid` of the trade. */
+    uid: string;
+    /** The trade's entry id: what `from_entry` and the id ledger speak of. */
+    id: string;
+    /** The trade's fill price: relative levels (`profit`, `loss`, `trail_points`) are measured from it. */
+    basis: number;
+    /** What the trade opened with: a `qty_percent` is a share of it. */
+    opened: number;
+    /** The bar the unit was created on; it is live from the next. */
+    placedBar: number;
+    trail_peak: number;
+    filled: boolean;
+}
+export interface PendingEntry {
+    id: string;
+    dir: string;
+    qty: number;
+    limit: number;
+    stop: number;
+    /** The bar this order was first registered on. See `livesYet`. */
+    placedBar: number;
+    oca_name: string;
+    oca_type: string;
+    /** Placed by `strategy.order`, which `pyramiding` does not bind. */
+    exempt?: boolean;
+}
+export interface RiskState {
+    max_intraday_loss: number;
+    max_intraday_loss_type: string;
+    max_intraday_filled_orders: number;
+    max_drawdown: number;
+    max_drawdown_type: string;
+    max_cons_loss_days: number;
+    max_position_size: number;
+    allow_entry_in: string;
+    start_equity: number;
+    peak_equity: number;
+    last_day: number;
+    daily_filled_orders: number;
+    cons_loss_days: number;
+    prev_day_equity: number;
+    last_settled_day: number;
+    is_halted: boolean;
+}
+export declare const risk: {
+    max_intraday_loss: (ctx: Context, value: any, type?: string) => void;
+    max_intraday_filled_orders: (ctx: Context, count: any) => void;
+    max_drawdown: (ctx: Context, value: any, type?: string) => void;
+    max_cons_loss_days: (ctx: Context, count: any) => void;
+    max_position_size: (ctx: Context, size: any) => void;
+    allow_entry_in: (ctx: Context, dir: string) => void;
+};
+export declare function order(ctx: Context, id: string, dir: string, qty?: any, limit?: any, stop?: any, oca_name?: string, oca_type?: string, comment?: string, when?: any, alert_message?: string): void;
+export declare function entry(ctx: Context, id: string, direction: string, qty?: any, limit?: any, stop?: any, oca_name?: string, oca_type?: string, comment?: string, when?: any, alert_message?: string): any;
+export declare function close(ctx: Context, id: string, when?: any, comment?: string, qty?: any, qty_percent?: any, alert_message?: string, immediately?: any, disable_alert?: any): any;
+export declare function close_all(ctx: Context, comment?: string, when?: any, alert_message?: string, immediately?: any, disable_alert?: any): any;
+export declare function cancel(ctx: Context, id: string, when?: any): void;
+export declare function cancel_all(ctx: Context): void;
+export declare function exit(ctx: Context, id: string, from_entry?: string, qty?: any, qty_percent?: any, profit?: any, limit?: any, loss?: any, stop?: any, trail_price?: any, trail_points?: any, trail_offset?: any, oca_name?: string, comment?: string, when?: any, alert_message?: string, comment_profit?: string, comment_loss?: string, comment_trailing?: string): void;
+export declare function processPendingOrders(ctx: Context, high: number, low: number): void;
+export interface MarketOrder {
+    kind: "entry" | "close";
+    id: string;
+    direction?: string;
+    qty?: number;
+    comment?: string;
+    /** For a close: the entry it closes, or absent for the whole position. */
+    entry?: string;
+    /** For a close: `qty` / `qty_percent`, which limit how much of that entry goes. */
+    qty_percent?: number;
+    /** For an entry placed by `strategy.order`, which `pyramiding` does not bind. */
+    exempt?: boolean;
+    /** For an entry: the close of the bar that placed it, which sizes it (see `Broker.sizesAtOrderPrice`). */
+    placedClose?: number;
+    /** For a close placed with `immediately`: it fills at the close of this bar, once the script has run. */
+    atClose?: boolean;
+}
+/** @getter */
+export declare function position_size(ctx: Context): number;
+/** @getter */
+export declare function opentrades(ctx: Context): number;
+/** @getter */
+export declare function max_drawdown(ctx: Context): number;
+/** @getter */
+export declare function max_drawdown_percent(ctx: Context): number;
+/** @getter */
+export declare function max_runup(ctx: Context): number;
+/** @getter */
+export declare function max_runup_percent(ctx: Context): number;
+/**
+ * Converts between the strategy's account currency and the symbol's. One
+ * currency runs here, so a value converts to itself.
+ */
+export declare function convert_to_symbol(value: any): number;
+export declare function convert_to_account(value: any): number;
+/**
+ * `strategy.default_entry_qty(fill_price)` — the quantity a `strategy.entry`
+ * with no `qty` would take at that price, by the script's default_qty_type.
+ */
+export declare function default_entry_qty(ctx: Context, fill_price: any): number;
+/**
+ * `strategy.margin_liquidation_price` — where the open position would be
+ * margin-called: the price at which equity falls to the margin it requires,
+ *
+ *     cash + (price - entry) * size = |size| * price * margin
+ *
+ * solved for price. `na` when flat, when the side's margin is 0, and for a
+ * long at 100% margin, which no price can call. TradingView's log has na on
+ * every long and 82588.14 for a 1.209 short entered at 82387.95.
+ *
+ * @getter
+ */
+export declare function margin_liquidation_price(ctx: Context): number;
+/** @getter */
+export declare function equity(ctx: Context): number;
+/**
+ * `strategy.position_avg_price` — the average entry price of the OPEN position.
+ *
+ * `na` while flat rather than 0: a script that plots it should draw nothing
+ * between trades, and zero would draw a line at the bottom of the chart.
+ *
+ * @getter
+ */
+export declare function position_avg_price(ctx: Context): number;
+/**
+ * `strategy.closedtrades` — how many trades have been closed.
+ *
+ * Also the root of the `strategy.closedtrades.*` accessors, which live in
+ * ./trades.ts; see the note there for why the two cannot share a file.
+ *
+ * @getter
+ */
+export declare function closedtrades(ctx: Context): number;
+/**
+ * `strategy.netprofit` — total REALISED profit, in the strategy's currency.
+ *
+ * Realised only: an open position's paper gain is `strategy.openprofit`, and
+ * the two together are what `strategy.equity` reports. Summed from the closed
+ * trades rather than tracked incrementally, so it cannot drift from them.
+ *
+ * @getter
+ */
+export declare function netprofit(ctx: Context): number;
+/**
+ * `strategy.openprofit` — the UNREALISED profit of the open position.
+ *
+ * @getter
+ */
+export declare function openprofit(ctx: Context): number;
+/**
+ * `strategy.grossprofit` and `strategy.grossloss` — the two halves of
+ * `netprofit`, both reported as POSITIVE numbers.
+ *
+ * @getter
+ */
+export declare function grossprofit(ctx: Context): number;
+/** @getter */
+export declare function grossloss(ctx: Context): number;
+/**
+ * `strategy.initial_capital` — the equity the strategy started with.
+ *
+ * @getter
+ */
+export declare function initial_capital(ctx: Context): number;
+/**
+ * `strategy.wintrades` / `strategy.losstrades` / `strategy.eventrades` — how
+ * the closed trades came out.
+ *
+ * A trade that broke exactly even is neither a win nor a loss, which is why
+ * there are three and not two: `wintrades + losstrades` does NOT have to equal
+ * `closedtrades`, and a script that assumes it does misreports its win rate.
+ *
+ * @getter
+ */
+export declare function wintrades(ctx: Context): number;
+/** @getter */
+export declare function losstrades(ctx: Context): number;
+/** @getter */
+export declare function eventrades(ctx: Context): number;
+/**
+ * `strategy.avg_winning_trade` / `strategy.avg_losing_trade` — the mean result
+ * of the winners and of the losers, both as POSITIVE amounts.
+ *
+ * `na` when there are none of that kind, not 0: a strategy that has never lost
+ * has no average loss, and reporting zero would make a profit factor infinite
+ * in one direction and meaningless in the other.
+ *
+ * @getter
+ */
+export declare function avg_winning_trade(ctx: Context): number;
+/** @getter */
+export declare function avg_losing_trade(ctx: Context): number;
+/**
+ * `strategy.avg_trade_percent` — the mean of each closed trade's result as a
+ * percentage of what it cost to enter (entry price × size).
+ * @getter
+ */
+export declare function avg_trade_percent(ctx: Context): number;
+/**
+ * `strategy.openprofit_percent` — the open position's unrealised result as a
+ * percentage of the initial capital, as `netprofit_percent` is of realised.
+ * @getter
+ */
+export declare function openprofit_percent(ctx: Context): number;
+/** `strategy.avg_trade` — the mean result of ALL closed trades, signed. @getter */
+export declare function avg_trade(ctx: Context): number;
+/**
+ * `strategy.netprofit_percent` — realised profit as a percentage of the
+ * starting equity.
+ *
+ * @getter
+ */
+export declare function netprofit_percent(ctx: Context): number;
+/** @getter */
+export declare function grossprofit_percent(ctx: Context): number;
+/** @getter */
+export declare function grossloss_percent(ctx: Context): number;
+/**
+ * `strategy.account_currency` — the currency the strategy's results are in.
+ *
+ * Set by `strategy(..., currency = ...)`, and `currency.NONE` — the empty
+ * string — when the script did not ask, which means the symbol's own currency.
+ * A script pairs it with `request.currency_rate(syminfo.currency,
+ * strategy.account_currency)` to convert position values.
+ *
+ * @getter
+ */
+export declare function account_currency(ctx: Context): string;
+/** Size orders in contracts/shares — the default. */
+export declare const fixed = "strategy.fixed";
+/** Size orders as an amount of CASH in the strategy's currency. */
+export declare const cash = "strategy.cash";
+/** Size orders as a PERCENTAGE of available equity. */
+export declare const percent_of_equity = "strategy.percent_of_equity";
+export declare const __IS_NAMESPACE__ = true;

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

@@ -0,0 +1,209 @@
+/**
+ * `syminfo.*` — what a script can ask about its instrument.
+ *
+ * The namespace arrived at v4 (§3a of the migration guide), which moved the
+ * v1–v3 flat `ticker` and `tickerid` into it. Those two already live in
+ * ./chart.ts and ./ui.ts and are aliased by the rename table; this file adds the
+ * TEN members that have no earlier spelling.
+ *
+ * Descriptions are quoted from the manual's Chart information page:
+ *
+ *   basecurrency  "a string representing the instrument's base currency if the
+ *                  current symbol refers to a Forex pair, a cryptocurrency
+ *                  pair, or a derivative instrument based on a currency pair"
+ *   currency      "the currency of the instrument's quoted prices, or "NONE"
+ *                  if the dataset's values do not represent currency amounts"
+ *   description   "the description or extended name of the current instrument"
+ *   mintick       "the dataset's minimum tick size, i.e., the smallest
+ *                  increment by which the instrument's recorded prices change"
+ *   pointvalue    "the instrument's point value, which represents a multiplier
+ *                  of the instrument's price for determining the value of a
+ *                  single contract"
+ *   prefix        "the symbol's broker/exchange identifier"
+ *   root          "the instrument's root code if the symbol refers to a futures
+ *                  contract ... Otherwise, it stores the same value as
+ *                  syminfo.ticker"
+ *   session       "the dataset's session setting"
+ *   timezone      "the dataset's exchange time zone in the IANA time zone
+ *                  database format"
+ *   type          "the instrument's type. Possible values include "stock",
+ *                  "futures", "index", "forex", "crypto", "fund", "dr", "cfd",
+ *                  "bond", "warrant", "structured", and "right""
+ *
+ * ── Why every one of these is a getter over the Context ─────────────────────
+ *
+ * None is derivable from a bar. A CSV of prices does not record which exchange
+ * listed them or what currency they are in, so the HOST declares them — see
+ * `Context.provideSymbolInfo`, which also states each default.
+ *
+ * ── Why the absence of these was worse than an error ────────────────────────
+ *
+ * `syminfo` is a namespace the engine already had, and the emitter's namespace
+ * check asks only whether the ROOT exists — deliberately, since asserting
+ * registry completeness would reject a script for a member the engine simply
+ * has not got round to. So `syminfo.mintick` compiled, read `undefined`, and
+ * arithmetic on it produced `NaN` on every bar with no diagnostic anywhere.
+ * Twelve of TradingView's own v5 examples use it.
+ *
+ * v4+, which this file does not enforce: the registry split in ./index.ts keeps
+ * the namespace out of the v1–v3 view.
+ */
+import { Context } from "../context.js";
+export declare const syminfo: {
+    /**
+     * The dataset's symbol WITHOUT the exchange prefix — "AAPL".
+     *
+     * v4's spelling of the v1–v3 `ticker` variable, and implemented here rather
+     * than aliased to it so that it stays a sibling of `prefix`: the two are one
+     * split of one string.
+     * @getter
+     */
+    ticker: (ctx: Context) => string;
+    /**
+     * The full ticker identifier — "NASDAQ:AAPL".
+     *
+     * ── The conflation this ends ────────────────────────────────────────────
+     *
+     * Pine keeps FUNCTIONS and VARIABLES in separate namespaces, so v1–v4 spell
+     * two different things `tickerid`:
+     *
+     *   tickerid                    the current chart's ticker id  (a VARIABLE)
+     *   tickerid(prefix, ticker)    builds one from its parts      (a FUNCTION)
+     *
+     * v4 renamed only the variable — "The `ticker` and `tickerid` variables are
+     * renamed to `syminfo.ticker` and `syminfo.tickerid` respectively" — and v5
+     * renamed only the function, to `ticker.new`. This engine has one registry
+     * key per name, so it had aliased `syminfo.tickerid` to the FUNCTION: 89
+     * uses across TradingView's own v5 examples each read a function object
+     * instead of a string, silently.
+     * @getter
+     */
+    tickerid: (ctx: Context) => string;
+    /**
+     * The instrument's base currency — the LEFT half of a pair.
+     * @getter
+     */
+    basecurrency: (ctx: Context) => string;
+    /**
+     * The currency the instrument's prices are quoted in.
+     * @getter
+     */
+    currency: (ctx: Context) => string;
+    /**
+     * The instrument's description or extended name.
+     * @getter
+     */
+    description: (ctx: Context) => string;
+    /**
+     * The smallest increment by which prices change.
+     * @getter
+     */
+    mintick: (ctx: Context) => number;
+    /**
+     * The price multiplier for one contract.
+     * @getter
+     */
+    pointvalue: (ctx: Context) => number;
+    /**
+     * The broker/exchange identifier — "NASDAQ" for "NASDAQ:AAPL".
+     *
+     * DERIVED from the ticker id rather than stored, so the two cannot
+     * disagree: they are two readings of one string.
+     * @getter
+     */
+    prefix: (ctx: Context) => string;
+    /**
+     * The futures root code, or the plain ticker when the symbol is not one.
+     *
+     * The fallback is the manual's, not a convenience: "Otherwise, it stores
+     * the same value as syminfo.ticker."
+     * @getter
+     */
+    root: (ctx: Context) => string;
+    /**
+     * The dataset's session setting — "regular" or "extended".
+     * @getter
+     */
+    session: (ctx: Context) => string;
+    /**
+     * The exchange time zone, in IANA format.
+     *
+     * ⚠ This engine does not SHIFT anything by it. ./time.ts evaluates every
+     * calendar value in UTC and states the same divergence: a host that wants
+     * agreement supplies bar timestamps already shifted. Reporting the zone
+     * while ignoring it would be worse than reporting nothing, so it is said
+     * here too.
+     * @getter
+     */
+    timezone: (ctx: Context) => string;
+    /**
+     * The instrument's type — "stock", "futures", "crypto", "forex", …
+     * @getter
+     */
+    type: (ctx: Context) => string;
+    /**
+     * "The number of minimum price ticks in one point" side of the mintick:
+     * `syminfo.mintick = syminfo.minmove / syminfo.pricescale`. With the
+     * host stating only the tick, minmove is 1 and pricescale its inverse.
+     * @getter
+     */
+    pricescale: (ctx: Context) => number;
+    /** @getter */
+    minmove: (ctx: Context) => number;
+    /**
+     * Company and contract facts a host may know and this engine does not:
+     * empty strings, and `na` for the expiry of a symbol that is not a future.
+     * @getter
+     */
+    sector: (_ctx: Context) => string;
+    /** @getter */
+    industry: (_ctx: Context) => string;
+    /** @getter */
+    country: (_ctx: Context) => string;
+    /** @getter */
+    expiration_date: (_ctx: Context) => number;
+    /**
+     * What the symbol's volume counts: "base" (units of the base currency, as
+     * a crypto pair's does), "quote", "tick", or "n/a" when unspecified.
+     * @getter
+     */
+    volumetype: (ctx: Context) => string;
+    /**
+     * Company fundamentals and analyst figures: data a host may hold and this
+     * engine does not, so `na`.
+     * @getter
+     */
+    shares_outstanding_float: (_ctx: Context) => number;
+    /** @getter */
+    shares_outstanding_total: (_ctx: Context) => number;
+    /** @getter */
+    employees: (_ctx: Context) => number;
+    /** @getter */
+    shareholders: (_ctx: Context) => number;
+    /** @getter */
+    recommendations_buy: (_ctx: Context) => number;
+    /** @getter */
+    recommendations_buy_strong: (_ctx: Context) => number;
+    /** @getter */
+    recommendations_date: (_ctx: Context) => number;
+    /** @getter */
+    recommendations_hold: (_ctx: Context) => number;
+    /** @getter */
+    recommendations_sell: (_ctx: Context) => number;
+    /** @getter */
+    recommendations_sell_strong: (_ctx: Context) => number;
+    /** @getter */
+    recommendations_total: (_ctx: Context) => number;
+    /** @getter */
+    target_price_average: (_ctx: Context) => number;
+    /** @getter */
+    target_price_date: (_ctx: Context) => number;
+    /** @getter */
+    target_price_estimates: (_ctx: Context) => number;
+    /** @getter */
+    target_price_high: (_ctx: Context) => number;
+    /** @getter */
+    target_price_low: (_ctx: Context) => number;
+    /** @getter */
+    target_price_median: (_ctx: Context) => number;
+};