openpinescript 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,20 @@
+/**
+ * `font.*` — the two font families a label, box or table cell may ask for.
+ *
+ * Pine offers a choice of exactly two, and neither is a font NAME: they are
+ * requests for "the chart's usual typeface" and "something monospaced", which
+ * the platform resolves. This engine draws nothing, so it carries the constant
+ * through to the drawing record and no further.
+ *
+ * The values are the strings a renderer would want, so a host that does draw
+ * gets something usable rather than an opaque integer.
+ *
+ * v5-only: the registry split in ./index.ts keeps the namespace out of the
+ * v1–v4 views.
+ */
+export declare const font: {
+    /** The chart's default typeface. */
+    family_default: string;
+    /** A monospaced typeface — what a table of aligned numbers wants. */
+    family_monospace: string;
+};

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

@@ -0,0 +1,76 @@
+/**
+ * `request.footprint()` and the `footprint` / `volume_row` types — v6,
+ * January 2026.
+ *
+ * Signature and semantics, from the user manual ("Other timeframes and data",
+ * request.footprint()):
+ *
+ *   request.footprint(ticks_per_row, va_percent, imbalance_percent) → series footprint
+ *
+ *   ticks_per_row      "simple int": row size as a multiple of syminfo.mintick
+ *   va_percent         "simple float", default 70: share of total volume in the
+ *                      Value Area
+ *   imbalance_percent  "simple float", default 300: the buy/sell difference
+ *                      against an adjacent row that makes an imbalance
+ *
+ * "Returns a footprint ID, or na if no footprint is available for the bar."
+ * "Scripts can make only one request.footprint() call. Multiple calls cause a
+ * runtime error."
+ *
+ * ── Where the data comes from ──────────────────────────────────────────────
+ *
+ * Volume at price is not in an OHLCV bar, so the host supplies it, the way it
+ * supplies higher-timeframe candles: Context.provideFootprints, as volume per
+ * price LEVEL. This module groups levels into rows of `ticks_per_row` ticks and
+ * derives everything else — POC, Value Area, imbalances — from them.
+ *
+ * A script that requests footprints from a host that supplied none is refused,
+ * with the call that would fix it, which is the rule every other `request.*`
+ * here follows (./request.ts). A bar the host has no footprint for is `na`, as
+ * documented.
+ *
+ * ── Not documented, so chosen and stated ───────────────────────────────────
+ *
+ *   Row bounds     [k·size, (k+1)·size) — `down_price` is the row's floor and
+ *                  `up_price` its ceiling.
+ *   POC tie        the LOWER row, when two rows share the highest volume.
+ *   Value Area     grown one row at a time from the POC, taking whichever
+ *                  neighbour has more volume (the upper on a tie), until it
+ *                  holds `va_percent` of the bar's volume.
+ *   Imbalance      "exceeds ... by the given percentage" is read as a RATIO:
+ *                  300 means at least three times the other row's volume, and
+ *                  a row with no volume on the relevant side is no imbalance.
+ *
+ * These want a TradingView-captured fixture before they are trusted for
+ * numbers.
+ */
+import { Context } from "../context.js";
+import { type Row } from "../footprint.js";
+export declare const request: {
+    /** See the header for the signature and for what is documented. */
+    footprint: (ctx: Context, ticks_per_row: any, va_percent?: any, imbalance_percent?: any) => any;
+};
+export declare const footprint: {
+    total_volume: (id: any) => number;
+    buy_volume: (id: any) => number;
+    sell_volume: (id: any) => number;
+    delta: (id: any) => number;
+    /** The row with the highest total volume — the Point of Control. */
+    poc: (id: any) => Row;
+    /** The Value Area High row. */
+    vah: (id: any) => Row;
+    /** The Value Area Low row. */
+    val: (id: any) => Row;
+    /** "Every row, sorted by ascending price." A copy, so a script cannot reorder the footprint. */
+    rows: (id: any) => Row[];
+};
+export declare const volume_row: {
+    up_price: (id: any) => number;
+    down_price: (id: any) => number;
+    buy_volume: (id: any) => number;
+    sell_volume: (id: any) => number;
+    total_volume: (id: any) => number;
+    delta: (id: any) => number;
+    has_buy_imbalance: (id: any) => boolean;
+    has_sell_imbalance: (id: any) => boolean;
+};

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

@@ -0,0 +1,57 @@
+/**
+ * `format.*` — how a script's numbers are rendered.
+ *
+ * Two unrelated jobs share the namespace, which is why the values below are
+ * sentinels rather than anything computable:
+ *
+ *   1. `indicator(..., format = format.price, precision = 2)` — the price-axis
+ *      and Data Window rendering of every plot the script makes.
+ *
+ *      "The format parameter defines the type of formatting used for study
+ *       values appearing on the price axis, in indicator values or in the Data
+ *       Window, with possible values being: format.inherit, format.price and
+ *       format.volume."
+ *
+ *      "When format.price is used, the default precision will be '2', unless
+ *       one is specified using precision=."
+ *
+ *      "When format.volume is used, the format is equivalent to precision=0
+ *       used in earlier versions of Pine, where '5183' becomes '5.183K'."
+ *
+ *   2. `str.tostring(value, format.mintick)` — round to tick precision, then
+ *      stringify.
+ *
+ *      "use str.tostring(myValue, format.mintick) to first round the number to
+ *       tick precision and then return its string representation."
+ *
+ * ── Why the values are these strings ────────────────────────────────────────
+ *
+ * `str.tostring`'s second argument is EITHER one of these constants or a Pine
+ * number-format string like "#.##". The two have to be told apart at runtime,
+ * and a sentinel that reads back as its own name is the cheapest way to do it
+ * that also survives being printed: a script that puts `format.price` somewhere
+ * it does not belong sees `"format.price"` rather than `0` or `undefined`.
+ *
+ * Job (1) does not affect any number this engine computes. There is no price
+ * axis and no Data Window, so the constant is carried and ignored — the plot
+ * values are the same either way. That is a real difference from TradingView in
+ * what a user SEES, and none at all in what the script calculates.
+ *
+ * v5-only: the registry split in ./index.ts keeps the namespace out of the
+ * v1–v4 views. (v4 has a `format` argument on `study()` too, but spells its
+ * constants without the namespace.)
+ */
+/** The prefix every `format.*` sentinel carries, so they can be recognised. */
+export declare const FORMAT_PREFIX = "format.";
+export declare const format: {
+    /** Inherit the chart's own price formatting. The default. */
+    inherit: string;
+    /** Round to the instrument's tick size — `str.tostring`'s one live use. */
+    mintick: string;
+    /** Render as a percentage. */
+    percent: string;
+    /** Price formatting; implies `precision = 2` unless one is given. */
+    price: string;
+    /** Volume formatting: 5183 renders as "5.183K". */
+    volume: string;
+};

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

@@ -0,0 +1,71 @@
+import { Context } from "../context.js";
+import { StdlibEntry } from "./metadata.js";
+/**
+ * The v1–v3 stdlib: everything generated, minus the namespaces that do not
+ * exist yet.
+ *
+ * The subtraction is what keeps `array.new_float`, `label.new` and `str.length`
+ * from resolving at v1 — they live in the ordinary stdlib source files, because
+ * the runtime is one implementation across versions, so nothing else would stop
+ * them.
+ */
+export declare const BASE_REGISTRY: Record<string, StdlibEntry>;
+/** The v4-only names, kept aside so v4's view can add them back. */
+export declare const V4_NAMESPACE_REGISTRY: Record<string, StdlibEntry>;
+/** The v5-only names, kept aside so v5's view can add them back. */
+export declare const V5_NAMESPACE_REGISTRY: Record<string, StdlibEntry>;
+export declare const V4_REGISTRY: Record<string, StdlibEntry>;
+export declare const V4_VIEW: Record<string, StdlibEntry>;
+export declare const V5_REGISTRY: Record<string, StdlibEntry>;
+/** What a v5 script may spell. */
+export declare const V5_VIEW: Record<string, StdlibEntry>;
+/**
+ * The v6-only names, kept out of every earlier view and added back here.
+ *
+ * Built from GENERATED rather than from a literal, so a name on the v6 list
+ * that nothing implements yet is simply absent — rather than a registry entry
+ * pointing at nothing, which would compile and then fail at run time.
+ */
+export declare const V6_REGISTRY: Record<string, StdlibEntry>;
+/**
+ * What a v6 script may spell.
+ *
+ * v6 is the first version since v3 that renames nothing. Its registry delta is
+ * entirely SUBTRACTIVE plus a handful of new members, so this view is built
+ * the same way V5_VIEW is — remove, then add — with an empty rename table.
+ *
+ * The removals are the migration guide's: `transp` off the six plotting
+ * functions, `when` off the seven strategy functions. Those are PARAMETERS
+ * rather than registry keys, so they are enforced by the emitter, which can
+ * name the line; see transpiler/v6/ToJsVisitor.ts. Nothing v5 could spell as a
+ * NAME was taken away, which is why V6_REMOVED is empty rather than absent —
+ * an empty list that is spread is a statement that the question was asked.
+ */
+export declare const V6_VIEW: Record<string, StdlibEntry>;
+/**
+ * Every name the RUNTIME can resolve, at any version.
+ *
+ * Deliberately the union. The runtime is shared across versions by design
+ * (docs/common/ARCHITECTURE.md ("Design rules")) and is not the gatekeeper — the
+ * transpiler decides what a given version may spell and refuses to emit
+ * anything else. A union here just means the sandbox can execute whatever the
+ * transpiler let through.
+ *
+ * ORDER MATTERS for the one key that means different things at different
+ * versions: `input.float` is a constant at v4 and a function at v5, and one
+ * sandbox holds one object per name. V5_NAMESPACE_REGISTRY comes after
+ * V4_REGISTRY so the FUNCTION wins, and ./inputs.ts gives that function a
+ * `valueOf` returning the v4 constant so both readings survive.
+ */
+export declare const REGISTRY: Record<string, StdlibEntry>;
+/**
+ * The view a given version writes against.
+ *
+ * Used by `createStdlib` to settle the handful of keys that MEAN different
+ * things at different versions. It is not a gatekeeper — the transpiler decides
+ * what a version may spell, and this function is never consulted about whether
+ * a name is allowed, only about which of two meanings a name has.
+ */
+export declare function viewFor(version: number): Record<string, StdlibEntry>;
+export declare function createStdlib(ctx: Context): Record<string, any>;
+export { UNIMPLEMENTED_BUILTINS } from "./renames.js";

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

@@ -0,0 +1,14 @@
+import { Context } from "../context.js";
+/**
+ * Pine Script input() function
+ * @returns series float (or int/bool depending on type)
+ */
+export declare function input(ctx: Context, defval: any, title?: any, type?: any, minval?: any, maxval?: any, confirm?: any, step?: any, options?: any, tooltip?: any, inline?: any, group?: any, display?: any, active?: any): any;
+export declare const integer = "integer";
+export declare const float = "float";
+export declare const bool = "bool";
+export declare const string = "string";
+export declare const source = "source";
+export declare const resolution = "resolution";
+export declare const session = "session";
+export declare const symbol = "symbol";

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

@@ -0,0 +1,60 @@
+/**
+ * v5's TYPED input functions — `input.int()`, `input.float()`, `input.bool()`, …
+ *
+ * ── What changed at v5 ──────────────────────────────────────────────────────
+ *
+ * v1–v3 pass the type as a value: `input(14, type=integer)`.
+ * v4 moves those values into a namespace: `input(14, type=input.integer)`.
+ * v5 removes them as values and makes them FUNCTIONS: `input.int(14)`.
+ *
+ * Two of them also change name in the process — `integer` becomes `int` and
+ * `resolution` becomes `timeframe` (docs/common/VERSIONS.md §4c).
+ *
+ * ── Six of these names collide with v4's constants ──────────────────────────
+ *
+ * `float`, `bool`, `string`, `source`, `session` and `symbol` are live at BOTH
+ * v4 (as constants, holding the type name) and v5 (as the functions below), and
+ * the sandbox holds ONE object per name. Nothing in this file resolves that:
+ * `createStdlib` in ./index.ts binds each version's own meaning, reading the
+ * version off the Context.
+ *
+ * The alternative — one object that is callable AND stringifies to the v4
+ * constant — was tried and abandoned. It works for `input(1.0,
+ * type=input.float)`, which unwraps its argument, and leaks everywhere else:
+ * `x = input.float` at v4 binds a function that merely LOOKS like "float" to
+ * anything that asks it politely.
+ *
+ * `int`, `timeframe`, `color`, `time`, `price` and `text_area` have no v4
+ * constant of the same spelling, so they collide with nothing.
+ */
+import { Context } from "../context.js";
+export declare const input: {
+    int: (ctx: Context, defval: any, title?: any, minval?: any, maxval?: any, step?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, options?: any, active?: any) => any;
+    float: (ctx: Context, defval: any, title?: any, minval?: any, maxval?: any, step?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, options?: any, active?: any) => any;
+    bool: (ctx: Context, defval: any, title?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    string: (ctx: Context, defval: any, title?: any, options?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    color: (ctx: Context, defval: any, title?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    /** v5's rename of v4's `input.resolution`. */
+    timeframe: (ctx: Context, defval: any, title?: any, options?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    session: (ctx: Context, defval: any, title?: any, options?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    symbol: (ctx: Context, defval: any, title?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    /** The chart series an indicator runs on — `close`, `hl2`, another plot. */
+    source: (ctx: Context, defval: any, title?: any, tooltip?: any, inline?: any, group?: any, display?: any, active?: any) => any;
+    time: (ctx: Context, defval: any, title?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    price: (ctx: Context, defval: any, title?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    text_area: (ctx: Context, defval: any, title?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+    /**
+     * `input.enum(defaultValue, title, options, …)` — a dropdown of enum members.
+     *
+     * June 2024, with enums themselves: they "enable convenient dropdown input
+     * creation with the new input.enum() function", and "the input displays all
+     * enum field titles in its dropdown menu".
+     *
+     * The declared type is `enum` rather than `string` so a host rendering the
+     * inputs can list the right choices: `Context.enumMembers` holds every
+     * member of the enum the default belongs to, and `Context.enumTitles` turns
+     * each into the text the dropdown should show. A plain `string` input would
+     * offer a free-text box for a value that must be one of a fixed set.
+     */
+    enum: (ctx: Context, defval: any, title?: any, options?: any, tooltip?: any, inline?: any, group?: any, confirm?: any, display?: any, active?: any) => any;
+};

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

@@ -0,0 +1,97 @@
+/**
+ * Members whose NAMESPACE is older than they are.
+ *
+ * Most of `math.*`, `ta.*` and `ticker.*` is not written anywhere in that form.
+ * It is the v1–v4 FLAT names — `abs`, `sma`, `heikinashi` — which the v5 rename
+ * table moves under a namespace, so `math.ts`, `ta.ts` and `chart.ts` export
+ * flat functions and must keep doing so.
+ *
+ * The members below have no flat ancestor, and each one COLLIDES with a flat
+ * name that does:
+ *
+ *   math.pi      `math.ts` is the module named math; an object literal in it
+ *                could not also be called `math`
+ *   ta.max/min   flat `max` and `min` are already taken — they are what become
+ *                `math.max` and `math.min`
+ *   ticker.modify  flat `ticker` is already taken — it is the v1–v3 symbol name,
+ *                a FUNCTION, and TypeScript will not let one name be both
+ *
+ * So they are declared here as object literals, which the registry generator
+ * turns straight into dotted keys, and `createStdlib` merges onto the flat
+ * function of the same name where there is one. Gated to v5 with the rest of
+ * their namespaces by V5_ONLY_NAMESPACES.
+ */
+import { Context } from "../context.js";
+/** @returns {const float} */
+export declare const math: {
+    /** The ratio of a circle's circumference to its diameter. */
+    pi: number;
+    /** Euler's number, the base of the natural logarithm. */
+    e: number;
+    /**
+     * The golden ratio, (1 + √5) / 2.
+     *
+     * Written out rather than hard-coded to its decimal expansion so it carries
+     * every bit of double precision — a Fibonacci retracement level computed from
+     * a truncated constant drifts from TradingView's by the last digits, which is
+     * exactly the kind of divergence this engine exists to avoid.
+     */
+    phi: number;
+    /** The RECIPROCAL golden ratio, (√5 − 1) / 2 — `math.phi` minus one. */
+    rphi: number;
+};
+export declare const ta: {
+    /**
+     * The highest value `source` has held since the script began.
+     *
+     * `na` is SKIPPED rather than compared. A single absent bar would otherwise
+     * poison the record permanently — `NaN > x` is false and `x > NaN` is false,
+     * so the comparison never recovers — which is the same rule `ta.cum` follows
+     * and for the same reason.
+     *
+     * Undefined before the first finite value, which is `na`: a series that has
+     * never had a value has no maximum, and answering 0 would put a floor on
+     * every chart that plots it.
+     *
+     * @returns {series float} The all-time high, or na.
+     */
+    max: (ctx: Context, source: any) => number;
+    /**
+     * The lowest value `source` has held since the script began.
+     * @returns {series float} The all-time low, or na.
+     */
+    min: (ctx: Context, source: any) => number;
+};
+/**
+ * `ticker.modify(tickerid, session, adjustment, …)` — August 2024.
+ *
+ * Rebuilds a ticker id with different session or adjustment settings, leaving
+ * the symbol alone: `ticker.modify(syminfo.tickerid, session.extended)` is the
+ * standard way to ask for extended hours without hard-coding the symbol.
+ *
+ * The result is a MARKED symbol string, exactly as `heikinashi()` returns one —
+ * `Context.getSecurityData` reads the marker when the candles are fetched, so
+ * the whole request pipeline is reused rather than duplicated. A host that
+ * ignores the marker gets regular-session data, which is what it has.
+ */
+export declare const ticker: {
+    /**
+     * `ticker.standard(symbol)` — the ticker id with any non-standard chart
+     * type removed ("heikinashi:", "renko:" …), so a request reads ordinary
+     * candles. A plain id is returned as it is.
+     */
+    standard: (symbol?: any) => string;
+    /**
+     * `ticker.inherit(tickerid, from_tickerid)` — take another symbol's settings.
+     *
+     * Builds a ticker id for `tickerid` carrying whatever session, adjustment and
+     * chart-type modifiers `from_tickerid` was built with. The point is that the
+     * two requests then agree: comparing a symbol against an index is only
+     * meaningful if both are asked for on the same terms.
+     *
+     * The modifiers are the query string `ticker.modify` writes, so inheriting
+     * them is copying that half of the id onto a different symbol.
+     */
+    inherit: (tickerid: any, from_tickerid: any) => string;
+    modify: (tickerid: any, session?: any, adjustment?: any, ..._rest: any[]) => string;
+};

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

@@ -0,0 +1,31 @@
+/**
+ * Pine Logs — the `log.*` namespace. v5 only.
+ *
+ * ── Why this matters more than it looks ─────────────────────────────────────
+ *
+ * `log.info()` is how this project collects golden data from TradingView
+ * without a PRO+ subscription. "Export chart data…" is a paid feature; Pine
+ * Logs are not, they run on HISTORICAL bars (unlike `alert()`, which only ever
+ * fires on realtime bars), and they retain the last 10,000 messages. Every
+ * harness in conformance/v5/golden ends by writing one CSV row per bar through
+ * `log.info`, and scripts/common/make-log-harness.ts generates them.
+ *
+ * So the engine must be able to RUN those harnesses, not merely compile them —
+ * otherwise the one artefact that proves the harness itself is well-formed
+ * cannot be produced locally before it is pasted into TradingView.
+ *
+ * ── The flat `log` collision ────────────────────────────────────────────────
+ *
+ * v1–v4 spell the natural logarithm as the bare function `log(x)`; v5 renames
+ * it to `math.log` and gives the word to this namespace. Both spellings exist
+ * in the RUNTIME registry at once, deliberately — the runtime is one
+ * implementation across versions, and the transpiler decides which spelling
+ * each version may write. `createStdlib` in ./index.ts merges a namespace onto
+ * a callable of the same name, which is what makes the two coexist.
+ */
+import { Context } from "../context.js";
+export declare const log: {
+    info: (ctx: Context, message: any, ...args: any[]) => void;
+    warning: (ctx: Context, message: any, ...args: any[]) => void;
+    error: (ctx: Context, message: any, ...args: any[]) => void;
+};

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

@@ -0,0 +1,55 @@
+/**
+ * Pine Script maps — the `map.*` namespace. v5, August 2023.
+ *
+ * ── Representation ──────────────────────────────────────────────────────────
+ *
+ * A JavaScript `Map`, unwrapped. Same reasoning as arrays (see ./arrays.ts): a
+ * wrapper class would buy a type tag this engine does not model anywhere else,
+ * and cost interop with every iteration in the runtime.
+ *
+ * Keys are STORED UNWRAPPED. A Pine map key is a scalar, but the emitter hands
+ * the runtime a Series wherever the key came from a variable, and `Map` keys
+ * compare by identity — so putting `Series(3)` and later looking up `3` would
+ * miss, and worse, two writes of the same logical key would both be kept. Every
+ * entry point below therefore passes its key through `val` first.
+ *
+ * ── Insertion order is the documented order ─────────────────────────────────
+ *
+ * `map.keys()` and `map.values()` return arrays, and Pine specifies them as
+ * being in insertion order. `Map` iterates in insertion order, so nothing here
+ * has to sort — but a re-`put` of an existing key must not move it to the end,
+ * which is `Map.set`'s behaviour for an existing key and is why `put` does not
+ * delete-then-set.
+ *
+ * v5-only, which this file does not enforce: the registry split in ./index.ts
+ * keeps the namespace out of the v1–v4 views.
+ */
+export declare const map: {
+    /**
+     * `map.new<keyType, valueType>()`.
+     *
+     * The type arguments are parsed by the grammar and discarded by the
+     * emitter: this engine does not track element types anywhere, and a
+     * constructor that pretended to would be checking nothing.
+     */
+    new: () => Map<any, any>;
+    /** Pine returns `na` for a missing key rather than raising. */
+    get: (id: any, k: any) => any;
+    contains: (id: any, k: any) => boolean;
+    size: (id: any) => number;
+    /**
+     * `map.put(id, key, value)` — returns the PREVIOUS value, or na.
+     *
+     * The return value is not decoration: `map.put` is how a script detects a
+     * first write, and dropping it would make that idiom silently impossible.
+     */
+    put: (id: any, k: any, value: any) => any;
+    put_all: (id: any, id2: any) => void;
+    /** Returns the removed value, or na when the key was absent. */
+    remove: (id: any, k: any) => any;
+    clear: (id: any) => void;
+    keys: (id: any) => any[];
+    values: (id: any) => any[];
+    /** A shallow copy — the entries are shared, the map is not. */
+    copy: (id: any) => Map<any, any>;
+};

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

@@ -0,0 +1,71 @@
+/**
+ * The four maths built-ins TradingView added in Pine v4.
+ *
+ * ── Why they are FLAT functions here and not a `math` object ────────────────
+ *
+ * They were gated as v5-only, with a note claiming they had "no v1–v4 spelling
+ * to inherit from". That was wrong, and TradingView's own v4 release notes say
+ * so:
+ *
+ *   "todegrees(radians) - returns an approximately equivalent angle in degrees
+ *    from an angle measured in radians. toradians(degrees) - … random(min, max,
+ *    seed) - returns a pseudo-random value. … Using the same value for the
+ *    optional seed argument will produce a repeatable sequence."
+ *
+ *   "New function was added: round_to_mintick(x) - returns the value rounded to
+ *    the symbol's mintick …"
+ *
+ * All four are v4 built-ins that v5 moved under `math.` along with the rest of
+ * the maths library. So they belong here as flat names, gated to v4+ by
+ * V4_ONLY_NAMES, and aliased to `math.*` at v5 by V5_RENAMES — exactly the
+ * treatment `abs`, `sqrt` and `max` get. Declaring them as an object gave them
+ * `math.` keys directly, which made them unspellable at v4 (a v4 script calling
+ * `random(0, 255)` — as TradingView's own v4 documentation does — died with a
+ * ReferenceError) and left the flat v5 spelling un-removed.
+ *
+ * Source: https://www.tradingview.com/pine-script-docs/v4/release-notes/
+ */
+import { Context } from "../context.js";
+/**
+ * `random(min, max, seed)` — uniform in [min, max).
+ *
+ * ── What `seed` does here, and what it does not ─────────────────────────────
+ *
+ * Pine documents `seed` as making the sequence REPEATABLE, and that is what it
+ * does here: a seeded call draws from a deterministic generator held on the
+ * Context, so two runs of the same script over the same bars produce the same
+ * numbers. That is the property a backtest needs.
+ *
+ * It is NOT the same sequence TradingView produces. Their generator is not
+ * published, so no local implementation can match it, and a seeded script will
+ * disagree with the chart value by value. Stated rather than hidden: the
+ * alternative — ignoring the seed — loses reproducibility as well as parity,
+ * which is strictly worse.
+ *
+ * Unseeded, it is `Math.random`, which is what an unseeded Pine call is.
+ *
+ * @returns {series float} A pseudo-random value in [min, max).
+ */
+export declare function random(ctx: Context, min?: any, max?: any, seed?: any): number;
+/**
+ * Converts an angle measured in radians to an approximately equivalent angle
+ * measured in degrees.
+ * @returns {series float} The angle in degrees.
+ */
+export declare function todegrees(radians: any): number;
+/**
+ * Converts an angle measured in degrees to an approximately equivalent angle
+ * measured in radians.
+ * @returns {series float} The angle in radians.
+ */
+export declare function toradians(degrees: any): number;
+/**
+ * `round_to_mintick(x)` — round to the instrument's tick size.
+ *
+ * The tick comes from the Context rather than a constant: it is a property of
+ * the symbol being charted, and a script that draws a level at a price the
+ * exchange cannot quote is the thing this function exists to prevent.
+ *
+ * @returns {series float} `x` rounded to the nearest multiple of the mintick.
+ */
+export declare function round_to_mintick(ctx: Context, number: any): number;