# AlertaScript

> Official AlertaChart scripting documentation. Documented Pine-compatible spellings run without warnings. The documentation uses the alerta. presentation prefix.

Source code supplied to the editor is not automatically rewritten. Review examples and run them explicitly.

## Guides
- [AlertaScript](https://www.alertachart.com/alertascript): Turn chart data into indicators, strategies and alerts.
- [Getting started](https://www.alertachart.com/alertascript/getting-started): Your path from an empty editor to a useful script.
- [Quick start](https://www.alertachart.com/alertascript/getting-started/quick-start): Plot a configurable EMA in five lines.
- [Editor tour](https://www.alertachart.com/alertascript/getting-started/editor-tour): Write, run, save and inspect your script.
- [Your first indicator](https://www.alertachart.com/alertascript/getting-started/first-indicator): Create an RSI with editable inputs and reference levels.
- [Your first strategy](https://www.alertachart.com/alertascript/getting-started/first-strategy): Turn an EMA crossover into a testable trading rule.
- [Your first alert](https://www.alertachart.com/alertascript/getting-started/first-alert): Expose a named condition in the alert workflow.
- [Language guide](https://www.alertachart.com/alertascript/language): Understand the building blocks behind chart scripts.
- [Syntax and types](https://www.alertachart.com/alertascript/language/syntax-and-types): Declare values, pass arguments and keep types explicit.
- [Series and history](https://www.alertachart.com/alertascript/language/series-and-history): Read the current bar and earlier values safely.
- [Control flow](https://www.alertachart.com/alertascript/language/control-flow): Express conditions and bounded repetition.
- [Functions](https://www.alertachart.com/alertascript/language/functions): Extract a calculation without hiding its inputs.
- [User-defined types and methods](https://www.alertachart.com/alertascript/language/user-defined-types-and-methods): Group related values and attach meaningful operations.
- [Arrays](https://www.alertachart.com/alertascript/language/arrays): Manage an ordered collection with explicit bounds.
- [Maps](https://www.alertachart.com/alertascript/language/maps): Look up values by named keys.
- [Matrices](https://www.alertachart.com/alertascript/language/matrices): Represent and access rectangular numeric data.
- [Strings](https://www.alertachart.com/alertascript/language/strings): Format clear labels and messages.
- [Colors](https://www.alertachart.com/alertascript/language/colors): Separate a visual rule from its calculation.
- [Time and sessions](https://www.alertachart.com/alertascript/language/time-and-sessions): Interpret bar time in the correct market context.
- [Execution model](https://www.alertachart.com/alertascript/language/execution-model): Know what can change before the bar closes.
- [Guides](https://www.alertachart.com/alertascript/guides): Connect language features into practical workflows.
- [Drawings and visuals](https://www.alertachart.com/alertascript/guides/drawing-and-visuals): Choose between series plots and positioned objects.
- [Strategies and backtesting](https://www.alertachart.com/alertascript/guides/strategies-and-backtesting): Interpret simulated orders and exits correctly.
- [Multiple symbols and timeframes](https://www.alertachart.com/alertascript/guides/multi-symbol-and-timeframe): Evaluate an expression in another data context.
- [Order flow data](https://www.alertachart.com/alertascript/guides/order-flow-data): Use available trade-level information deliberately.
- [Alerts](https://www.alertachart.com/alertascript/guides/alerts): Separate the signal, its timing and its message.
- [Pine compatibility and migration](https://www.alertachart.com/alertascript/guides/pine-migration): Move a Pine-style script to AlertaScript: what runs as written, what returns na, and three tested examples.
- [Quick reference](https://www.alertachart.com/alertascript/reference): Find signatures, constants, variables and examples.
- [Frequently asked questions](https://www.alertachart.com/alertascript/faq): Answers to common script authoring questions.
- [Limits and availability](https://www.alertachart.com/alertascript/faq/limitations): Know the boundaries that affect a script result.
- [Troubleshooting](https://www.alertachart.com/alertascript/faq/troubleshooting): Reduce an error to a small, inspectable case.
- [Write with AI](https://www.alertachart.com/alertascript/ai-writing): Ask for a script that can be checked, not just generated.

## API reference

### alerta.ta.barssince
https://www.alertachart.com/alertascript/reference/builtins/ta.barssince
Signature: ta.barssince(condition)
Counts the number of bars since the condition was true.
TradingView-compatible spelling: ta.barssince; runs without warnings.

### alerta.ta.cum
https://www.alertachart.com/alertascript/reference/builtins/ta.cum
Signature: ta.cum(source)
Calculates the cumulative sum of source.
TradingView-compatible spelling: ta.cum; runs without warnings.

### alerta.ta.sma
https://www.alertachart.com/alertascript/reference/builtins/sma
Signature: sma(source, length)
Calculates the simple moving average over an N-bar period.
TradingView-compatible spelling: ta.sma; runs without warnings.

### alerta.ta.ema
https://www.alertachart.com/alertascript/reference/builtins/ema
Signature: ema(source, length)
Calculates the exponential moving average, assigning more weight to recent prices.
TradingView-compatible spelling: ta.ema; runs without warnings.

### alerta.ta.wma
https://www.alertachart.com/alertascript/reference/builtins/wma
Signature: wma(source, length)
Calculates the weighted moving average.
TradingView-compatible spelling: ta.wma; runs without warnings.

### alerta.ta.vwma
https://www.alertachart.com/alertascript/reference/builtins/vwma
Signature: vwma(source, length)
Returns the volume-weighted moving average of source for length bars.
TradingView-compatible spelling: ta.vwma; runs without warnings.

### alerta.ta.rma
https://www.alertachart.com/alertascript/reference/builtins/rma
Signature: rma(source, length)
Wilder's smoothing average (Relative Moving Average), the smoothing RSI and ATR are defined with. It follows Pine's recurrence: the first value is the simple average of the first length values, then alpha * source + (1 - alpha) * previous with alpha = 1 / length.
TradingView-compatible spelling: ta.rma; runs without warnings.

### alerta.ta.macd
https://www.alertachart.com/alertascript/reference/builtins/macd
Signature: macd(source, fast, slow, signal)
Returns MACD line, Signal line and Histogram.
TradingView-compatible spelling: ta.macd; runs without warnings.

### alerta.ta.rsi
https://www.alertachart.com/alertascript/reference/builtins/rsi
Signature: rsi(source, length)
Calculates the RSI, an oscillator measuring the speed and change of price movements.
TradingView-compatible spelling: ta.rsi; runs without warnings.

### alerta.ta.roc
https://www.alertachart.com/alertascript/reference/builtins/roc
Signature: roc(source, length)
Calculates the Rate of Change (percent) over an N-bar period.
TradingView-compatible spelling: ta.roc; runs without warnings.

### alerta.ta.mom
https://www.alertachart.com/alertascript/reference/builtins/mom
Signature: mom(source, length)
Calculates the momentum (difference) over an N-bar period.
TradingView-compatible spelling: ta.mom; runs without warnings.

### alerta.ta.kst
https://www.alertachart.com/alertascript/reference/builtins/kst
Signature: kst(source, roc1, roc2, roc3, roc4, sma1, sma2, sma3, sma4)
Weighted momentum oscillator built from four smoothed ROC components.
TradingView-compatible spelling: ta.kst; runs without warnings.

### alerta.ta.specialK
https://www.alertachart.com/alertascript/reference/builtins/ta.specialk
Signature: ta.specialK(source, length1, length2)
Martin J. Pring's Special K: twelve simple averages of rates of change, from a 10-bar to a 530-bar ROC, weighted 1-2-3-4 within the short, medium and long groups and summed, with a signal line that is a simple average of a simple average of it. Needs about 725 bars of history before its first value.
TradingView-compatible spelling: ta.specialK; runs without warnings.

### alerta.ta.tr
https://www.alertachart.com/alertascript/reference/builtins/tr
Signature: ta.tr(handle_na = false) or tr(high, low, close)
Calculates the True Range for each bar. Pine v6 form is `ta.tr(handle_na)` operating on chart H/L/C; a legacy 3-arg form accepting custom series is also supported.
TradingView-compatible spelling: ta.tr; runs without warnings.

### alerta.ta.cmo
https://www.alertachart.com/alertascript/reference/builtins/cmo
Signature: cmo(source, length)
Calculates the Chande Momentum Oscillator over an N-bar period.
TradingView-compatible spelling: ta.cmo; runs without warnings.

### alerta.ta.stochrsi
https://www.alertachart.com/alertascript/reference/builtins/stochrsi
Signature: stochrsi(source, length, rsiLength, k, d)
Calculates the Stochastic RSI oscillator.
TradingView-compatible spelling: ta.stochrsi; runs without warnings.

### alerta.ta.tsi
https://www.alertachart.com/alertascript/reference/builtins/tsi
Signature: ta.tsi(source, short_length, long_length) or tsi(source, longLength, shortLength)
Calculates the True Strength Index. Pine form `ta.tsi(source, short_length, long_length)`: EMA(EMA(change, long), short) / EMA(EMA(|change|, long), short), a ratio in [-1, 1]. The legacy bare form `tsi(source, longLength, shortLength)` (also `alerta.tsi`) takes the long length first and returns the same index times 100.
TradingView-compatible spelling: ta.tsi; runs without warnings.

### alerta.ta.pvo
https://www.alertachart.com/alertascript/reference/builtins/pvo
Signature: pvo(source, fastLength, slowLength, signalLength)
Calculates the Percentage Volume Oscillator (volume MACD).
TradingView-compatible spelling: ta.pvo; runs without warnings.

### alerta.ta.rvi
https://www.alertachart.com/alertascript/reference/builtins/rvi
Signature: rvi(open, high, low, close, length)
Calculates the Relative Vigor Index and signal line.
TradingView-compatible spelling: ta.rvi; runs without warnings.

### alerta.ta.fisher
https://www.alertachart.com/alertascript/reference/builtins/fisher
Signature: fisher(source, length)
Applies the Fisher Transform to a source series.
TradingView-compatible spelling: ta.fisher; runs without warnings.

### alerta.ta.cfo
https://www.alertachart.com/alertascript/reference/builtins/cfo
Signature: cfo(source, length)
Calculates the Chande Forecast Oscillator.
TradingView-compatible spelling: ta.cfo; runs without warnings.

### alerta.ta.stc
https://www.alertachart.com/alertascript/reference/builtins/stc
Signature: stc(source, fastLength, slowLength, cycleLength)
Calculates the Schaff Trend Cycle oscillator.
TradingView-compatible spelling: ta.stc; runs without warnings.

### alerta.ta.adxr
https://www.alertachart.com/alertascript/reference/builtins/adxr
Signature: adxr(high, low, close, length)
Calculates the ADXR by averaging current ADX with ADX from length bars ago.
TradingView-compatible spelling: ta.adxr; runs without warnings.

### alerta.ta.atrp
https://www.alertachart.com/alertascript/reference/builtins/atrp
Signature: atrp(high, low, close, length)
Calculates ATR as a percentage of price.
TradingView-compatible spelling: ta.atrp; runs without warnings.

### alerta.ta.chaikin
https://www.alertachart.com/alertascript/reference/builtins/chaikin
Signature: chaikin(high, low, close, volume, fastLength, slowLength)
Calculates the Chaikin Oscillator from ADL.
TradingView-compatible spelling: ta.chaikin; runs without warnings.

### alerta.ta.cvi
https://www.alertachart.com/alertascript/reference/builtins/cvi
Signature: cvi(high, low, emaLength, rocLength)
Measures volatility as percent change of EMA(high-low) over a lookback.
TradingView-compatible spelling: ta.cvi; runs without warnings.

### alerta.ta.adosc
https://www.alertachart.com/alertascript/reference/builtins/adosc
Signature: adosc(high, low, close, volume, fastLength, slowLength)
Calculates the Accumulation/Distribution Oscillator (Chaikin).
TradingView-compatible spelling: ta.adosc; runs without warnings.

### alerta.ta.vi
https://www.alertachart.com/alertascript/reference/builtins/vi
Signature: vi(high, low, close, length)
Calculates Vortex Indicator positive/negative lines.
TradingView-compatible spelling: ta.vi; runs without warnings.

### alerta.ta.trix
https://www.alertachart.com/alertascript/reference/builtins/trix
Signature: trix(source, length)
Calculates the percent rate of change of a triple-smoothed EMA.
TradingView-compatible spelling: ta.trix; runs without warnings.

### alerta.ta.willr
https://www.alertachart.com/alertascript/reference/builtins/williamsr
Signature: williamsr(high, low, close, length)
Measures overbought/oversold levels using the high/low range.
TradingView-compatible spelling: ta.willr; runs without warnings.

### alerta.ta.ultosc
https://www.alertachart.com/alertascript/reference/builtins/ultosc
Signature: ultosc(high, low, close, length1, length2, length3)
Calculates the Ultimate Oscillator using three timeframes.
TradingView-compatible spelling: ta.ultosc; runs without warnings.

### alerta.ta.natr
https://www.alertachart.com/alertascript/reference/builtins/natr
Signature: natr(high, low, close, length)
Calculates ATR normalized by price (percent).
TradingView-compatible spelling: ta.natr; runs without warnings.

### alerta.ta.adx
https://www.alertachart.com/alertascript/reference/builtins/adx
Signature: adx(high, low, close, length)
Measures trend strength using the Average Directional Index.
TradingView-compatible spelling: ta.adx; runs without warnings.

### alerta.ta.dmi
https://www.alertachart.com/alertascript/reference/builtins/dmi
Signature: dmi(diLength, adxSmoothing) or dmi(high, low, close, length)
Returns DI+ / DI- and ADX. Pine's form is ta.dmi(diLength, adxSmoothing), which smooths DI and ADX by DIFFERENT lengths and reads the chart's own high/low/close; the 4-argument form is kept for older scripts.
TradingView-compatible spelling: ta.dmi; runs without warnings.

### alerta.ta.aroon
https://www.alertachart.com/alertascript/reference/builtins/aroon
Signature: aroon(high, low, length)
Returns Aroon Up and Aroon Down values.
TradingView-compatible spelling: ta.aroon; runs without warnings.

### alerta.ta.hma
https://www.alertachart.com/alertascript/reference/builtins/hma
Signature: hma(source, length)
Calculates the Hull Moving Average.
TradingView-compatible spelling: ta.hma; runs without warnings.

### alerta.ta.alma
https://www.alertachart.com/alertascript/reference/builtins/alma
Signature: alma(source, length, offset, sigma, floor)
Calculates the Arnaud Legoux Moving Average.
TradingView-compatible spelling: ta.alma; runs without warnings.

### alerta.ta.dema
https://www.alertachart.com/alertascript/reference/builtins/dema
Signature: dema(source, length)
Calculates the Double Exponential Moving Average.
TradingView-compatible spelling: ta.dema; runs without warnings.

### alerta.ta.tema
https://www.alertachart.com/alertascript/reference/builtins/tema
Signature: tema(source, length)
Calculates the Triple Exponential Moving Average.
TradingView-compatible spelling: ta.tema; runs without warnings.

### alerta.ta.trima
https://www.alertachart.com/alertascript/reference/builtins/trima
Signature: trima(source, length)
Calculates the Triangular Moving Average.
TradingView-compatible spelling: ta.trima; runs without warnings.

### alerta.ta.kama
https://www.alertachart.com/alertascript/reference/builtins/kama
Signature: kama(source, length, fast, slow)
Calculates the Kaufman Adaptive Moving Average.
TradingView-compatible spelling: ta.kama; runs without warnings.

### alerta.ta.linreg
https://www.alertachart.com/alertascript/reference/builtins/linreg
Signature: linreg(source, length, offset)
Calculates the Linear Regression value over an N-bar window.
TradingView-compatible spelling: ta.linreg; runs without warnings.

### alerta.ta.t3
https://www.alertachart.com/alertascript/reference/builtins/t3
Signature: t3(source, length, vfactor)
Calculates the Tillson T3 moving average.
TradingView-compatible spelling: ta.t3; runs without warnings.

### alerta.ta.zlema
https://www.alertachart.com/alertascript/reference/builtins/zlema
Signature: zlema(source, length)
Calculates the Zero Lag Exponential Moving Average.
TradingView-compatible spelling: ta.zlema; runs without warnings.

### alerta.ta.smma
https://www.alertachart.com/alertascript/reference/builtins/smma
Signature: smma(source, length)
Calculates the Smoothed Moving Average.
TradingView-compatible spelling: ta.smma; runs without warnings.

### alerta.ta.atr
https://www.alertachart.com/alertascript/reference/builtins/atr
Signature: atr(length)
Calculates the Average True Range, a measure of market volatility.
TradingView-compatible spelling: ta.atr; runs without warnings.

### alerta.ta.bb
https://www.alertachart.com/alertascript/reference/builtins/bbands
Signature: bbands(source, length, mult)
Bollinger Bands: a simple moving average of source (the middle band) and the bands mult standard deviations above and below it. Returns the tuple [middle, upper, lower], as Pine's ta.bb does; ta.bbands and bbands are the same function.
TradingView-compatible spelling: ta.bb; runs without warnings.

### alerta.ta.stdev
https://www.alertachart.com/alertascript/reference/builtins/stdev
Signature: stdev(source, length, biased = true)
Calculates standard deviation of source over length bars. Pine v6 third argument `biased` selects the biased (Bessel-corrected off) or unbiased estimator; defaults to true.
TradingView-compatible spelling: ta.stdev; runs without warnings.

### alerta.ta.highest
https://www.alertachart.com/alertascript/reference/builtins/highest
Signature: highest(source, length)
Returns the highest value of source for length bars back.
TradingView-compatible spelling: ta.highest; runs without warnings.

### alerta.ta.highestbars
https://www.alertachart.com/alertascript/reference/builtins/highestbars
Signature: highestbars(source, length)
Returns the offset to the highest value of source over the last length bars, as Pine does: 0 on the current bar, negative before it (-3 = three bars ago). With a single argument — highestbars(length) — the source is high.
TradingView-compatible spelling: ta.highestbars; runs without warnings.

### alerta.ta.lowest
https://www.alertachart.com/alertascript/reference/builtins/lowest
Signature: lowest(source, length)
Returns the lowest value of source for length bars back.
TradingView-compatible spelling: ta.lowest; runs without warnings.

### alerta.ta.lowestbars
https://www.alertachart.com/alertascript/reference/builtins/lowestbars
Signature: lowestbars(source, length)
Returns the offset to the lowest value of source over the last length bars, as Pine does: 0 on the current bar, negative before it (-3 = three bars ago). With a single argument — lowestbars(length) — the source is low.
TradingView-compatible spelling: ta.lowestbars; runs without warnings.

### alerta.highestindex
https://www.alertachart.com/alertascript/reference/builtins/highestindex
Signature: highestindex(source, length)
Returns the absolute index of the highest value of source for length bars.

### alerta.lowestindex
https://www.alertachart.com/alertascript/reference/builtins/lowestindex
Signature: lowestindex(source, length)
Returns the absolute index of the lowest value of source for length bars.

### alerta.ta.crossover
https://www.alertachart.com/alertascript/reference/builtins/crossover
Signature: crossover(a, b)
Returns true if `a` crossed above `b`.
TradingView-compatible spelling: ta.crossover; runs without warnings.

### alerta.ta.crossunder
https://www.alertachart.com/alertascript/reference/builtins/crossunder
Signature: crossunder(a, b)
Returns true if `a` crossed below `b`.
TradingView-compatible spelling: ta.crossunder; runs without warnings.

### alerta.ta.cross
https://www.alertachart.com/alertascript/reference/builtins/ta.cross
Signature: ta.cross(a, b)
Returns true when `a` crosses `b` in either direction.
TradingView-compatible spelling: ta.cross; runs without warnings.

### alerta.ta.rising
https://www.alertachart.com/alertascript/reference/builtins/ta.rising
Signature: ta.rising(source, length)
Returns true when source is greater than all previous values in the lookback window.
TradingView-compatible spelling: ta.rising; runs without warnings.

### alerta.ta.falling
https://www.alertachart.com/alertascript/reference/builtins/ta.falling
Signature: ta.falling(source, length)
Returns true when source is lower than all previous values in the lookback window.
TradingView-compatible spelling: ta.falling; runs without warnings.

### alerta.ta.range
https://www.alertachart.com/alertascript/reference/builtins/ta.range
Signature: ta.range(source, length)
Returns max(source, length) - min(source, length).
TradingView-compatible spelling: ta.range; runs without warnings.

### alerta.ta.swma
https://www.alertachart.com/alertascript/reference/builtins/ta.swma
Signature: ta.swma(source)
4-period symmetric weighted moving average with weights [1, 2, 2, 1] / 6.
TradingView-compatible spelling: ta.swma; runs without warnings.

### alerta.ta.dev
https://www.alertachart.com/alertascript/reference/builtins/ta.dev
Signature: ta.dev(source, length)
Returns average absolute deviation from the moving mean over length bars.
TradingView-compatible spelling: ta.dev; runs without warnings.

### alerta.ta.variance
https://www.alertachart.com/alertascript/reference/builtins/ta.variance
Signature: ta.variance(source, length, biased)
Returns rolling variance. `biased=true` computes population variance, `false` uses sample variance.
TradingView-compatible spelling: ta.variance; runs without warnings.

### alerta.ta.percentrank
https://www.alertachart.com/alertascript/reference/builtins/ta.percentrank
Signature: ta.percentrank(source, length)
Returns the percentile rank (0..100) of the current value inside the rolling window.
TradingView-compatible spelling: ta.percentrank; runs without warnings.

### alerta.ta.percentile_nearest_rank
https://www.alertachart.com/alertascript/reference/builtins/ta.percentile_nearest_rank
Signature: ta.percentile_nearest_rank(source, length, percentage)
Returns rolling percentile using nearest-rank method.
TradingView-compatible spelling: ta.percentile_nearest_rank; runs without warnings.

### alerta.ta.percentile_linear_interpolation
https://www.alertachart.com/alertascript/reference/builtins/ta.percentile_linear_interpolation
Signature: ta.percentile_linear_interpolation(source, length, percentage)
Returns rolling percentile using linear interpolation between nearest ranks.
TradingView-compatible spelling: ta.percentile_linear_interpolation; runs without warnings.

### alerta.ta.kc
https://www.alertachart.com/alertascript/reference/builtins/ta.kc
Signature: ta.kc(source, length, mult, useTrueRange)
Returns Keltner Channel basis, upper and lower bands.
TradingView-compatible spelling: ta.kc; runs without warnings.

### alerta.ta.kcw
https://www.alertachart.com/alertascript/reference/builtins/ta.kcw
Signature: ta.kcw(source, length, mult, useTrueRange)
Returns channel width as `(upper - lower) / basis`.
TradingView-compatible spelling: ta.kcw; runs without warnings.

### alerta.ta.bbw
https://www.alertachart.com/alertascript/reference/builtins/ta.bbw
Signature: ta.bbw(source, length, mult)
Returns Bollinger width as `(upper - lower) / basis`.
TradingView-compatible spelling: ta.bbw; runs without warnings.

### alerta.ta.cog
https://www.alertachart.com/alertascript/reference/builtins/ta.cog
Signature: ta.cog(source, length)
Computes Center of Gravity oscillator over the lookback window.
TradingView-compatible spelling: ta.cog; runs without warnings.

### alerta.ta.correlation
https://www.alertachart.com/alertascript/reference/builtins/ta.correlation
Signature: ta.correlation(sourceA, sourceB, length)
Rolling Pearson correlation between two series.
TradingView-compatible spelling: ta.correlation; runs without warnings.

### alerta.ta.max
https://www.alertachart.com/alertascript/reference/builtins/ta.max
Signature: ta.max → series float
Pine v6 built-in VARIABLE (no parentheses): the running all-time high — the maximum of `high` from the first bar up to the current bar.
TradingView-compatible spelling: ta.max; runs without warnings.

### alerta.ta.min
https://www.alertachart.com/alertascript/reference/builtins/ta.min
Signature: ta.min → series float
Pine v6 built-in VARIABLE (no parentheses): the running all-time low — the minimum of `low` from the first bar up to the current bar.
TradingView-compatible spelling: ta.min; runs without warnings.

### alerta.ta.median
https://www.alertachart.com/alertascript/reference/builtins/ta.median
Signature: ta.median(source, length)
Returns rolling median of source values over length bars.
TradingView-compatible spelling: ta.median; runs without warnings.

### alerta.ta.mode
https://www.alertachart.com/alertascript/reference/builtins/ta.mode
Signature: ta.mode(source, length)
Returns most frequent value in the rolling window.
TradingView-compatible spelling: ta.mode; runs without warnings.

### alerta.alert
https://www.alertachart.com/alertascript/reference/builtins/alert
Signature: alert(message, freq)
Triggers an alert event when executed. freq controls dispatch cadence: once_per_bar (default), once_per_bar_close (held until the bar closes), all (every tick). Message supports {{placeholders}}: ticker, exchange, interval, time, OHLCV, plot_N, plot("Title"), syminfo.*, strategy.order.id/action/contracts/price/comment/alert_message, strategy.market_position(_size), strategy.prev_market_position(_size).
TradingView-compatible spelling: alert; runs without warnings.

### alerta.alertcondition
https://www.alertachart.com/alertascript/reference/builtins/alertcondition
Signature: alertcondition(condition, title, message)
Registers a named, selectable alert condition (listed by title in the alert UI) and fires it when the condition is true on the current bar. Message supports the same {{placeholder}} set as alert().
TradingView-compatible spelling: alertcondition; runs without warnings.

### alerta.input.source
https://www.alertachart.com/alertascript/reference/builtins/input.source
Signature: input.source(defval, title)
Creates a source selector input: the series chosen in the script's settings is the series the script reads.
TradingView-compatible spelling: input.source; runs without warnings.

### alerta.input.timeframe
https://www.alertachart.com/alertascript/reference/builtins/input.timeframe
Signature: input.timeframe(defval, title)
Creates a timeframe input suitable for request.security.
TradingView-compatible spelling: input.timeframe; runs without warnings.

### alerta.input.symbol
https://www.alertachart.com/alertascript/reference/builtins/input.symbol
Signature: input.symbol(defval, title)
Creates a symbol input suitable for request.security.
TradingView-compatible spelling: input.symbol; runs without warnings.

### alerta.input.time
https://www.alertachart.com/alertascript/reference/builtins/input.time
Signature: input.time(defval, title)
Creates a timestamp input (epoch milliseconds).
TradingView-compatible spelling: input.time; runs without warnings.

### alerta.input.session
https://www.alertachart.com/alertascript/reference/builtins/input.session
Signature: input.session(defval, title)
Creates a session string input (HHMM-HHMM[:days]).
TradingView-compatible spelling: input.session; runs without warnings.

### alerta.input.int
https://www.alertachart.com/alertascript/reference/builtins/input.int
Signature: input.int(defval, title, options)
Creates an integer input in the script's settings. Pine's named arguments are accepted: minval, maxval and step set the range the settings allow, options (a list of allowed values) offers only those values, and tooltip, inline and group arrange the input in the settings. The older `{ min, max, step }` object as the third argument is accepted too.
TradingView-compatible spelling: input.int; runs without warnings.

### alerta.input.float
https://www.alertachart.com/alertascript/reference/builtins/input.float
Signature: input.float(defval, title, options)
Creates a decimal-number input in the script's settings. Pine's named arguments are accepted: minval, maxval and step set the range the settings allow, options (a list of allowed values) offers only those values, and tooltip, inline and group arrange the input in the settings. The older `{ min, max, step }` object as the third argument is accepted too.
TradingView-compatible spelling: input.float; runs without warnings.

### alerta.input.bool
https://www.alertachart.com/alertascript/reference/builtins/input.bool
Signature: input.bool(defval, title)
Creates a boolean (checkbox) input parameter.
TradingView-compatible spelling: input.bool; runs without warnings.

### alerta.input.string
https://www.alertachart.com/alertascript/reference/builtins/input.string
Signature: input.string(defval, title)
Creates a string input parameter.
TradingView-compatible spelling: input.string; runs without warnings.

### alerta.input.color
https://www.alertachart.com/alertascript/reference/builtins/input.color
Signature: input.color(defval, title)
Creates a color picker input parameter.
TradingView-compatible spelling: input.color; runs without warnings.

### alerta.input.price
https://www.alertachart.com/alertascript/reference/builtins/input.price
Signature: input.price(defval, title, options)
Creates a price-like numeric input parameter.
TradingView-compatible spelling: input.price; runs without warnings.

### alerta.input.text_area
https://www.alertachart.com/alertascript/reference/builtins/input.text_area
Signature: input.text_area(defval, title)
Creates a multiline text input parameter.
TradingView-compatible spelling: input.text_area; runs without warnings.

### alerta.input.enum
https://www.alertachart.com/alertascript/reference/builtins/input.enum
Signature: input.enum(defval, title, options?)
Creates a dropdown input from a user-declared enum. Returns the selected enum MEMBER (not its title string), so it compares directly against EnumName.member. Member titles are what the user sees in the settings dialog.
TradingView-compatible spelling: input.enum; runs without warnings.

### alerta.time
https://www.alertachart.com/alertascript/reference/builtins/time
Signature: time() or time(timeframe, session?, timezone?, bars_back?, timeframe_bars_back?)
Returns bar open timestamps (epoch milliseconds). Also usable as a bare built-in variable (no parens). The Pine v6 overload `time(timeframe, session?, timezone?, bars_back?, timeframe_bars_back?)` is accepted; when a session is supplied the value is the bar time inside the session window (in the given timezone) and `na` outside.
TradingView-compatible spelling: time; runs without warnings.

### alerta.time_close
https://www.alertachart.com/alertascript/reference/builtins/time_close
Signature: time_close() or time_close(timeframe, session?, timezone?, bars_back?, timeframe_bars_back?)
Returns the bar's close time (epoch milliseconds): open + timeframe, calendar months for monthly bars, and the session close for a stock's daily bar. Also usable as a bare built-in variable. Takes the same optional arguments as `time`: with a timeframe, `time_close("D")` is the close of the higher-timeframe bar the current bar belongs to; with a session, the value is the close time inside the session window and `na` outside.
TradingView-compatible spelling: time_close; runs without warnings.

### alerta.timestamp
https://www.alertachart.com/alertascript/reference/builtins/timestamp
Signature: timestamp(year, month, day, hour, minute, second) | timestamp(timezone, year, month, day, …) | timestamp(dateString)
Builds a timestamp (milliseconds since the Unix epoch). Three forms: from date/time components, read on the chart symbol's exchange clock (`syminfo.timezone` — UTC on crypto charts, New York time on a US stock); with an IANA timezone as the first argument, which reads those components in that zone instead; or from a single DATE STRING — `timestamp("2024-01-01")`, `timestamp("2024-01-01 09:30")`, `timestamp("2026-08-01T11:00:00-0500")`. A date string without its own offset is read as UTC.
TradingView-compatible spelling: timestamp; runs without warnings.

### alerta.hour
https://www.alertachart.com/alertascript/reference/builtins/hour
Signature: hour(source?, timezone?)
Returns hour component from timestamp series. With a timezone arg, the hour is computed in that timezone (Pine v6). Without one, the chart symbol's exchange clock applies (`syminfo.timezone`): UTC on crypto charts, New York time on a US stock — daylight saving included.
TradingView-compatible spelling: hour; runs without warnings.

### alerta.minute
https://www.alertachart.com/alertascript/reference/builtins/minute
Signature: minute(source?, timezone?)
Returns minute component from timestamp series. With a timezone arg, the minute is computed in that timezone (Pine v6). Without one, the chart symbol's exchange clock applies (`syminfo.timezone`): UTC on crypto charts, New York time on a US stock — daylight saving included.
TradingView-compatible spelling: minute; runs without warnings.

### alerta.second
https://www.alertachart.com/alertascript/reference/builtins/second
Signature: second(source?, timezone?)
Returns second component from timestamp series. With a timezone arg, the second is computed in that timezone (Pine v6). Without one, the chart symbol's exchange clock applies (`syminfo.timezone`): UTC on crypto charts, New York time on a US stock — daylight saving included.
TradingView-compatible spelling: second; runs without warnings.

### alerta.dayofmonth
https://www.alertachart.com/alertascript/reference/builtins/dayofmonth
Signature: dayofmonth(source?, timezone?)
Returns day-of-month from timestamp series. With a timezone arg, computed in that timezone (Pine v6). Without one, the chart symbol's exchange clock applies (`syminfo.timezone`): UTC on crypto charts, New York time on a US stock — daylight saving included.
TradingView-compatible spelling: dayofmonth; runs without warnings.

### alerta.dayofweek
https://www.alertachart.com/alertascript/reference/builtins/dayofweek
Signature: dayofweek(source?, timezone?)
Returns the day of week from a timestamp (1=Sunday..7=Saturday). With a timezone arg, the day-of-week is computed in that timezone (Pine v6). Without one, the chart symbol's exchange clock applies (`syminfo.timezone`): UTC on crypto charts, New York time on a US stock — daylight saving included.
TradingView-compatible spelling: dayofweek; runs without warnings.

### alerta.weekofyear
https://www.alertachart.com/alertascript/reference/builtins/weekofyear
Signature: weekofyear(source?, timezone?)
Returns the ISO week number (weeks start on Monday) of a timestamp. With a timezone arg, the date is read in that timezone (Pine v6). Without one, the chart symbol's exchange clock applies (`syminfo.timezone`): UTC on crypto charts, New York time on a US stock — daylight saving included.
TradingView-compatible spelling: weekofyear; runs without warnings.

### alerta.month
https://www.alertachart.com/alertascript/reference/builtins/month
Signature: month(source?, timezone?)
Returns month (1..12) from timestamp series. With a timezone arg, computed in that timezone (Pine v6). Without one, the chart symbol's exchange clock applies (`syminfo.timezone`): UTC on crypto charts, New York time on a US stock — daylight saving included.
TradingView-compatible spelling: month; runs without warnings.

### alerta.year
https://www.alertachart.com/alertascript/reference/builtins/year
Signature: year(source?, timezone?)
Returns year from timestamp series. With a timezone arg, computed in that timezone (Pine v6). Without one, the chart symbol's exchange clock applies (`syminfo.timezone`): UTC on crypto charts, New York time on a US stock — daylight saving included.
TradingView-compatible spelling: year; runs without warnings.

### alerta.timeframe.in_seconds
https://www.alertachart.com/alertascript/reference/builtins/timeframe.in_seconds
Signature: timeframe.in_seconds(timeframe)
Returns timeframe duration in seconds.
TradingView-compatible spelling: timeframe.in_seconds; runs without warnings.

### alerta.timeframe.from_seconds
https://www.alertachart.com/alertascript/reference/builtins/timeframe.from_seconds
Signature: timeframe.from_seconds(seconds)
Converts seconds value to canonical timeframe string.
TradingView-compatible spelling: timeframe.from_seconds; runs without warnings.

### alerta.barstate.isfirst
https://www.alertachart.com/alertascript/reference/builtins/barstate.isfirst
Signature: barstate.isfirst
True only on first bar of current dataset.
TradingView-compatible spelling: barstate.isfirst; runs without warnings.

### alerta.barstate.islast
https://www.alertachart.com/alertascript/reference/builtins/barstate.islast
Signature: barstate.islast
True only on last bar of current dataset.
TradingView-compatible spelling: barstate.islast; runs without warnings.

### alerta.barstate.ishistory
https://www.alertachart.com/alertascript/reference/builtins/barstate.ishistory
Signature: barstate.ishistory
True for historical bars in current execution model.
TradingView-compatible spelling: barstate.ishistory; runs without warnings.

### alerta.barstate.isrealtime
https://www.alertachart.com/alertascript/reference/builtins/barstate.isrealtime
Signature: barstate.isrealtime
True on the latest bar during live delta execution (`update_last` and `append_last`).
TradingView-compatible spelling: barstate.isrealtime; runs without warnings.

### alerta.barstate.isnew
https://www.alertachart.com/alertascript/reference/builtins/barstate.isnew
Signature: barstate.isnew
True only when a new candle is appended (`append_last`) on the latest bar.
TradingView-compatible spelling: barstate.isnew; runs without warnings.

### alerta.barstate.isconfirmed
https://www.alertachart.com/alertascript/reference/builtins/barstate.isconfirmed
Signature: barstate.isconfirmed
True when bar is confirmed/closed in current execution model.
TradingView-compatible spelling: barstate.isconfirmed; runs without warnings.

### alerta.syminfo.tickerid
https://www.alertachart.com/alertascript/reference/builtins/syminfo.tickerid
Signature: syminfo.tickerid
Exchange-qualified symbol id (e.g. BINANCE:BTCUSDT). Inside request.security it is the requested symbol's; syminfo.main_tickerid stays the chart's. Pine v1–v3 scripts write it as `tickerid`.
TradingView-compatible spelling: syminfo.tickerid; runs without warnings.

### alerta.syminfo.ticker
https://www.alertachart.com/alertascript/reference/builtins/syminfo.ticker
Signature: syminfo.ticker
Ticker part of current symbol (e.g. BTCUSDT). Pine v1–v3 scripts write it as `ticker`.
TradingView-compatible spelling: syminfo.ticker; runs without warnings.

### alerta.syminfo.prefix
https://www.alertachart.com/alertascript/reference/builtins/syminfo.prefix
Signature: syminfo.prefix
Exchange prefix of current symbol (e.g. BINANCE).
TradingView-compatible spelling: syminfo.prefix; runs without warnings.

### alerta.syminfo.mintick
https://www.alertachart.com/alertascript/reference/builtins/syminfo.mintick
Signature: syminfo.mintick
Minimum price increment for the current symbol — the precision the chart's own price axis uses (a magnitude estimate from the last price when the script runs outside the chart). format.mintick and math.round_to_mintick use it.
TradingView-compatible spelling: syminfo.mintick; runs without warnings.

### alerta.timeframe.period
https://www.alertachart.com/alertascript/reference/builtins/timeframe.period
Signature: timeframe.period
Canonical chart timeframe identifier (e.g. 60, D, W, M). Inside request.security it is the requested timeframe; timeframe.main_period stays the chart's. Pine v1–v3 scripts write it as `period`.
TradingView-compatible spelling: timeframe.period; runs without warnings.

### alerta.timeframe.isintraday
https://www.alertachart.com/alertascript/reference/builtins/timeframe.isintraday
Signature: timeframe.isintraday
True when timeframe is minute/hour based. Pine v1–v3 scripts write it (and isdaily, isweekly, ismonthly, isdwm) without the timeframe. prefix.
TradingView-compatible spelling: timeframe.isintraday; runs without warnings.

### alerta.timeframe.isdaily
https://www.alertachart.com/alertascript/reference/builtins/timeframe.isdaily
Signature: timeframe.isdaily
True when timeframe period is D.
TradingView-compatible spelling: timeframe.isdaily; runs without warnings.

### alerta.timeframe.isweekly
https://www.alertachart.com/alertascript/reference/builtins/timeframe.isweekly
Signature: timeframe.isweekly
True when timeframe period is W.
TradingView-compatible spelling: timeframe.isweekly; runs without warnings.

### alerta.timeframe.ismonthly
https://www.alertachart.com/alertascript/reference/builtins/timeframe.ismonthly
Signature: timeframe.ismonthly
True when timeframe period is M.
TradingView-compatible spelling: timeframe.ismonthly; runs without warnings.

### alerta.ta.change
https://www.alertachart.com/alertascript/reference/builtins/change
Signature: change(source, length)
Difference between current value and previous value (length bars ago).
TradingView-compatible spelling: ta.change; runs without warnings.

### alerta.sum
https://www.alertachart.com/alertascript/reference/builtins/sum
Signature: sum(source, length)
Math namespace alias for sum.
TradingView-compatible spelling: math.sum; runs without warnings.

### alerta.ta.valuewhen
https://www.alertachart.com/alertascript/reference/builtins/valuewhen
Signature: valuewhen(condition, source, occurrence)
Returns the value of `source` when `condition` was last true.
TradingView-compatible spelling: ta.valuewhen; runs without warnings.

### alerta.ta.pivothigh
https://www.alertachart.com/alertascript/reference/builtins/pivothigh
Signature: pivothigh(source, leftLen, rightLen)
Returns price if it's a pivot high, else null. Confirmed rightLen bars ago.
TradingView-compatible spelling: ta.pivothigh; runs without warnings.

### alerta.ta.pivotlow
https://www.alertachart.com/alertascript/reference/builtins/pivotlow
Signature: pivotlow(source, leftLen, rightLen)
Returns price if it's a pivot low, else null. Confirmed rightLen bars ago.
TradingView-compatible spelling: ta.pivotlow; runs without warnings.

### alerta.ta.sar
https://www.alertachart.com/alertascript/reference/builtins/sar
Signature: sar(start, inc, max)
Parabolic Stop and Reverse indicator.
TradingView-compatible spelling: ta.sar; runs without warnings.

### alerta.ta.supertrend
https://www.alertachart.com/alertascript/reference/builtins/supertrend
Signature: supertrend(factor, atrLength, high, low, close)
Returns SuperTrend line and trend direction (+1/-1).
TradingView-compatible spelling: ta.supertrend; runs without warnings.

### alerta.ta.vwap
https://www.alertachart.com/alertascript/reference/builtins/vwap
Signature: ta.vwap(source, anchor?, stdev_mult?) → series float | [vwap, upper, lower]
Pine v6: volume-weighted average price, restarted whenever `anchor` is true — by default at the first bar of every trading day on the exchange clock (so on a daily chart it is the source itself). Two overloads:
  • `ta.vwap(source, anchor)` → series float
  • `ta.vwap(source, anchor, stdev_mult)` → tuple [vwap, upper, lower] with ±N·stdev bands.
The bare `ta.vwap` variable is the session VWAP of hlc3.
TradingView-compatible spelling: ta.vwap; runs without warnings.

### alerta.ta.stoch
https://www.alertachart.com/alertascript/reference/builtins/stoch
Signature: stoch(close, high, low, length, k_smooth, d_smooth)
Calculates the Stochastic Oscillator. Pine's `ta.stoch(source, high, low, length)` returns ONE series — the raw %K, 100 × (source − lowest low) / (highest high − lowest low) — which scripts smooth themselves, e.g. `k = ta.sma(ta.stoch(close, high, low, 14), 3)`. AlertaScript's own `[k, d] = stoch(close, high, low, 14)` returns the smoothed pair (k_smooth / d_smooth, default 3).
TradingView-compatible spelling: ta.stoch; runs without warnings.

### alerta.ta.cci
https://www.alertachart.com/alertascript/reference/builtins/cci
Signature: cci(source, length)
Calculates the CCI indicator.
TradingView-compatible spelling: ta.cci; runs without warnings.

### alerta.ta.obv
https://www.alertachart.com/alertascript/reference/builtins/obv
Signature: obv(close, volume)
Calculates OBV.
TradingView-compatible spelling: ta.obv; runs without warnings.

### alerta.ta.mfi
https://www.alertachart.com/alertascript/reference/builtins/mfi
Signature: mfi(high, low, close, volume, length)
Calculates MFI indicator. Accepts mfi(high, low, close, volume, length) or ta.mfi(source, length).
TradingView-compatible spelling: ta.mfi; runs without warnings.

### alerta.ta.kdj
https://www.alertachart.com/alertascript/reference/builtins/kdj
Signature: kdj(close, high, low, length, m1, m2)
Calculates the KDJ indicator.
TradingView-compatible spelling: ta.kdj; runs without warnings.

### alerta.ta.dc
https://www.alertachart.com/alertascript/reference/builtins/ta.dc
Signature: ta.dc(length)
Calculates the Donchian Channel — the highest high and lowest low over a given period. Returns an object with upper, lower, and basis (midline) series.
TradingView-compatible spelling: ta.dc; runs without warnings.

### alerta.ta.wvad
https://www.alertachart.com/alertascript/reference/builtins/ta.wvad
Signature: ta.wvad()
Calculates Williams Vane Accumulation/Distribution — a volume-weighted directional pressure indicator using (close - open) / (high - low) * volume.
TradingView-compatible spelling: ta.wvad; runs without warnings.

### alerta.ta.pivot_point_levels
https://www.alertachart.com/alertascript/reference/builtins/ta.pivot_point_levels
Signature: ta.pivot_point_levels(type, anchor, developing?) → array<float>
Pine v6: computes pivot levels (P, R1-R5, S1-S5) using one of six methods, anchored to a user-defined period.
TradingView-compatible spelling: ta.pivot_point_levels; runs without warnings.

### alerta.ta.rci
https://www.alertachart.com/alertascript/reference/builtins/ta.rci
Signature: ta.rci(source, length) → series float
Pine v6: Spearman rank correlation between `source` and the time index over `length` bars. Scaled to [-100, 100]. 100 = monotonically rising, -100 = monotonically falling.
TradingView-compatible spelling: ta.rci; runs without warnings.

### alerta.ta.wpr
https://www.alertachart.com/alertascript/reference/builtins/ta.wpr
Signature: ta.wpr(length) → series float
Pine v6 official name for Williams %R. Oscillator showing current close relative to the high/low range over `length` bars.
TradingView-compatible spelling: ta.wpr; runs without warnings.

### alerta.timeframe.change
https://www.alertachart.com/alertascript/reference/builtins/timeframe.change
Signature: timeframe.change(timeframe) → series bool
Pine v6: returns true on the first bar of every new period of the specified timeframe. Use it to anchor higher-timeframe-driven pivots, VWAP and aggregations.
TradingView-compatible spelling: timeframe.change; runs without warnings.

### alerta.ta.pvt
https://www.alertachart.com/alertascript/reference/builtins/ta.pvt
Signature: ta.pvt → series float
Pine built-in VARIABLE (no parentheses): cumulative sum of the close %-change weighted by volume — cum(change(close)/close[1] * volume). Rises when price gains on volume, falls when price drops on volume.
TradingView-compatible spelling: ta.pvt; runs without warnings.

### alerta.ta.accdist
https://www.alertachart.com/alertascript/reference/builtins/ta.accdist
Signature: ta.accdist → series float
Pine built-in VARIABLE (no parentheses): cumulative Accumulation/Distribution line — cum(((close-low)-(high-close))/(high-low) * volume). Measures buying vs. selling pressure via the close position inside the bar range.
TradingView-compatible spelling: ta.accdist; runs without warnings.

### alerta.ta.iii
https://www.alertachart.com/alertascript/reference/builtins/ta.iii
Signature: ta.iii → series float
Pine built-in VARIABLE (no parentheses): (2*close - high - low) / ((high - low) * volume). Gauges where the close sits in the bar range, normalized by volume.
TradingView-compatible spelling: ta.iii; runs without warnings.

### alerta.ta.nvi
https://www.alertachart.com/alertascript/reference/builtins/ta.nvi
Signature: ta.nvi → series float
Pine built-in VARIABLE (no parentheses): starts at 1.0 and compounds the close %-change ONLY on bars where volume fell versus the prior bar. Tracks what "smart money" does on quiet days.
TradingView-compatible spelling: ta.nvi; runs without warnings.

### alerta.ta.pvi
https://www.alertachart.com/alertascript/reference/builtins/ta.pvi
Signature: ta.pvi → series float
Pine built-in VARIABLE (no parentheses): starts at 1.0 and compounds the close %-change ONLY on bars where volume rose versus the prior bar. Mirror of ta.nvi for high-activity days.
TradingView-compatible spelling: ta.pvi; runs without warnings.

### alerta.ta.wad
https://www.alertachart.com/alertascript/reference/builtins/ta.wad
Signature: ta.wad → series float
Pine built-in VARIABLE (no parentheses): cumulative sum of close - min(low, close[1]) on up-closes and close - max(high, close[1]) on down-closes (0 when unchanged). Larry Williams’ accumulation/distribution measure.
TradingView-compatible spelling: ta.wad; runs without warnings.

### alerta.strategy.entry
https://www.alertachart.com/alertascript/reference/builtins/strategy.entry
Signature: strategy.entry(id, direction, qty, limit, stop, oca_name, oca_type, comment, alert_message)
Enters a market position (long or short) for strategy backtesting. Must run inside a strategy script header.
TradingView-compatible spelling: strategy.entry; runs without warnings.

### alerta.strategy.exit
https://www.alertachart.com/alertascript/reference/builtins/strategy.exit
Signature: strategy.exit(id, from_entry, qty, qty_percent, profit, limit, loss, stop, trail_price, trail_points, trail_offset, oca_name, comment, comment_profit, comment_loss, comment_trailing, alert_message)
Exits a specific entry by ID with take-profit / stop-loss / trailing legs. `profit`/`loss` are TICK offsets from the entry price; `limit`/`stop` are absolute prices. `from_entry` scopes the exit (and its qty/qty_percent) to trades opened by that entry id. Per-leg comments label the trade by whichever leg fired.
TradingView-compatible spelling: strategy.exit; runs without warnings.

### alerta.strategy.close
https://www.alertachart.com/alertascript/reference/builtins/strategy.close
Signature: strategy.close(id, comment, qty, qty_percent, alert_message, immediately)
Closes what the entry with this id opened, at market price, at the next bar's open (`immediately=true`: at the signal bar's close). With the default close_entries_rule (FIFO) that quantity is taken from the oldest open trades first, so the list of trades can show an earlier entry closed by this order; with close_entries_rule = "ANY" the entry's own trades are closed. When the entry has no open trade the call does nothing — it is not kept for a later position. Must run inside a strategy script header.
TradingView-compatible spelling: strategy.close; runs without warnings.

### alerta.request.security
https://www.alertachart.com/alertascript/reference/builtins/request.security
Signature: request.security(symbol, timeframe, expression, gaps, lookahead)
Requests data from another symbol or timeframe and aligns it to the chart's bars. The expression is calculated on the requested bars: a higher-timeframe EMA is the EMA of the higher-timeframe bars, not an average of the chart's values. The symbol and the timeframe do not have to be literals — an input, a variable, a function result or a condition may supply them, so one script can request several symbols or timeframes, also from a loop. A symbol AlertaChart has no data for returns na with a warning naming it; the rest of the script keeps running, and the chart's own bars are never substituted for it.
TradingView-compatible spelling: request.security; runs without warnings.

### alerta.request.financial
https://www.alertachart.com/alertascript/reference/builtins/request.financial
Signature: request.financial(symbol, financial_id, period, gaps?, ignore_invalid_symbol?, currency?)
Requests a fundamental metric (revenue, EPS, capex, …) for a symbol, period by period. There is no historical fundamentals feed behind this: the call is accepted and returns `na`, with a warning, exactly as TradingView does for a symbol it has no data on. Guard the result with `na(...)`. On a stock chart the company's current profile is available as `syminfo.*` — `syminfo.sector`, `syminfo.industry`, `syminfo.country`, `syminfo.shares_outstanding_total`.
TradingView-compatible spelling: request.financial; runs without warnings.

### alerta.request.earnings
https://www.alertachart.com/alertascript/reference/builtins/request.earnings
Signature: request.earnings(symbol, field, gaps?, lookahead?, ignore_invalid_symbol?, currency?)
Requests reported earnings for a symbol. The second argument selects which figure: `earnings.actual`, `earnings.estimate` or `earnings.standardized`. As with request.financial there is no fundamentals feed, so the call returns `na` with a warning instead of failing.
TradingView-compatible spelling: request.earnings; runs without warnings.

### alerta.request.dividends
https://www.alertachart.com/alertascript/reference/builtins/request.dividends
Signature: request.dividends(symbol, field?, gaps?, lookahead?, ignore_invalid_symbol?, currency?)
Requests dividend payments for a symbol (`dividends.gross` / `dividends.net`). Returns `na` with a warning — AlertaScript has no fundamentals feed.
TradingView-compatible spelling: request.dividends; runs without warnings.

### alerta.request.splits
https://www.alertachart.com/alertascript/reference/builtins/request.splits
Signature: request.splits(symbol, field, gaps?, lookahead?, ignore_invalid_symbol?)
Requests split events for a symbol (`splits.numerator` / `splits.denominator`). Returns `na` with a warning — AlertaScript has no fundamentals feed.
TradingView-compatible spelling: request.splits; runs without warnings.

### alerta.request.footprint
https://www.alertachart.com/alertascript/reference/builtins/request.footprint
Signature: request.footprint(ticks_per_row, va_percent, imbalance_percent) → footprint
The volume footprint of every bar: its buy and sell volume by price row, Point of Control, value area and diagonal imbalances, read through `footprint.*()` and `volume_row.*()`. AlertaChart builds it from the symbol's own order flow — the taker buy / sell volume AlertaChart records for every minute (Binance spot and perpetuals; Bybit, OKX and Coinbase for BTC, ETH, XRP and SOL), spread over each minute's traded range, and the exact trade prices of the exchange's live trade stream for the bars since the chart opened. Inside `request.security` with another symbol — written out, from an input or a variable — that symbol's order flow. na (with one warning) on symbols without order flow: stocks, CME futures, forex.
TradingView-compatible spelling: request.footprint; runs without warnings.

### alerta.request.security_lower_tf
https://www.alertachart.com/alertascript/reference/builtins/request.security_lower_tf
Signature: request.security_lower_tf(symbol, timeframe, expression) → array (or a tuple of arrays)
Requests EVERY lower-timeframe value that falls inside each chart bar. Unlike `request.security`, which projects one value per bar, this returns an ARRAY per bar — read it with `array.size` / `array.get` / `for … in`. The requested timeframe must not be higher than the chart timeframe (the chart's own gives one element per bar). When no intrabar series is available the arrays come back empty (size 0) and a warning is raised, so guard with `if arr.size() > 0`.
TradingView-compatible spelling: request.security_lower_tf; runs without warnings.

### alerta.strategy.order
https://www.alertachart.com/alertascript/reference/builtins/strategy.order
Signature: strategy.order(id, direction, qty, limit, stop, comment)
Places a market, limit, or stop order regardless of the current position. Does not automatically reverse positions like strategy.entry.
TradingView-compatible spelling: strategy.order; runs without warnings.

### alerta.strategy.equity
https://www.alertachart.com/alertascript/reference/builtins/strategy.equity
Signature: strategy.equity
Returns the current equity (initial capital + realized profit + open profit) for the strategy at the current bar.
TradingView-compatible spelling: strategy.equity; runs without warnings.

### alerta.strategy.netprofit_percent
https://www.alertachart.com/alertascript/reference/builtins/strategy.netprofit_percent
Signature: strategy.netprofit_percent
Realized net profit expressed as a percentage of the initial capital. Companion percent variants also available: strategy.openprofit_percent, strategy.grossprofit_percent, strategy.grossloss_percent, strategy.max_drawdown_percent, strategy.max_runup_percent.
TradingView-compatible spelling: strategy.netprofit_percent; runs without warnings.

### alerta.strategy.avg_trade
https://www.alertachart.com/alertascript/reference/builtins/strategy.avg_trade
Signature: strategy.avg_trade
Average profit/loss per closed trade. Companions: strategy.avg_trade_percent (per-trade % of entry notional), strategy.avg_winning_trade(_percent), strategy.avg_losing_trade(_percent).
TradingView-compatible spelling: strategy.avg_trade; runs without warnings.

### alerta.strategy.margin_liquidation_price
https://www.alertachart.com/alertascript/reference/builtins/strategy.margin_liquidation_price
Signature: strategy.margin_liquidation_price
Price at which a margin call would liquidate the position. AlertaScript does not simulate leverage/margin, so this returns na — matching Pine's value when margin requirements are 100%.
TradingView-compatible spelling: strategy.margin_liquidation_price; runs without warnings.

### alerta.strategy.position_size
https://www.alertachart.com/alertascript/reference/builtins/strategy.position_size
Signature: strategy.position_size
Returns the size of the current open position. Positive for long positions, negative for short positions, and 0 if neutral.
TradingView-compatible spelling: strategy.position_size; runs without warnings.

### alerta.strategy.openprofit
https://www.alertachart.com/alertascript/reference/builtins/strategy.openprofit
Signature: strategy.openprofit
Returns the unrealized profit/loss of the currently open positions.
TradingView-compatible spelling: strategy.openprofit; runs without warnings.

### alerta.strategy.risk.max_drawdown
https://www.alertachart.com/alertascript/reference/builtins/strategy.risk.max_drawdown
Signature: strategy.risk.max_drawdown(value, type)
Sets the maximum drawdown limit for the strategy. If reached, the strategy stops opening new positions.
TradingView-compatible spelling: strategy.risk.max_drawdown; runs without warnings.

### alerta.strategy.risk.max_position_size
https://www.alertachart.com/alertascript/reference/builtins/strategy.risk.max_position_size
Signature: strategy.risk.max_position_size(size)
Caps the quantity of any entry order to the specified size.
TradingView-compatible spelling: strategy.risk.max_position_size; runs without warnings.

### alerta.strategy.risk.allow_entry_in
https://www.alertachart.com/alertascript/reference/builtins/strategy.risk.allow_entry_in
Signature: strategy.risk.allow_entry_in(direction)
Restricts strategy entries to a specific direction.
TradingView-compatible spelling: strategy.risk.allow_entry_in; runs without warnings.

### alerta.strategy.opentrades
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades
Signature: strategy.opentrades
Returns the number of currently open trades in the strategy.
TradingView-compatible spelling: strategy.opentrades; runs without warnings.

### alerta.strategy.closedtrades
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades
Signature: strategy.closedtrades
Returns the total number of closed trades in the strategy performance history.
TradingView-compatible spelling: strategy.closedtrades; runs without warnings.

### alerta.strategy.opentrades.entry_price
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.entry_price
Signature: strategy.opentrades.entry_price(trade_index)
Returns the entry price for the specified open trade.
TradingView-compatible spelling: strategy.opentrades.entry_price; runs without warnings.

### alerta.strategy.closedtrades.profit
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.profit
Signature: strategy.closedtrades.profit(trade_index)
Returns the profit or loss for the specified closed trade.
TradingView-compatible spelling: strategy.closedtrades.profit; runs without warnings.

### alerta.strategy.cancel
https://www.alertachart.com/alertascript/reference/builtins/strategy.cancel
Signature: strategy.cancel(id)
Cancels pending orders and active exits with the given id.
TradingView-compatible spelling: strategy.cancel; runs without warnings.

### alerta.strategy.cancel_all
https://www.alertachart.com/alertascript/reference/builtins/strategy.cancel_all
Signature: strategy.cancel_all()
Cancels all pending entries and active exit orders.
TradingView-compatible spelling: strategy.cancel_all; runs without warnings.

### alerta.strategy.close_all
https://www.alertachart.com/alertascript/reference/builtins/strategy.close_all
Signature: strategy.close_all(comment, alert_message, immediately)
Closes all open positions at market. `immediately=true` fills at the signal bar's close instead of the next bar's open.
TradingView-compatible spelling: strategy.close_all; runs without warnings.

### alerta.strategy.risk.max_cons_loss_days
https://www.alertachart.com/alertascript/reference/builtins/strategy.risk.max_cons_loss_days
Signature: strategy.risk.max_cons_loss_days(count)
Stops new entries after the configured number of consecutive losing trades.
TradingView-compatible spelling: strategy.risk.max_cons_loss_days; runs without warnings.

### alerta.strategy.risk.max_intraday_filled_orders
https://www.alertachart.com/alertascript/reference/builtins/strategy.risk.max_intraday_filled_orders
Signature: strategy.risk.max_intraday_filled_orders(count)
Limits how many fills can occur within the current bar/day approximation.
TradingView-compatible spelling: strategy.risk.max_intraday_filled_orders; runs without warnings.

### alerta.strategy.risk.max_intraday_loss
https://www.alertachart.com/alertascript/reference/builtins/strategy.risk.max_intraday_loss
Signature: strategy.risk.max_intraday_loss(value, type)
Stops new entries when current bar/day loss limit is exceeded.
TradingView-compatible spelling: strategy.risk.max_intraday_loss; runs without warnings.

### alerta.strategy.opentrades.profit_percent
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.profit_percent
Signature: strategy.opentrades.profit_percent(trade_index)
Returns mark-to-market profit percent for an open trade.
TradingView-compatible spelling: strategy.opentrades.profit_percent; runs without warnings.

### alerta.strategy.closedtrades.profit_percent
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.profit_percent
Signature: strategy.closedtrades.profit_percent(trade_index)
Returns realized profit percent for a closed trade.
TradingView-compatible spelling: strategy.closedtrades.profit_percent; runs without warnings.

### alerta.strategy.opentrades.entry_bar_index
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.entry_bar_index
Signature: strategy.opentrades.entry_bar_index(trade_index)
Returns the entry bar index of an open trade.
TradingView-compatible spelling: strategy.opentrades.entry_bar_index; runs without warnings.

### alerta.strategy.closedtrades.entry_bar_index
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.entry_bar_index
Signature: strategy.closedtrades.entry_bar_index(trade_index)
Returns entry bar index for a closed trade.
TradingView-compatible spelling: strategy.closedtrades.entry_bar_index; runs without warnings.

### alerta.strategy.closedtrades.exit_bar_index
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.exit_bar_index
Signature: strategy.closedtrades.exit_bar_index(trade_index)
Returns exit bar index for a closed trade.
TradingView-compatible spelling: strategy.closedtrades.exit_bar_index; runs without warnings.

### alerta.strategy.opentrades.max_runup
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.max_runup
Signature: strategy.opentrades.max_runup(trade_index)
Returns max favorable excursion for an open trade.
TradingView-compatible spelling: strategy.opentrades.max_runup; runs without warnings.

### alerta.strategy.opentrades.max_drawdown
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.max_drawdown
Signature: strategy.opentrades.max_drawdown(trade_index)
Returns max adverse excursion for an open trade.
TradingView-compatible spelling: strategy.opentrades.max_drawdown; runs without warnings.

### alerta.strategy.closedtrades.max_runup
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.max_runup
Signature: strategy.closedtrades.max_runup(trade_index)
Returns max favorable excursion for a closed trade.
TradingView-compatible spelling: strategy.closedtrades.max_runup; runs without warnings.

### alerta.strategy.closedtrades.max_drawdown
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.max_drawdown
Signature: strategy.closedtrades.max_drawdown(trade_index)
Returns max adverse excursion for a closed trade.
TradingView-compatible spelling: strategy.closedtrades.max_drawdown; runs without warnings.

### alerta.strategy.opentrades.entry_id
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.entry_id
Signature: strategy.opentrades.entry_id(trade_index)
Returns entry id of an open trade.
TradingView-compatible spelling: strategy.opentrades.entry_id; runs without warnings.

### alerta.strategy.closedtrades.entry_id
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.entry_id
Signature: strategy.closedtrades.entry_id(trade_index)
Returns entry id of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.entry_id; runs without warnings.

### alerta.strategy.closedtrades.exit_id
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.exit_id
Signature: strategy.closedtrades.exit_id(trade_index)
Returns the id of the order that closed the trade: the strategy.exit id, the id passed to strategy.close, the reversing entry's id, or "close_all".
TradingView-compatible spelling: strategy.closedtrades.exit_id; runs without warnings.

### alerta.strategy.opentrades.entry_comment
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.entry_comment
Signature: strategy.opentrades.entry_comment(trade_index)
Returns entry comment of an open trade.
TradingView-compatible spelling: strategy.opentrades.entry_comment; runs without warnings.

### alerta.strategy.opentrades.entry_time
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.entry_time
Signature: strategy.opentrades.entry_time(trade_index)
Returns entry time of an open trade.
TradingView-compatible spelling: strategy.opentrades.entry_time; runs without warnings.

### alerta.strategy.opentrades.size
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.size
Signature: strategy.opentrades.size(trade_index)
Returns quantity of an open trade.
TradingView-compatible spelling: strategy.opentrades.size; runs without warnings.

### alerta.strategy.opentrades.commission
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.commission
Signature: strategy.opentrades.commission(trade_index)
Returns accumulated commission of an open trade.
TradingView-compatible spelling: strategy.opentrades.commission; runs without warnings.

### alerta.strategy.opentrades.profit
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.profit
Signature: strategy.opentrades.profit(trade_index)
Returns current unrealized profit of an open trade.
TradingView-compatible spelling: strategy.opentrades.profit; runs without warnings.

### alerta.strategy.opentrades.max_runup_percent
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.max_runup_percent
Signature: strategy.opentrades.max_runup_percent(trade_index)
Returns max runup percent for an open trade.
TradingView-compatible spelling: strategy.opentrades.max_runup_percent; runs without warnings.

### alerta.strategy.opentrades.max_drawdown_percent
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.max_drawdown_percent
Signature: strategy.opentrades.max_drawdown_percent(trade_index)
Returns max drawdown percent for an open trade.
TradingView-compatible spelling: strategy.opentrades.max_drawdown_percent; runs without warnings.

### alerta.strategy.opentrades.entry_bar
https://www.alertachart.com/alertascript/reference/builtins/strategy.opentrades.entry_bar
Signature: strategy.opentrades.entry_bar(trade_index)
Alias of entry bar index for open trades.
TradingView-compatible spelling: strategy.opentrades.entry_bar_index; runs without warnings.

### alerta.strategy.closedtrades.entry_price
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.entry_price
Signature: strategy.closedtrades.entry_price(trade_index)
Returns entry price of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.entry_price; runs without warnings.

### alerta.strategy.closedtrades.entry_comment
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.entry_comment
Signature: strategy.closedtrades.entry_comment(trade_index)
Returns entry comment of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.entry_comment; runs without warnings.

### alerta.strategy.closedtrades.entry_time
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.entry_time
Signature: strategy.closedtrades.entry_time(trade_index)
Returns entry time of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.entry_time; runs without warnings.

### alerta.strategy.closedtrades.exit_price
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.exit_price
Signature: strategy.closedtrades.exit_price(trade_index)
Returns exit price of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.exit_price; runs without warnings.

### alerta.strategy.closedtrades.exit_comment
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.exit_comment
Signature: strategy.closedtrades.exit_comment(trade_index)
Returns exit comment of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.exit_comment; runs without warnings.

### alerta.strategy.closedtrades.exit_time
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.exit_time
Signature: strategy.closedtrades.exit_time(trade_index)
Returns exit time of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.exit_time; runs without warnings.

### alerta.strategy.closedtrades.size
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.size
Signature: strategy.closedtrades.size(trade_index)
Returns quantity of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.size; runs without warnings.

### alerta.strategy.closedtrades.commission
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.commission
Signature: strategy.closedtrades.commission(trade_index)
Returns paid commission of a closed trade.
TradingView-compatible spelling: strategy.closedtrades.commission; runs without warnings.

### alerta.strategy.closedtrades.max_runup_percent
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.max_runup_percent
Signature: strategy.closedtrades.max_runup_percent(trade_index)
Returns max runup percent for a closed trade.
TradingView-compatible spelling: strategy.closedtrades.max_runup_percent; runs without warnings.

### alerta.strategy.closedtrades.max_drawdown_percent
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.max_drawdown_percent
Signature: strategy.closedtrades.max_drawdown_percent(trade_index)
Returns max drawdown percent for a closed trade.
TradingView-compatible spelling: strategy.closedtrades.max_drawdown_percent; runs without warnings.

### alerta.strategy.closedtrades.entry_bar
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.entry_bar
Signature: strategy.closedtrades.entry_bar(trade_index)
Alias of entry bar index for closed trades.
TradingView-compatible spelling: strategy.closedtrades.entry_bar_index; runs without warnings.

### alerta.strategy.closedtrades.exit_bar
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.exit_bar
Signature: strategy.closedtrades.exit_bar(trade_index)
Alias of exit bar index for closed trades.
TradingView-compatible spelling: strategy.closedtrades.exit_bar_index; runs without warnings.

### alerta.strategy.initial_capital
https://www.alertachart.com/alertascript/reference/builtins/strategy.initial_capital
Signature: strategy.initial_capital
Returns the starting capital defined in the strategy() declaration.
TradingView-compatible spelling: strategy.initial_capital; runs without warnings.

### alerta.strategy.grossprofit
https://www.alertachart.com/alertascript/reference/builtins/strategy.grossprofit
Signature: strategy.grossprofit
Returns the total profit from all winning closed trades.
TradingView-compatible spelling: strategy.grossprofit; runs without warnings.

### alerta.strategy.grossloss
https://www.alertachart.com/alertascript/reference/builtins/strategy.grossloss
Signature: strategy.grossloss
Returns the total loss (as a positive number) from all losing closed trades.
TradingView-compatible spelling: strategy.grossloss; runs without warnings.

### alerta.strategy.wintrades
https://www.alertachart.com/alertascript/reference/builtins/strategy.wintrades
Signature: strategy.wintrades
Returns the number of closed trades that ended with a profit.
TradingView-compatible spelling: strategy.wintrades; runs without warnings.

### alerta.strategy.losstrades
https://www.alertachart.com/alertascript/reference/builtins/strategy.losstrades
Signature: strategy.losstrades
Returns the number of closed trades that ended with a loss.
TradingView-compatible spelling: strategy.losstrades; runs without warnings.

### alerta.strategy.eventrades
https://www.alertachart.com/alertascript/reference/builtins/strategy.eventrades
Signature: strategy.eventrades
Returns the number of closed trades that ended at breakeven (no profit, no loss).
TradingView-compatible spelling: strategy.eventrades; runs without warnings.

### alerta.strategy.max_drawdown
https://www.alertachart.com/alertascript/reference/builtins/strategy.max_drawdown
Signature: strategy.max_drawdown
Returns the maximum equity drawdown of the backtest, intrabar as in the Strategy Tester: the highest closed-trade equity so far minus the equity at a bar's adverse extreme (the low of a long, the high of a short).
TradingView-compatible spelling: strategy.max_drawdown; runs without warnings.

### alerta.strategy.max_runup
https://www.alertachart.com/alertascript/reference/builtins/strategy.max_runup
Signature: strategy.max_runup
Returns the maximum equity run-up of the backtest, intrabar: the equity at a bar's favourable extreme minus the lowest closed-trade equity so far.
TradingView-compatible spelling: strategy.max_runup; runs without warnings.

### alerta.strategy.account_currency
https://www.alertachart.com/alertascript/reference/builtins/strategy.account_currency
Signature: strategy.account_currency
Returns the account currency of strategy equity and P&L: the strategy() currency, or the symbol's own currency when it is currency.NONE (the default) — e.g. "USDT" on BTCUSDT.
TradingView-compatible spelling: strategy.account_currency; runs without warnings.

### alerta.strategy.default_entry_qty
https://www.alertachart.com/alertascript/reference/builtins/strategy.default_entry_qty
Signature: strategy.default_entry_qty(fill_price)
Returns the default order quantity that strategy settings imply at a given fill price.
TradingView-compatible spelling: strategy.default_entry_qty; runs without warnings.

### alerta.plot
https://www.alertachart.com/alertascript/reference/builtins/plot
Signature: plot(series, { title, color, linewidth, style, pane, offset, display })
Plots a series on the chart.
TradingView-compatible spelling: plot; runs without warnings.

### alerta.hline
https://www.alertachart.com/alertascript/reference/builtins/hline
Signature: hline(price, { title, color, linestyle, linewidth })
Plots a horizontal line at a fixed price level.
TradingView-compatible spelling: hline; runs without warnings.

### alerta.plotshape
https://www.alertachart.com/alertascript/reference/builtins/plotshape
Signature: plotshape(series, { shape, location, color, text, size, transp })
Plots visual shapes on the chart based on a condition.
TradingView-compatible spelling: plotshape; runs without warnings.

### alerta.plotchar
https://www.alertachart.com/alertascript/reference/builtins/plotchar
Signature: plotchar(series, { char, location, color, text })
Plots a specific character on the chart based on a condition.
TradingView-compatible spelling: plotchar; runs without warnings.

### alerta.plotarrow
https://www.alertachart.com/alertascript/reference/builtins/plotarrow
Signature: plotarrow(series, { colorup, colordown, minheight, maxheight, offset, pane })  |  plotarrow(series, title, colorup, colordown, …)
Plots up/down arrows based on signed series values. Pine's positional order after the series is `title, colorup, colordown, offset, minheight, maxheight, editable, show_last, display, force_overlay` — `title` comes FIRST, as it does across the whole plot family.
TradingView-compatible spelling: plotarrow; runs without warnings.

### alerta.plotcandle
https://www.alertachart.com/alertascript/reference/builtins/plotcandle
Signature: plotcandle(open, high, low, close, { color, wickcolor, bordercolor, offset, pane })  |  plotcandle(open, high, low, close, title, color, wickcolor, …)
Plots custom candlesticks from OHLC series. Pine's positional order after close is `title, color, wickcolor, editable, show_last, bordercolor, display, format, precision, force_overlay` — `title` comes first and `bordercolor` sits AFTER show_last, not next to wickcolor.
TradingView-compatible spelling: plotcandle; runs without warnings.

### alerta.plotbar
https://www.alertachart.com/alertascript/reference/builtins/plotbar
Signature: plotbar(open, high, low, close, { color, offset, pane })  |  plotbar(open, high, low, close, title, color, …)
Plots OHLC bars (ticks on open/close). Pine's positional order after close is `title, color, editable, show_last, display, format, precision, force_overlay`.
TradingView-compatible spelling: plotbar; runs without warnings.

### alerta.bgcolor
https://www.alertachart.com/alertascript/reference/builtins/bgcolor
Signature: bgcolor(color, options)
Changes the background color of the chart based on a condition.
TradingView-compatible spelling: bgcolor; runs without warnings.

### alerta.barcolor
https://www.alertachart.com/alertascript/reference/builtins/barcolor
Signature: barcolor(color, { offset, editable })
Overrides candle/bar color on matching bars.
TradingView-compatible spelling: barcolor; runs without warnings.

### alerta.fill
https://www.alertachart.com/alertascript/reference/builtins/fill
Signature: fill(plot1_id, plot2_id, y1?, y2?, color1?, color2?, { color, title, fillgaps, top_color, bottom_color }?)
Fills the area between two plots (or two hlines). Each plot may be given by the handle plot() returns (p1 = plot(…)), by a plot() call written inline — fill(plot(a), plot(b), color = …) — or by its title. Pine v6's gradient form — fill(p1, p2, top_value, bottom_value, top_color, bottom_color) — works positionally and by name.
TradingView-compatible spelling: fill; runs without warnings.

### alerta.linefill
https://www.alertachart.com/alertascript/reference/builtins/linefill
Signature: linefill(line1_id, line2_id, options)
Fills the area between two line handles.
TradingView-compatible spelling: linefill.new; runs without warnings.

### alerta.drawLabel
https://www.alertachart.com/alertascript/reference/builtins/drawlabel
Signature: drawLabel(id, cond, x, y, text, options)
Draws a persistent label element on the chart at specific coordinates.
TradingView-compatible spelling: label.new; runs without warnings.

### alerta.drawBox
https://www.alertachart.com/alertascript/reference/builtins/drawbox
Signature: drawBox(id, cond, x1, y1, x2, y2, options)
Draws a persistent rectangle/zone on the chart. Ideal for FVG/OB.
TradingView-compatible spelling: box.new; runs without warnings.

### alerta.drawLine
https://www.alertachart.com/alertascript/reference/builtins/drawline
Signature: drawLine(id, cond, x1, y1, x2, y2, options)
Draws a persistent trendline or simple line between two points.
TradingView-compatible spelling: line.new; runs without warnings.

### alerta.drawTable
https://www.alertachart.com/alertascript/reference/builtins/drawtable
Signature: drawTable(id, row, col, text, options)
Draws a persistent table cell for creating HUDs and dashboards.
TradingView-compatible spelling: table.cell; runs without warnings.

### alerta.linefill.new
https://www.alertachart.com/alertascript/reference/builtins/linefill.new
Signature: linefill.new(line1, line2, color)
Creates a linefill handle between two line handles.
TradingView-compatible spelling: linefill.new; runs without warnings.

### alerta.linefill.delete
https://www.alertachart.com/alertascript/reference/builtins/linefill.delete
Signature: linefill.delete(id)
Deletes a linefill handle.
TradingView-compatible spelling: linefill.delete; runs without warnings.

### alerta.linefill.get_line1
https://www.alertachart.com/alertascript/reference/builtins/linefill.get_line1
Signature: linefill.get_line1(id)
Returns the first line handle used by the linefill.
TradingView-compatible spelling: linefill.get_line1; runs without warnings.

### alerta.linefill.get_line2
https://www.alertachart.com/alertascript/reference/builtins/linefill.get_line2
Signature: linefill.get_line2(id)
Returns the second line handle used by the linefill.
TradingView-compatible spelling: linefill.get_line2; runs without warnings.

### alerta.linefill.set_color
https://www.alertachart.com/alertascript/reference/builtins/linefill.set_color
Signature: linefill.set_color(id, color)
Updates linefill color.
TradingView-compatible spelling: linefill.set_color; runs without warnings.

### alerta.line.new
https://www.alertachart.com/alertascript/reference/builtins/line.new
Signature: line.new(x1, y1, x2, y2, options)  |  line.new(x1, y1, x2, y2, color=, style=, width=, extend=)  |  line.new(x1, y1, x2, y2, xloc, extend, color, style, width)
Creates a line object and returns its handle. Accepts the Alerta-canonical `options={...}` object form, the Pine v5/v6 direct-named-args dialect (`line.new(x1, y1, x2, y2, color=color.green, style=line.style_dashed, width=2, extend=extend.right)`), and Pine's fully POSITIONAL form, whose optional order is `xloc, extend, color, style, width, force_overlay`. All three forms produce identical output.
TradingView-compatible spelling: line.new; runs without warnings.

### alerta.line.copy
https://www.alertachart.com/alertascript/reference/builtins/line.copy
Signature: line.copy(id)
Creates a duplicate of an existing line and returns the new handle.
TradingView-compatible spelling: line.copy; runs without warnings.

### alerta.line.set_xy1
https://www.alertachart.com/alertascript/reference/builtins/line.set_xy1
Signature: line.set_xy1(id, x, y)
Updates line start point (x1, y1) together.
TradingView-compatible spelling: line.set_xy1; runs without warnings.

### alerta.line.set_xy2
https://www.alertachart.com/alertascript/reference/builtins/line.set_xy2
Signature: line.set_xy2(id, x, y)
Updates line end point (x2, y2) together.
TradingView-compatible spelling: line.set_xy2; runs without warnings.

### alerta.line.set_first_point
https://www.alertachart.com/alertascript/reference/builtins/line.set_first_point
Signature: line.set_first_point(id, point)
Updates the line start point from a `chart.point` object.
TradingView-compatible spelling: line.set_first_point; runs without warnings.

### alerta.line.set_second_point
https://www.alertachart.com/alertascript/reference/builtins/line.set_second_point
Signature: line.set_second_point(id, point)
Updates the line end point from a `chart.point` object.
TradingView-compatible spelling: line.set_second_point; runs without warnings.

### alerta.line.set_xloc
https://www.alertachart.com/alertascript/reference/builtins/line.set_xloc
Signature: line.set_xloc(id, x1, x2, xloc)
Sets both x-coordinates of the line and the x-location they are read in (bar index or bar time) at once.
TradingView-compatible spelling: line.set_xloc; runs without warnings.

### alerta.line.set_x1
https://www.alertachart.com/alertascript/reference/builtins/line.set_x1
Signature: line.set_x1(id, x)
Updates line start X coordinate.
TradingView-compatible spelling: line.set_x1; runs without warnings.

### alerta.line.set_y1
https://www.alertachart.com/alertascript/reference/builtins/line.set_y1
Signature: line.set_y1(id, y)
Updates line start Y coordinate.
TradingView-compatible spelling: line.set_y1; runs without warnings.

### alerta.line.set_x2
https://www.alertachart.com/alertascript/reference/builtins/line.set_x2
Signature: line.set_x2(id, x)
Updates line end X coordinate.
TradingView-compatible spelling: line.set_x2; runs without warnings.

### alerta.line.set_y2
https://www.alertachart.com/alertascript/reference/builtins/line.set_y2
Signature: line.set_y2(id, y)
Updates line end Y coordinate.
TradingView-compatible spelling: line.set_y2; runs without warnings.

### alerta.line.set_color
https://www.alertachart.com/alertascript/reference/builtins/line.set_color
Signature: line.set_color(id, color)
Updates line color.
TradingView-compatible spelling: line.set_color; runs without warnings.

### alerta.line.set_width
https://www.alertachart.com/alertascript/reference/builtins/line.set_width
Signature: line.set_width(id, width)
Updates line width.
TradingView-compatible spelling: line.set_width; runs without warnings.

### alerta.line.set_extend
https://www.alertachart.com/alertascript/reference/builtins/line.set_extend
Signature: line.set_extend(id, extend)
Updates line extend mode.
TradingView-compatible spelling: line.set_extend; runs without warnings.

### alerta.line.set_style
https://www.alertachart.com/alertascript/reference/builtins/line.set_style
Signature: line.set_style(id, style)
Updates line style (solid, dashed, dotted, etc.).
TradingView-compatible spelling: line.set_style; runs without warnings.

### alerta.line.set_zindex
https://www.alertachart.com/alertascript/reference/builtins/line.set_zindex
Signature: line.set_zindex(line_id, zindex)
Updates line z-index ordering.
TradingView-compatible spelling: line.set_zindex; runs without warnings.

### alerta.line.delete
https://www.alertachart.com/alertascript/reference/builtins/line.delete
Signature: line.delete(id)
Deletes a line object.
TradingView-compatible spelling: line.delete; runs without warnings.

### alerta.line.get_x1
https://www.alertachart.com/alertascript/reference/builtins/line.get_x1
Signature: line.get_x1(id)
Returns line start X coordinate.
TradingView-compatible spelling: line.get_x1; runs without warnings.

### alerta.line.get_y1
https://www.alertachart.com/alertascript/reference/builtins/line.get_y1
Signature: line.get_y1(id)
Returns line start Y coordinate.
TradingView-compatible spelling: line.get_y1; runs without warnings.

### alerta.line.get_x2
https://www.alertachart.com/alertascript/reference/builtins/line.get_x2
Signature: line.get_x2(id)
Returns line end X coordinate.
TradingView-compatible spelling: line.get_x2; runs without warnings.

### alerta.line.get_y2
https://www.alertachart.com/alertascript/reference/builtins/line.get_y2
Signature: line.get_y2(id)
Returns line end Y coordinate.
TradingView-compatible spelling: line.get_y2; runs without warnings.

### alerta.line.get_price
https://www.alertachart.com/alertascript/reference/builtins/line.get_price
Signature: line.get_price(id, x)
Returns interpolated price of a line at a target bar index.
TradingView-compatible spelling: line.get_price; runs without warnings.

### alerta.box.new
https://www.alertachart.com/alertascript/reference/builtins/box.new
Signature: box.new(left, top, right, bottom, options)  |  box.new(left, top, right, bottom, bgcolor=, border_color=, border_width=)  |  box.new(left, top, right, bottom, border_color, border_width, border_style, extend, xloc, bgcolor, text, …)
Creates a box object and returns its handle. Accepts the Alerta-canonical `options={...}` object form, the Pine v5/v6 direct-named-args dialect (`box.new(left, top, right, bottom, bgcolor=, border_color=, border_width=, extend=)`), and Pine's fully POSITIONAL form, whose optional order is `border_color, border_width, border_style, extend, xloc, bgcolor, text, text_size, text_color, text_halign, text_valign, text_wrap, text_font_family, force_overlay`. Note that `bgcolor` is the SIXTH optional, not the third. Snake-case aliases (`bg_color`, `border_color`, `border_style`) auto-map to canonical camelCase. All three forms produce identical output.
TradingView-compatible spelling: box.new; runs without warnings.

### alerta.box.copy
https://www.alertachart.com/alertascript/reference/builtins/box.copy
Signature: box.copy(id)
Creates a duplicate of an existing box and returns the new handle.
TradingView-compatible spelling: box.copy; runs without warnings.

### alerta.box.get_left
https://www.alertachart.com/alertascript/reference/builtins/box.get_left
Signature: box.get_left(id)
Returns box left coordinate.
TradingView-compatible spelling: box.get_left; runs without warnings.

### alerta.box.get_right
https://www.alertachart.com/alertascript/reference/builtins/box.get_right
Signature: box.get_right(id)
Returns box right coordinate.
TradingView-compatible spelling: box.get_right; runs without warnings.

### alerta.box.get_top
https://www.alertachart.com/alertascript/reference/builtins/box.get_top
Signature: box.get_top(id)
Returns box top price.
TradingView-compatible spelling: box.get_top; runs without warnings.

### alerta.box.get_bottom
https://www.alertachart.com/alertascript/reference/builtins/box.get_bottom
Signature: box.get_bottom(id)
Returns box bottom price.
TradingView-compatible spelling: box.get_bottom; runs without warnings.

### alerta.box.set_left
https://www.alertachart.com/alertascript/reference/builtins/box.set_left
Signature: box.set_left(id, left)
Updates box left coordinate.
TradingView-compatible spelling: box.set_left; runs without warnings.

### alerta.box.set_top
https://www.alertachart.com/alertascript/reference/builtins/box.set_top
Signature: box.set_top(id, top)
Updates box top price.
TradingView-compatible spelling: box.set_top; runs without warnings.

### alerta.box.set_right
https://www.alertachart.com/alertascript/reference/builtins/box.set_right
Signature: box.set_right(id, right)
Updates box right coordinate.
TradingView-compatible spelling: box.set_right; runs without warnings.

### alerta.box.set_bottom
https://www.alertachart.com/alertascript/reference/builtins/box.set_bottom
Signature: box.set_bottom(id, bottom)
Updates box bottom price.
TradingView-compatible spelling: box.set_bottom; runs without warnings.

### alerta.box.set_border_color
https://www.alertachart.com/alertascript/reference/builtins/box.set_border_color
Signature: box.set_border_color(id, color)
Updates box border color.
TradingView-compatible spelling: box.set_border_color; runs without warnings.

### alerta.box.set_border_style
https://www.alertachart.com/alertascript/reference/builtins/box.set_border_style
Signature: box.set_border_style(id, style)
Updates box border style token.
TradingView-compatible spelling: box.set_border_style; runs without warnings.

### alerta.box.set_border_width
https://www.alertachart.com/alertascript/reference/builtins/box.set_border_width
Signature: box.set_border_width(id, width)
Updates box border width.
TradingView-compatible spelling: box.set_border_width; runs without warnings.

### alerta.box.set_bgcolor
https://www.alertachart.com/alertascript/reference/builtins/box.set_bgcolor
Signature: box.set_bgcolor(id, color)
Updates box background color.
TradingView-compatible spelling: box.set_bgcolor; runs without warnings.

### alerta.box.set_extend
https://www.alertachart.com/alertascript/reference/builtins/box.set_extend
Signature: box.set_extend(id, extend)
Updates box extend mode.
TradingView-compatible spelling: box.set_extend; runs without warnings.

### alerta.box.set_xloc
https://www.alertachart.com/alertascript/reference/builtins/box.set_xloc
Signature: box.set_xloc(id, left, right, xloc)
Updates box left/right coordinates and X-location mode together.
TradingView-compatible spelling: box.set_xloc; runs without warnings.

### alerta.box.set_text
https://www.alertachart.com/alertascript/reference/builtins/box.set_text
Signature: box.set_text(id, text)
Updates text shown inside the box.
TradingView-compatible spelling: box.set_text; runs without warnings.

### alerta.box.set_text_color
https://www.alertachart.com/alertascript/reference/builtins/box.set_text_color
Signature: box.set_text_color(id, text_color)
Updates box text color.
TradingView-compatible spelling: box.set_text_color; runs without warnings.

### alerta.box.set_text_halign
https://www.alertachart.com/alertascript/reference/builtins/box.set_text_halign
Signature: box.set_text_halign(id, text_halign)
Updates horizontal alignment of box text.
TradingView-compatible spelling: box.set_text_halign; runs without warnings.

### alerta.box.set_text_valign
https://www.alertachart.com/alertascript/reference/builtins/box.set_text_valign
Signature: box.set_text_valign(id, text_valign)
Updates vertical alignment of box text.
TradingView-compatible spelling: box.set_text_valign; runs without warnings.

### alerta.box.set_text_size
https://www.alertachart.com/alertascript/reference/builtins/box.set_text_size
Signature: box.set_text_size(id, text_size)
Updates size of box text.
TradingView-compatible spelling: box.set_text_size; runs without warnings.

### alerta.box.set_zindex
https://www.alertachart.com/alertascript/reference/builtins/box.set_zindex
Signature: box.set_zindex(box_id, zindex)
Updates box z-index ordering.
TradingView-compatible spelling: box.set_zindex; runs without warnings.

### alerta.box.delete
https://www.alertachart.com/alertascript/reference/builtins/box.delete
Signature: box.delete(id)
Deletes a box object.
TradingView-compatible spelling: box.delete; runs without warnings.

### alerta.label.new
https://www.alertachart.com/alertascript/reference/builtins/label.new
Signature: label.new(x, y, text, options)  |  label.new(x, y, text, color=, textcolor=, style=, size=)  |  label.new(x, y, text, xloc, yloc, color, style, textcolor, size, textalign, tooltip)
Creates a label object and returns its handle. Accepts the Alerta-canonical `options={...}` object form, the Pine v5/v6 direct-named-args dialect (`label.new(x, y, text, color=, textcolor=, style=, size=, tooltip=)`), and Pine's fully POSITIONAL form, whose optional order is `xloc, yloc, color, style, textcolor, size, textalign, tooltip, text_font_family, force_overlay` — the order a wrapper function passes its parameters through. Snake-case `text_color` / `text_font_family` auto-map to `textColor` / `textFontFamily`. All three forms produce identical output.
TradingView-compatible spelling: label.new; runs without warnings.

### alerta.label.copy
https://www.alertachart.com/alertascript/reference/builtins/label.copy
Signature: label.copy(id)
Creates a duplicate of an existing label and returns the new handle.
TradingView-compatible spelling: label.copy; runs without warnings.

### alerta.label.get_x
https://www.alertachart.com/alertascript/reference/builtins/label.get_x
Signature: label.get_x(id)
Returns label X coordinate.
TradingView-compatible spelling: label.get_x; runs without warnings.

### alerta.label.get_y
https://www.alertachart.com/alertascript/reference/builtins/label.get_y
Signature: label.get_y(id)
Returns label Y coordinate.
TradingView-compatible spelling: label.get_y; runs without warnings.

### alerta.label.get_text
https://www.alertachart.com/alertascript/reference/builtins/label.get_text
Signature: label.get_text(id)
Returns label text.
TradingView-compatible spelling: label.get_text; runs without warnings.

### alerta.label.set_xy
https://www.alertachart.com/alertascript/reference/builtins/label.set_xy
Signature: label.set_xy(id, x, y)
Pine v6: set both x and y in a single call.
TradingView-compatible spelling: label.set_xy; runs without warnings.

### alerta.label.set_xloc
https://www.alertachart.com/alertascript/reference/builtins/label.set_xloc
Signature: label.set_xloc(id, x, xloc)
Pine v6: set the label's x-coordinate and switch xloc (bar_index | bar_time) at once.
TradingView-compatible spelling: label.set_xloc; runs without warnings.

### alerta.label.set_textalign
https://www.alertachart.com/alertascript/reference/builtins/label.set_textalign
Signature: label.set_textalign(id, textalign)
Updates label text alignment.
TradingView-compatible spelling: label.set_textalign; runs without warnings.

### alerta.label.set_tooltip
https://www.alertachart.com/alertascript/reference/builtins/label.set_tooltip
Signature: label.set_tooltip(id, tooltip)
Updates label tooltip content.
TradingView-compatible spelling: label.set_tooltip; runs without warnings.

### alerta.polyline.new
https://www.alertachart.com/alertascript/reference/builtins/polyline.new
Signature: polyline.new(points, curved, closed, xloc, line_color, fill_color, line_style, line_width, force_overlay)
Creates a polyline through an array of chart.point values. curved=true draws smooth segments, closed=true connects the last point back to the first (fill_color fills the enclosed area).
TradingView-compatible spelling: polyline.new; runs without warnings.

### alerta.polyline.push
https://www.alertachart.com/alertascript/reference/builtins/polyline.push
Signature: polyline.push(polyline_id, x, y)
Appends a point to an existing polyline.
TradingView-compatible spelling: polyline.push; runs without warnings.

### alerta.polyline.delete
https://www.alertachart.com/alertascript/reference/builtins/polyline.delete
Signature: polyline.delete(id)
Deletes a polyline object.
TradingView-compatible spelling: polyline.delete; runs without warnings.

### alerta.label.set_x
https://www.alertachart.com/alertascript/reference/builtins/label.set_x
Signature: label.set_x(id, x)
Updates label X coordinate.
TradingView-compatible spelling: label.set_x; runs without warnings.

### alerta.label.set_y
https://www.alertachart.com/alertascript/reference/builtins/label.set_y
Signature: label.set_y(id, y)
Updates label Y coordinate.
TradingView-compatible spelling: label.set_y; runs without warnings.

### alerta.label.set_text
https://www.alertachart.com/alertascript/reference/builtins/label.set_text
Signature: label.set_text(id, text)
Updates label text.
TradingView-compatible spelling: label.set_text; runs without warnings.

### alerta.label.set_zindex
https://www.alertachart.com/alertascript/reference/builtins/label.set_zindex
Signature: label.set_zindex(label_id, zindex)
Updates label z-index ordering.
TradingView-compatible spelling: label.set_zindex; runs without warnings.

### alerta.label.set_color
https://www.alertachart.com/alertascript/reference/builtins/label.set_color
Signature: label.set_color(id, color)
Updates label background color.
TradingView-compatible spelling: label.set_color; runs without warnings.

### alerta.label.set_textcolor
https://www.alertachart.com/alertascript/reference/builtins/label.set_textcolor
Signature: label.set_textcolor(id, textcolor)
Updates label text color.
TradingView-compatible spelling: label.set_textcolor; runs without warnings.

### alerta.label.set_size
https://www.alertachart.com/alertascript/reference/builtins/label.set_size
Signature: label.set_size(id, size)
Updates label size.
TradingView-compatible spelling: label.set_size; runs without warnings.

### alerta.label.set_style
https://www.alertachart.com/alertascript/reference/builtins/label.set_style
Signature: label.set_style(id, style)
Updates label style token.
TradingView-compatible spelling: label.set_style; runs without warnings.

### alerta.label.set_location
https://www.alertachart.com/alertascript/reference/builtins/label.set_location
Signature: label.set_location(label_id, location)
Updates label location mode.
TradingView-compatible spelling: label.set_location; runs without warnings.

### alerta.label.delete
https://www.alertachart.com/alertascript/reference/builtins/label.delete
Signature: label.delete(id)
Deletes a label object.
TradingView-compatible spelling: label.delete; runs without warnings.

### alerta.chart.point.new
https://www.alertachart.com/alertascript/reference/builtins/chart.point.new
Signature: chart.point.new(time, index, price) → chart.point
Constructs a Pine v6 `chart.point` from explicit time, index, and price. Used as a coordinate argument to line.new/box.new/label.new/polyline.new. `chart.point` is also usable as a TYPE ANNOTATION, including the array shorthand: `var chart.point[] pts = array.new<chart.point>(0)` and `f(chart.point[] pts) =>`.
TradingView-compatible spelling: chart.point.new; runs without warnings.

### alerta.chart.point.from_index
https://www.alertachart.com/alertascript/reference/builtins/chart.point.from_index
Signature: chart.point.from_index(index, price) → chart.point
Pine v6: creates a chart.point at a given bar index; time is auto-derived from the bar at that index.
TradingView-compatible spelling: chart.point.from_index; runs without warnings.

### alerta.chart.point.from_time
https://www.alertachart.com/alertascript/reference/builtins/chart.point.from_time
Signature: chart.point.from_time(time, price) → chart.point
Pine v6: creates a chart.point at a given timestamp; bar index is resolved at draw time.
TradingView-compatible spelling: chart.point.from_time; runs without warnings.

### alerta.chart.point.now
https://www.alertachart.com/alertascript/reference/builtins/chart.point.now
Signature: chart.point.now(price) → chart.point
Pine v6: chart.point at the current bar with the given price (close when none is given).
TradingView-compatible spelling: chart.point.now; runs without warnings.

### alerta.chart.point.copy
https://www.alertachart.com/alertascript/reference/builtins/chart.point.copy
Signature: chart.point.copy(point) → chart.point
Pine v6: returns a shallow copy of a chart.point.
TradingView-compatible spelling: chart.point.copy; runs without warnings.

### alerta.polyline.set_curved
https://www.alertachart.com/alertascript/reference/builtins/polyline.set_curved
Signature: polyline.set_curved(id, curved)
Pine v6: enables/disables curve smoothing on a polyline.
TradingView-compatible spelling: polyline.set_curved; runs without warnings.

### alerta.polyline.set_closed
https://www.alertachart.com/alertascript/reference/builtins/polyline.set_closed
Signature: polyline.set_closed(id, closed)
Pine v6: when true, the polyline closes back to its first point.
TradingView-compatible spelling: polyline.set_closed; runs without warnings.

### alerta.polyline.set_xloc
https://www.alertachart.com/alertascript/reference/builtins/polyline.set_xloc
Signature: polyline.set_xloc(id, xloc)
Pine v6: switches x-axis between bar_index and bar_time.
TradingView-compatible spelling: polyline.set_xloc; runs without warnings.

### alerta.polyline.set_line_color
https://www.alertachart.com/alertascript/reference/builtins/polyline.set_line_color
Signature: polyline.set_line_color(id, line_color)
Pine v6: sets the polyline stroke color.
TradingView-compatible spelling: polyline.set_line_color; runs without warnings.

### alerta.polyline.set_fill_color
https://www.alertachart.com/alertascript/reference/builtins/polyline.set_fill_color
Signature: polyline.set_fill_color(id, fill_color)
Pine v6: sets the polyline interior fill color (applies when closed=true).
TradingView-compatible spelling: polyline.set_fill_color; runs without warnings.

### alerta.polyline.set_line_style
https://www.alertachart.com/alertascript/reference/builtins/polyline.set_line_style
Signature: polyline.set_line_style(id, line_style)
Pine v6: solid | dashed | dotted.
TradingView-compatible spelling: polyline.set_line_style; runs without warnings.

### alerta.polyline.set_line_width
https://www.alertachart.com/alertascript/reference/builtins/polyline.set_line_width
Signature: polyline.set_line_width(id, line_width)
Pine v6: polyline stroke width in pixels.
TradingView-compatible spelling: polyline.set_line_width; runs without warnings.

### alerta.polyline.set_points
https://www.alertachart.com/alertascript/reference/builtins/polyline.set_points
Signature: polyline.set_points(id, points)
Pine v6: replaces the polyline's point array with a new array<chart.point>.
TradingView-compatible spelling: polyline.set_points; runs without warnings.

### alerta.polyline.delete_all
https://www.alertachart.com/alertascript/reference/builtins/polyline.delete_all
Signature: polyline.delete_all()
Pine v6: deletes every polyline created by the script in one call.
TradingView-compatible spelling: polyline.delete_all; runs without warnings.

### alerta.polyline.all
https://www.alertachart.com/alertascript/reference/builtins/polyline.all
Signature: polyline.all → array<polyline>
Pine v6: read-only array containing every active polyline handle.
TradingView-compatible spelling: polyline.all; runs without warnings.

### alerta.line.all
https://www.alertachart.com/alertascript/reference/builtins/line.all
Signature: line.all → array<line>
An array of every line the script has drawn and not deleted, oldest first. It is a new array on every read, so deleting lines while walking it — `for l in line.all` then `line.delete(l)`, or `array.get(line.all, i)` in a counted loop — deletes them all.
TradingView-compatible spelling: line.all; runs without warnings.

### alerta.line.delete_all
https://www.alertachart.com/alertascript/reference/builtins/line.delete_all
Signature: line.delete_all()
Pine v6: deletes every line created by the script.
TradingView-compatible spelling: line.delete_all; runs without warnings.

### alerta.label.all
https://www.alertachart.com/alertascript/reference/builtins/label.all
Signature: label.all → array<label>
Pine v6: read-only array of every active label handle.
TradingView-compatible spelling: label.all; runs without warnings.

### alerta.label.delete_all
https://www.alertachart.com/alertascript/reference/builtins/label.delete_all
Signature: label.delete_all()
Pine v6: deletes every label created by the script.
TradingView-compatible spelling: label.delete_all; runs without warnings.

### alerta.box.all
https://www.alertachart.com/alertascript/reference/builtins/box.all
Signature: box.all → array<box>
Pine v6: read-only array of every active box handle.
TradingView-compatible spelling: box.all; runs without warnings.

### alerta.box.delete_all
https://www.alertachart.com/alertascript/reference/builtins/box.delete_all
Signature: box.delete_all()
Pine v6: deletes every box created by the script.
TradingView-compatible spelling: box.delete_all; runs without warnings.

### alerta.table.all
https://www.alertachart.com/alertascript/reference/builtins/table.all
Signature: table.all → array<table>
Pine v6: read-only array of every active table handle.
TradingView-compatible spelling: table.all; runs without warnings.

### alerta.table.delete_all
https://www.alertachart.com/alertascript/reference/builtins/table.delete_all
Signature: table.delete_all()
Pine v6: deletes every table created by the script.
TradingView-compatible spelling: table.delete_all; runs without warnings.

### alerta.label.set_yloc
https://www.alertachart.com/alertascript/reference/builtins/label.set_yloc
Signature: label.set_yloc(id, yloc)
Pine v6: switches y-axis between price | abovebar | belowbar.
TradingView-compatible spelling: label.set_yloc; runs without warnings.

### alerta.label.set_point
https://www.alertachart.com/alertascript/reference/builtins/label.set_point
Signature: label.set_point(id, point)
Pine v6: set the label's position from a chart.point.
TradingView-compatible spelling: label.set_point; runs without warnings.

### alerta.label.set_text_font_family
https://www.alertachart.com/alertascript/reference/builtins/label.set_text_font_family
Signature: label.set_text_font_family(id, text_font_family)
Pine v6: switch the label text font family (font.family_default | font.family_monospace).
TradingView-compatible spelling: label.set_text_font_family; runs without warnings.

### alerta.label.set_text_formatting
https://www.alertachart.com/alertascript/reference/builtins/label.set_text_formatting
Signature: label.set_text_formatting(id, text_formatting)
Pine v6: apply italic/bold to the label text (text.format_bold | text.format_italic | text.format_none).
TradingView-compatible spelling: label.set_text_formatting; runs without warnings.

### alerta.box.set_lefttop
https://www.alertachart.com/alertascript/reference/builtins/box.set_lefttop
Signature: box.set_lefttop(id, left, top)
Pine v6: set left and top in one call.
TradingView-compatible spelling: box.set_lefttop; runs without warnings.

### alerta.box.set_rightbottom
https://www.alertachart.com/alertascript/reference/builtins/box.set_rightbottom
Signature: box.set_rightbottom(id, right, bottom)
Pine v6: set right and bottom in one call.
TradingView-compatible spelling: box.set_rightbottom; runs without warnings.

### alerta.box.set_top_left_point
https://www.alertachart.com/alertascript/reference/builtins/box.set_top_left_point
Signature: box.set_top_left_point(id, point)
Pine v6: set the box's top-left corner from a chart.point.
TradingView-compatible spelling: box.set_top_left_point; runs without warnings.

### alerta.box.set_bottom_right_point
https://www.alertachart.com/alertascript/reference/builtins/box.set_bottom_right_point
Signature: box.set_bottom_right_point(id, point)
Pine v6: set the box's bottom-right corner from a chart.point.
TradingView-compatible spelling: box.set_bottom_right_point; runs without warnings.

### alerta.box.set_text_font_family
https://www.alertachart.com/alertascript/reference/builtins/box.set_text_font_family
Signature: box.set_text_font_family(id, text_font_family)
Pine v6: switch the box's text font family.
TradingView-compatible spelling: box.set_text_font_family; runs without warnings.

### alerta.box.set_text_formatting
https://www.alertachart.com/alertascript/reference/builtins/box.set_text_formatting
Signature: box.set_text_formatting(id, text_formatting)
Pine v6: apply italic/bold to the box text.
TradingView-compatible spelling: box.set_text_formatting; runs without warnings.

### alerta.box.set_text_wrap
https://www.alertachart.com/alertascript/reference/builtins/box.set_text_wrap
Signature: box.set_text_wrap(id, text_wrap)
Pine v6: enable/disable text wrapping inside the box.
TradingView-compatible spelling: box.set_text_wrap; runs without warnings.

### alerta.table.set_position
https://www.alertachart.com/alertascript/reference/builtins/table.set_position
Signature: table.set_position(table_id, position)
Pine v6: relocate a table to a different chart corner.
TradingView-compatible spelling: table.set_position; runs without warnings.

### alerta.table.set_bgcolor
https://www.alertachart.com/alertascript/reference/builtins/table.set_bgcolor
Signature: table.set_bgcolor(table_id, bgcolor)
Sets the table's background color. It colors every cell without a background of its own — also the cells made before the call — while cells given their own bgcolor keep it. na removes the background.
TradingView-compatible spelling: table.set_bgcolor; runs without warnings.

### alerta.table.set_border_color
https://www.alertachart.com/alertascript/reference/builtins/table.set_border_color
Signature: table.set_border_color(table_id, border_color)
Pine v6: set the outer border / frame color.
TradingView-compatible spelling: table.set_border_color; runs without warnings.

### alerta.table.set_border_width
https://www.alertachart.com/alertascript/reference/builtins/table.set_border_width
Signature: table.set_border_width(table_id, border_width)
Pine v6: set the outer frame width in pixels.
TradingView-compatible spelling: table.set_border_width; runs without warnings.

### alerta.array.new_float
https://www.alertachart.com/alertascript/reference/builtins/array.new
Signature: array.new(size?, initialValue?)
Creates a new array. Optional `size` and `initialValue` match Pine behavior; a negative size, or one past 100,000 elements (Pine's collection limit), stops the script with a runtime error. Pine v6 generic form `array.new<T>(size, init)` is accepted and routes to the matching typed constructor (e.g. `array.new<float>()` → `array.new_float()`).
TradingView-compatible spelling: array.new_float; runs without warnings.

### alerta.array.new_int
https://www.alertachart.com/alertascript/reference/builtins/array.new_int
Signature: array.new_int(size?, initialValue?)
Creates a new int array. Pine v6 form `array.new<int>(size, init)` is an alias.
TradingView-compatible spelling: array.new_int; runs without warnings.

### alerta.array.new_bool
https://www.alertachart.com/alertascript/reference/builtins/array.new_bool
Signature: array.new_bool(size?, initialValue?)
Creates a new bool array. Pine v6 form `array.new<bool>(size, init)` is an alias.
TradingView-compatible spelling: array.new_bool; runs without warnings.

### alerta.array.new_string
https://www.alertachart.com/alertascript/reference/builtins/array.new_string
Signature: array.new_string(size?, initialValue?)
Creates a new string array. Pine v6 form `array.new<string>(size, init)` is an alias.
TradingView-compatible spelling: array.new_string; runs without warnings.

### alerta.array.new_color
https://www.alertachart.com/alertascript/reference/builtins/array.new_color
Signature: array.new_color(size?, initialValue?)
Creates a new color array.
TradingView-compatible spelling: array.new_color; runs without warnings.

### alerta.array.new_line
https://www.alertachart.com/alertascript/reference/builtins/array.new_line
Signature: array.new_line(size?, initialValue?)
Creates a new line-handle array.
TradingView-compatible spelling: array.new_line; runs without warnings.

### alerta.array.new_linefill
https://www.alertachart.com/alertascript/reference/builtins/array.new_linefill
Signature: array.new_linefill(size?, initialValue?)
Creates a new linefill-handle array.
TradingView-compatible spelling: array.new_linefill; runs without warnings.

### alerta.array.new_box
https://www.alertachart.com/alertascript/reference/builtins/array.new_box
Signature: array.new_box(size?, initialValue?)
Creates a new box-handle array.
TradingView-compatible spelling: array.new_box; runs without warnings.

### alerta.array.new_label
https://www.alertachart.com/alertascript/reference/builtins/array.new_label
Signature: array.new_label(size?, initialValue?)
Creates a new label-handle array.
TradingView-compatible spelling: array.new_label; runs without warnings.

### alerta.array.new_table
https://www.alertachart.com/alertascript/reference/builtins/array.new_table
Signature: array.new_table(size?, initialValue?)
Creates a new table-handle array.
TradingView-compatible spelling: array.new_table; runs without warnings.

### alerta.array.get
https://www.alertachart.com/alertascript/reference/builtins/array.get
Signature: array.get(id, index)
Returns the element at index. An index past either end stops the script with an error; in a //@version=6 script a negative index counts from the end (-1 is the last element).
TradingView-compatible spelling: array.get; runs without warnings.

### alerta.array.set
https://www.alertachart.com/alertascript/reference/builtins/array.set
Signature: array.set(id, index, value)
Sets an element at index. An index past either end stops the script with an error; in a //@version=6 script a negative index counts from the end (-1 is the last element).
TradingView-compatible spelling: array.set; runs without warnings.

### alerta.array.push
https://www.alertachart.com/alertascript/reference/builtins/array.push
Signature: array.push(id, value)
Appends value to array.
TradingView-compatible spelling: array.push; runs without warnings.

### alerta.array.pop
https://www.alertachart.com/alertascript/reference/builtins/array.pop
Signature: array.pop(id)
Removes and returns the last element. On an empty array it stops the script with a runtime error ("Cannot use pop() if array is empty."), as in Pine: check `array.size(id) > 0` first.
TradingView-compatible spelling: array.pop; runs without warnings.

### alerta.array.shift
https://www.alertachart.com/alertascript/reference/builtins/array.shift
Signature: array.shift(id)
Removes and returns the first element. On an empty array it stops the script with a runtime error ("Cannot use shift() if array is empty."), as in Pine: check `array.size(id) > 0` first.
TradingView-compatible spelling: array.shift; runs without warnings.

### alerta.array.unshift
https://www.alertachart.com/alertascript/reference/builtins/array.unshift
Signature: array.unshift(id, value)
Prepends value to array.
TradingView-compatible spelling: array.unshift; runs without warnings.

### alerta.array.size
https://www.alertachart.com/alertascript/reference/builtins/array.size
Signature: array.size(id)
Returns number of elements in array.
TradingView-compatible spelling: array.size; runs without warnings.

### alerta.array.insert
https://www.alertachart.com/alertascript/reference/builtins/array.insert
Signature: array.insert(id, index, value)
Inserts value at index. An index past the end stops the script with an error; in a //@version=6 script a negative index counts from the end.
TradingView-compatible spelling: array.insert; runs without warnings.

### alerta.array.remove
https://www.alertachart.com/alertascript/reference/builtins/array.remove
Signature: array.remove(id, index)
Removes and returns element at index. An index past either end stops the script with an error; in a //@version=6 script a negative index counts from the end (-1 is the last element).
TradingView-compatible spelling: array.remove; runs without warnings.

### alerta.array.clear
https://www.alertachart.com/alertascript/reference/builtins/array.clear
Signature: array.clear(id)
Clears all elements in an array.
TradingView-compatible spelling: array.clear; runs without warnings.

### alerta.array.first
https://www.alertachart.com/alertascript/reference/builtins/array.first
Signature: array.first(id)
Returns the first element of an array (series-aware). On an empty array it stops the script with a runtime error, as in Pine: check `array.size(id) > 0` first.
TradingView-compatible spelling: array.first; runs without warnings.

### alerta.array.avg
https://www.alertachart.com/alertascript/reference/builtins/array.avg
Signature: array.avg(id)
Returns the average of numeric values in the array.
TradingView-compatible spelling: array.avg; runs without warnings.

### alerta.array.min
https://www.alertachart.com/alertascript/reference/builtins/array.min
Signature: array.min(id, nth?)
Returns the minimum numeric value in the array, or the nth smallest when nth is given.
TradingView-compatible spelling: array.min; runs without warnings.

### alerta.array.indexof
https://www.alertachart.com/alertascript/reference/builtins/array.indexof
Signature: array.indexof(id, value)
Returns the index of a value in the array or -1 if not found (supports series value lookups).
TradingView-compatible spelling: array.indexof; runs without warnings.

### alerta.array.lastindexof
https://www.alertachart.com/alertascript/reference/builtins/array.lastindexof
Signature: array.lastindexof(id, value)
Returns the last index of a value in the array or -1 if not found.
TradingView-compatible spelling: array.lastindexof; runs without warnings.

### alerta.array.sort
https://www.alertachart.com/alertascript/reference/builtins/array.sort
Signature: array.sort(id, order?)
Sorts elements in the array in ascending or descending order: numbers by value, strings by character code; na elements go last (first when descending).
TradingView-compatible spelling: array.sort; runs without warnings.

### alerta.array.sum
https://www.alertachart.com/alertascript/reference/builtins/array.sum
Signature: array.sum(id)
Returns the sum of numeric values in the array.
TradingView-compatible spelling: array.sum; runs without warnings.

### alerta.array.max
https://www.alertachart.com/alertascript/reference/builtins/array.max
Signature: array.max(id, nth?)
Returns the maximum numeric value in the array, or the nth largest when nth is given.
TradingView-compatible spelling: array.max; runs without warnings.

### alerta.array.last
https://www.alertachart.com/alertascript/reference/builtins/array.last
Signature: array.last(id)
Returns the last element of the array. On an empty array it stops the script with a runtime error, as in Pine: check `array.size(id) > 0` first.
TradingView-compatible spelling: array.last; runs without warnings.

### alerta.array.slice
https://www.alertachart.com/alertascript/reference/builtins/array.slice
Signature: array.slice(id, begin, end?)
Returns a view of a portion of an array: an element written in the slice is written in the array, and the other way round, until either changes its size. Bounds past the array stop the script.
TradingView-compatible spelling: array.slice; runs without warnings.

### alerta.array.copy
https://www.alertachart.com/alertascript/reference/builtins/array.copy
Signature: array.copy(id)
Returns a shallow copy of an array structure.
TradingView-compatible spelling: array.copy; runs without warnings.

### alerta.array.reverse
https://www.alertachart.com/alertascript/reference/builtins/array.reverse
Signature: array.reverse(id)
Reverses an array structure in place.
TradingView-compatible spelling: array.reverse; runs without warnings.

### alerta.array.join
https://www.alertachart.com/alertascript/reference/builtins/array.join
Signature: array.join(id, separator?)
Creates and returns a new string by concatenating all of the elements in an array, separated by commas or a specified separator string.
TradingView-compatible spelling: array.join; runs without warnings.

### alerta.array.fill
https://www.alertachart.com/alertascript/reference/builtins/array.fill
Signature: array.fill(id, value, index_from?, index_to?)
Sets elements to a static value — the whole array, or only the [index_from, index_to) sub-range when bounds are given (index_to is exclusive).
TradingView-compatible spelling: array.fill; runs without warnings.

### alerta.array.includes
https://www.alertachart.com/alertascript/reference/builtins/array.includes
Signature: array.includes(id, value)
Returns true if array contains value, false otherwise.
TradingView-compatible spelling: array.includes; runs without warnings.

### alerta.array.abs
https://www.alertachart.com/alertascript/reference/builtins/array.abs
Signature: array.abs(id)
Returns a new array containing the absolute value of each numeric element.
TradingView-compatible spelling: array.abs; runs without warnings.

### alerta.array.every
https://www.alertachart.com/alertascript/reference/builtins/array.every
Signature: array.every(id)
Returns true if all elements are truthy.
TradingView-compatible spelling: array.every; runs without warnings.

### alerta.array.some
https://www.alertachart.com/alertascript/reference/builtins/array.some
Signature: array.some(id)
Returns true when at least one array element is truthy.
TradingView-compatible spelling: array.some; runs without warnings.

### alerta.array.binary_search
https://www.alertachart.com/alertascript/reference/builtins/array.binary_search
Signature: array.binary_search(id, value)
Searches a sorted numeric array and returns found index, or -1.
TradingView-compatible spelling: array.binary_search; runs without warnings.

### alerta.array.binary_search_leftmost
https://www.alertachart.com/alertascript/reference/builtins/array.binary_search_leftmost
Signature: array.binary_search_leftmost(id, value)
Returns the first matching index in a sorted numeric array, or the index immediately left of the insertion point.
TradingView-compatible spelling: array.binary_search_leftmost; runs without warnings.

### alerta.array.binary_search_rightmost
https://www.alertachart.com/alertascript/reference/builtins/array.binary_search_rightmost
Signature: array.binary_search_rightmost(id, value)
Returns the last matching index in a sorted numeric array, or the index immediately right of the insertion point.
TradingView-compatible spelling: array.binary_search_rightmost; runs without warnings.

### alerta.array.from
https://www.alertachart.com/alertascript/reference/builtins/array.from
Signature: array.from(v1, v2, ...)
Creates a new array from provided values.
TradingView-compatible spelling: array.from; runs without warnings.

### alerta.array.concat
https://www.alertachart.com/alertascript/reference/builtins/array.concat
Signature: array.concat(target, source)
Appends all elements from source array into target array, and returns the target so the call can be used as an expression.
TradingView-compatible spelling: array.concat; runs without warnings.

### alerta.array.range
https://www.alertachart.com/alertascript/reference/builtins/array.range
Signature: array.range(id)
Returns max(array) - min(array).
TradingView-compatible spelling: array.range; runs without warnings.

### alerta.array.stdev
https://www.alertachart.com/alertascript/reference/builtins/array.stdev
Signature: array.stdev(id, biased?)
Returns standard deviation of numeric values in array. biased=true (default) = population (÷n); biased=false = sample (÷n-1).
TradingView-compatible spelling: array.stdev; runs without warnings.

### alerta.array.variance
https://www.alertachart.com/alertascript/reference/builtins/array.variance
Signature: array.variance(id, biased?)
Returns variance of numeric values in array. biased=true (default) = population (÷n); biased=false = sample (÷n-1).
TradingView-compatible spelling: array.variance; runs without warnings.

### alerta.array.covariance
https://www.alertachart.com/alertascript/reference/builtins/array.covariance
Signature: array.covariance(a, b, biased?)
Returns covariance between two numeric arrays. biased=true (default) = population (÷n); biased=false = sample (÷n-1).
TradingView-compatible spelling: array.covariance; runs without warnings.

### alerta.array.median
https://www.alertachart.com/alertascript/reference/builtins/array.median
Signature: array.median(id)
Returns median of numeric values in array.
TradingView-compatible spelling: array.median; runs without warnings.

### alerta.array.mode
https://www.alertachart.com/alertascript/reference/builtins/array.mode
Signature: array.mode(id)
Returns most frequent numeric value in array.
TradingView-compatible spelling: array.mode; runs without warnings.

### alerta.array.percentile_nearest_rank
https://www.alertachart.com/alertascript/reference/builtins/array.percentile_nearest_rank
Signature: array.percentile_nearest_rank(id, percentage)
Returns nearest-rank percentile from array values.
TradingView-compatible spelling: array.percentile_nearest_rank; runs without warnings.

### alerta.array.percentile_linear_interpolation
https://www.alertachart.com/alertascript/reference/builtins/array.percentile_linear_interpolation
Signature: array.percentile_linear_interpolation(id, percentage)
Returns interpolated percentile from array values.
TradingView-compatible spelling: array.percentile_linear_interpolation; runs without warnings.

### alerta.array.percentrank
https://www.alertachart.com/alertascript/reference/builtins/array.percentrank
Signature: array.percentrank(id, index)
Returns the percent rank (0..100) of the element at index: the share of the other elements at or below it.
TradingView-compatible spelling: array.percentrank; runs without warnings.

### alerta.array.sort_indices
https://www.alertachart.com/alertascript/reference/builtins/array.sort_indices
Signature: array.sort_indices(id, order?)
Returns new array containing indices sorted by values.
TradingView-compatible spelling: array.sort_indices; runs without warnings.

### alerta.array.standardize
https://www.alertachart.com/alertascript/reference/builtins/array.standardize
Signature: array.standardize(id)
Returns z-score standardized values as a new array.
TradingView-compatible spelling: array.standardize; runs without warnings.

### alerta.map.new
https://www.alertachart.com/alertascript/reference/builtins/map.new
Signature: map.new() or map.new<K, V>()
Creates a new empty map/dictionary. Pine v6 generic form `map.new<K, V>()` is supported in declarations such as `var map<string, float> levels = map.new<string, float>()` — the "Previous Day and Week Levels" template in the script editor is a worked example.
TradingView-compatible spelling: map.new; runs without warnings.

### alerta.map.put
https://www.alertachart.com/alertascript/reference/builtins/map.put
Signature: map.put(id, key, value)
Inserts or updates the value associated with `key` in the map.
TradingView-compatible spelling: map.put; runs without warnings.

### alerta.map.get
https://www.alertachart.com/alertascript/reference/builtins/map.get
Signature: map.get(id, key)
Returns the value associated with `key`, or `na` if the key is not in the map.
TradingView-compatible spelling: map.get; runs without warnings.

### alerta.map.size
https://www.alertachart.com/alertascript/reference/builtins/map.size
Signature: map.size(id)
Returns the number of key/value pairs in the map.
TradingView-compatible spelling: map.size; runs without warnings.

### alerta.map.contains
https://www.alertachart.com/alertascript/reference/builtins/map.contains
Signature: map.contains(id, key)
Returns true if `key` is present in the map.
TradingView-compatible spelling: map.contains; runs without warnings.

### alerta.map.keys
https://www.alertachart.com/alertascript/reference/builtins/map.keys
Signature: map.keys(id)
Returns an array containing every key currently stored in the map. Iteration order is insertion order.
TradingView-compatible spelling: map.keys; runs without warnings.

### alerta.map.values
https://www.alertachart.com/alertascript/reference/builtins/map.values
Signature: map.values(id)
Returns an array containing every value currently stored in the map. Iteration order matches `map.keys`.
TradingView-compatible spelling: map.values; runs without warnings.

### alerta.map.remove
https://www.alertachart.com/alertascript/reference/builtins/map.remove
Signature: map.remove(id, key)
Removes the entry for `key` from the map. Returns the removed value, or na if the key was not present.
TradingView-compatible spelling: map.remove; runs without warnings.

### alerta.map.copy
https://www.alertachart.com/alertascript/reference/builtins/map.copy
Signature: map.copy(id) → map
Pine v6: returns a shallow copy of the map.
TradingView-compatible spelling: map.copy; runs without warnings.

### alerta.map.put_all
https://www.alertachart.com/alertascript/reference/builtins/map.put_all
Signature: map.put_all(id, id2)
Pine v6: copies every entry from `id2` into `id`. Existing keys are overwritten.
TradingView-compatible spelling: map.put_all; runs without warnings.

### alerta.map.clear
https://www.alertachart.com/alertascript/reference/builtins/map.clear
Signature: map.clear(id)
Removes every entry from the map, leaving it empty.
TradingView-compatible spelling: map.clear; runs without warnings.

### alerta.matrix.new
https://www.alertachart.com/alertascript/reference/builtins/matrix.new
Signature: matrix.new(rows, columns, value)
Creates a new matrix table. A negative size, or more than 100,000 elements (Pine's collection limit), stops the script with a runtime error.
TradingView-compatible spelling: matrix.new; runs without warnings.

### alerta.matrix.get
https://www.alertachart.com/alertascript/reference/builtins/matrix.get
Signature: matrix.get(id, row, column)
Gets a value from a matrix cell.
TradingView-compatible spelling: matrix.get; runs without warnings.

### alerta.matrix.set
https://www.alertachart.com/alertascript/reference/builtins/matrix.set
Signature: matrix.set(id, row, column, value)
Sets a value in a matrix cell.
TradingView-compatible spelling: matrix.set; runs without warnings.

### alerta.matrix.rows
https://www.alertachart.com/alertascript/reference/builtins/matrix.rows
Signature: matrix.rows(id)
Gets the number of rows in a matrix.
TradingView-compatible spelling: matrix.rows; runs without warnings.

### alerta.matrix.columns
https://www.alertachart.com/alertascript/reference/builtins/matrix.columns
Signature: matrix.columns(id)
Gets the number of columns in a matrix.
TradingView-compatible spelling: matrix.columns; runs without warnings.

### alerta.matrix.copy
https://www.alertachart.com/alertascript/reference/builtins/matrix.copy
Signature: matrix.copy(id)
Creates a deep copy of a matrix.
TradingView-compatible spelling: matrix.copy; runs without warnings.

### alerta.matrix.elements_count
https://www.alertachart.com/alertascript/reference/builtins/matrix.elements_count
Signature: matrix.elements_count(id)
Returns total number of elements (rows * columns).
TradingView-compatible spelling: matrix.elements_count; runs without warnings.

### alerta.matrix.fill
https://www.alertachart.com/alertascript/reference/builtins/matrix.fill
Signature: matrix.fill(id, value, from_row?, to_row?, from_column?, to_column?)
Fills matrix elements with a value — the whole matrix, or only the [from_row,to_row)×[from_column,to_column) block when bounds are given (to_* are exclusive).
TradingView-compatible spelling: matrix.fill; runs without warnings.

### alerta.matrix.row
https://www.alertachart.com/alertascript/reference/builtins/matrix.row
Signature: matrix.row(id, row)
Returns row values as an array.
TradingView-compatible spelling: matrix.row; runs without warnings.

### alerta.matrix.col
https://www.alertachart.com/alertascript/reference/builtins/matrix.col
Signature: matrix.col(id, column)
Returns column values as an array.
TradingView-compatible spelling: matrix.col; runs without warnings.

### alerta.matrix.transpose
https://www.alertachart.com/alertascript/reference/builtins/matrix.transpose
Signature: matrix.transpose(id)
Returns transposed matrix.
TradingView-compatible spelling: matrix.transpose; runs without warnings.

### alerta.matrix.sum
https://www.alertachart.com/alertascript/reference/builtins/matrix.sum
Signature: matrix.sum(a, b)
Element-wise sum of two matrices, or of a matrix and a number added to every element.
TradingView-compatible spelling: matrix.sum; runs without warnings.

### alerta.matrix.diff
https://www.alertachart.com/alertascript/reference/builtins/matrix.diff
Signature: matrix.diff(a, b)
Element-wise subtraction of two matrices, or of a number from every element.
TradingView-compatible spelling: matrix.diff; runs without warnings.

### alerta.matrix.mult
https://www.alertachart.com/alertascript/reference/builtins/matrix.mult
Signature: matrix.mult(a, b)
Returns the matrix product. The right operand can be a matrix, a number, or an array (a column vector: the result is an array).
TradingView-compatible spelling: matrix.mult; runs without warnings.

### alerta.matrix.trace
https://www.alertachart.com/alertascript/reference/builtins/matrix.trace
Signature: matrix.trace(id)
Returns diagonal sum for square matrices.
TradingView-compatible spelling: matrix.trace; runs without warnings.

### alerta.matrix.avg
https://www.alertachart.com/alertascript/reference/builtins/matrix.avg
Signature: matrix.avg(id)
Returns the arithmetic mean of all finite numeric matrix elements.
TradingView-compatible spelling: matrix.avg; runs without warnings.

### alerta.matrix.min
https://www.alertachart.com/alertascript/reference/builtins/matrix.min
Signature: matrix.min(id)
Returns the smallest finite numeric matrix element.
TradingView-compatible spelling: matrix.min; runs without warnings.

### alerta.matrix.max
https://www.alertachart.com/alertascript/reference/builtins/matrix.max
Signature: matrix.max(id)
Returns the largest finite numeric matrix element.
TradingView-compatible spelling: matrix.max; runs without warnings.

### alerta.matrix.median
https://www.alertachart.com/alertascript/reference/builtins/matrix.median
Signature: matrix.median(id)
Returns the median of finite numeric matrix elements. `na` values are ignored.
TradingView-compatible spelling: matrix.median; runs without warnings.

### alerta.matrix.mode
https://www.alertachart.com/alertascript/reference/builtins/matrix.mode
Signature: matrix.mode(id)
Returns the most frequent finite numeric matrix element. Ties resolve to the smallest value.
TradingView-compatible spelling: matrix.mode; runs without warnings.

### alerta.matrix.is_square
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_square
Signature: matrix.is_square(id)
Returns true if matrix has equal rows and columns.
TradingView-compatible spelling: matrix.is_square; runs without warnings.

### alerta.matrix.det
https://www.alertachart.com/alertascript/reference/builtins/matrix.det
Signature: matrix.det(id)
Returns determinant for square matrices.
TradingView-compatible spelling: matrix.det; runs without warnings.

### alerta.matrix.inv
https://www.alertachart.com/alertascript/reference/builtins/matrix.inv
Signature: matrix.inv(id)
Returns the inverse of a square matrix, or `na` when the matrix at the current bar is singular or not square. A regression's normal-equation matrix is legitimately singular during warm-up and whenever two predictors line up, so guard the result with `if not na(inv)` rather than assuming it exists.
TradingView-compatible spelling: matrix.inv; runs without warnings.

### alerta.matrix.rank
https://www.alertachart.com/alertascript/reference/builtins/matrix.rank
Signature: matrix.rank(id)
Returns matrix rank.
TradingView-compatible spelling: matrix.rank; runs without warnings.

### alerta.matrix.pinv
https://www.alertachart.com/alertascript/reference/builtins/matrix.pinv
Signature: matrix.pinv(id)
Returns Moore-Penrose pseudo inverse.
TradingView-compatible spelling: matrix.pinv; runs without warnings.

### alerta.matrix.pow
https://www.alertachart.com/alertascript/reference/builtins/matrix.pow
Signature: matrix.pow(id, power)
Returns a square matrix multiplied by itself `power` times.
TradingView-compatible spelling: matrix.pow; runs without warnings.

### alerta.matrix.concat
https://www.alertachart.com/alertascript/reference/builtins/matrix.concat
Signature: matrix.concat(a, b)
Appends the rows of the second matrix to the first (same column count) and returns the first.
TradingView-compatible spelling: matrix.concat; runs without warnings.

### alerta.matrix.submatrix
https://www.alertachart.com/alertascript/reference/builtins/matrix.submatrix
Signature: matrix.submatrix(id, fromRow, toRow, fromCol, toCol)
Returns a sliced submatrix using [from,to) ranges.
TradingView-compatible spelling: matrix.submatrix; runs without warnings.

### alerta.matrix.reshape
https://www.alertachart.com/alertascript/reference/builtins/matrix.reshape
Signature: matrix.reshape(id, rows, cols)
Gives the matrix a new shape in place, keeping its elements in order (rows × cols must equal the element count).
TradingView-compatible spelling: matrix.reshape; runs without warnings.

### alerta.matrix.reverse
https://www.alertachart.com/alertascript/reference/builtins/matrix.reverse
Signature: matrix.reverse(id)
Reverses the order of rows and columns in place: the first element becomes the last.
TradingView-compatible spelling: matrix.reverse; runs without warnings.

### alerta.matrix.sort
https://www.alertachart.com/alertascript/reference/builtins/matrix.sort
Signature: matrix.sort(id, column?, order?)
Sorts matrix rows in place by a column. Defaults to column `0` and ascending order.
TradingView-compatible spelling: matrix.sort; runs without warnings.

### alerta.matrix.swap_rows
https://www.alertachart.com/alertascript/reference/builtins/matrix.swap_rows
Signature: matrix.swap_rows(id, a, b)
Swaps two rows in place.
TradingView-compatible spelling: matrix.swap_rows; runs without warnings.

### alerta.matrix.swap_columns
https://www.alertachart.com/alertascript/reference/builtins/matrix.swap_columns
Signature: matrix.swap_columns(id, a, b)
Swaps two columns in place.
TradingView-compatible spelling: matrix.swap_columns; runs without warnings.

### alerta.matrix.add_row
https://www.alertachart.com/alertascript/reference/builtins/matrix.add_row
Signature: matrix.add_row(id, index, rowArray)
Inserts a row from array values; without them a row of na, at the end by default.
TradingView-compatible spelling: matrix.add_row; runs without warnings.

### alerta.matrix.remove_row
https://www.alertachart.com/alertascript/reference/builtins/matrix.remove_row
Signature: matrix.remove_row(id, index)
Removes the row at index and returns its values as an array.
TradingView-compatible spelling: matrix.remove_row; runs without warnings.

### alerta.matrix.add_col
https://www.alertachart.com/alertascript/reference/builtins/matrix.add_col
Signature: matrix.add_col(id, index, colArray)
Inserts a column from array values; without them a column of na, at the end by default.
TradingView-compatible spelling: matrix.add_col; runs without warnings.

### alerta.matrix.remove_col
https://www.alertachart.com/alertascript/reference/builtins/matrix.remove_col
Signature: matrix.remove_col(id, index)
Removes the column at index and returns its values as an array.
TradingView-compatible spelling: matrix.remove_col; runs without warnings.

### alerta.matrix.is_identity
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_identity
Signature: matrix.is_identity(id)
Returns true if matrix is identity.
TradingView-compatible spelling: matrix.is_identity; runs without warnings.

### alerta.matrix.is_diagonal
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_diagonal
Signature: matrix.is_diagonal(id)
Returns true if non-diagonal values are zero.
TradingView-compatible spelling: matrix.is_diagonal; runs without warnings.

### alerta.matrix.is_antidiagonal
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_antidiagonal
Signature: matrix.is_antidiagonal(id)
Returns true if all values outside the secondary diagonal are zero.
TradingView-compatible spelling: matrix.is_antidiagonal; runs without warnings.

### alerta.matrix.is_symmetric
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_symmetric
Signature: matrix.is_symmetric(id)
Returns true if matrix equals its transpose.
TradingView-compatible spelling: matrix.is_symmetric; runs without warnings.

### alerta.matrix.is_zero
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_zero
Signature: matrix.is_zero(id)
Returns true if all elements are zero.
TradingView-compatible spelling: matrix.is_zero; runs without warnings.

### alerta.matrix.is_binary
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_binary
Signature: matrix.is_binary(id)
Returns true if all values are 0 or 1.
TradingView-compatible spelling: matrix.is_binary; runs without warnings.

### alerta.matrix.is_triangular
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_triangular
Signature: matrix.is_triangular(id)
Returns true for upper or lower triangular matrices.
TradingView-compatible spelling: matrix.is_triangular; runs without warnings.

### alerta.matrix.is_antisymmetric
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_antisymmetric
Signature: matrix.is_antisymmetric(id)
Returns true if matrix is antisymmetric.
TradingView-compatible spelling: matrix.is_antisymmetric; runs without warnings.

### alerta.matrix.is_stochastic
https://www.alertachart.com/alertascript/reference/builtins/matrix.is_stochastic
Signature: matrix.is_stochastic(id)
Returns true when all rows sum to 1 and elements are non-negative.
TradingView-compatible spelling: matrix.is_stochastic; runs without warnings.

### alerta.matrix.kron
https://www.alertachart.com/alertascript/reference/builtins/matrix.kron
Signature: matrix.kron(a, b)
Returns Kronecker product of two matrices.
TradingView-compatible spelling: matrix.kron; runs without warnings.

### alerta.matrix.eigenvalues
https://www.alertachart.com/alertascript/reference/builtins/matrix.eigenvalues
Signature: matrix.eigenvalues(id)
Returns an array of eigenvalues for any NxN square matrix, in descending order. Symmetric matrices (covariance/correlation) use the Jacobi method; general matrices use QR iteration (real eigenvalues).
TradingView-compatible spelling: matrix.eigenvalues; runs without warnings.

### alerta.matrix.eigenvectors
https://www.alertachart.com/alertascript/reference/builtins/matrix.eigenvectors
Signature: matrix.eigenvectors(id)
Returns an NxN matrix whose COLUMNS are the eigenvectors, column order matching matrix.eigenvalues' descending eigenvalue order. Works for any square matrix (Jacobi for symmetric, inverse iteration for general).
TradingView-compatible spelling: matrix.eigenvectors; runs without warnings.

### alerta.table.new
https://www.alertachart.com/alertascript/reference/builtins/table.new
Signature: table.new(position, columns, rows, bgcolor, frame_color, frame_width, border_color, border_width)
Creates a new UI table on the chart.
TradingView-compatible spelling: table.new; runs without warnings.

### alerta.table.cell
https://www.alertachart.com/alertascript/reference/builtins/table.cell
Signature: table.cell(table_id, column, row, text, width, height, textColor, text_halign, text_valign, text_size, bgColor, tooltip, text_font_family)
Sets the content of a specific table cell.
TradingView-compatible spelling: table.cell; runs without warnings.

### alerta.table.cell_set_bgcolor
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_bgcolor
Signature: table.cell_set_bgcolor(table_id, column, row, bgcolor)
Updates the background color of a table cell.
TradingView-compatible spelling: table.cell_set_bgcolor; runs without warnings.

### alerta.table.cell_set_text
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_text
Signature: table.cell_set_text(table_id, column, row, text)
Updates text content of a table cell.
TradingView-compatible spelling: table.cell_set_text; runs without warnings.

### alerta.table.cell_set_text_color
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_text_color
Signature: table.cell_set_text_color(table_id, column, row, text_color)
Updates text color of a table cell.
TradingView-compatible spelling: table.cell_set_text_color; runs without warnings.

### alerta.table.cell_set_text_halign
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_text_halign
Signature: table.cell_set_text_halign(table_id, column, row, text_halign)
Updates horizontal text alignment of a table cell.
TradingView-compatible spelling: table.cell_set_text_halign; runs without warnings.

### alerta.table.cell_set_text_size
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_text_size
Signature: table.cell_set_text_size(table_id, column, row, text_size)
Updates text size of a table cell.
TradingView-compatible spelling: table.cell_set_text_size; runs without warnings.

### alerta.table.cell_set_text_valign
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_text_valign
Signature: table.cell_set_text_valign(table_id, column, row, text_valign)
Updates vertical text alignment metadata of a table cell.
TradingView-compatible spelling: table.cell_set_text_valign; runs without warnings.

### alerta.table.cell_set_tooltip
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_tooltip
Signature: table.cell_set_tooltip(table_id, column, row, tooltip)
Updates tooltip metadata of a table cell.
TradingView-compatible spelling: table.cell_set_tooltip; runs without warnings.

### alerta.table.cell_set_width
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_width
Signature: table.cell_set_width(table_id, column, row, width)
Updates width metadata of a table cell.
TradingView-compatible spelling: table.cell_set_width; runs without warnings.

### alerta.table.cell_set_height
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_height
Signature: table.cell_set_height(table_id, column, row, height)
Updates height metadata of a table cell.
TradingView-compatible spelling: table.cell_set_height; runs without warnings.

### alerta.table.clear
https://www.alertachart.com/alertascript/reference/builtins/table.clear
Signature: table.clear(table_id, start_column, start_row, end_column, end_row)
Clears all cells or a selected range from a table.
TradingView-compatible spelling: table.clear; runs without warnings.

### alerta.table.delete
https://www.alertachart.com/alertascript/reference/builtins/table.delete
Signature: table.delete(table_id)
Deletes a table and all of its cells.
TradingView-compatible spelling: table.delete; runs without warnings.

### alerta.table.merge_cells
https://www.alertachart.com/alertascript/reference/builtins/table.merge_cells
Signature: table.merge_cells(table_id, start_column, start_row, end_column, end_row)
Merges a rectangular range of cells: the top-left cell is drawn across the range, the cells it covers are not drawn (whenever they are written).
TradingView-compatible spelling: table.merge_cells; runs without warnings.

### switch
https://www.alertachart.com/alertascript/reference/builtins/switch
Signature: switch <expr>
    <pattern> => <body>
    <pattern> =>
        <indented block, last statement is the value>
    => <default>
Pine-style switch with indent-based body. Cases are evaluated top-to-bottom; first match wins. A trailing `=>` arm (no pattern) acts as the default case. Works as a statement OR as an expression (assignable to a variable). The subject may be omitted, in which case every case is a boolean condition and may open with `not`. `type` and `method` are soft keywords, so either can be used as an ordinary variable or parameter name — `f_ma(src, len, type) => switch type` is accepted. An arm may open an indented BLOCK instead of a single expression — declare locals, branch, and the block's last statement is the arm's value — and a pattern may itself be an enum member (`Model.rolling =>`) or start with a unary minus (`-1 =>`).
TradingView-compatible spelling: switch; runs without warnings.

### function-default-params
https://www.alertachart.com/alertascript/reference/builtins/function-default-params
Signature: name(param1, param2 = <default>, [type] param3 = <default>) =>
    <body>

name(value, param3 = other)   // named at the call site
Pine v6 parity: function parameters may declare default values. Defaults are evaluated at call time when the caller omits the slot and can reference earlier parameters. Typed prefixes (`float`, `int`, `string`, `bool`, `color`, `simple`, `series`) are accepted but informational only, and a qualifier may precede a USER type or enum — `simple ParticipationModel model`, `series Pivot p`, `simple Lib.Kind k`, `simple Sess[] all`. At the CALL SITE arguments may be named, exactly as for builtins: positional arguments fill slots left to right, a named argument claims its own slot, and any slot left over takes the parameter's default. Arguments are evaluated in the order they are written, whatever slots they fill — `f(b = array.pop(xs), a = array.pop(xs))` gives b the first value popped. The same applies to `method` calls.

### user-type-instances
https://www.alertachart.com/alertascript/reference/builtins/user-type-instances
Signature: type Name
    <type> field = <default>

method name(Name self, …) =>
    <body>

Name.new(<positional…>, field = <value>)
Pine v5/v6 user-defined types. `Type.new(...)` takes positional arguments in field-declaration order AND named ones for any field, in the same call — the two forms mix freely, and a field nobody names keeps its declared default. A `method` declared on the type dispatches on the RECEIVER's type, so several types may each declare their own `update` — and the same choice is made when the method is called in its function form, `update(x)`, by the type of its first argument. A method also dispatches on an instance read back out of a collection, directly (`arr.get(i).close()`) or through a variable (`Sess s = ss.get(i)` then `s.reset()`), and on a handle type — `method push_bar(float[] self, …)` is reached as `buf.push_bar(…)` wherever `buf` lives, including a field of another type.

### multiline-strings
https://www.alertachart.com/alertascript/reference/builtins/multiline-strings
Signature: '''text over
several lines'''  |  """text"""
Pine's multi-line string literal. `'''…'''` or `"""…"""` spans lines and may contain the other quote character — apostrophes and double quotes — without escaping, which is why long `tooltip =` texts are written this way. Everything between the delimiters is taken literally.

### compound-assignment
https://www.alertachart.com/alertascript/reference/builtins/compound-assignment
Signature: name += <expr>   //  also -=, *=, /=, %=
Pine v5/v6 parity: `x += y`, `x -= y`, `x *= y`, `x /= y`, `x %= y` are supported and desugar to `x := x + y` (etc.). Works on any reassignable variable (let/var/varip) and inside function bodies, if branches, for/while loops.

### generic-collection
https://www.alertachart.com/alertascript/reference/builtins/generic-collection
Signature: var array<T> name = array.new<T>(size?, initialValue?)
Pine v6 generic type syntax: `array<T>`, `matrix<T>`, `map<T>` work both as type annotations on var/let declarations and as call generics on `.new<T>(...)`. Equivalent to the type-suffixed form (e.g. `array.new<float>()` is the same as `array.new_float()`).

### alerta.input
https://www.alertachart.com/alertascript/reference/builtins/input
Signature: input(name, defaultValue, options) / input(defval, title, type)
Defines a user-configurable parameter that appears in the indicator settings. Supports AlertaScript input(name, defaultValue), Pine-style input(defaultValue, title="Name"), input(title="Name", defval=value), and legacy type=bool/int/float/string/source.
TradingView-compatible spelling: input; runs without warnings.

### alerta.iff
https://www.alertachart.com/alertascript/reference/builtins/iff
Signature: iff(condition, trueValue, falseValue)
Pine v1/v2 compatibility helper. Returns the true branch when condition is truthy, otherwise the false branch. Works with scalar values and series.
TradingView-compatible spelling: iff; runs without warnings.

### alerta.na
https://www.alertachart.com/alertascript/reference/builtins/na
Signature: na(val)
Returns true if the value is null, undefined, or NaN.
TradingView-compatible spelling: na; runs without warnings.

### alerta.nz
https://www.alertachart.com/alertascript/reference/builtins/nz
Signature: nz(val, replacement)
Replaces null, undefined, or NaN values with a replacement value (default 0).
TradingView-compatible spelling: nz; runs without warnings.

### alerta.fixnan
https://www.alertachart.com/alertascript/reference/builtins/fixnan
Signature: fixnan(source)
Replaces null/NaN values with the previous non-null value in the series.
TradingView-compatible spelling: fixnan; runs without warnings.

### alerta.typeof
https://www.alertachart.com/alertascript/reference/builtins/typeof
Signature: typeof(value)
Returns the runtime type name of a value, or series type for arrays.
TradingView-compatible spelling: typeof; runs without warnings.

### alerta.runtime.error
https://www.alertachart.com/alertascript/reference/builtins/runtime.error
Signature: runtime.error(message)
Stops the script with an error as soon as a bar reaches the call. Nothing the script would have drawn is shown, and the error reads "Runtime Error: <message>" with the line of the call. A call on a branch no bar reaches changes nothing, so it is the way to refuse settings or data a script cannot work with.
TradingView-compatible spelling: runtime.error; runs without warnings.

### alerta.bool
https://www.alertachart.com/alertascript/reference/builtins/bool
Signature: bool(value)
Casts a value to boolean using Pine-style truthiness.
TradingView-compatible spelling: bool; runs without warnings.

### alerta.int
https://www.alertachart.com/alertascript/reference/builtins/int
Signature: int(value)
Casts numeric values to integer (truncates fractional part).
TradingView-compatible spelling: int; runs without warnings.

### alerta.float
https://www.alertachart.com/alertascript/reference/builtins/float
Signature: float(value)
Casts value to floating-point number.
TradingView-compatible spelling: float; runs without warnings.

### alerta.string
https://www.alertachart.com/alertascript/reference/builtins/string
Signature: string(value)
Converts value to string representation.
TradingView-compatible spelling: string; runs without warnings.

### alerta.color
https://www.alertachart.com/alertascript/reference/builtins/color
Signature: color(value)
Casts value to color representation (hex/rgba string).
TradingView-compatible spelling: color; runs without warnings.

### alerta.color.new
https://www.alertachart.com/alertascript/reference/builtins/color.new
Signature: color.new(baseColor, transparency)
Returns the base color with the given transparency, 0 (opaque) to 100 (invisible). The transparency replaces the base color's own: color.new(c, 0) is opaque even when c was translucent. It may be a series, so one plot can change its transparency from bar to bar.
TradingView-compatible spelling: color.new; runs without warnings.

### alerta.color.rgb
https://www.alertachart.com/alertascript/reference/builtins/color.rgb
Signature: color.rgb(r, g, b, transparency)
Builds a color from red/green/blue and optional transparency.
TradingView-compatible spelling: color.rgb; runs without warnings.

### alerta.color.from_gradient
https://www.alertachart.com/alertascript/reference/builtins/color.from_gradient
Signature: color.from_gradient(source, min, max, colorA, colorB)
Interpolates between two colors based on source value inside min/max range.
TradingView-compatible spelling: color.from_gradient; runs without warnings.

### alerta.color.r
https://www.alertachart.com/alertascript/reference/builtins/color.r
Signature: color.r(colorValue)
Returns the red channel (0..255) of a color.
TradingView-compatible spelling: color.r; runs without warnings.

### alerta.color.g
https://www.alertachart.com/alertascript/reference/builtins/color.g
Signature: color.g(colorValue)
Returns the green channel (0..255) of a color.
TradingView-compatible spelling: color.g; runs without warnings.

### alerta.color.b
https://www.alertachart.com/alertascript/reference/builtins/color.b
Signature: color.b(colorValue)
Returns the blue channel (0..255) of a color.
TradingView-compatible spelling: color.b; runs without warnings.

### alerta.color.t
https://www.alertachart.com/alertascript/reference/builtins/color.t
Signature: color.t(colorValue)
Returns the transparency channel (0..100) of a color.
TradingView-compatible spelling: color.t; runs without warnings.

### alerta.math.abs
https://www.alertachart.com/alertascript/reference/builtins/abs
Signature: abs(x)
Absolute value of x.
TradingView-compatible spelling: math.abs; runs without warnings.

### alerta.math.min
https://www.alertachart.com/alertascript/reference/builtins/min
Signature: min(x, y)
Returns the smaller of two or more values.
TradingView-compatible spelling: math.min; runs without warnings.

### alerta.math.max
https://www.alertachart.com/alertascript/reference/builtins/max
Signature: max(x, y)
Returns the larger of two or more values.
TradingView-compatible spelling: math.max; runs without warnings.

### alerta.math.round
https://www.alertachart.com/alertascript/reference/builtins/round
Signature: round(x, precision?)
Rounds to the nearest integer, or — with `precision` — to that many decimal places. `math.round(x, 2)` is how dashboards trim a figure before `str.tostring`.
TradingView-compatible spelling: math.round; runs without warnings.

### alerta.fixed
https://www.alertachart.com/alertascript/reference/builtins/fixed
Signature: fixed(val, precision)
Format a number to fixed decimal places.

### alerta.math.sqrt
https://www.alertachart.com/alertascript/reference/builtins/sqrt
Signature: sqrt(x)
Square root of x.
TradingView-compatible spelling: math.sqrt; runs without warnings.

### alerta.math.pow
https://www.alertachart.com/alertascript/reference/builtins/pow
Signature: pow(x, y)
x raised to the power of y.
TradingView-compatible spelling: math.pow; runs without warnings.

### alerta.math.log
https://www.alertachart.com/alertascript/reference/builtins/log
Signature: log(x)
Natural logarithm (base e) of x.
TradingView-compatible spelling: math.log; runs without warnings.

### alerta.math.exp
https://www.alertachart.com/alertascript/reference/builtins/exp
Signature: exp(x)
Returns e raised to x.
TradingView-compatible spelling: math.exp; runs without warnings.

### alerta.math.ceil
https://www.alertachart.com/alertascript/reference/builtins/ceil
Signature: ceil(x)
Rounds x upward to nearest integer.
TradingView-compatible spelling: math.ceil; runs without warnings.

### alerta.math.floor
https://www.alertachart.com/alertascript/reference/builtins/floor
Signature: floor(x)
Rounds x downward to nearest integer.
TradingView-compatible spelling: math.floor; runs without warnings.

### alerta.math.avg
https://www.alertachart.com/alertascript/reference/builtins/avg
Signature: avg(a, b)
Returns the arithmetic mean of two or more values (na when any of them is na).
TradingView-compatible spelling: math.avg; runs without warnings.

### alerta.math.sin
https://www.alertachart.com/alertascript/reference/builtins/sin
Signature: sin(x)
Trigonometric sine of x (radians).
TradingView-compatible spelling: math.sin; runs without warnings.

### alerta.math.cos
https://www.alertachart.com/alertascript/reference/builtins/cos
Signature: cos(x)
Trigonometric cosine of x (radians).
TradingView-compatible spelling: math.cos; runs without warnings.

### alerta.math.tan
https://www.alertachart.com/alertascript/reference/builtins/tan
Signature: tan(x)
Trigonometric tangent of x (radians).
TradingView-compatible spelling: math.tan; runs without warnings.

### alerta.math.asin
https://www.alertachart.com/alertascript/reference/builtins/asin
Signature: asin(x)
Inverse sine of x.
TradingView-compatible spelling: math.asin; runs without warnings.

### alerta.math.acos
https://www.alertachart.com/alertascript/reference/builtins/acos
Signature: acos(x)
Inverse cosine of x.
TradingView-compatible spelling: math.acos; runs without warnings.

### alerta.math.atan
https://www.alertachart.com/alertascript/reference/builtins/atan
Signature: atan(x)
Inverse tangent of x.
TradingView-compatible spelling: math.atan; runs without warnings.

### alerta.math.sign
https://www.alertachart.com/alertascript/reference/builtins/sign
Signature: sign(x)
Returns sign of x: -1, 0, 1.
TradingView-compatible spelling: math.sign; runs without warnings.

### alerta.math.log10
https://www.alertachart.com/alertascript/reference/builtins/log10
Signature: log10(x)
Base-10 logarithm.
TradingView-compatible spelling: math.log10; runs without warnings.

### alerta.math.random
https://www.alertachart.com/alertascript/reference/builtins/random
Signature: random(min?, max?, seed?)
Returns a pseudo-random value in range [min, max]. With `seed`, the sequence is REPEATABLE: the same seed yields the same stream of values on every run, which is what a simulation needs so its paths do not redraw differently on each tick.
TradingView-compatible spelling: math.random; runs without warnings.

### alerta.math.round_to_mintick
https://www.alertachart.com/alertascript/reference/builtins/round_to_mintick
Signature: round_to_mintick(x)
Rounds value to the nearest multiple of syminfo.mintick, the symbol's tick size.
TradingView-compatible spelling: math.round_to_mintick; runs without warnings.

### alerta.math.sum
https://www.alertachart.com/alertascript/reference/builtins/math.sum
Signature: math.sum(source, length)
Namespace form of sum over a rolling window.
TradingView-compatible spelling: math.sum; runs without warnings.

### alerta.math.todegrees
https://www.alertachart.com/alertascript/reference/builtins/todegrees
Signature: todegrees(x)
Converts radians to degrees.
TradingView-compatible spelling: math.todegrees; runs without warnings.

### alerta.math.toradians
https://www.alertachart.com/alertascript/reference/builtins/toradians
Signature: toradians(x)
Converts degrees to radians.
TradingView-compatible spelling: math.toradians; runs without warnings.

### alerta.str.contains
https://www.alertachart.com/alertascript/reference/builtins/str.contains
Signature: str.contains(source, target)
Returns true if the source string contains the target string.
TradingView-compatible spelling: str.contains; runs without warnings.

### alerta.str.length
https://www.alertachart.com/alertascript/reference/builtins/str.length
Signature: str.length(source)
Returns the length of the string.
TradingView-compatible spelling: str.length; runs without warnings.

### alerta.str.substring
https://www.alertachart.com/alertascript/reference/builtins/str.substring
Signature: str.substring(source, begin, end)
Returns a substring from begin to end.
TradingView-compatible spelling: str.substring; runs without warnings.

### alerta.str.replace
https://www.alertachart.com/alertascript/reference/builtins/str.replace
Signature: str.replace(source, target, replacement, occurrence)
Replaces one occurrence of target with replacement — the first unless occurrence says otherwise.
TradingView-compatible spelling: str.replace; runs without warnings.

### alerta.str.replace_all
https://www.alertachart.com/alertascript/reference/builtins/str.replace_all
Signature: str.replace_all(source, target, replacement)
Replaces all occurrences of target with replacement.
TradingView-compatible spelling: str.replace_all; runs without warnings.

### alerta.str.split
https://www.alertachart.com/alertascript/reference/builtins/str.split
Signature: str.split(source, separator)
Splits string by separator into an array.
TradingView-compatible spelling: str.split; runs without warnings.

### alerta.str.lower
https://www.alertachart.com/alertascript/reference/builtins/str.lower
Signature: str.lower(source)
Converts string to lowercase.
TradingView-compatible spelling: str.lower; runs without warnings.

### alerta.str.upper
https://www.alertachart.com/alertascript/reference/builtins/str.upper
Signature: str.upper(source)
Converts string to uppercase.
TradingView-compatible spelling: str.upper; runs without warnings.

### alerta.str.format_time
https://www.alertachart.com/alertascript/reference/builtins/str.format_time
Signature: str.format_time(time, format?, timezone?)
Formats a UNIX time (milliseconds) as text with Java date letters: yyyy / yy (year), M / MM / MMM / MMMM (9, 09, Sep, September), d / dd, E / EEEE (Mon, Monday), HH (0–23), hh (1–12), a (AM/PM), k, K, mm, ss, SSS (milliseconds), D (day of year), w (week of year), u (weekday 1–7 from Monday), Z (+0300), XXX (+03:00) and z (EDT); text in single quotes is kept verbatim and '' is a quote. The time is read on the given timezone, or on the exchange clock (syminfo.timezone) when none is given — UTC on crypto charts.
TradingView-compatible spelling: str.format_time; runs without warnings.

### alerta.str.startswith
https://www.alertachart.com/alertascript/reference/builtins/str.startswith
Signature: str.startswith(source, prefix)
Checks if string starts with prefix.
TradingView-compatible spelling: str.startswith; runs without warnings.

### alerta.str.endswith
https://www.alertachart.com/alertascript/reference/builtins/str.endswith
Signature: str.endswith(source, suffix)
Checks if string ends with suffix.
TradingView-compatible spelling: str.endswith; runs without warnings.

### alerta.str.trim
https://www.alertachart.com/alertascript/reference/builtins/str.trim
Signature: str.trim(source)
Removes whitespace from start and end.
TradingView-compatible spelling: str.trim; runs without warnings.

### alerta.str.pos
https://www.alertachart.com/alertascript/reference/builtins/str.pos
Signature: str.pos(source, target)
Returns the index of the first occurrence of target, or na if it is not found.
TradingView-compatible spelling: str.pos; runs without warnings.

### alerta.str.match
https://www.alertachart.com/alertascript/reference/builtins/str.match
Signature: str.match(source, regex)
Returns the first regex match in the source string, or na when not found.
TradingView-compatible spelling: str.match; runs without warnings.

### alerta.str.tonumber
https://www.alertachart.com/alertascript/reference/builtins/str.tonumber
Signature: str.tonumber(source)
Converts a plain decimal number written as text into a float: digits, an optional sign at the start and at most one decimal point ("1234.50", "-12.5", "+3", ".5"). Anything else is na — an empty string, surrounding spaces, thousands separators ("1,234"), currency signs, exponents ("1e3") and hexadecimal ("0x10").
TradingView-compatible spelling: str.tonumber; runs without warnings.

### alerta.str.tostring
https://www.alertachart.com/alertascript/reference/builtins/str.tostring
Signature: str.tostring(value, format)
Converts value to string representation. Supports Pine-style format strings and format enums such as format.mintick. Without a format, a number is written with at most ten decimals and no exponent (0.1 + 0.2 gives "0.3"), na as "NaN", a bool as "true" or "false", and an array as its elements in brackets, such as "[1, 2, 3]".
TradingView-compatible spelling: str.tostring; runs without warnings.

### alerta.str.format
https://www.alertachart.com/alertascript/reference/builtins/str.format
Signature: str.format(template, arg0, arg1, ...)
Formats a template string using positional placeholders, read as Pine reads them (Java MessageFormat): {0}, {0,number,#.##}, {0,number,integer}, {0,number,percent}, {0,number,currency}, {0,date,yyyy-MM-dd} and {0,time,HH:mm}. Text between single quotes is written as it is, and two single quotes write one. A number argument is grouped by thousands by default, na is written as "NaN" and an array as "[1, 2, 3]".
TradingView-compatible spelling: str.format; runs without warnings.

### library
https://www.alertachart.com/alertascript/reference/builtins/library
Signature: library(title, overlay, dynamic_requests)
Defines the script as a reusable library header. Pine v6 libraries are imported via `import author/libraryName/version`. The body may contain `export` function declarations that become callable from importing scripts.
TradingView-compatible spelling: library; runs without warnings.

### indicator
https://www.alertachart.com/alertascript/reference/builtins/indicator
Signature: indicator(title, shorttitle, overlay, format, precision, max_labels_count, max_lines_count, max_boxes_count, max_bars_back, …, scale)
Defines the script as an indicator and sets its properties.
TradingView-compatible spelling: indicator; runs without warnings.

### strategy
https://www.alertachart.com/alertascript/reference/builtins/strategy
Signature: strategy(title, shorttitle, overlay, initial_capital, default_qty_value, default_qty_type, currency, pyramiding, commission_type, commission_value, slippage, process_orders_on_close, calc_on_order_fills, calc_on_every_tick, close_entries_rule, margin_long, margin_short, max_lines_count, max_labels_count, max_boxes_count, max_polylines_count, max_bars_back, risk_free_rate, use_bar_magnifier, fill_orders_on_standard_ohlc, scale)
Defines the script as a strategy and sets backtesting properties. Use as the single script header (do not combine with indicator/study headers).
TradingView-compatible spelling: strategy; runs without warnings.

### alerta.max_bars_back
https://www.alertachart.com/alertascript/reference/builtins/max_bars_back
Signature: max_bars_back(var, num)
Declares the historical-buffer budget for a series. Accepted for Pine compatibility and has no effect: every bar of a series' history can already be referenced.
TradingView-compatible spelling: max_bars_back; runs without warnings.

### alerta.math.rphi
https://www.alertachart.com/alertascript/reference/builtins/math.rphi
Signature: math.rphi
The reciprocal of the golden ratio φ, approximately 0.618. Equivalent to 1/φ or (√5 − 1) / 2.
TradingView-compatible spelling: math.rphi; runs without warnings.

### alerta.syminfo.currency
https://www.alertachart.com/alertascript/reference/builtins/syminfo.currency
Signature: syminfo.currency
Returns the quote currency of the current symbol (e.g. "USDT", "USD", "BTC").
TradingView-compatible spelling: syminfo.currency; runs without warnings.

### alerta.syminfo.basecurrency
https://www.alertachart.com/alertascript/reference/builtins/syminfo.basecurrency
Signature: syminfo.basecurrency
Returns the base asset of the current symbol (e.g. "BTC" from "BTCUSDT").
TradingView-compatible spelling: syminfo.basecurrency; runs without warnings.

### alerta.syminfo.timezone
https://www.alertachart.com/alertascript/reference/builtins/syminfo.timezone
Signature: syminfo.timezone
Returns the timezone of the current symbol's exchange: "UTC" for crypto, "America/New_York" for US stocks, forex and US indices, "America/Chicago" for CME/CBOT futures, "Europe/Istanbul" for Borsa Istanbul. It is also the default clock of hour(), dayofweek(), timestamp() and time() with a session.
TradingView-compatible spelling: syminfo.timezone; runs without warnings.

### alerta.syminfo.type
https://www.alertachart.com/alertascript/reference/builtins/syminfo.type
Signature: syminfo.type
Returns the asset type of the current symbol: "crypto", "stock", "forex", "index", "futures" or "economic" (FRED/macro series).
TradingView-compatible spelling: syminfo.type; runs without warnings.

### alerta.syminfo.description
https://www.alertachart.com/alertascript/reference/builtins/syminfo.description
Signature: syminfo.description
Returns a human-readable description or full name of the current symbol — the company name on a stock chart ("Apple Inc."), the ticker otherwise.
TradingView-compatible spelling: syminfo.description; runs without warnings.

### alerta.syminfo.session
https://www.alertachart.com/alertascript/reference/builtins/syminfo.session
Signature: syminfo.session
Returns the trading session string for the current symbol (e.g. "24x7" for crypto, "0930-1600" for NYSE).
TradingView-compatible spelling: syminfo.session; runs without warnings.

### alerta.syminfo.pointvalue
https://www.alertachart.com/alertascript/reference/builtins/syminfo.pointvalue
Signature: syminfo.pointvalue
Returns the monetary value of one price point move for the symbol (e.g. 1 for most crypto, 50 for ES futures).
TradingView-compatible spelling: syminfo.pointvalue; runs without warnings.

### alerta.syminfo.volumetype
https://www.alertachart.com/alertascript/reference/builtins/syminfo.volumetype
Signature: syminfo.volumetype
Returns the type of volume reported by the symbol (e.g. "base" for base asset volume, "quote" for quote asset volume).
TradingView-compatible spelling: syminfo.volumetype; runs without warnings.

### alerta.syminfo.country
https://www.alertachart.com/alertascript/reference/builtins/syminfo.country
Signature: syminfo.country
Two-letter ISO country of the symbol's listing ("US", "TR", "DE") on stock and index charts; an empty string for crypto, forex and macro series.
TradingView-compatible spelling: syminfo.country; runs without warnings.

### alerta.syminfo.sector
https://www.alertachart.com/alertascript/reference/builtins/syminfo.sector
Signature: syminfo.sector
The company's sector on a stock chart (e.g. "Electronic Technology"), from the same company profile the symbol panel shows. An empty string for anything that is not a stock, or when the profile has none.
TradingView-compatible spelling: syminfo.sector; runs without warnings.

### alerta.syminfo.industry
https://www.alertachart.com/alertascript/reference/builtins/syminfo.industry
Signature: syminfo.industry
The company's industry on a stock chart (e.g. "Telecommunications Equipment"). An empty string for anything that is not a stock, or when the profile has none.
TradingView-compatible spelling: syminfo.industry; runs without warnings.

### alerta.syminfo.shares_outstanding_total
https://www.alertachart.com/alertascript/reference/builtins/syminfo.shares_outstanding_total
Signature: syminfo.shares_outstanding_total
Total shares outstanding of the company on a stock chart — the latest figure, not a history. na for anything that is not a stock, or when the company profile has none. Multiply by close for an approximate market capitalisation.
TradingView-compatible spelling: syminfo.shares_outstanding_total; runs without warnings.

### alerta.syminfo.shares_outstanding_float
https://www.alertachart.com/alertascript/reference/builtins/syminfo.shares_outstanding_float
Signature: syminfo.shares_outstanding_float
Free-float shares of the company. The company profile AlertaChart carries has no float figure, so this is always na — guard it with na().
TradingView-compatible spelling: syminfo.shares_outstanding_float; runs without warnings.

### alerta.syminfo.employees
https://www.alertachart.com/alertascript/reference/builtins/syminfo.employees
Signature: syminfo.employees
Number of employees of the company. Not in the company profile AlertaChart carries, so always na — guard it with na().
TradingView-compatible spelling: syminfo.employees; runs without warnings.

### alerta.syminfo.shareholders
https://www.alertachart.com/alertascript/reference/builtins/syminfo.shareholders
Signature: syminfo.shareholders
Number of shareholders of the company. Not in the company profile AlertaChart carries, so always na — guard it with na().
TradingView-compatible spelling: syminfo.shareholders; runs without warnings.

### alerta.timeframe.multiplier
https://www.alertachart.com/alertascript/reference/builtins/timeframe.multiplier
Signature: timeframe.multiplier
Returns the numeric multiplier of the current timeframe: 15 on "15", 240 on a 4-hour chart ("240"), 1 on "D", 5 on "5D", 12 on "12M". Pine v1–v3 scripts write it as `interval`.
TradingView-compatible spelling: timeframe.multiplier; runs without warnings.

### alerta.timeframe.isminutes
https://www.alertachart.com/alertascript/reference/builtins/timeframe.isminutes
Signature: timeframe.isminutes
Returns true if the current chart timeframe is measured in minutes (e.g. 1m, 5m, 15m, 60m).
TradingView-compatible spelling: timeframe.isminutes; runs without warnings.

### alerta.timeframe.isseconds
https://www.alertachart.com/alertascript/reference/builtins/timeframe.isseconds
Signature: timeframe.isseconds
Returns true if the current chart timeframe is measured in seconds (e.g. 1S, 5S, 30S).
TradingView-compatible spelling: timeframe.isseconds; runs without warnings.

### alerta.timeframe.isdwm
https://www.alertachart.com/alertascript/reference/builtins/timeframe.isdwm
Signature: timeframe.isdwm
Returns true if the current chart timeframe is daily (D), weekly (W), or monthly (M).
TradingView-compatible spelling: timeframe.isdwm; runs without warnings.

### alerta.session.regular
https://www.alertachart.com/alertascript/reference/builtins/session.regular
Signature: session.regular
Pine v5/v6 session identifier — exchange's regular trading hours. Used as the `session` argument to `time()` / `input.session()`.
TradingView-compatible spelling: session.regular; runs without warnings.

### alerta.session.extended
https://www.alertachart.com/alertascript/reference/builtins/session.extended
Signature: session.extended
Pine v5/v6 session identifier — extended (pre + after) trading hours.
TradingView-compatible spelling: session.extended; runs without warnings.

### alerta.session.ismarket
https://www.alertachart.com/alertascript/reference/builtins/session.ismarket
Signature: session.ismarket → series<bool>
Pine v5/v6 series<bool>: true on every bar that opens inside the exchange's regular trading hours, read on the exchange's own clock (so daylight saving moves the window with it — 09:30–16:00 New York time for a US stock). Weekends are closed; exchange holidays are not modelled. A daily or longer bar is always in market, and so is every bar of a symbol that trades around the clock (crypto, forex, indices, futures).
TradingView-compatible spelling: session.ismarket; runs without warnings.

### alerta.session.ispremarket
https://www.alertachart.com/alertascript/reference/builtins/session.ispremarket
Signature: session.ispremarket → series<bool>
Pine v5/v6 series<bool>: true on bars that open inside the exchange's pre-market window (04:00–09:30 New York time for a US stock). Always false for symbols without extended hours.
TradingView-compatible spelling: session.ispremarket; runs without warnings.

### alerta.session.ispostmarket
https://www.alertachart.com/alertascript/reference/builtins/session.ispostmarket
Signature: session.ispostmarket → series<bool>
Pine v5/v6 series<bool>: true on bars that open inside the exchange's after-hours window (16:00–20:00 New York time for a US stock). Always false for symbols without extended hours.
TradingView-compatible spelling: session.ispostmarket; runs without warnings.

### alerta.session.isfirstbar
https://www.alertachart.com/alertascript/reference/builtins/session.isfirstbar
Signature: session.isfirstbar → series<bool>
Pine v5/v6 series<bool>: true on the first bar of each day's session (the exchange day time("D") uses; a CME session opens 17:00 Chicago, a forex one 17:00 New York), pre-market bars included; inside request.security, of the requested bars. session.isfirstbar_regular is the first regular-hours bar.
TradingView-compatible spelling: session.isfirstbar; runs without warnings.

### alerta.session.islastbar
https://www.alertachart.com/alertascript/reference/builtins/session.islastbar
Signature: session.islastbar → series<bool>
Pine v5/v6 series<bool>: true on the last bar of each day's session, post-market bars included; on the chart's last bar when the next bar would open a new day; inside request.security, of the requested bars. session.islastbar_regular is the last regular-hours bar.
TradingView-compatible spelling: session.islastbar; runs without warnings.

### alerta.ticker.new
https://www.alertachart.com/alertascript/reference/builtins/ticker.new
Signature: ticker.new(prefix, ticker, session?, adjustment?, backadjustment?, settlement_as_close?) → string
Pine v6: builds a ticker ID string from prefix + symbol (+ optional session and adjustment). With modifiers it is TradingView's `={"session":"regular","symbol":"NASDAQ:NVDA"}` form. Pass the result to `request.security()`: the request reads the plain symbol, and `session.regular` keeps a stock's intraday bars to its regular hours.
TradingView-compatible spelling: ticker.new; runs without warnings.

### alerta.ticker.modify
https://www.alertachart.com/alertascript/reference/builtins/ticker.modify
Signature: ticker.modify(tickerid, session?, adjustment?, backadjustment?, settlement_as_close?) → string
Pine v6: clones a ticker ID with a different session or adjustment (the ID's own modifiers kept where no new one is given).
TradingView-compatible spelling: ticker.modify; runs without warnings.

### alerta.ticker.heikinashi
https://www.alertachart.com/alertascript/reference/builtins/ticker.heikinashi
Signature: ticker.heikinashi(symbol) → string
Pine v6: returns a Heikin-Ashi ticker ID for the given symbol. request.security builds the Heikin-Ashi bars from that symbol's own bars at the requested timeframe.
TradingView-compatible spelling: ticker.heikinashi; runs without warnings.

### alerta.ticker.renko
https://www.alertachart.com/alertascript/reference/builtins/ticker.renko
Signature: ticker.renko(symbol, style?, arg?) → string
Pine v6: returns a Renko ticker ID. AlertaChart does not build Renko bars: request.security on this ticker returns na with a warning.
TradingView-compatible spelling: ticker.renko; runs without warnings.

### alerta.ticker.linebreak
https://www.alertachart.com/alertascript/reference/builtins/ticker.linebreak
Signature: ticker.linebreak(symbol, lines?) → string
Pine v6: returns a Line-Break ticker ID. AlertaChart does not build Line Break bars: request.security on this ticker returns na with a warning.
TradingView-compatible spelling: ticker.linebreak; runs without warnings.

### alerta.ticker.kagi
https://www.alertachart.com/alertascript/reference/builtins/ticker.kagi
Signature: ticker.kagi(symbol, reversal?) → string
Pine v6: returns a Kagi ticker ID. AlertaChart does not build Kagi bars: request.security on this ticker returns na with a warning.
TradingView-compatible spelling: ticker.kagi; runs without warnings.

### alerta.ticker.pointfigure
https://www.alertachart.com/alertascript/reference/builtins/ticker.pointfigure
Signature: ticker.pointfigure(symbol, source?, style?, boxSize?, reversal?) → string
Pine v6: returns a Point-and-Figure ticker ID. AlertaChart does not build Point & Figure bars: request.security on this ticker returns na with a warning.
TradingView-compatible spelling: ticker.pointfigure; runs without warnings.

### alerta.ticker.inherit
https://www.alertachart.com/alertascript/reference/builtins/ticker.inherit
Signature: ticker.inherit(from_tickerid, symbol) → string
Pine v6: builds a ticker that inherits the alternative-feed type of `from_tickerid` (HA/Renko/Kagi/PF) but uses a different symbol. From a plain chart the result is simply `symbol`, so `request.security(ticker.inherit(syminfo.tickerid, other), …)` fetches `other`.
TradingView-compatible spelling: ticker.inherit; runs without warnings.

### alerta.ticker.standard
https://www.alertachart.com/alertascript/reference/builtins/ticker.standard
Signature: ticker.standard(symbol?) → string
Pine v6: returns the standard ticker ID for the given symbol — no chart type (Heikin-Ashi, Renko, …) and no session or adjustment modifiers.
TradingView-compatible spelling: ticker.standard; runs without warnings.

### alerta.ticker.pricescale
https://www.alertachart.com/alertascript/reference/builtins/ticker.pricescale
Signature: ticker.pricescale() → int
Pine v6: returns the price scale (1/mintick) of the symbol.
TradingView-compatible spelling: ticker.pricescale; runs without warnings.

### alerta.ticker.mintick
https://www.alertachart.com/alertascript/reference/builtins/ticker.mintick
Signature: ticker.mintick() → float
Pine v6: returns the minimum price increment for the symbol.
TradingView-compatible spelling: ticker.mintick; runs without warnings.

### alerta.chart.fg_color
https://www.alertachart.com/alertascript/reference/builtins/chart.fg_color
Signature: chart.fg_color → color
Pine v6: the chart's foreground (text/axes) color. Use to keep custom drawings legible across light/dark themes.
TradingView-compatible spelling: chart.fg_color; runs without warnings.

### alerta.chart.bg_color
https://www.alertachart.com/alertascript/reference/builtins/chart.bg_color
Signature: chart.bg_color → color
Pine v6: the chart's background color.
TradingView-compatible spelling: chart.bg_color; runs without warnings.

### alerta.chart.is_standard
https://www.alertachart.com/alertascript/reference/builtins/chart.is_standard
Signature: chart.is_standard → bool
Pine v6: true when the chart uses standard candles (not Heikin-Ashi/Renko/Range/etc.).
TradingView-compatible spelling: chart.is_standard; runs without warnings.

### alerta.chart.left_visible_bar_time
https://www.alertachart.com/alertascript/reference/builtins/chart.left_visible_bar_time
Signature: chart.left_visible_bar_time → int
Pine v6: timestamp of the left-most visible bar. The script runs before the chart has a viewport, so every loaded bar counts as visible: the first loaded bar's time.
TradingView-compatible spelling: chart.left_visible_bar_time; runs without warnings.

### alerta.chart.right_visible_bar_time
https://www.alertachart.com/alertascript/reference/builtins/chart.right_visible_bar_time
Signature: chart.right_visible_bar_time → int
Pine v6: timestamp of the right-most visible bar: the last loaded bar's time (every loaded bar counts as visible).
TradingView-compatible spelling: chart.right_visible_bar_time; runs without warnings.

### alerta.strategy.percent_of_equity
https://www.alertachart.com/alertascript/reference/builtins/strategy.percent_of_equity
Signature: strategy.percent_of_equity → string
Pine v6 default_qty_type: orders sized as a percentage of current strategy equity.
TradingView-compatible spelling: strategy.percent_of_equity; runs without warnings.

### alerta.strategy.cash
https://www.alertachart.com/alertascript/reference/builtins/strategy.cash
Signature: strategy.cash → string
Pine v6 default_qty_type: orders sized in cash (account currency) per fill.
TradingView-compatible spelling: strategy.cash; runs without warnings.

### alerta.strategy.fixed
https://www.alertachart.com/alertascript/reference/builtins/strategy.fixed
Signature: strategy.fixed → string
Pine v6 default_qty_type: fixed quantity in shares/contracts.
TradingView-compatible spelling: strategy.fixed; runs without warnings.

### alerta.strategy.contracts
https://www.alertachart.com/alertascript/reference/builtins/strategy.contracts
Signature: strategy.contracts → string
Pine v6 default_qty_type: number of contracts.
TradingView-compatible spelling: strategy.contracts; runs without warnings.

### alerta.strategy.oca.none
https://www.alertachart.com/alertascript/reference/builtins/strategy.oca.none
Signature: strategy.oca.none → string
Pine v6 OCA type — order is not part of a One-Cancels-All group.
TradingView-compatible spelling: strategy.oca.none; runs without warnings.

### alerta.strategy.oca.cancel
https://www.alertachart.com/alertascript/reference/builtins/strategy.oca.cancel
Signature: strategy.oca.cancel → string
Pine v6 OCA type — when this order fills, every other order in the same OCA group is cancelled.
TradingView-compatible spelling: strategy.oca.cancel; runs without warnings.

### alerta.strategy.oca.reduce
https://www.alertachart.com/alertascript/reference/builtins/strategy.oca.reduce
Signature: strategy.oca.reduce → string
Pine v6 OCA type — siblings are qty-reduced (rather than fully cancelled) by the filled amount.
TradingView-compatible spelling: strategy.oca.reduce; runs without warnings.

### alerta.strategy.position_entry_name
https://www.alertachart.com/alertascript/reference/builtins/strategy.position_entry_name
Signature: strategy.position_entry_name → string
Pine v6: ID of the most recent open entry order.
TradingView-compatible spelling: strategy.position_entry_name; runs without warnings.

### alerta.strategy.position_size_max
https://www.alertachart.com/alertascript/reference/builtins/strategy.position_size_max
Signature: strategy.position_size_max → float
Pine v6: largest absolute position size held across the backtest.
TradingView-compatible spelling: strategy.position_size_max; runs without warnings.

### alerta.strategy.max_contracts_held_all
https://www.alertachart.com/alertascript/reference/builtins/strategy.max_contracts_held_all
Signature: strategy.max_contracts_held_all → float
Pine v6: largest absolute contract count held across the backtest (alias of position_size_max).
TradingView-compatible spelling: strategy.max_contracts_held_all; runs without warnings.

### alerta.strategy.max_contracts_held_long
https://www.alertachart.com/alertascript/reference/builtins/strategy.max_contracts_held_long
Signature: strategy.max_contracts_held_long → float
Pine v6: largest long-side contract count held.
TradingView-compatible spelling: strategy.max_contracts_held_long; runs without warnings.

### alerta.strategy.max_contracts_held_short
https://www.alertachart.com/alertascript/reference/builtins/strategy.max_contracts_held_short
Signature: strategy.max_contracts_held_short → float
Pine v6: largest short-side contract count held.
TradingView-compatible spelling: strategy.max_contracts_held_short; runs without warnings.

### enum
https://www.alertachart.com/alertascript/reference/builtins/enum
Signature: enum Name
    Member1 = "title1"
    Member2
Pine v6: declares an enumerated type with named members. Members can optionally carry a title (used by str.tostring and input.enum dropdowns) and behave as identity-stable runtime values. `EnumName.all()` returns an array of every member in declaration order.
TradingView-compatible spelling: enum; runs without warnings.

### import
https://www.alertachart.com/alertascript/reference/builtins/import
Signature: import publisher/library/version [as alias]
Pine v5/v6: imports a published library. `TradingView/ta` resolves to the REAL built-in ta.* surface (alias calls like ta7.rsi(...) run natively). Other libraries register a permissive stub — the script still runs, a warning is shown, and calls through the alias return na.
TradingView-compatible spelling: import; runs without warnings.

### alerta.adjustment.none
https://www.alertachart.com/alertascript/reference/builtins/adjustment.none
Signature: adjustment.none → string
Pine v5/v6: No price adjustment.
TradingView-compatible spelling: adjustment.none; runs without warnings.

### alerta.adjustment.splits
https://www.alertachart.com/alertascript/reference/builtins/adjustment.splits
Signature: adjustment.splits → string
Pine v5/v6: Adjust historical prices for stock splits.
TradingView-compatible spelling: adjustment.splits; runs without warnings.

### alerta.adjustment.dividends
https://www.alertachart.com/alertascript/reference/builtins/adjustment.dividends
Signature: adjustment.dividends → string
Pine v5/v6: Adjust historical prices for dividends.
TradingView-compatible spelling: adjustment.dividends; runs without warnings.

### alerta.backadjustment.inherit
https://www.alertachart.com/alertascript/reference/builtins/backadjustment.inherit
Signature: backadjustment.inherit → string
Pine v6: Inherit back-adjustment from source ticker (default).
TradingView-compatible spelling: backadjustment.inherit; runs without warnings.

### alerta.backadjustment.on
https://www.alertachart.com/alertascript/reference/builtins/backadjustment.on
Signature: backadjustment.on → string
Pine v6: Apply back-adjustment to continuous futures contract history.
TradingView-compatible spelling: backadjustment.on; runs without warnings.

### alerta.backadjustment.off
https://www.alertachart.com/alertascript/reference/builtins/backadjustment.off
Signature: backadjustment.off → string
Pine v6: Disable back-adjustment.
TradingView-compatible spelling: backadjustment.off; runs without warnings.

### alerta.settlement_as_close.inherit
https://www.alertachart.com/alertascript/reference/builtins/settlement_as_close.inherit
Signature: settlement_as_close.inherit → string
Pine v6: Inherit settlement-as-close setting (default).
TradingView-compatible spelling: settlement_as_close.inherit; runs without warnings.

### alerta.settlement_as_close.on
https://www.alertachart.com/alertascript/reference/builtins/settlement_as_close.on
Signature: settlement_as_close.on → string
Pine v6: Use settlement price as close on 1D+ timeframes.
TradingView-compatible spelling: settlement_as_close.on; runs without warnings.

### alerta.settlement_as_close.off
https://www.alertachart.com/alertascript/reference/builtins/settlement_as_close.off
Signature: settlement_as_close.off → string
Pine v6: Use actual session close.
TradingView-compatible spelling: settlement_as_close.off; runs without warnings.

### alerta.font.family_default
https://www.alertachart.com/alertascript/reference/builtins/font.family_default
Signature: font.family_default → string
Pine v6: Default chart font family.
TradingView-compatible spelling: font.family_default; runs without warnings.

### alerta.font.family_monospace
https://www.alertachart.com/alertascript/reference/builtins/font.family_monospace
Signature: font.family_monospace → string
Pine v6: Monospaced font family — useful for table dashboards.
TradingView-compatible spelling: font.family_monospace; runs without warnings.

### alerta.text.format_none
https://www.alertachart.com/alertascript/reference/builtins/text.format_none
Signature: text.format_none → string
Pine v6: No text formatting.
TradingView-compatible spelling: text.format_none; runs without warnings.

### alerta.text.format_bold
https://www.alertachart.com/alertascript/reference/builtins/text.format_bold
Signature: text.format_bold → string
Pine v6: Bold text formatting.
TradingView-compatible spelling: text.format_bold; runs without warnings.

### alerta.text.format_italic
https://www.alertachart.com/alertascript/reference/builtins/text.format_italic
Signature: text.format_italic → string
Pine v6: Italic text formatting. Combine with + (e.g. text.format_bold + text.format_italic).
TradingView-compatible spelling: text.format_italic; runs without warnings.

### alerta.text.align_left
https://www.alertachart.com/alertascript/reference/builtins/text.align_left
Signature: text.align_left → string
Pine v6: Left horizontal alignment.
TradingView-compatible spelling: text.align_left; runs without warnings.

### alerta.text.align_center
https://www.alertachart.com/alertascript/reference/builtins/text.align_center
Signature: text.align_center → string
Pine v6: Center horizontal alignment.
TradingView-compatible spelling: text.align_center; runs without warnings.

### alerta.text.align_right
https://www.alertachart.com/alertascript/reference/builtins/text.align_right
Signature: text.align_right → string
Pine v6: Right horizontal alignment.
TradingView-compatible spelling: text.align_right; runs without warnings.

### alerta.text.align_top
https://www.alertachart.com/alertascript/reference/builtins/text.align_top
Signature: text.align_top → string
Pine v6: Top vertical alignment.
TradingView-compatible spelling: text.align_top; runs without warnings.

### alerta.text.align_bottom
https://www.alertachart.com/alertascript/reference/builtins/text.align_bottom
Signature: text.align_bottom → string
Pine v6: Bottom vertical alignment.
TradingView-compatible spelling: text.align_bottom; runs without warnings.

### alerta.text.wrap_auto
https://www.alertachart.com/alertascript/reference/builtins/text.wrap_auto
Signature: text.wrap_auto → string
Pine v6: Auto-wrap text in box.
TradingView-compatible spelling: text.wrap_auto; runs without warnings.

### alerta.text.wrap_none
https://www.alertachart.com/alertascript/reference/builtins/text.wrap_none
Signature: text.wrap_none → string
Pine v6: Disable text wrapping in box.
TradingView-compatible spelling: text.wrap_none; runs without warnings.

### alerta.table.cell_set_text_font_family
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_text_font_family
Signature: table.cell_set_text_font_family(table_id, column, row, text_font_family) → void
Pine v6: switch a table cell's text font family.
TradingView-compatible spelling: table.cell_set_text_font_family; runs without warnings.

### alerta.table.cell_set_text_formatting
https://www.alertachart.com/alertascript/reference/builtins/table.cell_set_text_formatting
Signature: table.cell_set_text_formatting(table_id, column, row, text_formatting) → void
Pine v6: apply bold/italic formatting to a cell. Combine with + (e.g. text.format_bold + text.format_italic).
TradingView-compatible spelling: table.cell_set_text_formatting; runs without warnings.

### hlcc4
https://www.alertachart.com/alertascript/reference/builtins/hlcc4
Signature: hlcc4 → series float
Pine v6: shortcut for `(high + low + close + close) / 4`. Close is counted twice, giving more weight to the close price.
TradingView-compatible spelling: hlcc4; runs without warnings.

### ask
https://www.alertachart.com/alertascript/reference/builtins/ask
Signature: ask → series float
Pine v6: lowest price an active seller will accept for the instrument. Only available on the "1T" timeframe. On AlertaChart it is always `na`, tick charts included: scripts do not receive the order book's best prices.
TradingView-compatible spelling: ask; runs without warnings.

### bid
https://www.alertachart.com/alertascript/reference/builtins/bid
Signature: bid → series float
Pine v6: highest price an active buyer is willing to pay. Only available on the "1T" timeframe. On AlertaChart it is always `na`, tick charts included: scripts do not receive the order book's best prices.
TradingView-compatible spelling: bid; runs without warnings.

### last_bar_time
https://www.alertachart.com/alertascript/reference/builtins/last_bar_time
Signature: last_bar_time → series int
Pine v6: UNIX time (ms) of the last chart bar. For closed markets this is the final historical bar; for open markets it is the realtime bar.
TradingView-compatible spelling: last_bar_time; runs without warnings.

### time_tradingday
https://www.alertachart.com/alertascript/reference/builtins/time_tradingday
Signature: time_tradingday → series int
Pine v6: UNIX timestamp of 00:00 UTC of the trading day the current bar belongs to. Useful for overnight sessions where the bar may open on the previous calendar day.
TradingView-compatible spelling: time_tradingday; runs without warnings.

### timenow
https://www.alertachart.com/alertascript/reference/builtins/timenow
Signature: timenow → series int
Pine v6: the current time in UNIX milliseconds at the moment the script runs. It does not follow the bars: every bar of one run reads the same value, and the next run reads a later one.
TradingView-compatible spelling: timenow; runs without warnings.

### const
https://www.alertachart.com/alertascript/reference/builtins/const
Signature: const <type> <name> = <value>
Pine v6 qualifier: a value determined at compile time that never changes during execution. Hierarchy: const < input < simple < series.
TradingView-compatible spelling: const; runs without warnings.

### simple
https://www.alertachart.com/alertascript/reference/builtins/simple
Signature: simple <type> <name> = <value>
Pine v6 qualifier: a value resolved at the start of execution and unchanged afterward. Required for some library function parameters (e.g. `ta.ema(src, simple int length)`).
TradingView-compatible spelling: simple; runs without warnings.

### series
https://www.alertachart.com/alertascript/reference/builtins/series
Signature: series <type> <name> = <value>
Pine v6 qualifier: a value that may change per bar. This is the default qualifier for most expressions and library function parameters.
TradingView-compatible spelling: series; runs without warnings.

### footprint
https://www.alertachart.com/alertascript/reference/builtins/footprint
Signature: footprint
Pine v6 type returned by `request.footprint()`: one bar's volume footprint — its buy and sell volume by price row, POC, value area and imbalances. Read it with the `footprint.*()` functions or as methods (`fp.poc()`). On AlertaChart it is built from the chart symbol's own order flow; na where there is none.
TradingView-compatible spelling: footprint; runs without warnings.

### volume_row
https://www.alertachart.com/alertascript/reference/builtins/volume_row
Signature: volume_row
Pine v6 type for one price row of a `footprint`: its price bounds, buy and sell volume and diagonal imbalances. Returned by `footprint.rows()`, `footprint.poc()`, `footprint.vah()`, `footprint.val()` and `footprint.get_row_by_price()`.
TradingView-compatible spelling: volume_row; runs without warnings.

### alerta.footprint.buy_volume
https://www.alertachart.com/alertascript/reference/builtins/footprint.buy_volume
Signature: footprint.buy_volume(id) → series float
The bar's total buy (taker, ask-side) volume. Exactly the sum of its order-flow buckets' buy volume, whatever the row size.
TradingView-compatible spelling: footprint.buy_volume; runs without warnings.

### alerta.footprint.sell_volume
https://www.alertachart.com/alertascript/reference/builtins/footprint.sell_volume
Signature: footprint.sell_volume(id) → series float
The bar's total sell (taker, bid-side) volume.
TradingView-compatible spelling: footprint.sell_volume; runs without warnings.

### alerta.footprint.total_volume
https://www.alertachart.com/alertascript/reference/builtins/footprint.total_volume
Signature: footprint.total_volume(id) → series float
Buy plus sell volume of the bar.
TradingView-compatible spelling: footprint.total_volume; runs without warnings.

### alerta.footprint.delta
https://www.alertachart.com/alertascript/reference/builtins/footprint.delta
Signature: footprint.delta(id) → series float
Buy minus sell volume of the bar — its volume delta. The same at any ticks_per_row.
TradingView-compatible spelling: footprint.delta; runs without warnings.

### alerta.footprint.poc
https://www.alertachart.com/alertascript/reference/builtins/footprint.poc
Signature: footprint.poc(id) → volume_row
The row with the most volume (Point of Control). On a tie, the row nearest the bar's volume-weighted price.
TradingView-compatible spelling: footprint.poc; runs without warnings.

### alerta.footprint.vah
https://www.alertachart.com/alertascript/reference/builtins/footprint.vah
Signature: footprint.vah(id) → volume_row
The top row of the value area. The value area grows from the POC one row at a time — whichever neighbouring row holds more volume, the upper one on a tie — until it holds va_percent of the bar's volume.
TradingView-compatible spelling: footprint.vah; runs without warnings.

### alerta.footprint.val
https://www.alertachart.com/alertascript/reference/builtins/footprint.val
Signature: footprint.val(id) → volume_row
The bottom row of the value area (see footprint.vah).
TradingView-compatible spelling: footprint.val; runs without warnings.

### alerta.footprint.rows
https://www.alertachart.com/alertascript/reference/builtins/footprint.rows
Signature: footprint.rows(id) → array<volume_row>
Every row of the bar, lowest price first: from the lowest traded row to the highest, rows between them included. Each row spans ticks_per_row × syminfo.mintick on a fixed price grid; a trade at price p is in the row whose up_price is p rounded up to that grid.
TradingView-compatible spelling: footprint.rows; runs without warnings.

### alerta.footprint.get_row_by_price
https://www.alertachart.com/alertascript/reference/builtins/footprint.get_row_by_price
Signature: footprint.get_row_by_price(id, price) → volume_row
The row holding a price (down_price < price ≤ up_price), or na outside the bar's rows.
TradingView-compatible spelling: footprint.get_row_by_price; runs without warnings.

### alerta.volume_row.up_price
https://www.alertachart.com/alertascript/reference/builtins/volume_row.up_price
Signature: volume_row.up_price(id) → series float
The row's upper price bound.
TradingView-compatible spelling: volume_row.up_price; runs without warnings.

### alerta.volume_row.down_price
https://www.alertachart.com/alertascript/reference/builtins/volume_row.down_price
Signature: volume_row.down_price(id) → series float
The row's lower price bound (up_price − ticks_per_row × syminfo.mintick).
TradingView-compatible spelling: volume_row.down_price; runs without warnings.

### alerta.volume_row.buy_volume
https://www.alertachart.com/alertascript/reference/builtins/volume_row.buy_volume
Signature: volume_row.buy_volume(id) → series float
The row's buy (taker, ask-side) volume.
TradingView-compatible spelling: volume_row.buy_volume; runs without warnings.

### alerta.volume_row.sell_volume
https://www.alertachart.com/alertascript/reference/builtins/volume_row.sell_volume
Signature: volume_row.sell_volume(id) → series float
The row's sell (taker, bid-side) volume.
TradingView-compatible spelling: volume_row.sell_volume; runs without warnings.

### alerta.volume_row.total_volume
https://www.alertachart.com/alertascript/reference/builtins/volume_row.total_volume
Signature: volume_row.total_volume(id) → series float
The row's buy plus sell volume.
TradingView-compatible spelling: volume_row.total_volume; runs without warnings.

### alerta.volume_row.delta
https://www.alertachart.com/alertascript/reference/builtins/volume_row.delta
Signature: volume_row.delta(id) → series float
The row's buy minus sell volume.
TradingView-compatible spelling: volume_row.delta; runs without warnings.

### alerta.volume_row.has_buy_imbalance
https://www.alertachart.com/alertascript/reference/builtins/volume_row.has_buy_imbalance
Signature: volume_row.has_buy_imbalance(id) → series bool
Whether the row's buy volume is at least imbalance_percent / 100 times the sell volume of the row BELOW it (the diagonal comparison of a footprint chart). A zero on either side is no imbalance, so the bottom row never has one.
TradingView-compatible spelling: volume_row.has_buy_imbalance; runs without warnings.

### alerta.volume_row.has_sell_imbalance
https://www.alertachart.com/alertascript/reference/builtins/volume_row.has_sell_imbalance
Signature: volume_row.has_sell_imbalance(id) → series bool
Whether the row's sell volume is at least imbalance_percent / 100 times the buy volume of the row ABOVE it. A zero on either side is no imbalance, so the top row never has one.
TradingView-compatible spelling: volume_row.has_sell_imbalance; runs without warnings.

### alerta.dayofweek.monday
https://www.alertachart.com/alertascript/reference/builtins/dayofweek.monday
Signature: dayofweek.sunday … dayofweek.saturday → const int (1…7)
Pine v5/v6 day-of-week constants: dayofweek.sunday=1, monday=2, tuesday=3, wednesday=4, thursday=5, friday=6, saturday=7. Compare against the per-bar `dayofweek` series to gate logic to specific weekdays.
TradingView-compatible spelling: dayofweek.monday; runs without warnings.

### alerta.syminfo.main_tickerid
https://www.alertachart.com/alertascript/reference/builtins/syminfo.main_tickerid
Signature: syminfo.main_tickerid → simple string
Pine v6: the CHART's ticker id — unlike syminfo.tickerid, this stays the chart symbol even inside a request.security() context.
TradingView-compatible spelling: syminfo.main_tickerid; runs without warnings.

### alerta.timeframe.main_period
https://www.alertachart.com/alertascript/reference/builtins/timeframe.main_period
Signature: timeframe.main_period → simple string
Pine v6: the CHART's timeframe period — unlike timeframe.period, this stays the chart timeframe even inside a request.security() context. timeframe.isticks is also available (always false — tick charts are not supported).
TradingView-compatible spelling: timeframe.main_period; runs without warnings.

### alerta.request.currency_rate
https://www.alertachart.com/alertascript/reference/builtins/request.currency_rate
Signature: request.currency_rate(from, to, ignore_invalid_currency) → series float
Pine v6: the daily rate that converts `from` into `to`, from AlertaChart's own feeds — two fiat currencies read the forex pair (a pair carried only the other way round, e.g. USD→EUR from EURUSD, is inverted), a coin against the dollar reads its USDT pair (and the inverse for USD→coin). Identical currencies (and USD/USDT/USDC) are exactly 1.0; any other combination returns na with a warning.
TradingView-compatible spelling: request.currency_rate; runs without warnings.

### alerta.request.economic
https://www.alertachart.com/alertascript/reference/builtins/request.economic
Signature: request.economic(country_code, field, gaps?, ignore_invalid_symbol?) → series float
Pine v6: an economic series of a country — the ECONOMICS:<country><field> symbol — read at the chart's timeframe. AlertaChart carries the US headline series: GDP (USGDP), IRYY inflation rate (USIRYY), INTR interest rate (USINTR), UR unemployment rate (USUR), BOT balance of trade (USBOT) and DEBT government debt (USDEBT), monthly. Any other country or field returns na with a warning.
TradingView-compatible spelling: request.economic; runs without warnings.

### alerta.log.info
https://www.alertachart.com/alertascript/reference/builtins/log.info
Signature: log.info(message)  |  log.info(formatString, arg0, arg1, …)  — and the same for log.warning and log.error
Writes a message to the script's diagnostics, shown in the editor next to the line that wrote it: log.info as information, log.warning as a warning and log.error as an error (the chart's script badge counts warnings and errors). None of them stops the script — everything else still runs and draws; use runtime.error to stop it. Useful for inspecting calculations without drawing an extra plot.
TradingView-compatible spelling: log.info; runs without warnings.

### alerta.str.repeat
https://www.alertachart.com/alertascript/reference/builtins/str.repeat
Signature: str.repeat(source, repeat, separator = "")
Builds a string by repeating source a non-negative number of times, optionally inserting a separator between repetitions.
TradingView-compatible spelling: str.repeat; runs without warnings.

### alerta.barstate.islastconfirmedhistory
https://www.alertachart.com/alertascript/reference/builtins/barstate.islastconfirmedhistory
Signature: barstate.islastconfirmedhistory → series bool
Identifies the final confirmed historical bar in the current execution dataset, before the current realtime bar when one exists.
TradingView-compatible spelling: barstate.islastconfirmedhistory; runs without warnings.

### alerta.syminfo.root
https://www.alertachart.com/alertascript/reference/builtins/syminfo.root
Signature: syminfo.root → string
Returns the root identifier derived from the current symbol and instrument type. It is useful for displaying a contract family separately from its exchange-qualified ticker.
TradingView-compatible spelling: syminfo.root; runs without warnings.

### alerta.strategy.position_avg_price
https://www.alertachart.com/alertascript/reference/builtins/strategy.position_avg_price
Signature: strategy.position_avg_price → series float
Average entry price of the currently open simulated strategy position. The value follows fills in the strategy simulator. While the strategy has no position it is na, as in Pine.
TradingView-compatible spelling: strategy.position_avg_price; runs without warnings.

### alerta.strategy.netprofit
https://www.alertachart.com/alertascript/reference/builtins/strategy.netprofit
Signature: strategy.netprofit → series float
Cumulative realized profit and loss from closed simulated strategy trades. It does not include the unrealized profit of the currently open position.
TradingView-compatible spelling: strategy.netprofit; runs without warnings.

### chart.point
https://www.alertachart.com/alertascript/reference/builtins/chart.point
Signature: chart.point { time, index, price }
A drawing coordinate with time, index and price fields. Construct points with chart.point.now(), chart.point.from_index(), chart.point.from_time() or chart.point.new(), then pass them to supported drawing constructors.
TradingView-compatible spelling: chart.point; runs without warnings.

### open
https://www.alertachart.com/alertascript/reference/builtins/open
Signature: open → series float
Opening price of each chart bar.
TradingView-compatible spelling: open; runs without warnings.

### high
https://www.alertachart.com/alertascript/reference/builtins/high
Signature: high → series float
Highest traded price in each chart bar.
TradingView-compatible spelling: high; runs without warnings.

### low
https://www.alertachart.com/alertascript/reference/builtins/low
Signature: low → series float
Lowest traded price in each chart bar.
TradingView-compatible spelling: low; runs without warnings.

### close
https://www.alertachart.com/alertascript/reference/builtins/close
Signature: close → series float
Closing price of each historical bar, or the latest price of the current bar.
TradingView-compatible spelling: close; runs without warnings.

### volume
https://www.alertachart.com/alertascript/reference/builtins/volume
Signature: volume → series float
Volume supplied by the chart data provider for each bar; units and availability depend on the instrument.
TradingView-compatible spelling: volume; runs without warnings.

### hl2
https://www.alertachart.com/alertascript/reference/builtins/hl2
Signature: hl2 → series float
Average of the high and low of each bar: (high + low) / 2.
TradingView-compatible spelling: hl2; runs without warnings.

### hlc3
https://www.alertachart.com/alertascript/reference/builtins/hlc3
Signature: hlc3 → series float
Average of the high, low and close of each bar: (high + low + close) / 3.
TradingView-compatible spelling: hlc3; runs without warnings.

### ohlc4
https://www.alertachart.com/alertascript/reference/builtins/ohlc4
Signature: ohlc4 → series float
Average of each bar’s open, high, low and close.
TradingView-compatible spelling: ohlc4; runs without warnings.

### last_bar_index
https://www.alertachart.com/alertascript/reference/builtins/last_bar_index
Signature: last_bar_index → int
Zero-based index of the final bar in the current dataset. Changes when a new chart bar is appended.
TradingView-compatible spelling: last_bar_index; runs without warnings.

### alerta.syminfo.pricescale
https://www.alertachart.com/alertascript/reference/builtins/syminfo.pricescale
Signature: syminfo.pricescale → int
Price-scale denominator from the symbol metadata. Together with syminfo.minmove it determines the minimum price increment.
TradingView-compatible spelling: syminfo.pricescale; runs without warnings.

### if
https://www.alertachart.com/alertascript/reference/builtins/if
Signature: if close > open
Runs an indented block when its condition is true. An optional else branch handles the other case.
TradingView-compatible spelling: if; runs without warnings.

### var
https://www.alertachart.com/alertascript/reference/builtins/var
Signature: var float previous = na
Initializes a variable once and retains its value between bars. Use := to assign a new value to the existing variable.
TradingView-compatible spelling: var; runs without warnings.

### varip
https://www.alertachart.com/alertascript/reference/builtins/varip
Signature: varip int updates = 0
Declares a variable that persists between realtime updates. Historical bars do not reproduce every realtime update, so historical and live results can differ.
TradingView-compatible spelling: varip; runs without warnings.

### type
https://www.alertachart.com/alertascript/reference/builtins/type
Signature: type Level
Declares a structured value with named fields. Construct an instance with Type.new() and define receiver methods with method.
TradingView-compatible spelling: type; runs without warnings.

### export
https://www.alertachart.com/alertascript/reference/builtins/export
Signature: library("Example")
Marks a library declaration for use by an importing script. Availability also depends on the library resolver and the imported version.
TradingView-compatible spelling: export; runs without warnings.

### function-shadowing
https://www.alertachart.com/alertascript/reference/builtins/function-shadowing
Signature: average(float source, int length = 20) =>
User-defined names are resolved within their lexical scope. Avoid reusing builtin namespace names; use explicit namespaces to make a call’s meaning clear.

### bar_index
https://www.alertachart.com/alertascript/reference/builtins/bar_index
Signature: bar_index → series int
Zero-based position of the current bar within the chart dataset. Historical access such as bar_index[1] refers to the preceding bar.
TradingView-compatible spelling: bar_index; runs without warnings.

### alerta.session.isfirstbar_regular
https://www.alertachart.com/alertascript/reference/builtins/session.isfirstbar_regular
Signature: session.isfirstbar_regular → series bool
True on the first regular-hours bar of each day's session — on a stock, the first bar after the pre-market. On a symbol that trades around the clock it is the same bar as session.isfirstbar. Inside request.security, of the requested bars.
TradingView-compatible spelling: session.isfirstbar_regular; runs without warnings.

### alerta.session.islastbar_regular
https://www.alertachart.com/alertascript/reference/builtins/session.islastbar_regular
Signature: session.islastbar_regular → series bool
True on the last regular-hours bar of each day's session — on a stock, the last bar before the post-market. On a symbol that trades around the clock it is the same bar as session.islastbar. Inside request.security, of the requested bars.
TradingView-compatible spelling: session.islastbar_regular; runs without warnings.

### alerta.syminfo.minmove
https://www.alertachart.com/alertascript/reference/builtins/syminfo.minmove
Signature: syminfo.minmove → int
The numerator of the symbol's price step: syminfo.minmove / syminfo.pricescale is syminfo.mintick.
TradingView-compatible spelling: syminfo.minmove; runs without warnings.

### alerta.chart.is_heikinashi
https://www.alertachart.com/alertascript/reference/builtins/chart.is_heikinashi
Signature: chart.is_heikinashi → simple bool
True on a Heikin Ashi chart in Pine. On AlertaChart it is always false: a Heikin Ashi chart draws its candles from the standard bars, and scripts always run on the standard bars.
TradingView-compatible spelling: chart.is_heikinashi; runs without warnings.

### alerta.chart.is_renko
https://www.alertachart.com/alertascript/reference/builtins/chart.is_renko
Signature: chart.is_renko → simple bool
True on a Renko chart in Pine. On AlertaChart it is always false; chart.is_standard is true.
TradingView-compatible spelling: chart.is_renko; runs without warnings.

### alerta.chart.is_kagi
https://www.alertachart.com/alertascript/reference/builtins/chart.is_kagi
Signature: chart.is_kagi → simple bool
True on a Kagi chart in Pine. On AlertaChart it is always false; chart.is_standard is true.
TradingView-compatible spelling: chart.is_kagi; runs without warnings.

### alerta.chart.is_linebreak
https://www.alertachart.com/alertascript/reference/builtins/chart.is_linebreak
Signature: chart.is_linebreak → simple bool
True on a Line Break chart in Pine. On AlertaChart it is always false; chart.is_standard is true.
TradingView-compatible spelling: chart.is_linebreak; runs without warnings.

### alerta.chart.is_pnf
https://www.alertachart.com/alertascript/reference/builtins/chart.is_pnf
Signature: chart.is_pnf → simple bool
True on a Point & Figure chart in Pine. On AlertaChart it is always false; chart.is_standard is true.
TradingView-compatible spelling: chart.is_pnf; runs without warnings.

### alerta.chart.is_range
https://www.alertachart.com/alertascript/reference/builtins/chart.is_range
Signature: chart.is_range → simple bool
True on a Range chart in Pine. On AlertaChart it is always false; chart.is_standard is true.
TradingView-compatible spelling: chart.is_range; runs without warnings.

### alerta.str.length_in_pixels
https://www.alertachart.com/alertascript/reference/builtins/str.length_in_pixels
Signature: str.length_in_pixels(string, size)
The approximate width of a text in pixels, for laying out labels and tables: 7 pixels per character of the default font. The size argument is accepted; the estimate does not depend on it.
TradingView-compatible spelling: str.length_in_pixels; runs without warnings.

### alerta.linefill.all
https://www.alertachart.com/alertascript/reference/builtins/linefill.all
Signature: linefill.all → array<linefill>
An array of every linefill the script has made and not deleted, oldest first.
TradingView-compatible spelling: linefill.all; runs without warnings.

### alerta.strategy.convert_to_account
https://www.alertachart.com/alertascript/reference/builtins/strategy.convert_to_account
Signature: strategy.convert_to_account(value)
Converts a value in the symbol's currency to the strategy's account currency. Strategies here keep their money in the symbol's currency, so the value comes back unchanged — exact when both currencies are the same, as on every USDT pair.
TradingView-compatible spelling: strategy.convert_to_account; runs without warnings.

### alerta.strategy.convert_to_symbol
https://www.alertachart.com/alertascript/reference/builtins/strategy.convert_to_symbol
Signature: strategy.convert_to_symbol(value)
Converts a value in the strategy's account currency to the symbol's currency — the way to size an order from a cash amount. Strategies here keep their money in the symbol's currency, so the value comes back unchanged — exact when both currencies are the same, as on every USDT pair.
TradingView-compatible spelling: strategy.convert_to_symbol; runs without warnings.

### alerta.strategy.closedtrades.first_index
https://www.alertachart.com/alertascript/reference/builtins/strategy.closedtrades.first_index
Signature: strategy.closedtrades.first_index → int
The trade number of the oldest closed trade the strategy keeps. No closed trade is ever dropped from the list here, so it is always 0.
TradingView-compatible spelling: strategy.closedtrades.first_index; runs without warnings.

### history-operator
https://www.alertachart.com/alertascript/reference/builtins/history-operator
Signature: expression[offset]
expression[n] reads the value expression had n bars ago: close[1] is the previous bar's close, high[10] the high ten bars back. Where there is no such bar — the first bars of the chart — the result is na. The offset may be any non-negative int, also one that changes from bar to bar.

### alerta.barmerge.gaps_off
https://www.alertachart.com/alertascript/reference/builtins/barmerge.gaps_off
Signature: barmerge.gaps_off → const bool
Gap or lookahead option for a request.security() call. Use barmerge.gaps_off as a value, without parentheses.
TradingView-compatible spelling: barmerge.gaps_off; runs without warnings.

### alerta.barmerge.gaps_on
https://www.alertachart.com/alertascript/reference/builtins/barmerge.gaps_on
Signature: barmerge.gaps_on → const bool
Gap or lookahead option for a request.security() call. Use barmerge.gaps_on as a value, without parentheses.
TradingView-compatible spelling: barmerge.gaps_on; runs without warnings.

### alerta.barmerge.lookahead_off
https://www.alertachart.com/alertascript/reference/builtins/barmerge.lookahead_off
Signature: barmerge.lookahead_off → const bool
Gap or lookahead option for a request.security() call. Use barmerge.lookahead_off as a value, without parentheses.
TradingView-compatible spelling: barmerge.lookahead_off; runs without warnings.

### alerta.barmerge.lookahead_on
https://www.alertachart.com/alertascript/reference/builtins/barmerge.lookahead_on
Signature: barmerge.lookahead_on → const bool
Gap or lookahead option for a request.security() call. Use barmerge.lookahead_on as a value, without parentheses.
TradingView-compatible spelling: barmerge.lookahead_on; runs without warnings.

### alerta.currency.AED
https://www.alertachart.com/alertascript/reference/builtins/currency.aed
Signature: currency.AED → const string
Currency identifier accepted by strategy and data-request settings. Use currency.AED as a value, without parentheses.
TradingView-compatible spelling: currency.AED; runs without warnings.

### alerta.currency.ARS
https://www.alertachart.com/alertascript/reference/builtins/currency.ars
Signature: currency.ARS → const string
Currency identifier accepted by strategy and data-request settings. Use currency.ARS as a value, without parentheses.
TradingView-compatible spelling: currency.ARS; runs without warnings.

### alerta.currency.AUD
https://www.alertachart.com/alertascript/reference/builtins/currency.aud
Signature: currency.AUD → const string
Currency identifier accepted by strategy and data-request settings. Use currency.AUD as a value, without parentheses.
TradingView-compatible spelling: currency.AUD; runs without warnings.

### alerta.currency.BRL
https://www.alertachart.com/alertascript/reference/builtins/currency.brl
Signature: currency.BRL → const string
Currency identifier accepted by strategy and data-request settings. Use currency.BRL as a value, without parentheses.
TradingView-compatible spelling: currency.BRL; runs without warnings.

### alerta.currency.BTC
https://www.alertachart.com/alertascript/reference/builtins/currency.btc
Signature: currency.BTC → const string
Currency identifier accepted by strategy and data-request settings. Use currency.BTC as a value, without parentheses.
TradingView-compatible spelling: currency.BTC; runs without warnings.

### alerta.currency.CAD
https://www.alertachart.com/alertascript/reference/builtins/currency.cad
Signature: currency.CAD → const string
Currency identifier accepted by strategy and data-request settings. Use currency.CAD as a value, without parentheses.
TradingView-compatible spelling: currency.CAD; runs without warnings.

### alerta.currency.CHF
https://www.alertachart.com/alertascript/reference/builtins/currency.chf
Signature: currency.CHF → const string
Currency identifier accepted by strategy and data-request settings. Use currency.CHF as a value, without parentheses.
TradingView-compatible spelling: currency.CHF; runs without warnings.

### alerta.currency.CNY
https://www.alertachart.com/alertascript/reference/builtins/currency.cny
Signature: currency.CNY → const string
Currency identifier accepted by strategy and data-request settings. Use currency.CNY as a value, without parentheses.
TradingView-compatible spelling: currency.CNY; runs without warnings.

### alerta.currency.DKK
https://www.alertachart.com/alertascript/reference/builtins/currency.dkk
Signature: currency.DKK → const string
Currency identifier accepted by strategy and data-request settings. Use currency.DKK as a value, without parentheses.
TradingView-compatible spelling: currency.DKK; runs without warnings.

### alerta.currency.ETH
https://www.alertachart.com/alertascript/reference/builtins/currency.eth
Signature: currency.ETH → const string
Currency identifier accepted by strategy and data-request settings. Use currency.ETH as a value, without parentheses.
TradingView-compatible spelling: currency.ETH; runs without warnings.

### alerta.currency.EUR
https://www.alertachart.com/alertascript/reference/builtins/currency.eur
Signature: currency.EUR → const string
Currency identifier accepted by strategy and data-request settings. Use currency.EUR as a value, without parentheses.
TradingView-compatible spelling: currency.EUR; runs without warnings.

### alerta.currency.GBP
https://www.alertachart.com/alertascript/reference/builtins/currency.gbp
Signature: currency.GBP → const string
Currency identifier accepted by strategy and data-request settings. Use currency.GBP as a value, without parentheses.
TradingView-compatible spelling: currency.GBP; runs without warnings.

### alerta.currency.HKD
https://www.alertachart.com/alertascript/reference/builtins/currency.hkd
Signature: currency.HKD → const string
Currency identifier accepted by strategy and data-request settings. Use currency.HKD as a value, without parentheses.
TradingView-compatible spelling: currency.HKD; runs without warnings.

### alerta.currency.IDR
https://www.alertachart.com/alertascript/reference/builtins/currency.idr
Signature: currency.IDR → const string
Currency identifier accepted by strategy and data-request settings. Use currency.IDR as a value, without parentheses.
TradingView-compatible spelling: currency.IDR; runs without warnings.

### alerta.currency.ILS
https://www.alertachart.com/alertascript/reference/builtins/currency.ils
Signature: currency.ILS → const string
Currency identifier accepted by strategy and data-request settings. Use currency.ILS as a value, without parentheses.
TradingView-compatible spelling: currency.ILS; runs without warnings.

### alerta.currency.INR
https://www.alertachart.com/alertascript/reference/builtins/currency.inr
Signature: currency.INR → const string
Currency identifier accepted by strategy and data-request settings. Use currency.INR as a value, without parentheses.
TradingView-compatible spelling: currency.INR; runs without warnings.

### alerta.currency.JPY
https://www.alertachart.com/alertascript/reference/builtins/currency.jpy
Signature: currency.JPY → const string
Currency identifier accepted by strategy and data-request settings. Use currency.JPY as a value, without parentheses.
TradingView-compatible spelling: currency.JPY; runs without warnings.

### alerta.currency.KRW
https://www.alertachart.com/alertascript/reference/builtins/currency.krw
Signature: currency.KRW → const string
Currency identifier accepted by strategy and data-request settings. Use currency.KRW as a value, without parentheses.
TradingView-compatible spelling: currency.KRW; runs without warnings.

### alerta.currency.MXN
https://www.alertachart.com/alertascript/reference/builtins/currency.mxn
Signature: currency.MXN → const string
Currency identifier accepted by strategy and data-request settings. Use currency.MXN as a value, without parentheses.
TradingView-compatible spelling: currency.MXN; runs without warnings.

### alerta.currency.MYR
https://www.alertachart.com/alertascript/reference/builtins/currency.myr
Signature: currency.MYR → const string
Currency identifier accepted by strategy and data-request settings. Use currency.MYR as a value, without parentheses.
TradingView-compatible spelling: currency.MYR; runs without warnings.

### alerta.currency.NOK
https://www.alertachart.com/alertascript/reference/builtins/currency.nok
Signature: currency.NOK → const string
Currency identifier accepted by strategy and data-request settings. Use currency.NOK as a value, without parentheses.
TradingView-compatible spelling: currency.NOK; runs without warnings.

### alerta.currency.NONE
https://www.alertachart.com/alertascript/reference/builtins/currency.none
Signature: currency.NONE → const string
Currency identifier accepted by strategy and data-request settings. Use currency.NONE as a value, without parentheses.
TradingView-compatible spelling: currency.NONE; runs without warnings.

### alerta.currency.NZD
https://www.alertachart.com/alertascript/reference/builtins/currency.nzd
Signature: currency.NZD → const string
Currency identifier accepted by strategy and data-request settings. Use currency.NZD as a value, without parentheses.
TradingView-compatible spelling: currency.NZD; runs without warnings.

### alerta.currency.PHP
https://www.alertachart.com/alertascript/reference/builtins/currency.php
Signature: currency.PHP → const string
Currency identifier accepted by strategy and data-request settings. Use currency.PHP as a value, without parentheses.
TradingView-compatible spelling: currency.PHP; runs without warnings.

### alerta.currency.PLN
https://www.alertachart.com/alertascript/reference/builtins/currency.pln
Signature: currency.PLN → const string
Currency identifier accepted by strategy and data-request settings. Use currency.PLN as a value, without parentheses.
TradingView-compatible spelling: currency.PLN; runs without warnings.

### alerta.currency.RUB
https://www.alertachart.com/alertascript/reference/builtins/currency.rub
Signature: currency.RUB → const string
Currency identifier accepted by strategy and data-request settings. Use currency.RUB as a value, without parentheses.
TradingView-compatible spelling: currency.RUB; runs without warnings.

### alerta.currency.SAR
https://www.alertachart.com/alertascript/reference/builtins/currency.sar
Signature: currency.SAR → const string
Currency identifier accepted by strategy and data-request settings. Use currency.SAR as a value, without parentheses.
TradingView-compatible spelling: currency.SAR; runs without warnings.

### alerta.currency.SEK
https://www.alertachart.com/alertascript/reference/builtins/currency.sek
Signature: currency.SEK → const string
Currency identifier accepted by strategy and data-request settings. Use currency.SEK as a value, without parentheses.
TradingView-compatible spelling: currency.SEK; runs without warnings.

### alerta.currency.SGD
https://www.alertachart.com/alertascript/reference/builtins/currency.sgd
Signature: currency.SGD → const string
Currency identifier accepted by strategy and data-request settings. Use currency.SGD as a value, without parentheses.
TradingView-compatible spelling: currency.SGD; runs without warnings.

### alerta.currency.THB
https://www.alertachart.com/alertascript/reference/builtins/currency.thb
Signature: currency.THB → const string
Currency identifier accepted by strategy and data-request settings. Use currency.THB as a value, without parentheses.
TradingView-compatible spelling: currency.THB; runs without warnings.

### alerta.currency.TRY
https://www.alertachart.com/alertascript/reference/builtins/currency.try
Signature: currency.TRY → const string
Currency identifier accepted by strategy and data-request settings. Use currency.TRY as a value, without parentheses.
TradingView-compatible spelling: currency.TRY; runs without warnings.

### alerta.currency.TWD
https://www.alertachart.com/alertascript/reference/builtins/currency.twd
Signature: currency.TWD → const string
Currency identifier accepted by strategy and data-request settings. Use currency.TWD as a value, without parentheses.
TradingView-compatible spelling: currency.TWD; runs without warnings.

### alerta.currency.USD
https://www.alertachart.com/alertascript/reference/builtins/currency.usd
Signature: currency.USD → const string
Currency identifier accepted by strategy and data-request settings. Use currency.USD as a value, without parentheses.
TradingView-compatible spelling: currency.USD; runs without warnings.

### alerta.currency.USDC
https://www.alertachart.com/alertascript/reference/builtins/currency.usdc
Signature: currency.USDC → const string
Currency identifier accepted by strategy and data-request settings. Use currency.USDC as a value, without parentheses.
TradingView-compatible spelling: currency.USDC; runs without warnings.

### alerta.currency.USDT
https://www.alertachart.com/alertascript/reference/builtins/currency.usdt
Signature: currency.USDT → const string
Currency identifier accepted by strategy and data-request settings. Use currency.USDT as a value, without parentheses.
TradingView-compatible spelling: currency.USDT; runs without warnings.

### alerta.currency.VND
https://www.alertachart.com/alertascript/reference/builtins/currency.vnd
Signature: currency.VND → const string
Currency identifier accepted by strategy and data-request settings. Use currency.VND as a value, without parentheses.
TradingView-compatible spelling: currency.VND; runs without warnings.

### alerta.currency.ZAR
https://www.alertachart.com/alertascript/reference/builtins/currency.zar
Signature: currency.ZAR → const string
Currency identifier accepted by strategy and data-request settings. Use currency.ZAR as a value, without parentheses.
TradingView-compatible spelling: currency.ZAR; runs without warnings.

### alerta.dayofweek.friday
https://www.alertachart.com/alertascript/reference/builtins/dayofweek.friday
Signature: dayofweek.friday → const int
Weekday number used with dayofweek and session conditions. Use dayofweek.friday as a value, without parentheses.
TradingView-compatible spelling: dayofweek.friday; runs without warnings.

### alerta.dayofweek.saturday
https://www.alertachart.com/alertascript/reference/builtins/dayofweek.saturday
Signature: dayofweek.saturday → const int
Weekday number used with dayofweek and session conditions. Use dayofweek.saturday as a value, without parentheses.
TradingView-compatible spelling: dayofweek.saturday; runs without warnings.

### alerta.dayofweek.sunday
https://www.alertachart.com/alertascript/reference/builtins/dayofweek.sunday
Signature: dayofweek.sunday → const int
Weekday number used with dayofweek and session conditions. Use dayofweek.sunday as a value, without parentheses.
TradingView-compatible spelling: dayofweek.sunday; runs without warnings.

### alerta.dayofweek.thursday
https://www.alertachart.com/alertascript/reference/builtins/dayofweek.thursday
Signature: dayofweek.thursday → const int
Weekday number used with dayofweek and session conditions. Use dayofweek.thursday as a value, without parentheses.
TradingView-compatible spelling: dayofweek.thursday; runs without warnings.

### alerta.dayofweek.tuesday
https://www.alertachart.com/alertascript/reference/builtins/dayofweek.tuesday
Signature: dayofweek.tuesday → const int
Weekday number used with dayofweek and session conditions. Use dayofweek.tuesday as a value, without parentheses.
TradingView-compatible spelling: dayofweek.tuesday; runs without warnings.

### alerta.dayofweek.wednesday
https://www.alertachart.com/alertascript/reference/builtins/dayofweek.wednesday
Signature: dayofweek.wednesday → const int
Weekday number used with dayofweek and session conditions. Use dayofweek.wednesday as a value, without parentheses.
TradingView-compatible spelling: dayofweek.wednesday; runs without warnings.

### alerta.format.inherit
https://www.alertachart.com/alertascript/reference/builtins/format.inherit
Signature: format.inherit → const string
Number-format identifier for declaration or string formatting. Use format.inherit as a value, without parentheses.
TradingView-compatible spelling: format.inherit; runs without warnings.

### alerta.format.mintick
https://www.alertachart.com/alertascript/reference/builtins/format.mintick
Signature: format.mintick → const string
Number-format identifier for declaration or string formatting. Use format.mintick as a value, without parentheses.
TradingView-compatible spelling: format.mintick; runs without warnings.

### alerta.format.percent
https://www.alertachart.com/alertascript/reference/builtins/format.percent
Signature: format.percent → const string
Number-format identifier for declaration or string formatting. Use format.percent as a value, without parentheses.
TradingView-compatible spelling: format.percent; runs without warnings.

### alerta.format.price
https://www.alertachart.com/alertascript/reference/builtins/format.price
Signature: format.price → const string
Number-format identifier for declaration or string formatting. Use format.price as a value, without parentheses.
TradingView-compatible spelling: format.price; runs without warnings.

### alerta.format.volume
https://www.alertachart.com/alertascript/reference/builtins/format.volume
Signature: format.volume → const string
Number-format identifier for declaration or string formatting. Use format.volume as a value, without parentheses.
TradingView-compatible spelling: format.volume; runs without warnings.

### alerta.strategy.close_entries_rule.ANY
https://www.alertachart.com/alertascript/reference/builtins/strategy.close_entries_rule.any
Signature: strategy.close_entries_rule.ANY → const string
Entry matching rule used when closing strategy trades. Use strategy.close_entries_rule.ANY as a value, without parentheses.
TradingView-compatible spelling: strategy.close_entries_rule.ANY; runs without warnings.

### alerta.strategy.close_entries_rule.FIFO
https://www.alertachart.com/alertascript/reference/builtins/strategy.close_entries_rule.fifo
Signature: strategy.close_entries_rule.FIFO → const string
Entry matching rule used when closing strategy trades. Use strategy.close_entries_rule.FIFO as a value, without parentheses.
TradingView-compatible spelling: strategy.close_entries_rule.FIFO; runs without warnings.

### alerta.strategy.commission.cash_per_contract
https://www.alertachart.com/alertascript/reference/builtins/strategy.commission.cash_per_contract
Signature: strategy.commission.cash_per_contract → const string
Commission calculation mode in the strategy declaration. Use strategy.commission.cash_per_contract as a value, without parentheses.
TradingView-compatible spelling: strategy.commission.cash_per_contract; runs without warnings.

### alerta.strategy.commission.cash_per_order
https://www.alertachart.com/alertascript/reference/builtins/strategy.commission.cash_per_order
Signature: strategy.commission.cash_per_order → const string
Commission calculation mode in the strategy declaration. Use strategy.commission.cash_per_order as a value, without parentheses.
TradingView-compatible spelling: strategy.commission.cash_per_order; runs without warnings.

### alerta.strategy.commission.percent
https://www.alertachart.com/alertascript/reference/builtins/strategy.commission.percent
Signature: strategy.commission.percent → const string
Commission calculation mode in the strategy declaration. Use strategy.commission.percent as a value, without parentheses.
TradingView-compatible spelling: strategy.commission.percent; runs without warnings.

### alerta.strategy.direction.all
https://www.alertachart.com/alertascript/reference/builtins/strategy.direction.all
Signature: strategy.direction.all → const string
Direction accepted by the strategy risk configuration. Use strategy.direction.all as a value, without parentheses.
TradingView-compatible spelling: strategy.direction.all; runs without warnings.

### alerta.strategy.direction.long
https://www.alertachart.com/alertascript/reference/builtins/strategy.direction.long
Signature: strategy.direction.long → const string
Direction accepted by the strategy risk configuration. Use strategy.direction.long as a value, without parentheses.
TradingView-compatible spelling: strategy.direction.long; runs without warnings.

### alerta.strategy.direction.short
https://www.alertachart.com/alertascript/reference/builtins/strategy.direction.short
Signature: strategy.direction.short → const string
Direction accepted by the strategy risk configuration. Use strategy.direction.short as a value, without parentheses.
TradingView-compatible spelling: strategy.direction.short; runs without warnings.

### alerta.strategy.long
https://www.alertachart.com/alertascript/reference/builtins/strategy.long
Signature: strategy.long → const string
Strategy order direction or quantity mode. Use strategy.long as a value, without parentheses.
TradingView-compatible spelling: strategy.long; runs without warnings.

### alerta.strategy.short
https://www.alertachart.com/alertascript/reference/builtins/strategy.short
Signature: strategy.short → const string
Strategy order direction or quantity mode. Use strategy.short as a value, without parentheses.
TradingView-compatible spelling: strategy.short; runs without warnings.

### alerta.xloc.bar_index
https://www.alertachart.com/alertascript/reference/builtins/xloc.bar_index
Signature: xloc.bar_index → const string
Selects whether drawing x-coordinates represent bar indices or timestamps. Use xloc.bar_index as a value, without parentheses.
TradingView-compatible spelling: xloc.bar_index; runs without warnings.

### alerta.xloc.bar_time
https://www.alertachart.com/alertascript/reference/builtins/xloc.bar_time
Signature: xloc.bar_time → const string
Selects whether drawing x-coordinates represent bar indices or timestamps. Use xloc.bar_time as a value, without parentheses.
TradingView-compatible spelling: xloc.bar_time; runs without warnings.

### alerta.yloc.abovebar
https://www.alertachart.com/alertascript/reference/builtins/yloc.abovebar
Signature: yloc.abovebar → const string
Selects whether label y-coordinates represent a price or a bar-relative location. Use yloc.abovebar as a value, without parentheses.
TradingView-compatible spelling: yloc.abovebar; runs without warnings.

### alerta.yloc.belowbar
https://www.alertachart.com/alertascript/reference/builtins/yloc.belowbar
Signature: yloc.belowbar → const string
Selects whether label y-coordinates represent a price or a bar-relative location. Use yloc.belowbar as a value, without parentheses.
TradingView-compatible spelling: yloc.belowbar; runs without warnings.

### alerta.yloc.price
https://www.alertachart.com/alertascript/reference/builtins/yloc.price
Signature: yloc.price → const string
Selects whether label y-coordinates represent a price or a bar-relative location. Use yloc.price as a value, without parentheses.
TradingView-compatible spelling: yloc.price; runs without warnings.

### alerta.color.aqua
https://www.alertachart.com/alertascript/reference/builtins/color.aqua
Signature: color.aqua → const string
Named color for plots, drawings, fills and table cells. Use color.aqua as a value, without parentheses.
TradingView-compatible spelling: color.aqua; runs without warnings.

### alerta.color.black
https://www.alertachart.com/alertascript/reference/builtins/color.black
Signature: color.black → const string
Named color for plots, drawings, fills and table cells. Use color.black as a value, without parentheses.
TradingView-compatible spelling: color.black; runs without warnings.

### alerta.color.blue
https://www.alertachart.com/alertascript/reference/builtins/color.blue
Signature: color.blue → const string
Named color for plots, drawings, fills and table cells. Use color.blue as a value, without parentheses.
TradingView-compatible spelling: color.blue; runs without warnings.

### alerta.color.fuchsia
https://www.alertachart.com/alertascript/reference/builtins/color.fuchsia
Signature: color.fuchsia → const string
Named color for plots, drawings, fills and table cells. Use color.fuchsia as a value, without parentheses.
TradingView-compatible spelling: color.fuchsia; runs without warnings.

### alerta.color.gray
https://www.alertachart.com/alertascript/reference/builtins/color.gray
Signature: color.gray → const string
Named color for plots, drawings, fills and table cells. Use color.gray as a value, without parentheses.
TradingView-compatible spelling: color.gray; runs without warnings.

### alerta.color.green
https://www.alertachart.com/alertascript/reference/builtins/color.green
Signature: color.green → const string
Named color for plots, drawings, fills and table cells. Use color.green as a value, without parentheses.
TradingView-compatible spelling: color.green; runs without warnings.

### alerta.color.lime
https://www.alertachart.com/alertascript/reference/builtins/color.lime
Signature: color.lime → const string
Named color for plots, drawings, fills and table cells. Use color.lime as a value, without parentheses.
TradingView-compatible spelling: color.lime; runs without warnings.

### alerta.color.maroon
https://www.alertachart.com/alertascript/reference/builtins/color.maroon
Signature: color.maroon → const string
Named color for plots, drawings, fills and table cells. Use color.maroon as a value, without parentheses.
TradingView-compatible spelling: color.maroon; runs without warnings.

### alerta.color.navy
https://www.alertachart.com/alertascript/reference/builtins/color.navy
Signature: color.navy → const string
Named color for plots, drawings, fills and table cells. Use color.navy as a value, without parentheses.
TradingView-compatible spelling: color.navy; runs without warnings.

### alerta.color.olive
https://www.alertachart.com/alertascript/reference/builtins/color.olive
Signature: color.olive → const string
Named color for plots, drawings, fills and table cells. Use color.olive as a value, without parentheses.
TradingView-compatible spelling: color.olive; runs without warnings.

### alerta.color.orange
https://www.alertachart.com/alertascript/reference/builtins/color.orange
Signature: color.orange → const string
Named color for plots, drawings, fills and table cells. Use color.orange as a value, without parentheses.
TradingView-compatible spelling: color.orange; runs without warnings.

### alerta.color.purple
https://www.alertachart.com/alertascript/reference/builtins/color.purple
Signature: color.purple → const string
Named color for plots, drawings, fills and table cells. Use color.purple as a value, without parentheses.
TradingView-compatible spelling: color.purple; runs without warnings.

### alerta.color.red
https://www.alertachart.com/alertascript/reference/builtins/color.red
Signature: color.red → const string
Named color for plots, drawings, fills and table cells. Use color.red as a value, without parentheses.
TradingView-compatible spelling: color.red; runs without warnings.

### alerta.color.silver
https://www.alertachart.com/alertascript/reference/builtins/color.silver
Signature: color.silver → const string
Named color for plots, drawings, fills and table cells. Use color.silver as a value, without parentheses.
TradingView-compatible spelling: color.silver; runs without warnings.

### alerta.color.teal
https://www.alertachart.com/alertascript/reference/builtins/color.teal
Signature: color.teal → const string
Named color for plots, drawings, fills and table cells. Use color.teal as a value, without parentheses.
TradingView-compatible spelling: color.teal; runs without warnings.

### alerta.color.white
https://www.alertachart.com/alertascript/reference/builtins/color.white
Signature: color.white → const string
Named color for plots, drawings, fills and table cells. Use color.white as a value, without parentheses.
TradingView-compatible spelling: color.white; runs without warnings.

### alerta.color.yellow
https://www.alertachart.com/alertascript/reference/builtins/color.yellow
Signature: color.yellow → const string
Named color for plots, drawings, fills and table cells. Use color.yellow as a value, without parentheses.
TradingView-compatible spelling: color.yellow; runs without warnings.

### alerta.math.pi
https://www.alertachart.com/alertascript/reference/builtins/math.pi
Signature: math.pi → const float
Mathematical constant available without calling a function. Use math.pi as a value, without parentheses.
TradingView-compatible spelling: math.pi; runs without warnings.

### alerta.math.e
https://www.alertachart.com/alertascript/reference/builtins/math.e
Signature: math.e → const float
Mathematical constant available without calling a function. Use math.e as a value, without parentheses.
TradingView-compatible spelling: math.e; runs without warnings.

### alerta.math.phi
https://www.alertachart.com/alertascript/reference/builtins/math.phi
Signature: math.phi → const float
Mathematical constant available without calling a function. Use math.phi as a value, without parentheses.
TradingView-compatible spelling: math.phi; runs without warnings.

### alerta.plot.style_line
https://www.alertachart.com/alertascript/reference/builtins/plot.style_line
Signature: plot.style_line → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_line as a value, without parentheses.
TradingView-compatible spelling: plot.style_line; runs without warnings.

### alerta.plot.style_stepline
https://www.alertachart.com/alertascript/reference/builtins/plot.style_stepline
Signature: plot.style_stepline → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_stepline as a value, without parentheses.
TradingView-compatible spelling: plot.style_stepline; runs without warnings.

### alerta.plot.style_steplinebr
https://www.alertachart.com/alertascript/reference/builtins/plot.style_steplinebr
Signature: plot.style_steplinebr → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_steplinebr as a value, without parentheses.
TradingView-compatible spelling: plot.style_steplinebr; runs without warnings.

### alerta.plot.style_stepline_diamond
https://www.alertachart.com/alertascript/reference/builtins/plot.style_stepline_diamond
Signature: plot.style_stepline_diamond → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_stepline_diamond as a value, without parentheses.
TradingView-compatible spelling: plot.style_stepline_diamond; runs without warnings.

### alerta.plot.style_histogram
https://www.alertachart.com/alertascript/reference/builtins/plot.style_histogram
Signature: plot.style_histogram → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_histogram as a value, without parentheses.
TradingView-compatible spelling: plot.style_histogram; runs without warnings.

### alerta.plot.style_columns
https://www.alertachart.com/alertascript/reference/builtins/plot.style_columns
Signature: plot.style_columns → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_columns as a value, without parentheses.
TradingView-compatible spelling: plot.style_columns; runs without warnings.

### alerta.plot.style_area
https://www.alertachart.com/alertascript/reference/builtins/plot.style_area
Signature: plot.style_area → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_area as a value, without parentheses.
TradingView-compatible spelling: plot.style_area; runs without warnings.

### alerta.plot.style_circles
https://www.alertachart.com/alertascript/reference/builtins/plot.style_circles
Signature: plot.style_circles → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_circles as a value, without parentheses.
TradingView-compatible spelling: plot.style_circles; runs without warnings.

### alerta.plot.style_cross
https://www.alertachart.com/alertascript/reference/builtins/plot.style_cross
Signature: plot.style_cross → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_cross as a value, without parentheses.
TradingView-compatible spelling: plot.style_cross; runs without warnings.

### alerta.plot.style_linebr
https://www.alertachart.com/alertascript/reference/builtins/plot.style_linebr
Signature: plot.style_linebr → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_linebr as a value, without parentheses.
TradingView-compatible spelling: plot.style_linebr; runs without warnings.

### alerta.plot.style_levels
https://www.alertachart.com/alertascript/reference/builtins/plot.style_levels
Signature: plot.style_levels → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_levels as a value, without parentheses.
TradingView-compatible spelling: plot.style_levels; runs without warnings.

### alerta.plot.style_areabr
https://www.alertachart.com/alertascript/reference/builtins/plot.style_areabr
Signature: plot.style_areabr → const string
Plot rendering style or line pattern passed to plot(). Use plot.style_areabr as a value, without parentheses.
TradingView-compatible spelling: plot.style_areabr; runs without warnings.

### alerta.plot.linestyle_solid
https://www.alertachart.com/alertascript/reference/builtins/plot.linestyle_solid
Signature: plot.linestyle_solid → const string
Plot rendering style or line pattern passed to plot(). Use plot.linestyle_solid as a value, without parentheses.
TradingView-compatible spelling: plot.linestyle_solid; runs without warnings.

### alerta.plot.linestyle_dotted
https://www.alertachart.com/alertascript/reference/builtins/plot.linestyle_dotted
Signature: plot.linestyle_dotted → const string
Plot rendering style or line pattern passed to plot(). Use plot.linestyle_dotted as a value, without parentheses.
TradingView-compatible spelling: plot.linestyle_dotted; runs without warnings.

### alerta.plot.linestyle_dashed
https://www.alertachart.com/alertascript/reference/builtins/plot.linestyle_dashed
Signature: plot.linestyle_dashed → const string
Plot rendering style or line pattern passed to plot(). Use plot.linestyle_dashed as a value, without parentheses.
TradingView-compatible spelling: plot.linestyle_dashed; runs without warnings.

### alerta.style.line
https://www.alertachart.com/alertascript/reference/builtins/style.line
Signature: style.line → const string
Rendering style identifier for chart output. Use style.line as a value, without parentheses.
TradingView-compatible spelling: style.line; runs without warnings.

### alerta.style.stepline
https://www.alertachart.com/alertascript/reference/builtins/style.stepline
Signature: style.stepline → const string
Rendering style identifier for chart output. Use style.stepline as a value, without parentheses.
TradingView-compatible spelling: style.stepline; runs without warnings.

### alerta.style.histogram
https://www.alertachart.com/alertascript/reference/builtins/style.histogram
Signature: style.histogram → const string
Rendering style identifier for chart output. Use style.histogram as a value, without parentheses.
TradingView-compatible spelling: style.histogram; runs without warnings.

### alerta.style.columns
https://www.alertachart.com/alertascript/reference/builtins/style.columns
Signature: style.columns → const string
Rendering style identifier for chart output. Use style.columns as a value, without parentheses.
TradingView-compatible spelling: style.columns; runs without warnings.

### alerta.style.area
https://www.alertachart.com/alertascript/reference/builtins/style.area
Signature: style.area → const string
Rendering style identifier for chart output. Use style.area as a value, without parentheses.
TradingView-compatible spelling: style.area; runs without warnings.

### alerta.style.circles
https://www.alertachart.com/alertascript/reference/builtins/style.circles
Signature: style.circles → const string
Rendering style identifier for chart output. Use style.circles as a value, without parentheses.
TradingView-compatible spelling: style.circles; runs without warnings.

### alerta.style.cross
https://www.alertachart.com/alertascript/reference/builtins/style.cross
Signature: style.cross → const string
Rendering style identifier for chart output. Use style.cross as a value, without parentheses.
TradingView-compatible spelling: style.cross; runs without warnings.

### alerta.style.xcross
https://www.alertachart.com/alertascript/reference/builtins/style.xcross
Signature: style.xcross → const string
Rendering style identifier for chart output. Use style.xcross as a value, without parentheses.
TradingView-compatible spelling: style.xcross; runs without warnings.

### alerta.location.abovebar
https://www.alertachart.com/alertascript/reference/builtins/location.abovebar
Signature: location.abovebar → const string
Vertical location for plotshape() and plotchar(). Use location.abovebar as a value, without parentheses.
TradingView-compatible spelling: location.abovebar; runs without warnings.

### alerta.location.belowbar
https://www.alertachart.com/alertascript/reference/builtins/location.belowbar
Signature: location.belowbar → const string
Vertical location for plotshape() and plotchar(). Use location.belowbar as a value, without parentheses.
TradingView-compatible spelling: location.belowbar; runs without warnings.

### alerta.location.top
https://www.alertachart.com/alertascript/reference/builtins/location.top
Signature: location.top → const string
Vertical location for plotshape() and plotchar(). Use location.top as a value, without parentheses.
TradingView-compatible spelling: location.top; runs without warnings.

### alerta.location.bottom
https://www.alertachart.com/alertascript/reference/builtins/location.bottom
Signature: location.bottom → const string
Vertical location for plotshape() and plotchar(). Use location.bottom as a value, without parentheses.
TradingView-compatible spelling: location.bottom; runs without warnings.

### alerta.location.absolute
https://www.alertachart.com/alertascript/reference/builtins/location.absolute
Signature: location.absolute → const string
Vertical location for plotshape() and plotchar(). Use location.absolute as a value, without parentheses.
TradingView-compatible spelling: location.absolute; runs without warnings.

### alerta.size.auto
https://www.alertachart.com/alertascript/reference/builtins/size.auto
Signature: size.auto → const string
Size preset for text and chart markers. Use size.auto as a value, without parentheses.
TradingView-compatible spelling: size.auto; runs without warnings.

### alerta.size.tiny
https://www.alertachart.com/alertascript/reference/builtins/size.tiny
Signature: size.tiny → const string
Size preset for text and chart markers. Use size.tiny as a value, without parentheses.
TradingView-compatible spelling: size.tiny; runs without warnings.

### alerta.size.small
https://www.alertachart.com/alertascript/reference/builtins/size.small
Signature: size.small → const string
Size preset for text and chart markers. Use size.small as a value, without parentheses.
TradingView-compatible spelling: size.small; runs without warnings.

### alerta.size.normal
https://www.alertachart.com/alertascript/reference/builtins/size.normal
Signature: size.normal → const string
Size preset for text and chart markers. Use size.normal as a value, without parentheses.
TradingView-compatible spelling: size.normal; runs without warnings.

### alerta.size.large
https://www.alertachart.com/alertascript/reference/builtins/size.large
Signature: size.large → const string
Size preset for text and chart markers. Use size.large as a value, without parentheses.
TradingView-compatible spelling: size.large; runs without warnings.

### alerta.size.huge
https://www.alertachart.com/alertascript/reference/builtins/size.huge
Signature: size.huge → const string
Size preset for text and chart markers. Use size.huge as a value, without parentheses.
TradingView-compatible spelling: size.huge; runs without warnings.

### alerta.shape.xcross
https://www.alertachart.com/alertascript/reference/builtins/shape.xcross
Signature: shape.xcross → const string
Marker shape for plotshape(). Use shape.xcross as a value, without parentheses.
TradingView-compatible spelling: shape.xcross; runs without warnings.

### alerta.shape.cross
https://www.alertachart.com/alertascript/reference/builtins/shape.cross
Signature: shape.cross → const string
Marker shape for plotshape(). Use shape.cross as a value, without parentheses.
TradingView-compatible spelling: shape.cross; runs without warnings.

### alerta.shape.triangleup
https://www.alertachart.com/alertascript/reference/builtins/shape.triangleup
Signature: shape.triangleup → const string
Marker shape for plotshape(). Use shape.triangleup as a value, without parentheses.
TradingView-compatible spelling: shape.triangleup; runs without warnings.

### alerta.shape.triangledown
https://www.alertachart.com/alertascript/reference/builtins/shape.triangledown
Signature: shape.triangledown → const string
Marker shape for plotshape(). Use shape.triangledown as a value, without parentheses.
TradingView-compatible spelling: shape.triangledown; runs without warnings.

### alerta.shape.flag
https://www.alertachart.com/alertascript/reference/builtins/shape.flag
Signature: shape.flag → const string
Marker shape for plotshape(). Use shape.flag as a value, without parentheses.
TradingView-compatible spelling: shape.flag; runs without warnings.

### alerta.shape.circle
https://www.alertachart.com/alertascript/reference/builtins/shape.circle
Signature: shape.circle → const string
Marker shape for plotshape(). Use shape.circle as a value, without parentheses.
TradingView-compatible spelling: shape.circle; runs without warnings.

### alerta.shape.arrowup
https://www.alertachart.com/alertascript/reference/builtins/shape.arrowup
Signature: shape.arrowup → const string
Marker shape for plotshape(). Use shape.arrowup as a value, without parentheses.
TradingView-compatible spelling: shape.arrowup; runs without warnings.

### alerta.shape.arrowdown
https://www.alertachart.com/alertascript/reference/builtins/shape.arrowdown
Signature: shape.arrowdown → const string
Marker shape for plotshape(). Use shape.arrowdown as a value, without parentheses.
TradingView-compatible spelling: shape.arrowdown; runs without warnings.

### alerta.shape.labelup
https://www.alertachart.com/alertascript/reference/builtins/shape.labelup
Signature: shape.labelup → const string
Marker shape for plotshape(). Use shape.labelup as a value, without parentheses.
TradingView-compatible spelling: shape.labelup; runs without warnings.

### alerta.shape.labeldown
https://www.alertachart.com/alertascript/reference/builtins/shape.labeldown
Signature: shape.labeldown → const string
Marker shape for plotshape(). Use shape.labeldown as a value, without parentheses.
TradingView-compatible spelling: shape.labeldown; runs without warnings.

### alerta.shape.square
https://www.alertachart.com/alertascript/reference/builtins/shape.square
Signature: shape.square → const string
Marker shape for plotshape(). Use shape.square as a value, without parentheses.
TradingView-compatible spelling: shape.square; runs without warnings.

### alerta.shape.diamond
https://www.alertachart.com/alertascript/reference/builtins/shape.diamond
Signature: shape.diamond → const string
Marker shape for plotshape(). Use shape.diamond as a value, without parentheses.
TradingView-compatible spelling: shape.diamond; runs without warnings.

### alerta.line.style_solid
https://www.alertachart.com/alertascript/reference/builtins/line.style_solid
Signature: line.style_solid → const string
Stroke or arrow style for line objects. Use line.style_solid as a value, without parentheses.
TradingView-compatible spelling: line.style_solid; runs without warnings.

### alerta.line.style_dashed
https://www.alertachart.com/alertascript/reference/builtins/line.style_dashed
Signature: line.style_dashed → const string
Stroke or arrow style for line objects. Use line.style_dashed as a value, without parentheses.
TradingView-compatible spelling: line.style_dashed; runs without warnings.

### alerta.line.style_dotted
https://www.alertachart.com/alertascript/reference/builtins/line.style_dotted
Signature: line.style_dotted → const string
Stroke or arrow style for line objects. Use line.style_dotted as a value, without parentheses.
TradingView-compatible spelling: line.style_dotted; runs without warnings.

### alerta.line.style_arrow_left
https://www.alertachart.com/alertascript/reference/builtins/line.style_arrow_left
Signature: line.style_arrow_left → const string
Stroke or arrow style for line objects. Use line.style_arrow_left as a value, without parentheses.
TradingView-compatible spelling: line.style_arrow_left; runs without warnings.

### alerta.line.style_arrow_right
https://www.alertachart.com/alertascript/reference/builtins/line.style_arrow_right
Signature: line.style_arrow_right → const string
Stroke or arrow style for line objects. Use line.style_arrow_right as a value, without parentheses.
TradingView-compatible spelling: line.style_arrow_right; runs without warnings.

### alerta.line.style_arrow_both
https://www.alertachart.com/alertascript/reference/builtins/line.style_arrow_both
Signature: line.style_arrow_both → const string
Stroke or arrow style for line objects. Use line.style_arrow_both as a value, without parentheses.
TradingView-compatible spelling: line.style_arrow_both; runs without warnings.

### alerta.hline.style_solid
https://www.alertachart.com/alertascript/reference/builtins/hline.style_solid
Signature: hline.style_solid → const string
Stroke pattern for horizontal reference lines. Use hline.style_solid as a value, without parentheses.
TradingView-compatible spelling: hline.style_solid; runs without warnings.

### alerta.hline.style_dashed
https://www.alertachart.com/alertascript/reference/builtins/hline.style_dashed
Signature: hline.style_dashed → const string
Stroke pattern for horizontal reference lines. Use hline.style_dashed as a value, without parentheses.
TradingView-compatible spelling: hline.style_dashed; runs without warnings.

### alerta.hline.style_dotted
https://www.alertachart.com/alertascript/reference/builtins/hline.style_dotted
Signature: hline.style_dotted → const string
Stroke pattern for horizontal reference lines. Use hline.style_dotted as a value, without parentheses.
TradingView-compatible spelling: hline.style_dotted; runs without warnings.

### alerta.position.top_right
https://www.alertachart.com/alertascript/reference/builtins/position.top_right
Signature: position.top_right → const string
Table anchor within the chart pane. Use position.top_right as a value, without parentheses.
TradingView-compatible spelling: position.top_right; runs without warnings.

### alerta.position.top_left
https://www.alertachart.com/alertascript/reference/builtins/position.top_left
Signature: position.top_left → const string
Table anchor within the chart pane. Use position.top_left as a value, without parentheses.
TradingView-compatible spelling: position.top_left; runs without warnings.

### alerta.position.bottom_right
https://www.alertachart.com/alertascript/reference/builtins/position.bottom_right
Signature: position.bottom_right → const string
Table anchor within the chart pane. Use position.bottom_right as a value, without parentheses.
TradingView-compatible spelling: position.bottom_right; runs without warnings.

### alerta.position.bottom_left
https://www.alertachart.com/alertascript/reference/builtins/position.bottom_left
Signature: position.bottom_left → const string
Table anchor within the chart pane. Use position.bottom_left as a value, without parentheses.
TradingView-compatible spelling: position.bottom_left; runs without warnings.

### alerta.position.bottom_center
https://www.alertachart.com/alertascript/reference/builtins/position.bottom_center
Signature: position.bottom_center → const string
Table anchor within the chart pane. Use position.bottom_center as a value, without parentheses.
TradingView-compatible spelling: position.bottom_center; runs without warnings.

### alerta.position.top_center
https://www.alertachart.com/alertascript/reference/builtins/position.top_center
Signature: position.top_center → const string
Table anchor within the chart pane. Use position.top_center as a value, without parentheses.
TradingView-compatible spelling: position.top_center; runs without warnings.

### alerta.position.middle_right
https://www.alertachart.com/alertascript/reference/builtins/position.middle_right
Signature: position.middle_right → const string
Table anchor within the chart pane. Use position.middle_right as a value, without parentheses.
TradingView-compatible spelling: position.middle_right; runs without warnings.

### alerta.position.middle_left
https://www.alertachart.com/alertascript/reference/builtins/position.middle_left
Signature: position.middle_left → const string
Table anchor within the chart pane. Use position.middle_left as a value, without parentheses.
TradingView-compatible spelling: position.middle_left; runs without warnings.

### alerta.position.middle_center
https://www.alertachart.com/alertascript/reference/builtins/position.middle_center
Signature: position.middle_center → const string
Table anchor within the chart pane. Use position.middle_center as a value, without parentheses.
TradingView-compatible spelling: position.middle_center; runs without warnings.

### alerta.order.ascending
https://www.alertachart.com/alertascript/reference/builtins/order.ascending
Signature: order.ascending → const string
Ascending or descending collection sort order. Use order.ascending as a value, without parentheses.
TradingView-compatible spelling: order.ascending; runs without warnings.

### alerta.order.descending
https://www.alertachart.com/alertascript/reference/builtins/order.descending
Signature: order.descending → const string
Ascending or descending collection sort order. Use order.descending as a value, without parentheses.
TradingView-compatible spelling: order.descending; runs without warnings.

### alerta.scale.left
https://www.alertachart.com/alertascript/reference/builtins/scale.left
Signature: scale.left → const string
Price scale placement in the indicator declaration. Use scale.left as a value, without parentheses.
TradingView-compatible spelling: scale.left; runs without warnings.

### alerta.scale.none
https://www.alertachart.com/alertascript/reference/builtins/scale.none
Signature: scale.none → const string
Price scale placement in the indicator declaration. Use scale.none as a value, without parentheses.
TradingView-compatible spelling: scale.none; runs without warnings.

### alerta.scale.right
https://www.alertachart.com/alertascript/reference/builtins/scale.right
Signature: scale.right → const string
Price scale placement in the indicator declaration. Use scale.right as a value, without parentheses.
TradingView-compatible spelling: scale.right; runs without warnings.

### alerta.display.none
https://www.alertachart.com/alertascript/reference/builtins/display.none
Signature: display.none → const string
Visibility location for plot output. Use display.none as a value, without parentheses.
TradingView-compatible spelling: display.none; runs without warnings.

### alerta.display.all
https://www.alertachart.com/alertascript/reference/builtins/display.all
Signature: display.all → const string
Visibility location for plot output. Use display.all as a value, without parentheses.
TradingView-compatible spelling: display.all; runs without warnings.

### alerta.display.pane
https://www.alertachart.com/alertascript/reference/builtins/display.pane
Signature: display.pane → const string
Visibility location for plot output. Use display.pane as a value, without parentheses.
TradingView-compatible spelling: display.pane; runs without warnings.

### alerta.display.price_scale
https://www.alertachart.com/alertascript/reference/builtins/display.price_scale
Signature: display.price_scale → const string
Visibility location for plot output. Use display.price_scale as a value, without parentheses.
TradingView-compatible spelling: display.price_scale; runs without warnings.

### alerta.display.data_window
https://www.alertachart.com/alertascript/reference/builtins/display.data_window
Signature: display.data_window → const string
Visibility location for plot output. Use display.data_window as a value, without parentheses.
TradingView-compatible spelling: display.data_window; runs without warnings.

### alerta.display.status_line
https://www.alertachart.com/alertascript/reference/builtins/display.status_line
Signature: display.status_line → const string
Visibility location for plot output. Use display.status_line as a value, without parentheses.
TradingView-compatible spelling: display.status_line; runs without warnings.

### alerta.extend.none
https://www.alertachart.com/alertascript/reference/builtins/extend.none
Signature: extend.none → const string
Direction in which a drawing extends past its anchors. Use extend.none as a value, without parentheses.
TradingView-compatible spelling: extend.none; runs without warnings.

### alerta.extend.left
https://www.alertachart.com/alertascript/reference/builtins/extend.left
Signature: extend.left → const string
Direction in which a drawing extends past its anchors. Use extend.left as a value, without parentheses.
TradingView-compatible spelling: extend.left; runs without warnings.

### alerta.extend.right
https://www.alertachart.com/alertascript/reference/builtins/extend.right
Signature: extend.right → const string
Direction in which a drawing extends past its anchors. Use extend.right as a value, without parentheses.
TradingView-compatible spelling: extend.right; runs without warnings.

### alerta.extend.both
https://www.alertachart.com/alertascript/reference/builtins/extend.both
Signature: extend.both → const string
Direction in which a drawing extends past its anchors. Use extend.both as a value, without parentheses.
TradingView-compatible spelling: extend.both; runs without warnings.

### alerta.label.style_label_up
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_up
Signature: label.style_label_up → const string
Shape and anchor style for a label object. Use label.style_label_up as a value, without parentheses.
TradingView-compatible spelling: label.style_label_up; runs without warnings.

### alerta.label.style_label_down
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_down
Signature: label.style_label_down → const string
Shape and anchor style for a label object. Use label.style_label_down as a value, without parentheses.
TradingView-compatible spelling: label.style_label_down; runs without warnings.

### alerta.label.style_label_left
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_left
Signature: label.style_label_left → const string
Shape and anchor style for a label object. Use label.style_label_left as a value, without parentheses.
TradingView-compatible spelling: label.style_label_left; runs without warnings.

### alerta.label.style_label_right
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_right
Signature: label.style_label_right → const string
Shape and anchor style for a label object. Use label.style_label_right as a value, without parentheses.
TradingView-compatible spelling: label.style_label_right; runs without warnings.

### alerta.label.style_label_center
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_center
Signature: label.style_label_center → const string
Shape and anchor style for a label object. Use label.style_label_center as a value, without parentheses.
TradingView-compatible spelling: label.style_label_center; runs without warnings.

### alerta.label.style_label_lower_left
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_lower_left
Signature: label.style_label_lower_left → const string
Shape and anchor style for a label object. Use label.style_label_lower_left as a value, without parentheses.
TradingView-compatible spelling: label.style_label_lower_left; runs without warnings.

### alerta.label.style_label_lower_right
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_lower_right
Signature: label.style_label_lower_right → const string
Shape and anchor style for a label object. Use label.style_label_lower_right as a value, without parentheses.
TradingView-compatible spelling: label.style_label_lower_right; runs without warnings.

### alerta.label.style_label_upper_left
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_upper_left
Signature: label.style_label_upper_left → const string
Shape and anchor style for a label object. Use label.style_label_upper_left as a value, without parentheses.
TradingView-compatible spelling: label.style_label_upper_left; runs without warnings.

### alerta.label.style_label_upper_right
https://www.alertachart.com/alertascript/reference/builtins/label.style_label_upper_right
Signature: label.style_label_upper_right → const string
Shape and anchor style for a label object. Use label.style_label_upper_right as a value, without parentheses.
TradingView-compatible spelling: label.style_label_upper_right; runs without warnings.

### alerta.label.style_triangleup
https://www.alertachart.com/alertascript/reference/builtins/label.style_triangleup
Signature: label.style_triangleup → const string
Shape and anchor style for a label object. Use label.style_triangleup as a value, without parentheses.
TradingView-compatible spelling: label.style_triangleup; runs without warnings.

### alerta.label.style_triangledown
https://www.alertachart.com/alertascript/reference/builtins/label.style_triangledown
Signature: label.style_triangledown → const string
Shape and anchor style for a label object. Use label.style_triangledown as a value, without parentheses.
TradingView-compatible spelling: label.style_triangledown; runs without warnings.

### alerta.label.style_xcross
https://www.alertachart.com/alertascript/reference/builtins/label.style_xcross
Signature: label.style_xcross → const string
Shape and anchor style for a label object. Use label.style_xcross as a value, without parentheses.
TradingView-compatible spelling: label.style_xcross; runs without warnings.

### alerta.label.style_cross
https://www.alertachart.com/alertascript/reference/builtins/label.style_cross
Signature: label.style_cross → const string
Shape and anchor style for a label object. Use label.style_cross as a value, without parentheses.
TradingView-compatible spelling: label.style_cross; runs without warnings.

### alerta.label.style_flag
https://www.alertachart.com/alertascript/reference/builtins/label.style_flag
Signature: label.style_flag → const string
Shape and anchor style for a label object. Use label.style_flag as a value, without parentheses.
TradingView-compatible spelling: label.style_flag; runs without warnings.

### alerta.label.style_circle
https://www.alertachart.com/alertascript/reference/builtins/label.style_circle
Signature: label.style_circle → const string
Shape and anchor style for a label object. Use label.style_circle as a value, without parentheses.
TradingView-compatible spelling: label.style_circle; runs without warnings.

### alerta.label.style_arrowup
https://www.alertachart.com/alertascript/reference/builtins/label.style_arrowup
Signature: label.style_arrowup → const string
Shape and anchor style for a label object. Use label.style_arrowup as a value, without parentheses.
TradingView-compatible spelling: label.style_arrowup; runs without warnings.

### alerta.label.style_arrowdown
https://www.alertachart.com/alertascript/reference/builtins/label.style_arrowdown
Signature: label.style_arrowdown → const string
Shape and anchor style for a label object. Use label.style_arrowdown as a value, without parentheses.
TradingView-compatible spelling: label.style_arrowdown; runs without warnings.

### alerta.label.style_square
https://www.alertachart.com/alertascript/reference/builtins/label.style_square
Signature: label.style_square → const string
Shape and anchor style for a label object. Use label.style_square as a value, without parentheses.
TradingView-compatible spelling: label.style_square; runs without warnings.

### alerta.label.style_diamond
https://www.alertachart.com/alertascript/reference/builtins/label.style_diamond
Signature: label.style_diamond → const string
Shape and anchor style for a label object. Use label.style_diamond as a value, without parentheses.
TradingView-compatible spelling: label.style_diamond; runs without warnings.

### alerta.label.style_text_outline
https://www.alertachart.com/alertascript/reference/builtins/label.style_text_outline
Signature: label.style_text_outline → const string
Shape and anchor style for a label object. Use label.style_text_outline as a value, without parentheses.
TradingView-compatible spelling: label.style_text_outline; runs without warnings.

### alerta.label.style_none
https://www.alertachart.com/alertascript/reference/builtins/label.style_none
Signature: label.style_none → const string
Shape and anchor style for a label object. Use label.style_none as a value, without parentheses.
TradingView-compatible spelling: label.style_none; runs without warnings.

### alerta.alert.freq_once_per_bar
https://www.alertachart.com/alertascript/reference/builtins/alert.freq_once_per_bar
Signature: alert.freq_once_per_bar → const string
Alert delivery frequency while the script is running. Use alert.freq_once_per_bar as a value, without parentheses.
TradingView-compatible spelling: alert.freq_once_per_bar; runs without warnings.

### alerta.alert.freq_once_per_bar_close
https://www.alertachart.com/alertascript/reference/builtins/alert.freq_once_per_bar_close
Signature: alert.freq_once_per_bar_close → const string
Alert delivery frequency while the script is running. Use alert.freq_once_per_bar_close as a value, without parentheses.
TradingView-compatible spelling: alert.freq_once_per_bar_close; runs without warnings.

### alerta.alert.freq_all
https://www.alertachart.com/alertascript/reference/builtins/alert.freq_all
Signature: alert.freq_all → const string
Alert delivery frequency while the script is running. Use alert.freq_all as a value, without parentheses.
TradingView-compatible spelling: alert.freq_all; runs without warnings.