# 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.

### How it works
AlertaScript brings your analysis rules onto the AlertaChart chart. Read price and volume series, calculate indicators, draw levels and test trading ideas in a single scripting environment.

### Put it into practice
Start with a small indicator and inspect its output on historical and live bars. The reference documents exact signatures, accepted spellings and data requirements; guides connect those building blocks into usable workflows.

### Continue reading
- [Getting started](https://www.alertachart.com/alertascript/getting-started): Your path from an empty editor to a useful script.

### How it works
Build one observable result first: a moving average, an oscillator or a named alert condition. Each tutorial introduces a separate workflow so you can understand the output before combining features.

### Put it into practice
Open Alerta Script from the chart, create a draft and run the quick-start example. Then choose the indicator, strategy or alert tutorial. Save the script before experimenting with additional rules.

### Continue reading
- [Quick start](https://www.alertachart.com/alertascript/getting-started/quick-start): Plot a configurable EMA in five lines.

### How it works
The indicator declaration sets the title and chart placement. input.int exposes a length setting; close supplies the price series; alerta.ta.ema calculates the moving average. plot turns the calculated series into a visible line.

### Put it into practice
Run the example, change Length from 20 to 50 and compare the line with price. Early bars may lack enough history for a calculation. Keep the script small while checking that the chart symbol and timeframe match your intended analysis.

### Working example
```
indicator("My first EMA", overlay=true)
length = input.int(20, "Length", minval=1)
average = alerta.ta.ema(close, length)
plot(average, "EMA", color=color.blue, linewidth=2)
plot(close, "Close", color=color.new(color.gray, 80))
```
- [Editor tour](https://www.alertachart.com/alertascript/getting-started/editor-tour): Write, run, save and inspect your script.

### How it works
The editor brings code, templates and execution feedback together. The Documentation button opens the documentation website in a separate tab. Contextual help on a function provides its reference link without replacing the code you are editing.

### Put it into practice
Read the exact line and message when execution fails. If an existing draft is being edited, opening a documentation example preserves it and offers a separate tab. Examples are not run or saved automatically; inspect the code before doing either.
- [Your first indicator](https://www.alertachart.com/alertascript/getting-started/first-indicator): Create an RSI with editable inputs and reference levels.

### How it works
An indicator calculates values without simulating orders. overlay=false places the RSI in its own pane; input.int exposes the lookback; hline adds stable comparison levels at 70 and 30.

### Put it into practice
Run the example on two timeframes and inspect the same historical segment. Inputs change the calculation, while colors and line styles change its presentation. Keep plot titles descriptive because they also help identify values and alert placeholders.

### Working example
```
indicator("My RSI", overlay=false)
length = input.int(14, "Length", minval=1)
rsi = alerta.ta.rsi(close, length)
plot(rsi, "RSI", color=color.blue)
hline(70, "Upper")
hline(30, "Lower")
```
- [Your first strategy](https://www.alertachart.com/alertascript/getting-started/first-strategy): Turn an EMA crossover into a testable trading rule.

### How it works
A strategy declaration enables simulated order logic. The example opens a long position when the fast EMA crosses above the slow EMA and closes the matching entry when the cross reverses. Entry IDs connect related order actions.

### Put it into practice
Inspect trades and performance in the Strategy Tester. A plotted signal is not necessarily the fill price: order timing and the available bar data matter. Check position size, fees and the test interval before interpreting results; a strategy script does not by itself send live exchange orders.

### Working example
EMA(10) crossing above EMA(30) enters Long; crossing below closes Long. This compares two averages, not price against an average. The code has no explicit barstate.isconfirmed guard. Evaluation and simulated fills depend on strategy execution settings; the script neither creates a notification subscription nor sends live orders.
```
strategy("EMA cross", overlay=true)
fast = ta.ema(close, 10)
slow = ta.ema(close, 30)
if ta.crossover(fast, slow)
    strategy.entry("Long", strategy.long)
if ta.crossunder(fast, slow)
    strategy.close("Long")
plot(fast, "Fast")
plot(slow, "Slow")
```

### Continue reading
- [Your first alert](https://www.alertachart.com/alertascript/getting-started/first-alert): Expose a named condition in the alert workflow.

### How it works
alertcondition registers a title, a boolean series and a message. The example names an upward EMA cross so the condition can be identified in the alert interface. The ticker placeholder is resolved when the event is produced.

### Put it into practice
Run the script, create the corresponding alert and verify its condition and notification settings. An intrabar cross can disappear before the candle closes. Decide whether you want live-bar behavior or a confirmed-close signal; script execution alone is not a promise of unattended server monitoring.

### Working example
Here close crosses above EMA(20): the preceding close was at or below its EMA and the current price is above it. This is price versus one EMA, not two EMA lines. There is no barstate.isconfirmed guard, so the live-bar condition may change. Running the script only registers the condition; create an alert and choose its frequency and notification channels separately.
```
indicator("EMA cross alert", overlay=true)
average = ta.ema(close, 20)
signal = ta.crossover(close, average)
plot(average, "EMA")
alertcondition(signal, "Close above EMA", "{{ticker}} crossed above EMA")
```

### Continue reading
- [Language guide](https://www.alertachart.com/alertascript/language): Understand the building blocks behind chart scripts.

### How it works
AlertaScript combines familiar Pine-compatible expressions with chart series, collections and drawing objects. Learn how values evolve across bars before moving into reusable functions, arrays or multi-timeframe requests.

### Put it into practice
Read syntax and series first. Then follow the sections for the data structures your script actually uses. A numeric series, an array and a drawing ID are different kinds of values, even when all three are stored in variables.

### Continue reading
- [Syntax and types](https://www.alertachart.com/alertascript/language/syntax-and-types): Declare values, pass arguments and keep types explicit.

### How it works
Use = for a declaration and := when reassigning an existing variable in Pine-style code. int, float, bool, string and color describe different values. Named arguments make optional settings easier to read.

### Put it into practice
Give ambiguous values an explicit type, especially when initializing with na. Match each argument to the function signature rather than relying on automatic conversion. Use typed inputs such as input.int or input.bool so settings express the intended value type.

### Working example
```
indicator("Typed inputs", overlay=true)
int length = input.int(20, "Length", minval=1)
float source = close
bool rising = close > open
plot(ta.ema(source, length), "EMA", color=rising ? color.green : color.red)
```
- [Series and history](https://www.alertachart.com/alertascript/language/series-and-history): Read the current bar and earlier values safely.

### How it works
close is the current price series; close[1] reads the preceding bar. The bracket is a history offset, not an array position. The first loaded bar has no previous value, so history-dependent expressions can produce na. Inside a function, x[1] of a parameter or a local variable is its value at the function's previous call, so a function called only on some bars looks back to its previous call, not to the previous bar.

### Put it into practice
Check na before dividing, comparing or drawing from unavailable history. A longer lookback needs sufficient loaded bars. Avoid replacing missing prices with zero just to force a visible result: that changes the meaning of averages, returns and signals.

### Working example
```
indicator("Bar change", overlay=false)
previous = close[1]
change = na(previous) ? na : close - previous
plot(change, "Change", style=plot.style_histogram)
```
- [Control flow](https://www.alertachart.com/alertascript/language/control-flow): Express conditions and bounded repetition.

### How it works
if selects a branch, a ternary expression selects a value, and loops repeat a block. Conditions are evaluated in the current bar context. Compute reusable time-series indicators consistently, then use conditions to decide what to display or trade.

### Put it into practice
Keep loops bounded and stop when the intended result is found. For small choices, a ternary expression is often clearer than a loop. Be especially careful with loops that grow a collection on every bar; their cost increases with chart history.

### Working example
```
indicator("Bar direction", overlay=false)
direction = close > open ? 1 : close < open ? -1 : 0
plot(direction, "Direction", style=plot.style_histogram)
```
- [Functions](https://www.alertachart.com/alertascript/language/functions): Extract a calculation without hiding its inputs.

### How it works
A user function names a repeatable calculation and returns its final expression. Pass required series and parameters explicitly so callers can see what influences the result. Typed parameters make custom helpers easier to inspect. Arguments can be named at the call site, as in f(close, length = 50); they are evaluated in the order written. Methods with the same name can be declared for several types: the type of the receiver picks the method. A function can be declared more than once with a different number or type of parameters; each call runs the declaration its arguments match. A function cannot call itself, and it cannot change a variable declared outside it with :=; both are errors that say what to write instead.

### Put it into practice
The range example divides the candle range by its price basis and handles a zero basis. Test helpers with missing values and boundary inputs before using them in a strategy. Distinguish your own function names from documented built-ins and aliases.

### Working example
```
indicator("Relative range", overlay=false)
relativeRange(float hi, float lo, float basis) =>
    basis == 0 ? na : (hi - lo) / basis * 100
plot(relativeRange(high, low, close), "Range %")
```
- [User-defined types and methods](https://www.alertachart.com/alertascript/language/user-defined-types-and-methods): Group related values and attach meaningful operations.

### How it works
A type declaration describes fields; its constructor creates an instance. A method uses a typed first parameter as its receiver. The example groups a high and low price, then exposes their width as a method.

### Put it into practice
Use types for coherent records such as a price zone or trade state. chart.point is a built-in type, not a price-series variable. Keep user-defined field and method names separate from global built-ins when reading errors or searching the reference.

### Working example
```
indicator("Price range", overlay=false)
type PriceRange
    float hi
    float lo
method width(PriceRange this) =>
    this.hi - this.lo
range = PriceRange.new(high, low)
plot(range.width(), "Range")
```
- [Arrays](https://www.alertachart.com/alertascript/language/arrays): Manage an ordered collection with explicit bounds.

### How it works
Arrays store multiple values inside one object. array.get and array.set use zero-based indices; close[1] instead accesses bar history. A var array can persist between bars, so additions accumulate unless you remove old values.

### Put it into practice
The example keeps only the most recent 20 samples by shifting the oldest after each push. Check array.size before indexing or removing an element. Choose a maximum length deliberately; an ever-growing array is rarely necessary for a rolling calculation. An index past the end stops the script with an error. In a //@version=6 script a negative index counts from the end, so array.get(a, -1) is the last element. array.slice returns a view: writing an element of the slice changes the original array.

### Working example
```
indicator("Array average", overlay=true)
var samples = array.new<float>(0)
array.push(samples, close)
if array.size(samples) > 20
    array.shift(samples)
plot(array.avg(samples), "Average")
```

### Continue reading
- [Maps](https://www.alertachart.com/alertascript/language/maps): Look up values by named keys.

### How it works
A map stores key-value pairs and is useful when position is less meaningful than identity. map.put creates or replaces a value under a key; map.get retrieves it. Key and value types are specified when the map is constructed.

### Put it into practice
Choose stable keys such as level names and check map.contains when absence is possible. Reusing a key replaces its value rather than appending a second item. Use an array when ordering and numeric positions are the primary requirement.

### Working example
```
indicator("Named levels", overlay=true)
levels = map.new<string, float>()
map.put(levels, "high", high)
map.put(levels, "low", low)
plot(map.get(levels, "high"), "High")
```
- [Matrices](https://www.alertachart.com/alertascript/language/matrices): Represent and access rectangular numeric data.

### How it works
Matrices organize values by row and column. matrix.new sets the dimensions and initial value; matrix.set updates a cell; matrix.get reads it. Both coordinates are zero-based.

### Put it into practice
Check dimensions before indexing and ensure compatible sizes before combining matrices. Keep the example small while verifying row and column orientation. A matrix represents a structured collection, not automatically a window of historical bars.

### Working example
```
indicator("Matrix example", overlay=false)
values = matrix.new<float>(2, 2, 0.0)
matrix.set(values, 0, 0, close)
matrix.set(values, 1, 1, open)
plot(matrix.get(values, 0, 0) - matrix.get(values, 1, 1), "Body")
```
- [Strings](https://www.alertachart.com/alertascript/language/strings): Format clear labels and messages.

### How it works
Strings carry titles, symbols and human-readable text. Concatenate strings with + and format numeric values with str.tostring. format.mintick follows the symbol price precision and avoids arbitrary decimal counts. str.tonumber reads only plain decimals such as 1234.5 or -12; text such as 1,234 or 1e3 gives na. An na string joined with + counts as empty text. Without a format, str.tostring writes a number with at most ten decimals and no exponent, so 0.1 + 0.2 gives 0.3, and na is written as NaN. str.format reads Pine's placeholders, such as {0}, {0,number,#.##} and {0,number,percent}.

### Put it into practice
Use a stable plot title and concise alert text. Creating a new label on every update can accumulate objects; retain and update an existing label for a lasting dashboard. String formatting changes presentation, not the underlying numeric calculation.

### Working example
```
indicator("Price label", overlay=true)
if barstate.islast
    label.new(bar_index, high, syminfo.ticker + " " + str.tostring(close, format.mintick))
```
- [Colors](https://www.alertachart.com/alertascript/language/colors): Separate a visual rule from its calculation.

### How it works
A color can be selected by a condition and passed to plots, candles or backgrounds. color.new adds transparency: 0 is opaque and 100 is fully transparent. The example colors bullish and bearish bars independently of any trading order. The transparency replaces the color's own: color.new(c, 0) is opaque even when c was translucent. It can also change from bar to bar.

### Put it into practice
Use translucent backgrounds so candles remain readable. Check both light and dark themes, and use titles or shapes as well as color to convey meaning. Changing a plot color should not alter the signal calculation.

### Working example
```
indicator("Candle colors", overlay=true)
tint = close >= open ? color.teal : color.red
barcolor(tint)
bgcolor(color.new(tint, 94))
```
- [Time and sessions](https://www.alertachart.com/alertascript/language/time-and-sessions): Interpret bar time in the correct market context.

### How it works
time exposes bar timestamps; time() can filter bars by timeframe, session and timezone. A session expression such as 0930-1600:23456 defines weekdays and hours in the supplied timezone. Outside that session the result is na.

### Put it into practice
Prefer named zones such as America/New_York when daylight saving changes matter. Exchange sessions do not always start at midnight, and extended-hours bars depend on the data feed. Separate a chart display timezone from the session timezone used by your rule.

### Working example
```
indicator("Session", overlay=true)
inSession = not na(time(timeframe.period, "0930-1600:23456", "America/New_York"))
bgcolor(inSession ? color.new(color.blue, 92) : na)
```
- [Execution model](https://www.alertachart.com/alertascript/language/execution-model): Know what can change before the bar closes.

### How it works
Scripts calculate against chart bars and update as current data changes. Historical bars have completed OHLCV values; a live bar is still forming. var preserves initialized state across bars, while history references read earlier series values.

### Put it into practice
Use barstate.isconfirmed when a rule explicitly requires a completed candle. Test both historical results and live updates. After a symbol, timeframe or input change, a script may recalculate over the available dataset; do not treat in-memory state as permanent storage.

### Working example
```
indicator("Confirmed close", overlay=true)
value = barstate.isconfirmed ? close : na
plot(value, "Confirmed close", style=plot.style_circles)
```
- [Guides](https://www.alertachart.com/alertascript/guides): Connect language features into practical workflows.

### How it works
These guides combine calculations with chart output, simulated trades, external contexts and alerts. Start from the result you want to inspect and keep data availability separate from the rule that processes it.

### Put it into practice
Use the drawing guide for overlays, the strategy guide for order simulation and the multi-timeframe guide for request contexts. For an existing Pine script, read the migration guide before changing working names or syntax.

### Continue reading
- [Drawings and visuals](https://www.alertachart.com/alertascript/guides/drawing-and-visuals): Choose between series plots and positioned objects.

### How it works
plot follows a series across bars; line, label, box and table create objects with their own lifetimes and coordinates. A line can use bar indices or timestamps depending on xloc. These coordinate systems are not interchangeable.

### Put it into practice
The example deletes its previous last-bar line before creating a replacement. For persistent objects, keep an ID and use set methods when appropriate. Limit object creation and verify extension, scale and pane placement instead of creating an object on every update.

### Working example
```
indicator("Last-bar range", overlay=true)
var line rangeLine = na
if barstate.islast
    line.delete(rangeLine)
    rangeLine := line.new(bar_index, low, bar_index, high, color=color.blue, width=2)
```
- [Strategies and backtesting](https://www.alertachart.com/alertascript/guides/strategies-and-backtesting): Interpret simulated orders and exits correctly.

### How it works
strategy.entry opens simulated entries; strategy.close closes an entry ID; strategy.exit attaches exit rules. In strategy.exit, profit and loss are distances in ticks, while limit and stop are absolute prices. They are not interchangeable percentages. Within a bar, orders fill in the order the price reaches them: market orders at the open, then resting orders along the path open, nearer extreme, farther extreme, close. Orders are kept by id: two entries of other ids on one bar both fill (within pyramiding), a resting limit or stop waits beside later orders, and an OCA group answers when one of its orders fills.

### Put it into practice
Verify tick size, quantity, fees and fill assumptions before comparing strategies. Separate the signal bar from the simulated fill, and inspect individual trades as well as aggregate performance. Historical results depend on the supplied data and do not guarantee future outcomes. A new alert created on a strategy fires on every order fill by default.

### Working example
```
strategy("EMA with exit", overlay=true)
average = ta.ema(close, 20)
if ta.crossover(close, average)
    strategy.entry("Long", strategy.long)
strategy.exit("Exit", "Long", profit=100, loss=50)
plot(average, "EMA")
```
- [Multiple symbols and timeframes](https://www.alertachart.com/alertascript/guides/multi-symbol-and-timeframe): Evaluate an expression in another data context.

### How it works
request.security evaluates its expression for the requested symbol and timeframe, then aligns the result to the chart. A higher-timeframe EMA is calculated from higher-timeframe bars; requesting close and averaging it afterward is a different calculation. The symbol and timeframe can come from inputs, variables or a loop, and a request can sit inside an if block or a function. The expression may also return a string, a color, an array or a user-defined type.

### Put it into practice
Use lookahead_off for a baseline without future-bar alignment. An unconfirmed higher-timeframe candle can still change. Check gaps, market sessions and symbol availability; a syntactically valid request does not establish that every exchange or asset has the same historical coverage.

### Working example
```
indicator("Hourly EMA", overlay=true)
hourly = request.security(syminfo.tickerid, "60", ta.ema(close, 20), lookahead=barmerge.lookahead_off)
plot(hourly, "Hourly EMA", color=color.blue)
```

### Continue reading
- [Order flow data](https://www.alertachart.com/alertascript/guides/order-flow-data): Use available trade-level information deliberately.

### How it works
request.footprint returns a footprint object when the chart has the required order-flow data. The object exposes bar delta, volume rows and profile information. A missing footprint is na, not a zero-volume bar.

### Put it into practice
Guard access with na checks, as in the delta example. request.security also reads order-flow series by ticker: BINANCE:BTCUSDT.P_OI, .P_FUNDING, .P_CVD, BINANCE:BTCUSDT_CVD, .P_NETLONG, .P_NETSHORT, .P_LIQ_LONG, .P_LIQ_SHORT — open interest and net positions in coins, funding as a decimal rate per 8 h, cumulative delta in coins (spot without .P), liquidations as USD notional. Name a venue (BINANCE, BYBIT, OKX, COINBASE, HYPERLIQUID) or sum them all with AGG:BTC.P_…; coverage differs by venue, and a series a venue lacks is na. These tickers come with the Pro and Elite plans; on other plans they return na with a warning.

### Working example
```
indicator("Bar delta", overlay=false)
footprint fp = request.footprint(10)
delta = na(fp) ? na : fp.delta()
plot(delta, "Bar delta", style=plot.style_histogram)
```

### Continue reading
- [Alerts](https://www.alertachart.com/alertascript/guides/alerts): Separate the signal, its timing and its message.

### How it works
alertcondition exposes a named condition; alert emits an event from the executing code path. alert.freq_once_per_bar_close delays dispatch until the candle closes, while other frequency modes permit different live-bar behavior.

### Put it into practice
Use readable titles and supported placeholders such as {{ticker}}. Check the configured alert in the interface and test a reachable condition. Runtime events and notification delivery are distinct; verify monitoring and delivery settings rather than assuming a script runs continuously after its chart is closed.

### Working example
This example uses the same price-above-EMA(20) crossover, with alert.freq_once_per_bar_close. The condition must be true at the closing update; an earlier intrabar cross that reverses is insufficient. Create an alert for the script’s alert() events and configure notifications separately.
```
indicator("Bar-close alert", overlay=true)
average = ta.ema(close, 20)
if ta.crossover(close, average)
    alert("{{ticker}} crossed above EMA", alert.freq_once_per_bar_close)
plot(average, "EMA")
```
- [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.

### How it works
AlertaScript supports a broad Pine-compatible surface, including namespaced calls, collections, types and strategies. Supported names such as ta.ema and alerta.ta.ema resolve to the same calculation. Existing compatible spelling can run without a naming warning.
The documentation writes AlertaScript functions with the alerta. prefix so you can tell them apart, but nothing has to be renamed: code written with ta.*, math.*, str.* or strategy.* can be pasted as it is. The editor does not rewrite what you paste; it runs exactly the code you see.

### Put it into practice
Start by running the original script and inspect actual diagnostics. Search by the original name or its AlertaScript spelling before replacing anything. Data-feed availability, live-bar behavior and simulation assumptions still require checking; an accepted function name alone does not prove every external dataset exists.

### Run the original script first
Open Alerta Script from the Indicators menu of the chart, paste the script without changes and press Run. Problems are reported with their line and message. A Run that ends without an error also saves the script under My scripts; warnings do not block it.
- An error stops the run. Read its line, then search this documentation by the original function name or by its alerta. spelling before you change code.
- A warning lets the script run and explains a value it could not supply, for example a request that returns na.
- An empty chart is not always an error: bars without enough history, na results, an oscillator in its own pane or a request for data the chart does not have all leave a plot empty.

### One calculation, two spellings
Both lines come from the same 20-period EMA and lie on top of each other. Keep whichever spelling your code already uses.
```
indicator("EMA spellings", overlay=true)
original = ta.ema(close, 20)
prefixed = alerta.ta.ema(close, 20)
plot(original, "TradingView-compatible")
plot(prefixed, "AlertaScript", color=color.blue)
```

### Migration checklist
Go through these parts of every script you move. Most need no change; the point is to know which values depend on data rather than on syntax.
Part of the script | What to check
Declaration | indicator(...) or strategy(...), the title and overlay. overlay=false puts the output in its own pane.
Inputs | Defaults and the minimum and maximum of input.int, input.float, input.timeframe and the others. They become the settings behind the gear of the script on the chart.
Calculations | Each ta.*, math.* or array.* function you call has a reference page. Search by the name you know.
Other symbols and timeframes | Every request.security call: the symbol must exist on AlertaChart and have history for the period you look at.
Fundamental data | request.financial, request.earnings, request.dividends and request.splits return na (next section).
Alerts | alertcondition titles and messages, and whether a condition has to wait for the candle to close.
Strategy settings | Initial capital, order size, commission and pyramiding in strategy(...). The Strategy tester settings can change them later without editing the code.
Drawings | line, label, box and table objects. Execution and drawing resources are bounded, so delete objects you no longer need instead of creating new ones on every bar.

### What returns na or is not supported
These limits come from the data AlertaChart has, not from the language. A script that relies on them still runs, but the values involved stay empty, so judge a migration by its output and not only by the absence of errors.
Call | In AlertaScript
request.financial, request.earnings, request.dividends, request.splits | Return na because there is no fundamentals feed. The editor shows a warning unless the call passes ignore_invalid_symbol = true.
request.seed, request.quandl | Not supported. They return na with a warning.
request.security on ticker.renko, ticker.kagi, ticker.linebreak or ticker.pointfigure | Returns na with a warning: these bars are not built. ticker.heikinashi works; its bars are built from the symbol's own bars.
syminfo.current_contract | Not supported. It does not give a contract code.
Footprint and open-interest data (request.footprint, tickers such as BINANCE:BTCUSDT.P_OI) | Pro and Elite plans, on supported markets and timeframes. On other plans they return na with a warning (see the order flow guide below).
Historical depth | Depends on the chart and its data source, so a long lookback can start later than on another platform.

### Example: EMA crossover strategy
A complete strategy with three inputs. It opens a long position when the 9-period EMA crosses above the 21-period EMA, closes it on the opposite cross and keeps a protective stop 2 % below the average entry price. It is a rule to study, not a recommendation.
Before you run it:
- strategy(...) sets what the Strategy tester starts from: 10,000 initial capital, 10 % of equity per order and 0.1 % commission.
- stop= in strategy.exit is an absolute price, so the example turns the percentage input into a price. profit= and loss= would be distances in ticks.
- In the simulation, an order placed on the signal bar fills at the open of the next bar, so the marked signal and the fill price are different prices.
- Read the trades in the Strategy tester under the chart. A strategy script does not send orders to an exchange.
```
//@version=5
strategy("EMA crossover strategy", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
fastLength = input.int(9, "Fast EMA length", minval=1)
slowLength = input.int(21, "Slow EMA length", minval=2)
stopPercent = input.float(2.0, "Stop loss (%)", minval=0.1, step=0.1)

fast = ta.ema(close, fastLength)
slow = ta.ema(close, slowLength)
crossUp = ta.crossover(fast, slow)
crossDown = ta.crossunder(fast, slow)

if crossUp
    strategy.entry("Long", strategy.long)
if crossDown
    strategy.close("Long", comment="EMA cross down")
// A protective stop: an absolute price, recalculated from the average entry price.
if strategy.position_size > 0
    strategy.exit("Stop", "Long", stop=strategy.position_avg_price * (1 - stopPercent / 100))

plot(fast, "Fast EMA", color=color.teal)
plot(slow, "Slow EMA", color=color.orange)
plotshape(crossUp, title="Cross up", style=shape.triangleup, location=location.belowbar, color=color.teal, size=size.tiny)
```

### Example: RSI divergence with alert conditions
An indicator in its own pane. It compares RSI pivots with price: a lower price low on a higher RSI low is marked as bullish, a higher price high on a lower RSI high as bearish. Two named alert conditions make each case selectable when you create an alert.
Before you run it:
- A pivot needs pivotBars bars on its right. With the default of 5, a divergence is confirmed five bars after the pivot; offset draws the mark back on the pivot bar, which is where history shows it.
- Running the script only defines the conditions. Alerts on a script come with the Pro and Elite plans: open Create Alert, choose Script as the source and this script, pick the condition by its title under Script alerts and check the notification settings. {{ticker}} is replaced by the symbol when the alert fires.
- A divergence describes momentum; it does not say when or whether price turns.
```
//@version=5
indicator("RSI divergence finder", overlay=false)
rsiLength = input.int(14, "RSI length", minval=2)
pivotBars = input.int(5, "Bars on each side of a pivot", minval=1)

rsi = ta.rsi(close, rsiLength)
// A pivot is only known pivotBars bars after it formed.
rsiLow = ta.pivotlow(rsi, pivotBars, pivotBars)
rsiHigh = ta.pivothigh(rsi, pivotBars, pivotBars)
newLow = not na(rsiLow)
newHigh = not na(rsiHigh)

// RSI and price at the previous pivot of the same kind.
lastRsiLow = ta.valuewhen(newLow, rsi[pivotBars], 1)
lastPriceLow = ta.valuewhen(newLow, low[pivotBars], 1)
lastRsiHigh = ta.valuewhen(newHigh, rsi[pivotBars], 1)
lastPriceHigh = ta.valuewhen(newHigh, high[pivotBars], 1)

// Price makes a lower low while RSI makes a higher low (bullish), or the reverse at highs (bearish).
bullish = newLow and low[pivotBars] < lastPriceLow and rsi[pivotBars] > lastRsiLow
bearish = newHigh and high[pivotBars] > lastPriceHigh and rsi[pivotBars] < lastRsiHigh

plot(rsi, "RSI", color=color.purple)
hline(70, "Upper level")
hline(30, "Lower level")
plot(bullish ? rsi[pivotBars] : na, "Bullish divergence", color=color.green, style=plot.style_circles, linewidth=4, offset=-pivotBars)
plot(bearish ? rsi[pivotBars] : na, "Bearish divergence", color=color.red, style=plot.style_circles, linewidth=4, offset=-pivotBars)
alertcondition(bullish, "Bullish RSI divergence", "{{ticker}}: bullish RSI divergence confirmed")
alertcondition(bearish, "Bearish RSI divergence", "{{ticker}}: bearish RSI divergence confirmed")
```

### Example: higher-timeframe trend filter
request.security evaluates the whole expression on the requested timeframe, here a 50-period EMA of 4-hour bars, and aligns the result with the chart. One call returns both values as a tuple.
Before you run it:
- Requesting close and averaging it on the chart would be a different calculation from an EMA computed on 4-hour bars.
- lookahead=barmerge.lookahead_off is the baseline without future bars. While the current 4-hour candle is open, its values can still change.
- input.timeframe lets you pick another higher timeframe from the settings without editing the code.
```
//@version=5
indicator("Higher-timeframe trend filter", overlay=true)
higherTf = input.timeframe("240", "Higher timeframe")
emaLength = input.int(50, "EMA length on the higher timeframe", minval=1)

// One request returns both values, each calculated on the higher timeframe's own bars.
[htfEma, htfClose] = request.security(syminfo.tickerid, higherTf, [ta.ema(close, emaLength), close], lookahead=barmerge.lookahead_off)
uptrend = htfClose > htfEma

plot(htfEma, "Higher-timeframe EMA", color=uptrend ? color.teal : color.red, linewidth=2)
bgcolor(uptrend ? color.new(color.teal, 92) : color.new(color.red, 92), title="Trend background")
```

### Differences to expect
Identical code can still show different numbers on two platforms. These are the usual reasons:
- Live and closed bars: scripts recalculate while the current candle forms. Use barstate.isconfirmed when a rule must wait for the close.
- Alerts: alert.freq_once_per_bar_close waits for the close. Running a script is not, by itself, unattended monitoring on a server.
- Strategy fills: within a bar, market orders fill at the open and resting orders along the path open, nearer extreme, farther extreme, close. Match quantity, commission and the test range before comparing reports.
- Data: compare the same symbol, exchange and timeframe. The same pair on two exchanges is two different series.
- Resources: execution and drawing are bounded. The limits page does not publish fixed numbers, so keep loops and object counts bounded instead of relying on one.

### Continue reading
- [Quick reference](https://www.alertachart.com/alertascript/reference): Find signatures, constants, variables and examples.

### How it works
The reference separates callable functions from variables, types and constant families. Each function page describes arguments, return values, accepted spellings and an example. Search accepts both AlertaScript-prefixed and compatible original names.

### Put it into practice
Use parameter names and types to resolve call errors. A variable is read directly; a function is called with parentheses; a constant selects a documented mode. Reference descriptions may remain in English while navigation and guides follow your chosen language.

### Continue reading
- [Frequently asked questions](https://www.alertachart.com/alertascript/faq): Answers to common script authoring questions.

### How it works
A blank output is not always an execution failure: early history, na results, pane placement or unavailable requested data can explain it. A strategy simulates orders, while an indicator only calculates and draws unless you add an alert workflow.

### Put it into practice
Use troubleshooting for a reproducible error and limitations for data and runtime boundaries. Before reporting a mismatch, compare the same symbol, exchange, timeframe and settings. Include the smallest script that still demonstrates the behavior.

### Continue reading
- [Limits and availability](https://www.alertachart.com/alertascript/faq/limitations): Know the boundaries that affect a script result.

### How it works
Execution and drawing resources are bounded, and historical depth depends on the chart and data source. Footprint and open-interest data are available only for supported contexts and with the Pro and Elite plans. request.financial, request.earnings, request.dividends and request.splits return na because there is no fundamentals feed, with a warning unless the call passes ignore_invalid_symbol = true; request.seed and request.quandl are not supported and return na too. In request.security, Renko, Kagi, Line Break and Point & Figure tickers return na with a warning; Heikin-Ashi tickers are built from the symbol's own bars.

### Put it into practice
Check each reference entry for its actual behavior. syminfo.current_contract is not supported. Avoid inventing numeric limits that are not documented; reduce unbounded loops and object growth, handle unavailable values and verify the dataset before blaming the calculation.
- [Troubleshooting](https://www.alertachart.com/alertascript/faq/troubleshooting): Reduce an error to a small, inspectable case.

### How it works
Start with the reported line and exact message. Check spelling, argument order, types and missing history. If the script runs but draws nothing, inspect na results, overlay placement, transparency and the requested symbol or timeframe.

### Put it into practice
Keep a copy, remove unrelated logic and reproduce with the same settings. Use the editor Feedback flow to send the failing code and diagnostics when you choose to submit them. Never include API keys, passwords or other secrets in a support example.

### Working example
```
indicator("Safe change", overlay=false)
previous = close[1]
change = na(previous) or previous == 0 ? na : (close / previous - 1) * 100
plot(change, "Change %")
```
- [Write with AI](https://www.alertachart.com/alertascript/ai-writing): Ask for a script that can be checked, not just generated.

### How it works
Give the assistant your market, timeframe, inputs, exact entry or alert rule and expected output. Point it to the AlertaScript reference and ask it to use documented functions and supported datasets. A precise rule is easier to verify than a request for a profitable indicator.

### Put it into practice
Ask for one complete script plus a short explanation of bar-close behavior, na handling and any request.security calls. Run it, inspect the output and test boundary cases before adding complexity. Keep original compatible names when supported; do not mechanically rename every call.

### Continue reading

## 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.
- condition: series bool; required: true; default: not specified. Condition to evaluate.
Returns: series int
```
indicator("Bars Since Example")
// Search latest cross condition
const isCross = ta.crossover(close, ta.sma(close, 20))
const barsPassed = ta.barssince(isCross)
plot(barsPassed, { title: "Bars Since Cross", color: "#F59E0B" })
```
Aliases: ta.barssince

### 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.
- source: series; required: true; default: not specified. Series of values to process.
Returns: series float
```
indicator("Cumulative Volume", overlay=false)
// Track running total of volume across all bars
const totalVol = ta.cum(volume)
plot(totalVol, { title: "Total Volume", color: "#3B82F6", style: "area" })
```
Aliases: ta.cum

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(sma(close, 20))
```
Aliases: ta.sma

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(ema(close, 20))
```
Aliases: ta.ema

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(wma(close, 15))
```
Aliases: ta.wma

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(vwma(close, 20))
```
Aliases: ta.vwma

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
const rmaLine = rma(close, 14)
```
Aliases: ta.rma

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- fast: int; required: true; default: not specified. Fast EMA length.
- slow: int; required: true; default: not specified. Slow EMA length.
- signal: int; required: not specified; default: 9. Signal line length.
Returns: [macdLine, signalLine, histogram]
```
indicator("MACD Pro", overlay=false)
[macdLine, signalLine, hist] = macd(close, 12, 26, 9)
plot(macdLine, { title: "MACD Line", color: color.blue, pane: "oscillator" })
plot(signalLine, { title: "Signal Line", color: color.orange, pane: "oscillator" })
plot(hist, { title: "Histogram", style: "histogram", pane: "oscillator" })
```
Aliases: ta.macd

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
indicator("RSI Pro", overlay=false)
r = rsi(close, 14)
plot(r, { title: "RSI", color: color.purple, pane: "oscillator" })
h1 = hline(70, { title: "Overbought", color: color.red, style: "dashed", pane: "oscillator" })
h2 = hline(30, { title: "Oversold", color: color.green, style: "dashed", pane: "oscillator" })
fill(h1, h2, { color: "rgba(168, 85, 247, 0.05)", pane: "oscillator" })
```
Aliases: ta.rsi

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(roc(close, 9), { pane: "oscillator" })
```
Aliases: ta.roc

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(mom(close, 10), { pane: "oscillator" })
```
Aliases: ta.mom

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- roc1: int; required: false; default: not specified. ROC period 1 (default 10).
- roc2: int; required: false; default: not specified. ROC period 2 (default 15).
- roc3: int; required: false; default: not specified. ROC period 3 (default 20).
- roc4: int; required: false; default: not specified. ROC period 4 (default 30).
- sma1: int; required: false; default: not specified. Smoothing for ROC1 (default 10).
- sma2: int; required: false; default: not specified. Smoothing for ROC2 (default 10).
- sma3: int; required: false; default: not specified. Smoothing for ROC3 (default 10).
- sma4: int; required: false; default: not specified. Smoothing for ROC4 (default 15).
Returns: series float
```
plot(kst(close, 10, 15, 20, 30, 10, 10, 10, 15), { pane: "oscillator" })
```
Aliases: ta.kst

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length1: int; required: false; default: 100. Length of the first simple average of the signal line.
- length2: int; required: false; default: 100. Length of the second simple average of the signal line.
Returns: [specialK, signal]
```
[sk, signal] = ta.specialK(close, 100, 100)
plot(sk, { title: "Special K", pane: "oscillator" })
plot(signal, { title: "Signal", pane: "oscillator" })
```
Special K = Σ w·SMA(ROC(n), m) over (n, m, w) = (10,10,1) (15,10,2) (20,10,3) (30,15,4) (40,50,1) (65,65,2) (75,75,3) (100,100,4) (195,130,1) (265,130,2) (390,130,3) (530,195,4), ROC in percent; signal = SMA(SMA(Special K, length1), length2). Source: Martin J. Pring, "Technical Analysis Explained", 5th ed.
Reached through a `TradingView/ta` import alias too (`TVta.specialK`).
Aliases: ta.specialK

### 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.
- handle_na: series bool; required: false; default: not specified. If true, returns high - low when the previous close is na (avoids na in the first bars). Defaults to false. (Pine v6 form: ta.tr(handle_na))
- low: series; required: false; default: not specified. Low series — legacy 3-arg form only.
- close: series; required: false; default: not specified. Close series — legacy 3-arg form only.
Returns: series float
```
plot(ta.tr(true), { pane: "oscillator" })
plot(tr(high, low, close), { pane: "oscillator" })
```
Aliases: ta.tr

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(cmo(close, 14), { pane: "oscillator" })
```
Aliases: ta.cmo

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: false; default: not specified. Stoch RSI length (default 14).
- rsiLength: int; required: false; default: not specified. RSI length (default 14).
- k: int; required: false; default: not specified. K smoothing (default 3).
- d: int; required: false; default: not specified. D smoothing (default 3).
Returns: [k, d]
```
[k, d] = stochrsi(close, 14, 14, 3, 3)
plot(k, { title: "StochRSI K", color: color.blue, pane: "oscillator" })
plot(d, { title: "StochRSI D", color: color.orange, pane: "oscillator" })
```
Aliases: ta.stochrsi

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- longLength: int; required: false; default: not specified. ta.tsi: short_length, the second smoothing (default 13). Legacy tsi(): the long smoothing length (default 25).
- shortLength: int; required: false; default: not specified. ta.tsi: long_length, the first smoothing (default 25). Legacy tsi(): the short smoothing length (default 13).
Returns: series float
```
plot(ta.tsi(close, 13, 25), { pane: "oscillator" })
plot(tsi(close, 25, 13), { pane: "oscillator" })
```
Aliases: ta.tsi

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- fastLength: int; required: false; default: not specified. Fast EMA length (default 12).
- slowLength: int; required: false; default: not specified. Slow EMA length (default 26).
- signalLength: int; required: false; default: not specified. Signal EMA length (default 9).
Returns: [pvoLine, signal, hist]
```
[pvoLine, signal, hist] = pvo(volume, 12, 26, 9)
plot(pvoLine, { title: "PVO", color: color.blue, pane: "oscillator" })
plot(signal, { title: "Signal", color: color.orange, pane: "oscillator" })
plot(hist, { title: "Histogram", style: "histogram", pane: "oscillator" })
```
Aliases: ta.pvo

### 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.
- open: series; required: true; default: not specified. Open series.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- length: int; required: false; default: not specified. Length (default 10).
Returns: [rviLine, signal]
```
[rviLine, signal] = rvi(open, high, low, close, 10)
plot(rviLine, { title: "RVI", color: color.blue, pane: "oscillator" })
plot(signal, { title: "Signal", color: color.orange, pane: "oscillator" })
```
Aliases: ta.rvi

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: false; default: not specified. Length (default 10).
Returns: series float
```
plot(fisher(close, 10), { pane: "oscillator" })
```
Aliases: ta.fisher

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: false; default: not specified. Length (default 9).
Returns: series float
```
plot(cfo(close, 9), { pane: "oscillator" })
```
Aliases: ta.cfo

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- fastLength: int; required: false; default: not specified. Fast EMA length (default 23).
- slowLength: int; required: false; default: not specified. Slow EMA length (default 50).
- cycleLength: int; required: false; default: not specified. Cycle length (default 10).
Returns: series float
```
plot(stc(close, 23, 50, 10), { pane: "oscillator" })
```
Aliases: ta.stc

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- length: int; required: false; default: not specified. Length (default 14).
Returns: series float
```
plot(adxr(high, low, close, 14), { pane: "oscillator" })
```
Aliases: ta.adxr

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- length: int; required: false; default: not specified. Length (default 14).
Returns: series float
```
plot(atrp(high, low, close, 14), { pane: "oscillator" })
```
Aliases: ta.atrp

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- volume: series; required: true; default: not specified. Volume series.
- fastLength: int; required: false; default: not specified. Fast EMA length (default 3).
- slowLength: int; required: false; default: not specified. Slow EMA length (default 10).
Returns: series float
```
plot(chaikin(high, low, close, volume, 3, 10), { pane: "oscillator" })
```
Aliases: ta.chaikin

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- emaLength: int; required: false; default: not specified. EMA smoothing length (default 10).
- rocLength: int; required: false; default: not specified. Rate-of-change length (default 10).
Returns: series float
```
plot(cvi(high, low, 10, 10), { pane: "oscillator" })
```
Aliases: ta.cvi

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- volume: series; required: true; default: not specified. Volume series.
- fastLength: int; required: false; default: not specified. Fast EMA length (default 3).
- slowLength: int; required: false; default: not specified. Slow EMA length (default 10).
Returns: series float
```
plot(adosc(high, low, close, volume, 3, 10), { pane: "oscillator" })
```
Aliases: ta.adosc

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- length: int; required: false; default: not specified. Length (default 14).
Returns: [vip, vin]
```
[vip, vin] = vi(high, low, close, 14)
plot(vip, { title: "VI+", color: color.green, pane: "oscillator" })
plot(vin, { title: "VI-", color: color.red, pane: "oscillator" })
```
Aliases: ta.vi, ta.vortex

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: false; default: not specified. Number of bars (length, default 18).
Returns: series float
```
plot(trix(close, 18), { pane: "oscillator" })
```
Aliases: ta.trix

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- length: int; required: false; default: not specified. Number of bars (length, default 14).
Returns: series float
```
plot(williamsr(high, low, close, 14), { pane: "oscillator" })
```
Aliases: ta.willr, ta.williamsr

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- length1: int; required: false; default: not specified. Short length (default 7).
- length2: int; required: false; default: not specified. Medium length (default 14).
- length3: int; required: false; default: not specified. Long length (default 28).
Returns: series float
```
plot(ultosc(high, low, close, 7, 14, 28), { pane: "oscillator" })
```
Aliases: ta.ultosc

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(natr(high, low, close, 14), { pane: "oscillator" })
```
Aliases: ta.natr

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- close: series; required: true; default: not specified. Close series.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(adx(high, low, close, 14))
```
Aliases: ta.adx

### 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.
- diLength: int; required: true; default: not specified. DI smoothing length. This is Pine's own form — ta.dmi(diLength, adxSmoothing) reads the chart's own H/L/C.
- adxSmoothing: int; required: not specified; default: not specified. ADX smoothing length. Defaults to diLength.
- close: series; required: not specified; default: not specified. Legacy 4-argument form only: close series.
- length: int; required: not specified; default: not specified. Legacy 4-argument form only: length.
Returns: { plus, minus, adx }
```
indicator("DMI", overlay=false)
[diPlus, diMinus, adxValue] = ta.dmi(14, 14)
plot(diPlus, { title: "+DI", pane: "oscillator" })
plot(diMinus, { title: "-DI", pane: "oscillator" })
plot(adxValue, { title: "ADX", pane: "oscillator" })
```
Aliases: ta.dmi

### 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.
- high: series; required: true; default: not specified. High series.
- low: series; required: true; default: not specified. Low series.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: { up, down }
```
indicator("Aroon", overlay=false)
[up, down] = ta.aroon(high, low, 14)
plot(up, "Aroon up")
plot(down, "Aroon down")
```
Aliases: ta.aroon

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(hma(close, 55))
```
Aliases: ta.hma

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
- offset: float; required: false; default: not specified. Offset (default 0.85).
- sigma: float; required: false; default: not specified. Sigma (default 6).
- floor: bool; required: false; default: not specified. Pine v6: floor the offset position offset * (length - 1) before the weights are computed (default false).
Returns: series float
```
plot(alma(close, 9, 0.85, 6))
```
Aliases: ta.alma

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(dema(close, 21))
```
Aliases: ta.dema

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(tema(close, 21))
```
Aliases: ta.tema

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(trima(close, 10))
```
Aliases: ta.trima

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
- fast: int; required: false; default: not specified. Fast period (default 2).
- slow: int; required: false; default: not specified. Slow period (default 30).
Returns: series float
```
plot(kama(close, 10, 2, 30))
```
Aliases: ta.kama

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
- offset: int; required: false; default: not specified. Regression offset (default 0).
Returns: series float
```
plot(linreg(close, 14, 0))
```
Aliases: ta.linreg

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
- vfactor: float; required: false; default: not specified. Volume factor (default 0.7).
Returns: series float
```
plot(t3(close, 5, 0.7))
```
Aliases: ta.t3

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(zlema(close, 10))
```
Aliases: ta.zlema

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(smma(close, 10))
```
Aliases: ta.smma

### 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.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
plot(atr(14), { pane: "oscillator" })
```
Aliases: ta.atr

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars.
- mult: float; required: true; default: not specified. Standard deviation multiplier.
Returns: [middle, upper, lower]
```
[basis, upper, lower] = ta.bb(close, 20, 2.0)
plot(basis, "Basis")
plot(upper, "Upper")
plot(lower, "Lower")
```
Aliases: ta.bbands, ta.bb

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
- biased: bool; required: false; default: not specified. Pine v6 estimator switch. When true (default) uses the biased / population formula (divides by N); when false uses the unbiased / sample formula (divides by N-1).
Returns: series float
```
plot(stdev(close, 20), { pane: "oscillator" })
plot(stdev(close, 20, true), { pane: "oscillator" })
```
Aliases: ta.stdev

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
const hh = highest(high, 20)
```
Aliases: ta.highest

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series int
```
const hh_off = highestbars(high, 20)
```
Returns offset, not absolute bar_index. For absolute index use highestindex().
Aliases: ta.highestbars

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series float
```
const ll = lowest(low, 20)
```
Aliases: ta.lowest

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series int
```
const ll_off = lowestbars(low, 20)
```
Returns offset, not absolute bar_index. For absolute index use lowestindex().
Aliases: ta.lowestbars

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series int
```
const h_idx = highestindex(high, 20)
```
AlertaScript returns absolute bar_index, whereas Pine ta.highestbars returns offset.

### 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.
- source: series; required: true; default: not specified. Series of values to process.
- length: int; required: true; default: not specified. Number of bars (length).
Returns: series int
```
const l_idx = lowestindex(low, 20)
```
AlertaScript returns absolute bar_index, whereas Pine ta.lowestbars returns offset.

### 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.
- a: series; required: true; default: not specified. First series.
- b: series; required: true; default: not specified. Second series.
Returns: series bool
```
const buy = crossover(sma(close, 10), sma(close, 20))
```
Aliases: ta.crossover

### 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.
- a: series; required: true; default: not specified. First series.
- b: series; required: true; default: not specified. Second series.
Returns: series bool
```
const sell = crossunder(sma(close, 10), sma(close, 20))
```
Aliases: ta.crossunder

### 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.
- a: series; required: true; default: not specified. First series.
- b: series; required: true; default: not specified. Second series.
Returns: series bool
```
lineA = sma(close, 10)
lineB = sma(close, 20)
crossed = ta.cross(lineA, lineB)
plot(crossed ? 1 : 0, { title: "Cross Any", pane: "oscillator" })
```
Aliases: ta.cross

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback window.
Returns: series bool
```
isRising = ta.rising(close, 5)
plot(isRising ? 1 : 0, { title: "Rising", pane: "oscillator" })
```
Aliases: ta.rising

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback window.
Returns: series bool
```
isFalling = ta.falling(close, 5)
plot(isFalling ? 1 : 0, { title: "Falling", pane: "oscillator" })
```
Aliases: ta.falling

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback window.
Returns: series float
```
r = ta.range(close, 20)
plot(r, { title: "Range" })
```
Aliases: ta.range

### 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.
- source: series; required: true; default: not specified. Source series.
Returns: series float
```
sw = ta.swma(close)
plot(sw, { title: "SWMA", color: "#60A5FA" })
```
Aliases: ta.swma

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback window.
Returns: series float
```
mad = ta.dev(close, 20)
plot(mad, { title: "MAD", pane: "oscillator" })
```
Aliases: ta.dev

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback window.
- biased: bool; required: false; default: true. Population variance when true; sample variance when false.
Returns: series float
```
vPop = ta.variance(close, 20, true)
vSample = ta.variance(close, 20, false)
plot(vPop, { title: "Variance Pop", pane: "oscillator" })
plot(vSample, { title: "Variance Sample", pane: "oscillator" })
```
Aliases: ta.variance

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback window.
Returns: series float
```
pr = ta.percentrank(close, 50)
plot(pr, { title: "PercentRank", pane: "oscillator" })
```
Aliases: ta.percentrank

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback window.
- percentage: float; required: true; default: not specified. Percentile level between 0 and 100.
Returns: series float
```
p75 = ta.percentile_nearest_rank(close, 20, 75)
plot(p75, { title: "P75 NR", pane: "oscillator" })
```
Aliases: ta.percentile_nearest_rank

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback window.
- percentage: float; required: true; default: not specified. Percentile level between 0 and 100.
Returns: series float
```
p75 = ta.percentile_linear_interpolation(close, 20, 75)
plot(p75, { title: "P75 LI", pane: "oscillator" })
```
Aliases: ta.percentile_linear_interpolation

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback length.
- mult: float; required: false; default: 1.5. Band multiplier.
- useTrueRange: bool; required: false; default: true. Uses true range when true, high-low range when false.
Returns: [basis, upper, lower]
```
[basis, upper, lower] = ta.kc(close, 20, 1.5, true)
plot(basis, { title: "KC Basis" })
plot(upper, { title: "KC Upper" })
plot(lower, { title: "KC Lower" })
```
Aliases: ta.kc

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback length.
- mult: float; required: false; default: 1.5. Band multiplier.
- useTrueRange: bool; required: false; default: true. Uses true range when true.
Returns: series float
```
w = ta.kcw(close, 20, 1.5, true)
plot(w, { title: "KC Width", pane: "oscillator" })
```
Aliases: ta.kcw

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback length.
- mult: float; required: false; default: 2.0. Band multiplier.
Returns: series float
```
w = ta.bbw(close, 20, 2.0)
plot(w, { title: "BBW", pane: "oscillator" })
```
Aliases: ta.bbw

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback length.
Returns: series float
```
c = ta.cog(close, 10)
plot(c, { title: "COG", pane: "oscillator" })
```
Aliases: ta.cog

### 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.
- sourceA: series; required: true; default: not specified. First source series.
- sourceB: series; required: true; default: not specified. Second source series.
- length: int; required: true; default: not specified. Lookback length.
Returns: series float
```
corr = ta.correlation(close, volume, 20)
plot(corr, { title: "Correlation", pane: "oscillator" })
```
Aliases: ta.correlation

### 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.
Returns: series float
```
//@version=6
indicator("ATH", overlay=true)
plot(ta.max, title="All-time high", color=color.green)
```
Aliases: ta.max, alerta.ta.max
Alternate form: ta.max(source)
Returns running all-time maximum of source.
Returns: series float
- source: series. Source series.
```
mx = ta.max(close)
plot(mx, { title: "All-time Max" })
```

### 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.
Returns: series float
```
//@version=6
indicator("ATL", overlay=true)
plot(ta.min, title="All-time low", color=color.red)
```
Aliases: ta.min, alerta.ta.min
Alternate form: ta.min(source)
Returns running all-time minimum of source.
Returns: series float
- source: series. Source series.
```
mn = ta.min(close)
plot(mn, { title: "All-time Min" })
```

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback length.
Returns: series float
```
m = ta.median(close, 21)
plot(m, { title: "Median" })
```
Aliases: ta.median

### 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.
- source: series; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Lookback length.
Returns: series float
```
m = ta.mode(close, 21)
plot(m, { title: "Mode" })
```
Aliases: ta.mode

### 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.
- message: string; required: true; default: not specified. Alert message text — {{placeholder}} tokens are substituted at fire time.
- freq: string; required: false; default: alert.freq_once_per_bar. alert.freq_once_per_bar | alert.freq_once_per_bar_close | alert.freq_all.
Returns: void
```
if crossover(close, sma(close, 20))
  alert("Bullish crossover", alert.freq_once_per_bar_close)
```

### 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.
- condition: series bool; required: true; default: not specified. Condition that enables alert.
- title: string; required: false; default: not specified. Display title for alert.
- message: string; required: false; default: not specified. Alert message text.
Returns: void
```
indicator("Bearish price crossover", overlay=true)
ma = ta.sma(close, 20)
signal = ta.crossunder(close, ma)
plot(ma, "SMA 20")
plotshape(signal, title="Price crossed below SMA", style=shape.triangledown, location=location.abovebar)
alertcondition(signal, "Bearish", "Price crossed below SMA 20")
```

### 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.
- defval: series; required: true; default: not specified. Default source (e.g. close).
- title: string; required: false; default: not specified. Input title.
Returns: series float
```
src = input.source(close, "Source")
plot(ema(src, 20))
```

### 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.
- defval: string; required: true; default: not specified. Default timeframe (e.g. "60", "D").
- title: string; required: false; default: not specified. Input title.
Returns: string
```
tf = input.timeframe("60", "HTF")
plot(close, { title: "Selected TF Input" })
```

### 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.
- defval: string; required: true; default: not specified. Default symbol (e.g. BINANCE:BTCUSDT).
- title: string; required: false; default: not specified. Input title.
Returns: string
```
sym = input.symbol("SELF", "Symbol")
plot(close, { title: "Selected Symbol Input" })
```

### 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.
- defval: int; required: true; default: not specified. Default timestamp.
- title: string; required: false; default: not specified. Input title.
Returns: int
```
t0 = input.time(1704067200000, "Start")
cond = time >= t0
```

### 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.
- defval: string; required: true; default: not specified. Default session string.
- title: string; required: false; default: not specified. Input title.
Returns: string
```
sess = input.session("0900-1700", "Session")
```

### 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.
- defval: int; required: true; default: not specified. Default integer value.
- title: string; required: false; default: not specified. Input title.
- options: object; required: false; default: not specified. Optional constraints { min, max, step }.
Returns: int
```
len = input.int(14, "Length", minval = 1, maxval = 200)
plot(len, { pane: "oscillator" })
```

### 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.
- defval: float; required: true; default: not specified. Default float value.
- title: string; required: false; default: not specified. Input title.
- options: object; required: false; default: not specified. Optional constraints { min, max, step }.
Returns: float
```
mult = input.float(2.5, "Multiplier", minval = 0.1, step = 0.1)
plot(mult, { pane: "oscillator" })
```

### 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.
- defval: bool; required: true; default: not specified. Default boolean value.
- title: string; required: false; default: not specified. Input title.
Returns: bool
```
show = input.bool(true, "Show Line")
plot(show ? close : na)
```

### 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.
- defval: string; required: true; default: not specified. Default string value.
- title: string; required: false; default: not specified. Input title.
Returns: string
```
tag = input.string("BTC", "Tag")
if barstate.islast
  label.new(bar_index, high, tag)
```

### 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.
- defval: color; required: true; default: not specified. Default color.
- title: string; required: false; default: not specified. Input title.
Returns: color
```
lineColor = input.color(color.green, "Line Color")
plot(close, { color: lineColor })
```

### 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.
- defval: float; required: true; default: not specified. Default price value.
- title: string; required: false; default: not specified. Input title.
- options: object; required: false; default: not specified. Optional constraints { min, max, step }.
Returns: float
```
lvl = input.price(100.0, "Level")
plot(lvl)
```

### 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.
- defval: string; required: true; default: not specified. Default multiline text.
- title: string; required: false; default: not specified. Input title.
Returns: string
```
notes = input.text_area("line1\nline2", "Notes")
if barstate.islast
  label.new(bar_index, high, notes)
```

### 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.
- defval: enum member; required: true; default: not specified. Default selected enum member (e.g. Side.Long).
- title: string; required: false; default: not specified. Input title.
- options: array<enum member>; required: false; default: not specified. Restrict the dropdown to a subset of members. Omitted = every member of the enum.
Returns: enum member
```
enum Side
    Long = "Buy side"
    Short = "Sell side"
side = input.enum(Side.Long, "Direction")
plot(side == Side.Long ? 1 : -1, { pane: "oscillator" })
```

### 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.
- timeframe: simple string; required: false; default: not specified. Optional resolution to evaluate the time at (Pine v6 overload).
- session: simple string; required: false; default: not specified. Session spec, e.g. "0930-1100" or "2200-0200:23456". When present, the function returns na outside the session window.
- timezone: simple string; required: false; default: not specified. IANA name ("America/New_York"), "UTC", or "GMT±N". Defaults to UTC.
- bars_back: series int; required: false; default: not specified. Read the chart bar N back (a negative N reads the bar N ahead; past the last loaded bar the chart's timeframe steps on). Applied before the session mask; used to detect session edges.
- timeframe_bars_back: series int; required: false; default: not specified. Read the `timeframe` bar N back from the one holding the chart bar (negative: ahead). Not combined with a session.
Returns: series int
```
plot(time, { pane: "oscillator" })
plot(time(timeframe.period), { pane: "oscillator" })
plot(time("D", timeframe_bars_back = 1), { title: "previous day open", pane: "oscillator" })
```

### 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.
- timeframe: simple string; required: false; default: not specified. Optional resolution to evaluate the close time at.
- session: simple string; required: false; default: not specified. Session spec, e.g. "0930-1600". When present, returns na outside the session window.
- timezone: simple string; required: false; default: not specified. IANA name, "UTC", or "GMT±N". Defaults to UTC.
- bars_back: series int; required: false; default: not specified. The close of the chart bar N back (a negative N reads the bar N ahead; past the last loaded bar the chart's timeframe steps on).
- timeframe_bars_back: series int; required: false; default: not specified. The close of the `timeframe` bar N back from the one holding the chart bar (negative: ahead). Not combined with a session.
Returns: series int
```
plot(time_close(), { pane: "oscillator" })
plot(nz(time_close("D"), time), { title: "session close", pane: "oscillator" })
```

### 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.
- year: int or string; required: true; default: not specified. Year — or, in the other two forms, an IANA timezone followed by the date components, or a whole date string on its own.
- month: int; required: false; default: not specified. Month 1..12. Omitted in the date-string form.
- day: int; required: false; default: not specified. Day of month. Omitted in the date-string form.
- hour: int; required: false; default: not specified. Hour.
- minute: int; required: false; default: not specified. Minute.
- second: int; required: false; default: not specified. Second.
Returns: int
```
t = timestamp(2026, 4, 10, 12, 0, 0)
fromText = timestamp("2026-04-10 12:00")
plot(t == fromText ? 1 : 0, { title: "same instant", pane: "oscillator" })
```

### 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.
- source: series int; required: false; default: not specified. Timestamp source. Defaults to time.
- timezone: simple string; required: false; default: not specified. IANA timezone, "UTC", or "GMT±N".
Returns: series int
```
plot(hour(), { pane: "oscillator" })
```

### 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.
- source: series int; required: false; default: not specified. Timestamp source. Defaults to time.
- timezone: simple string; required: false; default: not specified. IANA timezone, "UTC", or "GMT±N".
Returns: series int
```
plot(minute(), { pane: "oscillator" })
```

### 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.
- source: series int; required: false; default: not specified. Timestamp source. Defaults to time.
- timezone: simple string; required: false; default: not specified. IANA timezone, "UTC", or "GMT±N".
Returns: series int
```
plot(second(), { pane: "oscillator" })
```

### 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.
- source: series int; required: false; default: not specified. Timestamp source. Defaults to time.
- timezone: simple string; required: false; default: not specified. IANA timezone, "UTC", or "GMT±N".
Returns: series int
```
plot(dayofmonth(), { pane: "oscillator" })
```

### 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.
- source: series int; required: false; default: not specified. Timestamp source. Defaults to time.
- timezone: simple string; required: false; default: not specified. IANA timezone, "UTC", or "GMT±N". Defaults to chart exchange / UTC.
Returns: series int
```
plot(dayofweek(), { pane: "oscillator" })
```

### 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.
- source: series int; required: false; default: not specified. Timestamp source. Defaults to time.
- timezone: simple string; required: false; default: not specified. IANA timezone, "UTC", or "GMT±N". Defaults to chart exchange / UTC.
Returns: series int
```
plot(weekofyear(), { pane: "oscillator" })
```

### 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.
- source: series int; required: false; default: not specified. Timestamp source. Defaults to time.
- timezone: simple string; required: false; default: not specified. IANA timezone, "UTC", or "GMT±N".
Returns: series int
```
plot(month(), { pane: "oscillator" })
```

### 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.
- source: series int; required: false; default: not specified. Timestamp source. Defaults to time.
- timezone: simple string; required: false; default: not specified. IANA timezone, "UTC", or "GMT±N".
Returns: series int
```
plot(year(), { pane: "oscillator" })
```

### 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.
- timeframe: string; required: false; default: not specified. Timeframe string. Defaults to chart timeframe.
Returns: int
```
secs = timeframe.in_seconds("60")
plot(secs, { pane: "oscillator" })
```

### 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.
- seconds: int; required: true; default: not specified. Duration in seconds.
Returns: string
```
tf = timeframe.from_seconds(3600)
if barstate.islast
  label.new(bar_index, high, tf)
```

### 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.
Returns: series bool
```
plotshape(barstate.isfirst, { style: "circle" })
```

### 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.
Returns: series bool
```
plotshape(barstate.islast, { style: "circle" })
```

### 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.
Returns: series bool
```
plotshape(barstate.ishistory, { style: "circle" })
```

### 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.
Returns: series bool
```
plotshape(barstate.isrealtime, { style: "circle" })
```
Only realtime updates can produce the marker; historical bars are false.

### 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.
Returns: series bool
```
plotshape(barstate.isnew, { style: "triangleup", color: "#22C55E" })
```

### 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.
Returns: series bool
```
plotshape(barstate.isconfirmed, { style: "circle" })
```

### 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.
Returns: string
```
id = syminfo.tickerid
```

### 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.
Returns: string
```
tk = syminfo.ticker
```

### 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.
Returns: string
```
ex = syminfo.prefix
```

### 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.
Returns: float
```
mt = syminfo.mintick
```

### 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.
Returns: string
```
p = timeframe.period
```

### 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.
Returns: bool
```
x = timeframe.isintraday
```

### 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.
Returns: bool
```
x = timeframe.isdaily
```

### 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.
Returns: bool
```
x = timeframe.isweekly
```

### 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.
Returns: bool
```
x = timeframe.ismonthly
```

### 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.
- source: series; required: true; default: not specified. Series of values.
- length: int; required: not specified; default: 1. Number of bars back.
Returns: series float
```
const priceChange = change(close)
```
Aliases: ta.change

### 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.
- source: series float; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Window length.
Returns: series float
```
v = sum(close, 14)
plot(v, { pane: "oscillator" })
```
Aliases: math.sum
Alternate form: sum(source, length)
Sum of source for length bars.
Returns: series float
- source: series. Series of values to process.
- length: int. Number of bars.
```
const volSum = sum(volume, 20)
```

### 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.
- condition: series bool; required: true; default: not specified. Condition to evaluate.
- source: series; required: true; default: not specified. Source series.
- occurrence: int; required: not specified; default: 0. 0 for most recent, 1 for previous, etc.
Returns: series any
```
ph = pivothigh(high, 5, 5)
lastHigh = valuewhen(ph !== null, high, 0)
plot(lastHigh)
```
Until the condition has been true `occurrence + 1` times the result is `na`. Used as a price level for a box or line, keep `na` rather than replacing it with 0: a level of 0 stretches the drawing down to zero.
Aliases: ta.valuewhen

### 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.
- source: series; required: true; default: not specified. Input series.
- leftLen: int; required: true; default: not specified. Bars to the left.
- rightLen: int; required: true; default: not specified. Bars to the right.
Returns: series float
```
const ph = pivothigh(high, 10, 10)
if (ph) { plotShape(ph, { style: "label_down" }) }
```
Aliases: ta.pivothigh

### 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.
- source: series; required: true; default: not specified. Input series.
- leftLen: int; required: true; default: not specified. Bars to the left.
- rightLen: int; required: true; default: not specified. Bars to the right.
Returns: series float
```
const pl = pivotlow(low, 10, 10)
```
Aliases: ta.pivotlow

### 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.
- start: float; required: true; default: not specified. Start value.
- inc: float; required: true; default: not specified. Increment.
- max: float; required: true; default: not specified. Maximum value.
Returns: series float
```
plot(sar(0.02, 0.02, 0.2), { style: "cross" })
```
Aliases: ta.sar

### 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.
- factor: float; required: false; default: not specified. ATR multiplier (default 3).
- atrLength: int; required: false; default: not specified. ATR length (default 10).
- high: series; required: false; default: not specified. High series (default chart high).
- low: series; required: false; default: not specified. Low series (default chart low).
- close: series; required: false; default: not specified. Close series (default chart close).
Returns: { supertrend, direction }
```
const [st, dir] = supertrend(3, 10)
plot(st)
plotshape(crossover(dir, 0), { style: "triangleup", color: color.green })
```
Aliases: ta.supertrend

### 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.
- source: series float; required: true; default: not specified. Price source (e.g. close, hlc3).
- anchor: series bool; required: not specified; default: not specified. Reset condition. Default is `timeframe.change("1D")`.
- stdev_mult: simple float; required: not specified; default: not specified. When present, the function returns ±N·stdev bands as a tuple.
Returns: series float | tuple
```
// Daily-anchored VWAP with ±1σ bands.
[v, u, l] = ta.vwap(close, timeframe.change("D"), 1.0)
plot(v)
plot(u)
plot(l)
```
Aliases: ta.vwap

### 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.
- close: series float; required: true; default: not specified. Close price series.
- high: series float; required: true; default: not specified. High price series.
- low: series float; required: true; default: not specified. Low price series.
- length: int; required: true; default: not specified. Length.
- k_smooth: int; required: not specified; default: 3. Smooth K.
- d_smooth: int; required: not specified; default: 3. Smooth D.
Returns: [k, d]
```
[k, d] = stoch(close, high, low, 14)
plot(k, { title: "K", color: color.blue, pane: "oscillator" })
plot(d, { title: "D", color: color.orange, pane: "oscillator" })
```
Aliases: ta.stoch

### 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.
- source: series float; required: true; default: not specified. Source price series.
- length: int; required: true; default: not specified. Length.
Returns: series float
```
plot(cci(close, 20), { pane: "oscillator" })
```
Aliases: ta.cci

### 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.
- close: series float; required: true; default: not specified. Close price series.
- volume: series float; required: true; default: not specified. Volume series.
Returns: series float
```
plot(obv(close, volume), { pane: "oscillator" })
```
Aliases: ta.obv

### 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.
- high: series float; required: true; default: not specified. High price.
- low: series float; required: true; default: not specified. Low price.
- close: series float; required: true; default: not specified. Close price.
- volume: series float; required: true; default: not specified. Volume.
- length: int; required: true; default: not specified. Length.
Returns: series float
```
plot(mfi(high, low, close, volume, 14), { pane: "oscillator" })
```
Aliases: ta.mfi

### 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.
- close: series float; required: true; default: not specified. Close.
- high: series float; required: true; default: not specified. High.
- low: series float; required: true; default: not specified. Low.
- length: int; required: true; default: not specified. n length.
- m1: int; required: true; default: not specified. m1 smooth.
- m2: int; required: true; default: not specified. m2 smooth.
Returns: [k, d, j]
```
[k, d, j] = kdj(close, high, low, 9, 3, 3)
plot(k, { title: "K", color: color.blue, pane: "oscillator" })
plot(d, { title: "D", color: color.orange, pane: "oscillator" })
plot(j, { title: "J", color: color.purple, pane: "oscillator" })
```
Aliases: ta.kdj

### 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.
- length: int; required: true; default: not specified. Lookback period in bars.
Returns: { upper: series float, lower: series float, basis: series float }
```
indicator("Donchian Channel", overlay=true)
const dc = ta.dc(20)
plot(dc.upper, { title: "DC Upper", color: "#3B82F6" })
plot(dc.basis, { title: "DC Midline", color: "#9CA3AF" })
plot(dc.lower, { title: "DC Lower", color: "#EF4444" })
fill(plot(dc.upper, { display: "none" }), plot(dc.lower, { display: "none" }), { color: "rgba(59,130,246,0.05)" })
```
Aliases: ta.dc

### 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.
Returns: series float
```
indicator("WVAD", overlay=false)
const wvad = ta.wvad()
const wvadSmooth = sma(wvad, 14)
plot(wvadSmooth, { title: "WVAD (14)", color: wvadSmooth > 0 ? "#10B981" : "#EF4444", style: "histogram" })
hline(0)
```
Aliases: ta.wvad

### 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.
- type: series string; required: true; default: not specified. "Traditional" | "Fibonacci" | "Woodie" | "Classic" | "DM" | "Camarilla".
- anchor: series bool; required: true; default: not specified. Resets the accumulator when true (e.g. `timeframe.change("W")`).
- developing: series bool; required: not specified; default: not specified. When true, the pivot is recomputed live within the current anchor period. Default false. NOTE: developing=true is illegal with type="Woodie".
Returns: array<float>
```
//@version=6
indicator("Weekly Pivots", overlay=true)
weekChange = timeframe.change("W")
levels = ta.pivot_point_levels("Traditional", weekChange)
if weekChange
    for lvl in levels
        line.new(time, lvl, time + timeframe.in_seconds("W") * 1000, lvl, xloc=xloc.bar_time)
```
Aliases: alerta.ta.pivot_point_levels

### 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.
- source: series float; required: true; default: not specified. Price source.
- length: simple int; required: true; default: not specified. Window length.
Returns: series float
```
plot(ta.rci(close, 14))
```
Aliases: alerta.ta.rci

### 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.
- length: series int; required: true; default: not specified. Window length.
Returns: series float
```
plot(ta.wpr(14), color = color.orange)
```
Aliases: alerta.ta.wpr, ta.willr, williamsr

### 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.
- timeframe: series string; required: true; default: not specified. Target timeframe (e.g. "D", "W", "1M").
Returns: series bool
```
isNewDay = timeframe.change("D")
bgcolor(isNewDay ? color.new(color.green, 80) : na)
```
Aliases: alerta.timeframe.change

### 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.
Returns: series float
```
//@version=6
indicator("PVT", overlay=false)
plot(ta.pvt, title="PVT", color=color.teal)
```
Aliases: alerta.ta.pvt, pvt

### 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.
Returns: series float
```
//@version=6
indicator("AccDist", overlay=false)
plot(ta.accdist, title="A/D", color=color.blue)
```
Aliases: alerta.ta.accdist, accdist

### 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.
Returns: series float
```
//@version=6
indicator("III", overlay=false)
plot(ta.iii, title="III", color=color.purple)
```
Aliases: alerta.ta.iii, iii

### 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.
Returns: series float
```
//@version=6
indicator("NVI", overlay=false)
plot(ta.nvi, title="NVI", color=color.red)
```
Aliases: alerta.ta.nvi, nvi

### 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.
Returns: series float
```
//@version=6
indicator("PVI", overlay=false)
plot(ta.pvi, title="PVI", color=color.green)
```
Aliases: alerta.ta.pvi, pvi

### 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.
Returns: series float
```
//@version=6
indicator("WAD", overlay=false)
plot(ta.wad, title="WAD", color=color.orange)
```
Aliases: alerta.ta.wad, wad

### 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.
- id: string; required: true; default: not specified. Unique identifier for the order.
- direction: string; required: true; default: not specified. "long" or "short" (or strategy.long / strategy.short).
- qty: float; required: not specified; default: not specified. Quantity (contracts or percentage depending on settings).
- limit: float; required: not specified; default: not specified. Optional limit price.
- stop: float; required: not specified; default: not specified. Optional stop price.
- oca_name: string; required: not specified; default: not specified. One-Cancels-All group name; orders sharing a group cancel each other when one fills.
- oca_type: string; required: not specified; default: not specified. OCA behaviour: strategy.oca.cancel | strategy.oca.reduce | strategy.oca.none.
- comment: string; required: not specified; default: not specified. Free-text annotation attached to the order (visible in trade list / alerts).
- alert_message: string; required: not specified; default: not specified. Custom alert payload — used when the order fires its alert.
Returns: void
```
strategy("Entry Example", overlay=true)
if bar_index == 1
  strategy.entry("Buy", "long")
```
Use inside strategy scripts only. Replace default indicator header with a strategy header.
Orders are kept by id. A second call with the same id replaces the waiting order (on the same bar or while a limit or stop entry still rests); a call with another id waits beside it — two entries on one bar both fill, within the pyramiding limit, and a buy stop above and a sell stop below both rest until the price reaches one of them.
An OCA group answers when one of its orders FILLS: with strategy.oca.cancel the group's other orders are withdrawn, with strategy.oca.reduce they shrink by the filled quantity (and are withdrawn at zero). An order the strategy refuses — over the pyramiding limit or a risk rule — fills nothing and cancels nothing.
Aliases: buy, sell, enter

### 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.
- id: string; required: true; default: not specified. Order ID for the exit.
- from_entry: string; required: not specified; default: not specified. The entry ID to exit from. qty/qty_percent apply to that entry's trades only.
- qty: float; required: not specified; default: not specified. Quantity to exit.
- qty_percent: float; required: not specified; default: not specified. Percentage of the (scoped) position to exit (0-100).
- profit: float; required: not specified; default: not specified. Take-profit distance in TICKS from the entry price.
- limit: float; required: not specified; default: not specified. Explicit take-profit PRICE (overrides profit).
- loss: float; required: not specified; default: not specified. Stop-loss distance in TICKS from the entry price.
- stop: float; required: not specified; default: not specified. Explicit stop-loss PRICE (overrides loss).
- trail_price: float; required: not specified; default: not specified. Trailing stop activation price.
- trail_points: float; required: not specified; default: not specified. Trailing stop activation: profit from the entry, in ticks. The trailing stop starts once price gets this far in the trade's favour.
- trail_offset: float; required: not specified; default: not specified. Trailing distance in ticks: once active, the stop follows the best price since activation this far behind. Needs trail_price or trail_points.
- oca_name: string; required: not specified; default: not specified. OCA group name for bracket OCO behavior.
- comment: string; required: not specified; default: not specified. Default exit comment.
- comment_profit: string; required: not specified; default: not specified. Comment used when the take-profit leg fires.
- comment_loss: string; required: not specified; default: not specified. Comment used when the stop-loss leg fires.
- comment_trailing: string; required: not specified; default: not specified. Comment used when the trailing stop fires.
- alert_message: string; required: not specified; default: not specified. Text for the {{strategy.order.alert_message}} placeholder.
Returns: void
```
strategy("Exit Example", overlay=true)
if bar_index == 1
  strategy.entry("Buy", strategy.long)
strategy.exit("ExitBuy", "Buy", limit = close * 1.01, stop = close * 0.99, comment_profit = "TP", comment_loss = "SL")
```
Use inside strategy scripts only. Replace default indicator header with a strategy header.
An exit placed together with its entry already protects the entry's first bar. When one bar reaches both the target and the stop, the one the price reaches first along open → nearer extreme → farther extreme → close fills: a bar whose low is nearer the open than its high hits a long's stop first.
A trailing stop starts once the price has moved trail_points ticks (or reached trail_price) in the trade's favour and then stays active, following the best price trail_offset ticks behind.
Aliases: tp, sl, takeprofit, stoploss

### 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.
- id: string; required: true; default: not specified. The entry ID to close.
- comment: string; required: not specified; default: not specified. Comment on the chart.
- qty: float; required: not specified; default: not specified. Quantity to close.
- qty_percent: float; required: not specified; default: not specified. Percentage of the position to close (0-100).
- alert_message: string; required: not specified; default: not specified. Text for the {{strategy.order.alert_message}} placeholder.
- immediately: bool; required: not specified; default: false. true = fill at this bar's close instead of the next bar's open.
Returns: void
```
strategy("Close Example", overlay=true)
if bar_index == 1
  strategy.entry("Buy", "long")
if bar_index == 2
  strategy.close("Buy")
```
Use inside strategy scripts only. Replace default indicator header with a strategy header.
Aliases: close_position

### 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.
- symbol: string; required: true; default: not specified. Ticker (e.g. "BINANCE:BTCUSDT", "NASDAQ:AAPL", an order-flow ticker such as "BINANCE:BTCUSDT.P_FUNDING"); syminfo.tickerid or "SELF" for the chart's own symbol.
- timeframe: string; required: true; default: not specified. Timeframe string (e.g. "D", "60", "240").
- expression: any; required: true; default: not specified. Expression to evaluate in that timeframe (e.g. close, sma(close, 20)). A tuple such as [close, time_close, time] returns one series per member.
- gaps: bool; required: false; default: not specified. Whether to return gaps (barmerge.gaps_on/off). Default false.
- lookahead: bool; required: false; default: not specified. Whether to allow lookahead (barmerge.lookahead_on/off). lookahead_on reads the higher timeframe's finished bar, so the series can repaint on history — it runs, with a warning saying so (not for the non-repainting form, an expression offset by one).
- currency: string; required: false; default: not specified. Read the requested symbol's prices in this currency (currency.EUR, "BTC", syminfo.currency …): open, high, low and close — and everything the expression builds from them — at the daily rate of the day before each bar; volume and literals stay as they are. Until the rate's data is loaded the request is na with a warning naming it.
Returns: series any
```
indicator("Funding rate", overlay = false)
// Order flow (Pro): Binance's BTC perpetual funding rate; any ticker works here ("ES1!", "NASDAQ:AAPL", …)
sym = input.symbol("BINANCE:BTCUSDT.P_FUNDING", "Ticker")
[rate, dailyRate] = request.security(sym, timeframe.period, [close, close * 3])
plot(rate * 100, "Funding % per 8 h")
plot(dailyRate * 100, "Funding % per day")
```
Tickers are answered from AlertaChart's own feeds: crypto venues (BINANCE, BYBIT, OKX, COINBASE, HYPERLIQUID, …), US stocks (NASDAQ:AAPL), Hong Kong, Shanghai, Shenzhen and London listings (HKEX:700, SSE:600519, SZSE:300903, LSE:HSBA), forex (OANDA:EURUSD), indices (TVC:DXY, TVC:VIX, SP:SPX), CME/CBOT/COMEX/NYMEX continuous futures (CME_MINI:ES1!), US macro series (FRED:CPIAUCSL, TVC:US10Y), crypto market cap (CRYPTOCAP:TOTAL, BTC.D) and spread formulas (NASDAQ:AAPL/NASDAQ:MSFT). Symbols resolve with or without an exchange prefix when unique. Borsa Istanbul symbols are not available yet and return na with a warning.
Stock, forex, futures and index tickers (and spreads with such a leg) come with the plans that open those charts (Trader and above); on other plans they return na, with a warning naming the plan. Crypto pairs, crypto market cap and US macro series are on every plan; order-flow tickers are Pro and Elite (below).
Spot gold and silver (OANDA:XAUUSD, TVC:GOLD, XAGUSD …) read the chart's own XAU/USD and XAG/USD on the plans that open those charts (Trader and above). On other plans the same tickers read Binance's XAUUSDT / XAGUSDT perpetual, and a warning names the plan the spot price comes with.
US macro series by their FRED id or TradingView name: Treasury yields (FRED:DGS10 or TVC:US10Y, US02Y, US05Y, GS20, US30Y, the 3-month bill FRED:DTB3), SOFR, the fed funds rate (FRED:DFF), the overnight reverse repo (FRED:RRPONTSYD), the 10Y–2Y and 10Y–3M spreads (FRED:T10Y2Y, FRED:T10Y3M) and the high-yield and corporate bond spreads (FRED:BAMLH0A0HYM2, FRED:BAMLC0A0CM) are daily: a request at an intraday timeframe reads the daily values. Release-based series such as CPI (FRED:CPIAUCSL), GDP or unemployment are monthly.
Order-flow data of crypto perpetuals is read the same way (Pro and Elite plans): EX:PAIR.P_OI open interest, EX:PAIR.P_FUNDING the funding rate (decimal per 8 hours, 0.0001 = 0.01 %), EX:PAIR.P_CVD cumulative volume delta in coins (EX:PAIR_CVD on spot; the bar's volume is its delta), EX:PAIR.P_LIQ_LONG / EX:PAIR.P_LIQ_SHORT the notional liquidated in the bar (USD) and EX:PAIR.P_NETLONG / EX:PAIR.P_NETSHORT net positions (coins), where EX is BINANCE, BYBIT, OKX, COINBASE or HYPERLIQUID — or AGG for every venue together (AGG:BTC.P_FUNDING, AGG:ETH.P_OI). Without the plan these tickers return na with a warning saying so. A venue's open interest is sampled every 5 minutes: on a 1- to 4-minute chart each value lands on the last chart bar of its 5-minute period, never ahead of the price.
Alignment follows Pine on historical bars: a request at the chart's own timeframe is the bar itself, and a higher-timeframe value (lookahead off) arrives on the chart bar that closes together with it — the last bar of its period. barmerge.lookahead_on reads the higher timeframe's finished bar and warns that the series can repaint; its non-repainting form, an expression offset by one (`close[1]` with lookahead_on), runs without that warning.
On the live (realtime) bar the request reads the higher timeframe's bar in progress, as Pine does — a daily close on an hourly chart is today's close so far, and barstate.isconfirmed inside the expression is false there. Such a value can change until its period closes (repaint); the non-repainting form `request.security(sym, tf, x[barstate.isrealtime ? 1 : 0])[barstate.isrealtime ? 0 : 1]` reads closed periods only.
Timeframe tokens follow Pine (1, 5, 60, 240, D, W, M; 1m, 1H, 1D; lowercase m = minutes, uppercase M = months).
A symbol or timeframe that changes from bar to bar — picked by a condition, read from an array of inputs, or walked by `for … in` — makes one request per value, each read where the call runs. A request inside an if block, a loop or a function is evaluated on the bars that reach it.
The expression may return a number, bool, string or color, a tuple such as [close, time_close, time] (destructured on assignment), an array, a matrix or a map (each chart bar gets it as it stood at the end of its requested bar) or an instance of a user-defined type. Before the first requested bar the value is na. A tuple is read only by taking it apart (`[a, b] = request.security(…)`); used as one value it is an error.
The variables the expression names are computed on the requested bars too, with the statements that write them — `var` sums, loops (their break and continue included), arrays and maps the script fills with push / put, and objects whose fields it writes.
Inside the expression, syminfo.*, timeframe.period and barstate.islast describe the requested symbol and bars; syminfo.main_tickerid and timeframe.main_period stay the chart's.
The expression — or a function it calls — may itself call request.security / request.economic (nested requests): the inner request runs in the outer one's context, its "" symbol and timeframe being the outer request's.
On a live chart another symbol's forming bar follows that symbol's own updates, so a spread or a comparison keeps moving with both markets.
Aliases: security, mtf, htf

### 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.
- symbol: string; required: true; default: not specified. Symbol to query, e.g. syminfo.tickerid.
- financial_id: string; required: true; default: not specified. Metric id, e.g. "TOTAL_REVENUE", "CAPITAL_EXPENDITURES".
- period: string; required: true; default: not specified. Reporting period: "FQ", "FH", "FY", "TTM".
- gaps: const; required: not specified; default: not specified. barmerge.gaps_on / barmerge.gaps_off.
- ignore_invalid_symbol: bool; required: not specified; default: not specified. Return na instead of raising for an unavailable symbol.
- currency: string; required: not specified; default: not specified. Convert the result into this currency.
Returns: series float — na without a fundamentals feed
```
rev = request.financial(syminfo.tickerid, "TOTAL_REVENUE", "FQ", ignore_invalid_symbol = true)
plot(na(rev) ? 0 : rev, { title: "Revenue", pane: "oscillator" })
```
No fundamentals feed: always na plus a warning. The call no longer stops the script.

### 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.
- symbol: string; required: true; default: not specified. Symbol to query.
- field: const; required: true; default: not specified. earnings.actual | earnings.estimate | earnings.standardized.
- gaps: const; required: not specified; default: not specified. barmerge.gaps_on / barmerge.gaps_off.
- lookahead: const; required: not specified; default: not specified. barmerge.lookahead_on / barmerge.lookahead_off.
- ignore_invalid_symbol: bool; required: not specified; default: not specified. Return na instead of raising for an unavailable symbol.
- currency: string; required: not specified; default: not specified. Convert the result into this currency.
Returns: series float — na without a fundamentals feed
```
eps = request.earnings(syminfo.tickerid, earnings.actual, ignore_invalid_symbol = true)
plot(na(eps) ? 0 : eps, { title: "EPS", pane: "oscillator" })
```
`earnings.actual` / `.estimate` / `.standardized` are the field constants.
No fundamentals feed: always na plus a warning.

### 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.
- symbol: string; required: true; default: not specified. Symbol to query.
- field: const; required: not specified; default: not specified. dividends.gross | dividends.net.
- gaps: const; required: not specified; default: not specified. barmerge.gaps_on / barmerge.gaps_off.
- lookahead: const; required: not specified; default: not specified. barmerge.lookahead_on / barmerge.lookahead_off.
- ignore_invalid_symbol: bool; required: not specified; default: not specified. Return na instead of raising.
- currency: string; required: not specified; default: not specified. Convert the result into this currency.
Returns: series float — na without a fundamentals feed
```
d = request.dividends(syminfo.tickerid, dividends.gross, ignore_invalid_symbol = true)
plot(na(d) ? 0 : d, { title: "Dividend", pane: "oscillator" })
```

### 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.
- symbol: string; required: true; default: not specified. Symbol to query.
- field: const; required: true; default: not specified. splits.numerator | splits.denominator.
- gaps: const; required: not specified; default: not specified. barmerge.gaps_on / barmerge.gaps_off.
- lookahead: const; required: not specified; default: not specified. barmerge.lookahead_on / barmerge.lookahead_off.
- ignore_invalid_symbol: bool; required: not specified; default: not specified. Return na instead of raising.
Returns: series float — na without a fundamentals feed
```
s = request.splits(syminfo.tickerid, splits.numerator, ignore_invalid_symbol = true)
plot(na(s) ? 0 : s, { title: "Split numerator", pane: "oscillator" })
```

### 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.
- ticks_per_row: simple int; required: true; default: not specified. Row height in ticks (syminfo.mintick). A bar with more than 5000 rows is na.
- va_percent: simple float; required: not specified; default: 70. Share of the bar's volume the value area holds.
- imbalance_percent: simple float; required: not specified; default: 300. How many percent of the diagonal row's opposite volume a row's buy (or sell) volume must reach to be an imbalance: 300 = three times.
Returns: series footprint — na where the bar has no order flow
```
indicator("Footprint delta")
footprint fp = request.footprint(20, 70, 300)
float buyVol = na(fp) ? na : fp.buy_volume()
float sellVol = na(fp) ? na : fp.sell_volume()
plot(buyVol - sellVol, "Footprint delta", style = plot.style_columns)
```
Bar totals are exact: buy_volume, sell_volume and delta are the sums of the bar's minutes (for 4h and daily charts, 5-minute buckets).
Closed bars' rows are rebuilt from minutes, not from single trades: with 1m buckets, measured against Binance trades, the POC is within one row 90 % of the time at ≤ 10 rows a bar, 72 % at 10–20 rows and 45 % at 20–40 rows. Wider rows (a larger ticks_per_row) are closer to the exact footprint.
History reaches back at most about 21 days on charts up to 1h and 100 days on 4h and daily charts — less where the record is shorter (Bybit, OKX and Coinbase: about 50 days).
Tick and range charts and seconds timeframes have no footprint.
Minutes the live trade stream missed — a dropped connection or skipped trades — are filled from the recorded minutes once they are fetched again after the gap; until then the bar is na. A minute missing from the record as well leaves its bar na.
In a request of another timeframe the stream's levels count only as whole bars inside a longer bar. A lower-timeframe request (`request.security_lower_tf`) of the chart's own symbol reads the live stream's minute bars, which the chart keeps while such a script runs, and the recorded minutes before them.

### 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.
- symbol: string; required: true; default: not specified. Symbol to query. An empty string ("") means the chart's own symbol, same as `syminfo.tickerid`.
- timeframe: string; required: true; default: not specified. Lower timeframe token.
- expression: any; required: true; default: not specified. Expression to evaluate.
- ignore_invalid_timeframe: bool; required: not specified; default: not specified. Pine v6: return na instead of raising when the requested timeframe is higher than the chart's.
- currency: string; required: not specified; default: not specified. Pine v6: convert the result into this currency.
- ignore_invalid_symbol: bool; required: not specified; default: not specified. Pine v6: return na instead of raising for an unavailable symbol.
- calc_bars_count: int; required: not specified; default: not specified. Pine v6: use only the last N bars of the requested context.
Returns: array<any> — one array per bar; a tuple expression returns one array per member
```
vols = request.security_lower_tf("", "1S", volume)
n = array.size(vols)
plot(n > 0 ? array.sum(vols) : na, { title: "Intrabar volume" })
```
Returns an ARRAY per bar, not a projected series — `plot(request.security_lower_tf(...))` is a type error in Pine and here.
A tuple expression returns a tuple of arrays: `[h, l, v] = request.security_lower_tf("", "1", [high, low, volume])`.
No lookahead: a bar receives only the lower-timeframe bars that fall inside it.
A timeframe higher than the chart's is an error; the chart's own timeframe returns one element per bar.
No intrabar data available → empty arrays plus a warning, never a stopped script.
Aliases: security_lower_tf

### 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.
- id: string; required: true; default: not specified. Unique identifier for the order.
- direction: string; required: true; default: not specified. "long" or "short".
- qty: float; required: not specified; default: not specified. Quantity (contracts or percentage).
- limit: float; required: not specified; default: not specified. Limit price for the order.
- stop: float; required: not specified; default: not specified. Stop price for the order.
- comment: string; required: not specified; default: not specified. Order comment.
Returns: void
```
strategy("Order Example", overlay=true)
if bar_index == 1
  strategy.order("AddMore", "long", 10)
```

### 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.
Returns: series float
```
strategy("Equity Plot", overlay=false)
plot(strategy.equity, { title: "Current Equity" })
```

### 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.
Returns: series float
```
strategy("NP%", overlay=false)
plot(strategy.netprofit_percent, title="Net Profit %")
```
Aliases: strategy.openprofit_percent, strategy.grossprofit_percent, strategy.grossloss_percent, strategy.max_drawdown_percent, strategy.max_runup_percent

### 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.
Returns: series float
```
strategy("AvgTrade", overlay=false)
plot(strategy.avg_trade, title="Avg Trade")
plot(strategy.avg_winning_trade, title="Avg Win")
```
Aliases: strategy.avg_trade_percent, strategy.avg_winning_trade, strategy.avg_winning_trade_percent, strategy.avg_losing_trade, strategy.avg_losing_trade_percent

### 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.
Returns: series float (na)
```
strategy("Margin liquidation price", overlay=true, margin_long=25)
if bar_index == 3
    strategy.entry("Long", strategy.long, qty=100)
plot(strategy.margin_liquidation_price, "Liquidation price")
```

### 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.
Returns: series float
```
strategy("Pos Size Plot", overlay=false)
plot(strategy.position_size, { title: "Position Size" })
```

### 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.
Returns: series float
```
strategy("Open Profit Plot", overlay=false)
plot(strategy.openprofit, { title: "Unrealized PnL" })
```

### 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.
- value: float; required: true; default: not specified. The maximum drawdown threshold.
- type: string; required: not specified; default: not specified. "cash" or "percent". Default is "cash".
Returns: void
```
strategy("Risk: Max DD", overlay=true)
strategy.risk.max_drawdown(15, "percent")
```

### 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.
- size: float; required: true; default: not specified. Maximum allowed position size.
Returns: void
```
strategy("Risk: Max Size", overlay=true)
strategy.risk.max_position_size(10)
strategy.entry("BigOrder", "long", 100) // will be capped to 10
```

### 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.
- direction: string; required: true; default: not specified. "long", "short", or "all".
Returns: void
```
strategy("Risk: Long Only", overlay=true)
strategy.risk.allow_entry_in("long")
```

### 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.
Returns: int
```
strategy("Open Trades Count", overlay=true)
plot(strategy.opentrades, { pane: "oscillator" })
```

### 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.
Returns: int
```
strategy("Closed Trades Count", overlay=true)
plot(strategy.closedtrades, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. The index of the open trade (0 is oldest).
Returns: float
```
strategy("strategy.opentrades.entry_price", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
value = strategy.opentrades > 0 ? strategy.opentrades.entry_price(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. The index of the closed trade (0 is oldest).
Returns: float
```
strategy("Last Trade Profit", overlay=true)
lastProfit = strategy.closedtrades > 0 ? strategy.closedtrades.profit(strategy.closedtrades - 1) : 0
plot(lastProfit, { pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Order or exit id to cancel.
Returns: void
```
strategy("Cancel Example", overlay=true)
if bar_index == 1
  strategy.entry("L1", "long", limit = close * 0.99)
if bar_index == 2
  strategy.cancel("L1")
```

### 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.
Returns: void
```
strategy("Cancel All Example", overlay=true)
if bar_index == 1
  strategy.entry("L1", "long", limit = close * 0.99)
if bar_index == 2
  strategy.cancel_all()
```

### 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.
- comment: string; required: not specified; default: not specified. Optional close reason shown on the trade.
- alert_message: string; required: not specified; default: not specified. Text for the {{strategy.order.alert_message}} placeholder.
- immediately: bool; required: not specified; default: false. true = fill at this bar's close instead of the next bar's open.
Returns: void
```
strategy("Close All Example", overlay=true)
if bar_index == 1
  strategy.entry("L1", "long")
if bar_index == 2
  strategy.close_all()
```

### 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.
- count: int; required: true; default: not specified. Max consecutive losing sequence.
Returns: void
```
strategy("Risk Consecutive Loss", overlay=true)
strategy.risk.max_cons_loss_days(2)
```

### 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.
- count: int; required: true; default: not specified. Max filled orders.
Returns: void
```
strategy("Risk Filled Orders", overlay=true)
strategy.risk.max_intraday_filled_orders(3)
```

### 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.
- value: float; required: true; default: not specified. Loss threshold.
- type: string; required: not specified; default: not specified. "cash" or "percent".
Returns: void
```
strategy("Risk Intraday Loss", overlay=true)
strategy.risk.max_intraday_loss(2, "percent")
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: float
```
strategy("Open Profit %", overlay=true)
p = strategy.opentrades > 0 ? strategy.opentrades.profit_percent(0) : 0
plot(p, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("Closed Profit %", overlay=true)
p = strategy.closedtrades > 0 ? strategy.closedtrades.profit_percent(strategy.closedtrades - 1) : 0
plot(p, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: int
```
strategy("strategy.opentrades.entry_bar_index", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
value = strategy.opentrades > 0 ? strategy.opentrades.entry_bar_index(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: int
```
strategy("strategy.closedtrades.entry_bar_index", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.entry_bar_index(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: int
```
strategy("strategy.closedtrades.exit_bar_index", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.exit_bar_index(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: float
```
strategy("Open Runup", overlay=true)
v = strategy.opentrades > 0 ? strategy.opentrades.max_runup(0) : 0
plot(v, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: float
```
strategy("Open Drawdown", overlay=true)
v = strategy.opentrades > 0 ? strategy.opentrades.max_drawdown(0) : 0
plot(v, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("Closed Runup", overlay=true)
v = strategy.closedtrades > 0 ? strategy.closedtrades.max_runup(0) : 0
plot(v, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("Closed Drawdown", overlay=true)
v = strategy.closedtrades > 0 ? strategy.closedtrades.max_drawdown(0) : 0
plot(v, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: string
```
strategy("strategy.opentrades.entry_id", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
value = strategy.opentrades > 0 ? strategy.opentrades.entry_id(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: string
```
strategy("strategy.closedtrades.entry_id", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.entry_id(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: string
```
strategy("strategy.closedtrades.exit_id", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.exit_id(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: string
```
strategy("strategy.opentrades.entry_comment", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
value = strategy.opentrades > 0 ? strategy.opentrades.entry_comment(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: int
```
strategy("strategy.opentrades.entry_time", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
value = strategy.opentrades > 0 ? strategy.opentrades.entry_time(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: float
```
strategy("Open Size", overlay=true)
s = strategy.opentrades > 0 ? strategy.opentrades.size(0) : 0
plot(s, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: float
```
strategy("Open Commission", overlay=true)
c = strategy.opentrades > 0 ? strategy.opentrades.commission(0) : 0
plot(c, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: float
```
strategy("Open Profit", overlay=true)
p = strategy.opentrades > 0 ? strategy.opentrades.profit(0) : 0
plot(p, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: float
```
strategy("Open Runup %", overlay=true)
v = strategy.opentrades > 0 ? strategy.opentrades.max_runup_percent(0) : 0
plot(v, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: float
```
strategy("Open Drawdown %", overlay=true)
v = strategy.opentrades > 0 ? strategy.opentrades.max_drawdown_percent(0) : 0
plot(v, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Open trade index.
Returns: int
```
strategy("strategy.opentrades.entry_bar", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
value = strategy.opentrades > 0 ? strategy.opentrades.entry_bar(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("strategy.closedtrades.entry_price", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.entry_price(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: string
```
strategy("strategy.closedtrades.entry_comment", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.entry_comment(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: int
```
strategy("strategy.closedtrades.entry_time", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.entry_time(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("strategy.closedtrades.exit_price", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.exit_price(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: string
```
strategy("strategy.closedtrades.exit_comment", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.exit_comment(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: int
```
strategy("strategy.closedtrades.exit_time", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.exit_time(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("Closed Size", overlay=true)
s = strategy.closedtrades > 0 ? strategy.closedtrades.size(0) : 0
plot(s, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("Closed Commission", overlay=true)
c = strategy.closedtrades > 0 ? strategy.closedtrades.commission(0) : 0
plot(c, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("Closed Runup %", overlay=true)
v = strategy.closedtrades > 0 ? strategy.closedtrades.max_runup_percent(0) : 0
plot(v, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: float
```
strategy("Closed Drawdown %", overlay=true)
v = strategy.closedtrades > 0 ? strategy.closedtrades.max_drawdown_percent(0) : 0
plot(v, { pane: "oscillator" })
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: int
```
strategy("strategy.closedtrades.entry_bar", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.entry_bar(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
- trade_index: int; required: true; default: not specified. Closed trade index.
Returns: int
```
strategy("strategy.closedtrades.exit_bar", overlay=false)
if bar_index == 3
    strategy.entry("Long", strategy.long, comment="Example entry")
if bar_index == 8
    strategy.close("Long", comment="Example exit")
value = strategy.closedtrades > 0 ? strategy.closedtrades.exit_bar(0) : na
var result = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(result, 0, 0, str.tostring(value), text_color=chart.fg_color)
```

### 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.
Returns: float
```
strategy("Capital Info", overlay=true)
const pct = (strategy.equity / strategy.initial_capital - 1) * 100
plot(pct, { title: "Return %", pane: "oscillator" })
```

### 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.
Returns: float
```
strategy("P&L Breakdown", overlay=true)
plot(strategy.grossprofit, { title: "Gross Profit", color: "#10B981", pane: "oscillator" })
plot(strategy.grossloss, { title: "Gross Loss", color: "#EF4444", pane: "oscillator" })
```

### 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.
Returns: float
```
strategy("Loss Report", overlay=true)
const ratio = strategy.grossprofit / math.max(strategy.grossloss, 1)
plot(ratio, { title: "Profit Factor", pane: "oscillator" })
```

### 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.
Returns: int
```
strategy("Win Rate", overlay=true)
const wr = strategy.closedtrades > 0 ? strategy.wintrades / strategy.closedtrades * 100 : 0
plot(wr, { title: "Win Rate %", pane: "oscillator" })
```

### 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.
Returns: int
```
strategy("Trade Stats", overlay=true)
plot(strategy.wintrades, { title: "Wins", color: "#10B981", pane: "oscillator" })
plot(strategy.losstrades, { title: "Losses", color: "#EF4444", pane: "oscillator" })
```

### 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.
Returns: int
```
strategy("Even Trades", overlay=true)
plot(strategy.eventrades, { title: "Breakeven Trades", pane: "oscillator" })
```

### 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.
Returns: float
```
strategy("Drawdown Monitor", overlay=true)
plot(strategy.max_drawdown, { title: "Max Drawdown", color: "#EF4444", pane: "oscillator" })
```

### 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.
Returns: float
```
strategy("Runup Monitor", overlay=true)
plot(strategy.max_runup, { title: "Max Run-up", color: "#10B981", pane: "oscillator" })
```

### 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.
Returns: string
```
strategy("Currency Label", overlay=true)
drawTable("cur", 0, 0, strategy.account_currency, { position: "top_right" })
```

### 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.
- fill_price: series int|float; required: true; default: not specified. Price used to estimate the default quantity.
Returns: series float
```
strategy("Qty Preview", overlay=false, default_qty_type=strategy.percent_of_equity, default_qty_value=10)
plot(strategy.default_entry_qty(close), { title: "Default qty", pane: "oscillator" })
```

### 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.
- series: series float; required: true; default: not specified. Data to plot.
- options: object; required: not specified; default: not specified. Plot styling and config: { title, color, style, linewidth, pane, offset, display }
Returns: void
```
plot(sma(close, 20), { color: "#2962FF", linewidth: 2 })
```
Aliases: line

### 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.
- price: float; required: true; default: not specified. Price level.
- options: object; required: not specified; default: not specified. Styling config.
Returns: void
```
hline(100.0, { color: "gray", linestyle: "dashed" })
```
Aliases: horizontal line

### 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.
- series: series bool; required: true; default: not specified. Where to draw: true, or a price with location.absolute; false/na draws nothing.
- options: object; required: not specified; default: not specified. Styling config (style: "label_up"/"label_down"/"triangle_up", textcolor, transp, etc).
Returns: void
```
const cross = crossover(sma(close, 10), sma(close, 20))
plotshape(cross, { shape: "triangle_up", location: "belowbar", color: "green" })
```
Aliases: shape

### 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.
- series: series bool; required: true; default: not specified. Where to draw: true, or a price with location.absolute; false/na draws nothing.
- options: object; required: not specified; default: not specified. Styling config (char: string).
Returns: void
```
const isBull = close > open
plotchar(isBull, { char: "↑", location: "abovebar", color: "green" })
```
Aliases: char

### 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.
- series: series float; required: true; default: not specified. Positive values draw up arrows, negative values draw down arrows.
- options: object; required: not specified; default: not specified. Arrow styling options, in Pine's positional order: title, colorup, colordown, offset, minheight, maxheight, editable, show_last, display, force_overlay.
Returns: void
```
sig = close - open
plotarrow(sig, { colorup: "#22c55e", colordown: "#ef4444" })
```
Aliases: arrow

### 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.
- open: series float; required: true; default: not specified. Open series.
- high: series float; required: true; default: not specified. High series.
- low: series float; required: true; default: not specified. Low series.
- close: series float; required: true; default: not specified. Close series.
- options: object; required: not specified; default: not specified. In Pine's positional order: title, color, wickcolor, editable, show_last, bordercolor, display, format, precision, force_overlay (plus `offset` and `pane`).
Returns: void
```
plotcandle(open, high, low, close, { color: "#22c55e", wickcolor: "#16a34a", bordercolor: "#16a34a" })
```
Aliases: candle

### 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.
- open: series float; required: true; default: not specified. Open series.
- high: series float; required: true; default: not specified. High series.
- low: series float; required: true; default: not specified. Low series.
- close: series float; required: true; default: not specified. Close series.
- options: object; required: not specified; default: not specified. In Pine's positional order: title, color, editable, show_last, display, format, precision, force_overlay (plus `offset` and `pane`).
Returns: void
```
plotbar(open, high, low, close, { color: "#ef4444" })
```
Aliases: bar

### 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.
- color: series string; required: true; default: not specified. Color string, null for no color.
- options: object; required: not specified; default: not specified. { pane, title }
Returns: void
```
const c = close > open ? "rgba(0, 255, 0, 0.05)" : "rgba(255, 0, 0, 0.05)"
bgcolor(c, { pane: "oscillator" })
```
Aliases: background

### 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.
- color: series string; required: true; default: not specified. Color string, null for default color.
- options: object; required: not specified; default: not specified. Optional render options.
Returns: void
```
isBull = close > open
barcolor(isBull ? "#22c55e" : "#ef4444")
```
Aliases: candlecolor

### 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.
- plot1: plot | string; required: true; default: not specified. First plot: a plot handle, an inline plot() call or the plot's title.
- plot2: plot | string; required: true; default: not specified. Second plot: a plot handle, an inline plot() call or the plot's title.
- y1: series float; required: not specified; default: not specified. Optional top series for advanced fills.
- y2: series float; required: not specified; default: not specified. Optional bottom series for advanced fills.
- color1: string; required: not specified; default: not specified. Primary fill color.
- color2: string; required: not specified; default: not specified. Secondary fill color.
- options: object; required: not specified; default: not specified. Optional settings, accepted as named arguments too: color, title, fillgaps, display, editable, and Pine v6's gradient form top_value / bottom_value / top_color / bottom_color.
Returns: void
```
basis = sma(close, 20)
deviation = stdev(close, 20)
upper = basis + deviation
lower = basis - deviation
plot(upper, { title: "up" })
plot(lower, { title: "down" })
fill("up", "down", { color: "rgba(0,0,255,0.1)" })
```
Aliases: cloud

### 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.
- line1_id: line handle; required: true; default: not specified. First line handle.
- line2_id: line handle; required: true; default: not specified. Second line handle.
- options: object; required: not specified; default: not specified. { color, title } object.
Returns: linefill handle
```
line1 = line.new(bar_index - 10, low[10], bar_index, low)
line2 = line.new(bar_index - 10, high[10], bar_index, high)
lf = linefill(line1, line2, { color: "rgba(239,68,68,0.15)" })
```
Aliases: linefill.new

### 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.
- id: string; required: true; default: not specified. Unique ID per element (use mode "append" or "replace").
- cond: series bool; required: true; default: not specified. Condition to draw the label on current bar.
- x: int; required: true; default: not specified. Bar index (e.g. bar_index).
- y: float; required: true; default: not specified. Price level.
- text: string; required: true; default: not specified. Text to display in the label.
- options: object; required: not specified; default: not specified. { location, style, color, textColor, size, mode }
Returns: void
```
drawLabel("LL", true, bar_index, low, "LL", { style: "label_up", color: "transparent", textColor: "white", mode: "append" })
```
Legacy alias: prefer object API (`label.new` + `label.set_*`) for Pine parity.
Aliases: label.new, label

### 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.
- id: string; required: true; default: not specified. Unique ID.
- cond: series bool; required: true; default: not specified. Condition.
- x1: int; required: true; default: not specified. Left bar_index.
- y1: float; required: true; default: not specified. Top price.
- x2: int; required: true; default: not specified. Right bar_index.
- y2: float; required: true; default: not specified. Bottom price.
- options: object; required: not specified; default: not specified. { bgColor, borderColor, extend, isMitigated, mode, text }
Returns: void
```
isOB = bar_index > 10
top = high
bot = low
drawBox("ob", isOB, bar_index - 5, top, bar_index, bot, { extend: "right", mode: "append" })
```
Legacy alias: prefer object API (`box.new` + `box.set_*`) for Pine parity.
Aliases: box.new, box, zone

### 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.
- id: string; required: true; default: not specified. Unique ID.
- cond: series bool; required: true; default: not specified. Condition.
- x1: int; required: true; default: not specified. Left bar_index.
- y1: float; required: true; default: not specified. Start price.
- x2: int; required: true; default: not specified. Right bar_index.
- y2: float; required: true; default: not specified. End price.
- options: object; required: not specified; default: not specified. { color, lineWidth, style, extend, mode }
Returns: void
```
isBOS = bar_index > 10
lastPivotX = bar_index - 5
lastPivotY = high[5]
drawLine("BOS_" + bar_index, isBOS, lastPivotX, lastPivotY, bar_index, lastPivotY, { color: "gray", mode: "append" })
```
Legacy alias: prefer object API (`line.new` + `line.set_*`) for Pine parity.
Aliases: line.new, trendline

### 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.
- id: string; required: true; default: not specified. Table ID.
- row: int; required: true; default: not specified. Row index (0-based).
- col: int; required: true; default: not specified. Column index (0-based).
- text: string; required: true; default: not specified. Text/Value to display.
- options: object; required: not specified; default: not specified. { position, bgColor, textColor, textAlign, size, fontWeight }
Returns: void
```
drawTable("hud", 0, 0, "RSI: " + fixed(rsi(close, 14), 2), { position: "top_right", bgColor: "#1e222d" })
```
Legacy alias: prefer object API (`table.new` + `table.cell`) for Pine parity.
Aliases: table.new, table.cell, dashboard

### 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.
- line1: line handle; required: true; default: not specified. First line handle.
- line2: line handle; required: true; default: not specified. Second line handle.
- color: string; required: not specified; default: not specified. Fill color.
Returns: linefill handle
```
l1 = line.new(bar_index - 10, low[10], bar_index, low)
l2 = line.new(bar_index - 10, high[10], bar_index, high)
lf = linefill.new(l1, l2, "rgba(239,68,68,0.15)")
```

### 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.
- id: linefill handle; required: true; default: not specified. Linefill handle to delete.
Returns: void
```
l1 = line.new(bar_index - 10, low[10], bar_index, low)
l2 = line.new(bar_index - 10, high[10], bar_index, high)
lf = linefill.new(l1, l2, "rgba(239,68,68,0.15)")
linefill.delete(lf)
```

### 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.
- id: linefill handle; required: true; default: not specified. Linefill handle.
Returns: line handle
```
l1 = line.new(bar_index - 10, low[10], bar_index, low)
l2 = line.new(bar_index - 10, high[10], bar_index, high)
lf = linefill.new(l1, l2, "rgba(239,68,68,0.15)")
a = linefill.get_line1(lf)
```

### 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.
- id: linefill handle; required: true; default: not specified. Linefill handle.
Returns: line handle
```
l1 = line.new(bar_index - 10, low[10], bar_index, low)
l2 = line.new(bar_index - 10, high[10], bar_index, high)
lf = linefill.new(l1, l2, "rgba(239,68,68,0.15)")
b = linefill.get_line2(lf)
```

### 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.
- id: linefill handle; required: true; default: not specified. Linefill handle.
- color: string; required: true; default: not specified. New fill color.
Returns: void
```
l1 = line.new(bar_index - 10, low[10], bar_index, low)
l2 = line.new(bar_index - 10, high[10], bar_index, high)
lf = linefill.new(l1, l2, "rgba(239,68,68,0.15)")
linefill.set_color(lf, "rgba(34,197,94,0.15)")
```

### 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.
- x1: int; required: true; default: not specified. First X coordinate (bar index).
- y1: float; required: true; default: not specified. First Y coordinate (price).
- x2: int; required: true; default: not specified. Second X coordinate (bar index).
- y2: float; required: true; default: not specified. Second Y coordinate (price).
- options: object; required: not specified; default: not specified. Optional style settings, in Pine's positional order: xloc, extend, color, style, width, force_overlay. Equivalent to the direct named-arg form.
Returns: line handle
```
ln = line.new(bar_index - 5, low, bar_index, high, color=color.green, style=line.style_dashed, width=2)
```

### 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.
- id: line handle; required: true; default: not specified. Source line handle.
Returns: line handle
```
ln = line.new(bar_index - 5, low, bar_index, high)
ln2 = line.copy(ln)
line.set_color(ln2, "#f59e0b")
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- x: int; required: true; default: not specified. New X1 coordinate.
- y: float; required: true; default: not specified. New Y1 coordinate.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_xy1(ln, bar_index - 10, low[1])
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- x: int; required: true; default: not specified. New X2 coordinate.
- y: float; required: true; default: not specified. New Y2 coordinate.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_xy2(ln, bar_index, high)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- point: chart.point; required: true; default: not specified. New first point.
Returns: void
```
var ln = line.new(bar_index - 5, low, bar_index, high)
if barstate.islast
    p = chart.point.from_index(bar_index - 10, low[1])
    line.set_first_point(ln, p)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- point: chart.point; required: true; default: not specified. New second point.
Returns: void
```
var ln = line.new(bar_index - 5, low, bar_index, high)
if barstate.islast
    p = chart.point.from_index(bar_index + 1, high)
    line.set_second_point(ln, p)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- x1: series int; required: true; default: not specified. New x of the first point, in the given xloc.
- x2: series int; required: true; default: not specified. New x of the second point, in the given xloc.
- xloc: series string; required: true; default: not specified. xloc.bar_index | xloc.bar_time
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
if barstate.islast
    line.set_xloc(ln, time[5], time, xloc.bar_time)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- x: int; required: true; default: not specified. New X1 value.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_x1(ln, bar_index - 10)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- y: float; required: true; default: not specified. New Y1 value.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_y1(ln, low)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- x: int; required: true; default: not specified. New X2 value.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_x2(ln, bar_index)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- y: float; required: true; default: not specified. New Y2 value.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_y2(ln, high)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- color: string; required: true; default: not specified. New color value.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_color(ln, "#22c55e")
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- width: int; required: true; default: not specified. New width value.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_width(ln, 2)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- extend: string; required: true; default: not specified. none | left | right | both
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_extend(ln, "right")
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- style: string; required: true; default: not specified. Line style token.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_style(ln, "dashed")
```

### 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.
- line_id: line handle; required: true; default: not specified. Target line handle.
- zindex: int; required: true; default: not specified. New z-index value.
Returns: void
```
ln = line.new(bar_index - 5, low, bar_index, high)
line.set_zindex(ln, 10)
```

### 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.
- id: line handle; required: true; default: not specified. Line handle to delete.
Returns: void
```
indicator("line.delete", overlay=false)
var object = line.new(bar_index, low, bar_index + 5, high)
if bar_index == 10
    line.delete(object)
plot(array.size(line.all), "line objects remaining")
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
Returns: int
```
ln = line.new(bar_index - 5, low, bar_index, high)
x1 = line.get_x1(ln)
plot(x1, { pane: "oscillator" })
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
Returns: float
```
ln = line.new(bar_index - 5, low, bar_index, high)
y1 = line.get_y1(ln)
plot(y1)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
Returns: int
```
ln = line.new(bar_index - 5, low, bar_index, high)
x2 = line.get_x2(ln)
plot(x2, { pane: "oscillator" })
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
Returns: float
```
ln = line.new(bar_index - 5, low, bar_index, high)
y2 = line.get_y2(ln)
plot(y2)
```

### 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.
- id: line handle; required: true; default: not specified. Target line handle.
- x: int; required: true; default: not specified. Target bar index.
Returns: float
```
ln = line.new(bar_index - 5, low, bar_index, high)
p = line.get_price(ln, bar_index)
plot(p)
```

### 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.
- left: int; required: true; default: not specified. Left bar index.
- top: float; required: true; default: not specified. Top price.
- right: int; required: true; default: not specified. Right bar index.
- bottom: float; required: true; default: not specified. Bottom price.
- options: object; required: not specified; default: not specified. Optional style settings, in Pine's positional order: border_color, border_width, border_style, extend, xloc, bgcolor / bg_color, text, text_size, text_color, text_halign, text_valign, text_wrap, text_font_family, force_overlay. Equivalent to the direct named-arg form.
Returns: box handle
```
bx = box.new(bar_index - 5, high, bar_index, low, bgcolor=color.new(color.green, 80), border_color=color.green)
```

### 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.
- id: box handle; required: true; default: not specified. Source box handle.
Returns: box handle
```
bx = box.new(bar_index - 5, high, bar_index, low)
bx2 = box.copy(bx)
box.set_border_color(bx2, "#f59e0b")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
Returns: int
```
bx = box.new(bar_index - 5, high, bar_index, low)
l = box.get_left(bx)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
Returns: int
```
bx = box.new(bar_index - 5, high, bar_index, low)
r = box.get_right(bx)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
Returns: float
```
bx = box.new(bar_index - 5, high, bar_index, low)
t = box.get_top(bx)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
Returns: float
```
bx = box.new(bar_index - 5, high, bar_index, low)
b = box.get_bottom(bx)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- left: int; required: true; default: not specified. New left coordinate.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_left(bx, bar_index - 10)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- top: float; required: true; default: not specified. New top value.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_top(bx, high)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- right: int; required: true; default: not specified. New right coordinate.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_right(bx, bar_index)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- bottom: float; required: true; default: not specified. New bottom value.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_bottom(bx, low)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- color: string; required: true; default: not specified. New border color.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_border_color(bx, "#ef4444")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- style: string; required: true; default: not specified. solid | dashed | dotted
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_border_style(bx, "dashed")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- width: int; required: true; default: not specified. New border width.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_border_width(bx, 2)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- color: string; required: true; default: not specified. New background color.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_bgcolor(bx, "rgba(16,185,129,0.15)")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- extend: string; required: true; default: not specified. none | left | right | both
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_extend(bx, "right")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- left: int; required: true; default: not specified. New left coordinate.
- right: int; required: true; default: not specified. New right coordinate.
- xloc: string; required: true; default: not specified. bar_index | bar_time
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_xloc(bx, bar_index - 10, bar_index, xloc.bar_index)
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- text: string; required: true; default: not specified. Text value.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_text(bx, "OB")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- text_color: string; required: true; default: not specified. Text color.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_text_color(bx, "#ffffff")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- text_halign: string; required: true; default: not specified. left | center | right
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_text_halign(bx, "center")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- text_valign: string; required: true; default: not specified. top | center | bottom
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_text_valign(bx, "center")
```

### 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.
- id: box handle; required: true; default: not specified. Target box handle.
- text_size: string; required: true; default: not specified. tiny | small | normal | large | huge
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_text_size(bx, "small")
```

### 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.
- box_id: box handle; required: true; default: not specified. Target box handle.
- zindex: int; required: true; default: not specified. New z-index value.
Returns: void
```
bx = box.new(bar_index - 5, high, bar_index, low)
box.set_zindex(bx, 5)
```

### 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.
- id: box handle; required: true; default: not specified. Box handle to delete.
Returns: void
```
indicator("box.delete", overlay=false)
var object = box.new(bar_index, high, bar_index + 5, low)
if bar_index == 10
    box.delete(object)
plot(array.size(box.all), "box objects remaining")
```

### 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.
- x: int; required: true; default: not specified. Bar index.
- y: float; required: true; default: not specified. Price level.
- text: string; required: false; default: not specified. Label text. Optional; defaults to empty string when omitted. Pine v5/v6 allows label.new(x, y, color=...) without text.
- options: object; required: not specified; default: not specified. Optional style settings, in Pine's positional order: xloc, yloc, color, style, textcolor / text_color, size, textalign / textAlign / text_halign, tooltip, text_font_family, text_formatting, force_overlay. Equivalent to the direct named-arg form.
Returns: label handle
```
lb = label.new(bar_index, high, "BoS", style=label.style_label_down, color=color.green, textcolor=color.white)
```

### 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.
- id: label handle; required: true; default: not specified. Source label handle.
Returns: label handle
```
lb = label.new(bar_index, close, "Signal")
lb2 = label.copy(lb)
label.set_text(lb2, "Copy")
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
Returns: int
```
lb = label.new(bar_index, close, "Signal")
x = label.get_x(lb)
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
Returns: float
```
lb = label.new(bar_index, close, "Signal")
y = label.get_y(lb)
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
Returns: string
```
lb = label.new(bar_index, close, "Signal")
t = label.get_text(lb)
```

### 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.
- id: label; required: true; default: not specified. Label handle.
- x: int; required: true; default: not specified. New x value.
- y: float; required: true; default: not specified. New y value.
Returns: void
```
lbl = label.new(bar_index, high, "x")
label.set_xy(lbl, bar_index, close)
```
Aliases: alerta.label.set_xy
Alternate form: label.set_xy(id, x, y)
Updates label X and Y coordinates together.
Returns: void
- id: label handle. Target label handle.
- x: int. New X coordinate.
- y: float. New Y coordinate.
```
lb = label.new(bar_index, close, "Signal")
label.set_xy(lb, bar_index, high)
```

### 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.
- id: label; required: true; default: not specified. Label handle.
- x: int; required: true; default: not specified. New x value.
- xloc: string; required: true; default: not specified. xloc.bar_index | xloc.bar_time.
Returns: void
```
lbl = label.new(bar_index, high, "x")
label.set_xloc(lbl, time, xloc.bar_time)
```
Aliases: alerta.label.set_xloc
Alternate form: label.set_xloc(id, x, xloc)
Updates label X-location mode. Pine v6 can also update X and xloc together.
Returns: void
- id: label handle. Target label handle.
- x: int. New X coordinate.
- xloc: string. bar_index | bar_time
```
lb = label.new(bar_index, close, "Signal")
label.set_xloc(lb, bar_index, xloc.bar_index)
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- textalign: string; required: true; default: not specified. left | center | right
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_textalign(lb, "center")
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- tooltip: string; required: true; default: not specified. Tooltip text.
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_tooltip(lb, "Extra context")
```

### 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.
- points: array<chart.point>; required: true; default: not specified. Points the polyline passes through, in order.
- curved: bool; required: not specified; default: false. Draw smooth curved segments between points.
- closed: bool; required: not specified; default: false. Connect the last point back to the first.
- xloc: string; required: not specified; default: xloc.bar_index. xloc.bar_index or xloc.bar_time.
- line_color: color; required: not specified; default: not specified. Stroke color.
- fill_color: color; required: not specified; default: not specified. Fill color for closed polylines.
- line_style: string; required: not specified; default: line.style_solid. solid / dashed / dotted.
- line_width: int; required: not specified; default: 1. Stroke width.
- force_overlay: bool; required: not specified; default: false. Pine v6: draw on the main (price) pane even from an oscillator script.
Returns: polyline handle
```
pts = array.new<chart.point>()
array.push(pts, chart.point.from_index(bar_index - 4, low))
array.push(pts, chart.point.from_index(bar_index, high))
pl = polyline.new(pts, curved=true)
```

### 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.
- polyline_id: polyline handle; required: true; default: not specified. Target polyline handle.
- x: int; required: true; default: not specified. Bar index for point.
- y: float; required: true; default: not specified. Price value for point.
Returns: void
```
indicator("polyline.push", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.push(p, time, close)
```

### 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.
- id: polyline handle; required: true; default: not specified. Polyline handle to delete.
Returns: void
```
indicator("polyline.delete", overlay=false)
var object = polyline.new(array.from(chart.point.from_index(bar_index, low), chart.point.from_index(bar_index + 5, high)))
if bar_index == 10
    polyline.delete(object)
plot(array.size(polyline.all), "polyline objects remaining")
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- x: int; required: true; default: not specified. New X coordinate.
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_x(lb, bar_index)
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- y: float; required: true; default: not specified. New Y coordinate.
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_y(lb, close)
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- text: string; required: true; default: not specified. New text value.
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_text(lb, "Updated")
```

### 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.
- label_id: label handle; required: true; default: not specified. Target label handle.
- zindex: int; required: true; default: not specified. New z-index value.
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_zindex(lb, 12)
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- color: string; required: true; default: not specified. New color value.
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_color(lb, "#ef4444")
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- textcolor: string; required: true; default: not specified. New text color.
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_textcolor(lb, "#ffffff")
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- size: string; required: true; default: not specified. Size token (small, normal, large).
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_size(lb, "small")
```

### 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.
- id: label handle; required: true; default: not specified. Target label handle.
- style: string; required: true; default: not specified. Style token (label_up, label_down, none).
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_style(lb, "label_up")
```

### 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.
- label_id: label handle; required: true; default: not specified. Target label handle.
- location: string; required: true; default: not specified. Location token (abovebar, belowbar, absolute).
Returns: void
```
lb = label.new(bar_index, close, "Signal")
label.set_location(lb, "abovebar")
```

### 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.
- id: label handle; required: true; default: not specified. Label handle to delete.
Returns: void
```
indicator("label.delete", overlay=false)
var object = label.new(bar_index, high, "Example")
if bar_index == 10
    label.delete(object)
plot(array.size(label.all), "label objects remaining")
```

### 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.
- time: int; required: true; default: not specified. Timestamp (ms).
- index: int; required: true; default: not specified. Bar index.
- price: float; required: true; default: not specified. Price (y).
Returns: chart.point
```
p = chart.point.new(time, bar_index, close)
ln = line.new(bar_index - 1, low, bar_index, high)
line.set_first_point(ln, p)
```
Aliases: alerta.chart.point.new

### 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.
- index: int; required: true; default: not specified. Bar index.
- price: float; required: true; default: not specified. Price.
Returns: chart.point
```
ln = line.new(bar_index - 5, low, bar_index, high)
p1 = chart.point.from_index(bar_index - 10, low)
p2 = chart.point.from_index(bar_index, high)
line.set_first_point(ln, p1)
line.set_second_point(ln, p2)
```
Aliases: alerta.chart.point.from_index

### 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.
- time: int; required: true; default: not specified. Timestamp (ms).
- price: float; required: true; default: not specified. Price.
Returns: chart.point
```
p = chart.point.from_time(time, close)
```
Aliases: alerta.chart.point.from_time

### 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.
- price: float; required: not specified; default: not specified. Price. Optional; the default is close.
Returns: chart.point
```
label.new(chart.point.now(close), "now")
```
Aliases: alerta.chart.point.now

### 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.
- point: chart.point; required: true; default: not specified. Source point.
Returns: chart.point
```
p1 = chart.point.from_index(bar_index, close)
p2 = chart.point.copy(p1)
```
Aliases: alerta.chart.point.copy

### 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.
- id: polyline; required: true; default: not specified. Polyline handle.
- curved: bool; required: true; default: not specified. true = curved, false = straight.
Returns: void
```
indicator("polyline.set_curved", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.set_curved(p, true)
```
Aliases: alerta.polyline.set_curved

### 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.
- id: polyline; required: true; default: not specified. Polyline handle.
- closed: bool; required: true; default: not specified. Close the path.
Returns: void
```
indicator("polyline.set_closed", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.set_closed(p, true)
```
Aliases: alerta.polyline.set_closed

### 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.
- id: polyline; required: true; default: not specified. Polyline handle.
- xloc: string; required: true; default: not specified. xloc.bar_index | xloc.bar_time.
Returns: void
```
indicator("polyline.set_xloc", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.set_xloc(p, xloc.bar_time)
```
Aliases: alerta.polyline.set_xloc

### 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.
- id: polyline; required: true; default: not specified. Polyline handle.
- line_color: color; required: true; default: not specified. Stroke color.
Returns: void
```
indicator("polyline.set_line_color", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.set_line_color(p, color.blue)
```
Aliases: alerta.polyline.set_line_color, polyline.set_color

### 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.
- id: polyline; required: true; default: not specified. Polyline handle.
- fill_color: color; required: true; default: not specified. Fill color.
Returns: void
```
indicator("polyline.set_fill_color", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.set_fill_color(p, color.new(color.blue, 75))
```
Aliases: alerta.polyline.set_fill_color

### 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.
- id: polyline; required: true; default: not specified. Polyline handle.
- line_style: string; required: true; default: not specified. line.style_solid | line.style_dashed | line.style_dotted.
Returns: void
```
indicator("polyline.set_line_style", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.set_line_style(p, line.style_dashed)
```
Aliases: alerta.polyline.set_line_style

### 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.
- id: polyline; required: true; default: not specified. Polyline handle.
- line_width: int; required: true; default: not specified. Width (px).
Returns: void
```
indicator("polyline.set_line_width", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.set_line_width(p, 3)
```
Aliases: alerta.polyline.set_line_width

### 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.
- id: polyline; required: true; default: not specified. Polyline handle.
- points: array<chart.point>; required: true; default: not specified. New point array.
Returns: void
```
indicator("polyline.set_points", overlay=true)
if barstate.islast
    points = array.from(chart.point.from_time(time[8], close[8]), chart.point.from_time(time[4], close[4]), chart.point.from_time(time[1], close[1]))
    p = polyline.new(points, xloc=xloc.bar_time)
    polyline.set_points(p, array.from(chart.point.from_time(time[6], close[6]), chart.point.from_time(time[3], close[3]), chart.point.from_time(time[0], close[0])))
```
Aliases: alerta.polyline.set_points

### 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.
Returns: void
```
indicator("polyline.delete_all", overlay=false)
var object = polyline.new(array.from(chart.point.from_index(bar_index, low), chart.point.from_index(bar_index + 5, high)))
if bar_index == 10
    polyline.delete_all()
plot(array.size(polyline.all), "polyline objects remaining")
```
Aliases: alerta.polyline.delete_all

### 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.
Returns: array<polyline>
```
indicator("polyline.all", overlay=false)
var object = polyline.new(array.from(chart.point.from_index(bar_index, low), chart.point.from_index(bar_index + 5, high)))
plot(array.size(polyline.all), "polyline objects remaining")
```
Aliases: alerta.polyline.all

### 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.
Returns: array<line>
```
indicator("line.all", overlay=false)
var object = line.new(bar_index, low, bar_index + 5, high)
plot(array.size(line.all), "line objects remaining")
```
Aliases: alerta.line.all

### 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.
Returns: void
```
indicator("line.delete_all", overlay=false)
var object = line.new(bar_index, low, bar_index + 5, high)
if bar_index == 10
    line.delete_all()
plot(array.size(line.all), "line objects remaining")
```
Aliases: alerta.line.delete_all

### 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.
Returns: array<label>
```
indicator("label.all", overlay=false)
var object = label.new(bar_index, high, "Example")
plot(array.size(label.all), "label objects remaining")
```
Aliases: alerta.label.all

### 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.
Returns: void
```
indicator("label.delete_all", overlay=false)
var object = label.new(bar_index, high, "Example")
if bar_index == 10
    label.delete_all()
plot(array.size(label.all), "label objects remaining")
```
Aliases: alerta.label.delete_all

### 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.
Returns: array<box>
```
indicator("box.all", overlay=false)
var object = box.new(bar_index, high, bar_index + 5, low)
plot(array.size(box.all), "box objects remaining")
```
Aliases: alerta.box.all

### 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.
Returns: void
```
indicator("box.delete_all", overlay=false)
var object = box.new(bar_index, high, bar_index + 5, low)
if bar_index == 10
    box.delete_all()
plot(array.size(box.all), "box objects remaining")
```
Aliases: alerta.box.delete_all

### 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.
Returns: array<table>
```
indicator("table.all", overlay=false)
var object = table.new(position.top_right, 1, 1)
if barstate.isfirst
    table.cell(object, 0, 0, "Example", text_color=chart.fg_color)
plot(array.size(table.all), "table objects remaining")
```
Aliases: alerta.table.all

### 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.
Returns: void
```
indicator("table.delete_all", overlay=false)
var object = table.new(position.top_right, 1, 1)
if barstate.isfirst
    table.cell(object, 0, 0, "Example", text_color=chart.fg_color)
if bar_index == 10
    table.delete_all()
plot(array.size(table.all), "table objects remaining")
```
Aliases: alerta.table.delete_all

### 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.
- id: label; required: true; default: not specified. Label handle.
- yloc: string; required: true; default: not specified. yloc.price | yloc.abovebar | yloc.belowbar.
Returns: void
```
lbl = label.new(bar_index, high, "x")
label.set_yloc(lbl, yloc.abovebar)
```
Aliases: alerta.label.set_yloc

### 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.
- id: label; required: true; default: not specified. Label handle.
- point: chart.point; required: true; default: not specified. Coordinate.
Returns: void
```
lbl = label.new(bar_index, high, "x")
label.set_point(lbl, chart.point.now(close))
```
Aliases: alerta.label.set_point

### 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.
- id: label; required: true; default: not specified. Label handle.
- text_font_family: string; required: true; default: not specified. Font family.
Returns: void
```
lbl = label.new(bar_index, high, "x")
label.set_text_font_family(lbl, font.family_monospace)
```
Aliases: alerta.label.set_text_font_family, label.set_textfont_family

### 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.
- id: label; required: true; default: not specified. Label handle.
- text_formatting: string; required: true; default: not specified. Formatting flag.
Returns: void
```
lbl = label.new(bar_index, high, "x")
label.set_text_formatting(lbl, "bold")
```
Aliases: alerta.label.set_text_formatting

### 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.
- id: box; required: true; default: not specified. Box handle.
- left: int; required: true; default: not specified. Left x.
- top: float; required: true; default: not specified. Top y.
Returns: void
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_lefttop(b, bar_index - 10, high)
```
Aliases: alerta.box.set_lefttop

### 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.
- id: box; required: true; default: not specified. Box handle.
- right: int; required: true; default: not specified. Right x.
- bottom: float; required: true; default: not specified. Bottom y.
Returns: void
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_rightbottom(b, bar_index, low)
```
Aliases: alerta.box.set_rightbottom

### 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.
- id: box; required: true; default: not specified. Box handle.
- point: chart.point; required: true; default: not specified. Top-left coordinate.
Returns: void
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_top_left_point(b, chart.point.now(high))
```
Aliases: alerta.box.set_top_left_point

### 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.
- id: box; required: true; default: not specified. Box handle.
- point: chart.point; required: true; default: not specified. Bottom-right coordinate.
Returns: void
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_bottom_right_point(b, chart.point.now(low))
```
Aliases: alerta.box.set_bottom_right_point

### 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.
- id: box; required: true; default: not specified. Box handle.
- text_font_family: string; required: true; default: not specified. Font family.
Returns: void
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_text(b, "Zone")
box.set_text_font_family(b, font.family_monospace)
```
Aliases: alerta.box.set_text_font_family

### 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.
- id: box; required: true; default: not specified. Box handle.
- text_formatting: string; required: true; default: not specified. Formatting flag.
Returns: void
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_text(b, "Zone")
box.set_text_formatting(b, "bold")
```
Aliases: alerta.box.set_text_formatting

### 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.
- id: box; required: true; default: not specified. Box handle.
- text_wrap: string; required: true; default: not specified. text.wrap_auto | text.wrap_none.
Returns: void
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_text(b, "Zone notes")
box.set_text_wrap(b, text.wrap_auto)
```
Aliases: alerta.box.set_text_wrap

### 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.
- table_id: table; required: true; default: not specified. Table handle.
- position: string; required: true; default: not specified. top_left | top_center | top_right | middle_left | middle_right | bottom_left | bottom_center | bottom_right.
Returns: void
```
var t = table.new("top_right", 2, 2)
table.set_position(t, "bottom_right")
if barstate.islast
    table.cell(t, 0, 0, "Styled cell", text_color=chart.fg_color)
    table.cell(t, 1, 0, "Second cell", text_color=chart.fg_color)
```
Aliases: alerta.table.set_position

### 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.
- table_id: table; required: true; default: not specified. Table handle.
- bgcolor: color; required: true; default: not specified. Background color.
Returns: void
```
var t = table.new("top_right", 2, 2)
table.set_bgcolor(t, color.new(color.black, 80))
if barstate.islast
    table.cell(t, 0, 0, "Styled cell", text_color=chart.fg_color)
    table.cell(t, 1, 0, "Second cell", text_color=chart.fg_color)
```
Aliases: alerta.table.set_bgcolor

### 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.
- table_id: table; required: true; default: not specified. Table handle.
- border_color: color; required: true; default: not specified. Border color.
Returns: void
```
var t = table.new("top_right", 2, 2)
table.set_border_color(t, color.white)
if barstate.islast
    table.cell(t, 0, 0, "Styled cell", text_color=chart.fg_color)
    table.cell(t, 1, 0, "Second cell", text_color=chart.fg_color)
```
Aliases: alerta.table.set_border_color, table.set_frame_color

### 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.
- table_id: table; required: true; default: not specified. Table handle.
- border_width: int; required: true; default: not specified. Border width (px).
Returns: void
```
var t = table.new("top_right", 2, 2)
table.set_border_width(t, 2)
if barstate.islast
    table.cell(t, 0, 0, "Styled cell", text_color=chart.fg_color)
    table.cell(t, 1, 0, "Second cell", text_color=chart.fg_color)
```
Aliases: alerta.table.set_border_width, table.set_frame_width

### 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.
- size: int | series int; required: not specified; default: not specified. Optional initial size. Defaults to 0.
- initialValue: any | series; required: not specified; default: not specified. Optional initial fill value for each created element.
Returns: Array
```
arrA = array.new()
arrB = array.new_float(3, close)
// Pine v6 generic form (also supported):
var array<float> arrC = array.new<float>()
var array<int>   arrD = array.new<int>(9, 0)
```
Aliases: array.new_float, array, alerta.array.new

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: int; required: not specified; default: not specified. Optional initial int value.
Returns: Array<int>
```
arr = array.new_int(3, 0)
// Equivalent Pine v6 generic form:
var array<int> arr2 = array.new<int>(3, 0)
```
Aliases: alerta.array.new_int, array.new<int>

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: bool; required: not specified; default: not specified. Optional initial bool value.
Returns: Array<bool>
```
arr = array.new_bool(3, false)
// Equivalent Pine v6 generic form:
var array<bool> arr2 = array.new<bool>(3, false)
```
Aliases: alerta.array.new_bool, array.new<bool>

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: string; required: not specified; default: not specified. Optional initial string value.
Returns: Array<string>
```
arr = array.new_string(2, "")
// Equivalent Pine v6 generic form:
var array<string> arr2 = array.new<string>(2, "")
```
Aliases: alerta.array.new_string, array.new<string>

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: color; required: not specified; default: not specified. Optional initial color.
Returns: Array<color>
```
arr = array.new_color(1, color.new(color.green, 50))
```

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: line; required: not specified; default: not specified. Optional initial line handle.
Returns: Array<line>
```
arr = array.new_line(0)
```

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: linefill; required: not specified; default: not specified. Optional initial linefill handle.
Returns: Array<linefill>
```
indicator("Linefill array size", overlay=false)
fills = array.new_linefill(0)
plot(array.size(fills), "Empty linefill array size")
```

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: box; required: not specified; default: not specified. Optional initial box handle.
Returns: Array<box>
```
arr = array.new_box(0)
```

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: label; required: not specified; default: not specified. Optional initial label handle.
Returns: Array<label>
```
arr = array.new_label(0)
```

### 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.
- size: int; required: not specified; default: not specified. Optional initial size.
- initialValue: table; required: not specified; default: not specified. Optional initial table handle.
Returns: Array<table>
```
arr = array.new_table(0)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- index: int; required: true; default: not specified. Zero-based index; negative counts from the end in v6.
Returns: any
```
arr = array.new_float(2, 0)
v = array.get(arr, 0)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- index: int; required: true; default: not specified. Zero-based index; negative counts from the end in v6.
- value: any; required: true; default: not specified. Value to assign.
Returns: void
```
arr = array.new_float(0)
array.push(arr, 0)
array.set(arr, 0, close)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- value: any; required: true; default: not specified. Value to append.
Returns: void
```
arr = array.new_float(0)
array.push(arr, close)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: any
```
arr = array.new_float(0)
array.push(arr, close)
last = array.pop(arr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: any
```
arr = array.new_float(0)
array.push(arr, close)
first = array.shift(arr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- value: any; required: true; default: not specified. Value to prepend.
Returns: void
```
arr = array.new_float(0)
array.unshift(arr, close)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: int
```
arr = array.new_float(0)
array.push(arr, close)
n = array.size(arr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- index: int; required: true; default: not specified. Target index; negative counts from the end in v6.
- value: any; required: true; default: not specified. Value to insert.
Returns: void
```
arr = array.new_float(0)
array.push(arr, close)
array.insert(arr, 0, open)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- index: int; required: true; default: not specified. Target index; negative counts from the end in v6.
Returns: any
```
arr = array.new_float(0)
array.push(arr, close)
array.push(arr, open)
v = array.remove(arr, 0)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: void
```
myArr = array.new_float(0)
array.push(myArr, close)
array.clear(myArr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: any
```
myArr = array.new_float(0)
array.push(myArr, close)
firstVal = array.first(myArr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: float
```
myArr = array.new_float(0)
array.push(myArr, close)
array.push(myArr, close[1])
avgVal = array.avg(myArr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- nth: int; required: false; default: 0. 0-based rank: 0 = smallest, 1 = second smallest, …
Returns: float
```
myArr = array.new_float(0)
array.push(myArr, close)
array.push(myArr, close[1])
minVal = array.min(myArr)
secondMin = array.min(myArr, 1)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- value: any; required: true; default: not specified. Value to search for.
Returns: int
```
myArr = array.new_float(0)
array.push(myArr, close)
valueSeries = close
idx = array.indexof(myArr, valueSeries)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- value: any; required: true; default: not specified. Value to search for.
Returns: int
```
myArr = array.new_float(0)
array.push(myArr, 1)
array.push(myArr, 2)
array.push(myArr, 1)
idx = array.lastindexof(myArr, 1)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- order: string; required: false; default: not specified. "asc" or "desc" (default "asc")
Returns: void
```
indicator("Array Sort Example")
// Collect last 3 closing prices and sort them
myArr = array.new_float(0)
array.push(myArr, close)
array.push(myArr, close[1])
array.push(myArr, close[2])
array.sort(myArr, "desc")
plot(array.get(myArr, 0), { title: "Highest of Last 3" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: float
```
myArr = array.new_float(0)
array.push(myArr, 10)
array.push(myArr, 20)
sumVal = array.sum(myArr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- nth: int; required: false; default: 0. 0-based rank: 0 = largest, 1 = second largest, …
Returns: float
```
indicator("Array Max Example", overlay=false)
// Find highest spread in last 5 bars
spreads = array.new_float()
for i = 0 to 4
    array.push(spreads, high[i] - low[i])
maxSpread = array.max(spreads)
plot(maxSpread, { color: color.red, pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: any
```
myArr = array.new_float(0)
array.push(myArr, 10)
lastVal = array.last(myArr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- begin: int; required: true; default: not specified. Start index.
- end: int; required: false; default: not specified. End index (exclusive, at most the array size).
Returns: Array
```
myArr = array.new_float(0)
array.push(myArr, 10)
array.push(myArr, 20)
subArr = array.slice(myArr, 0, 2)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: Array
```
myArr = array.new_float(0)
newArr = array.copy(myArr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: void
```
myArr = array.new_float(0)
array.reverse(myArr)
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- separator: string; required: false; default: not specified. Separator string.
Returns: string
```
indicator("Array Join Example")
// Create a label containing all conditions met
conditions = array.new_string()
if close > sma(close,20)
    array.push(conditions, "Above SMA")
if rsi(close,14) > 70
    array.push(conditions, "Overbought")

if barstate.islast and array.size(conditions) > 0
    label.new(bar_index, high, array.join(conditions, "\n"))
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- value: any; required: true; default: not specified. Value to fill.
- index_from: int; required: false; default: 0. Start index (inclusive).
- index_to: int; required: false; default: not specified. End index (EXCLUSIVE). Omitted = to the end.
Returns: void
```
indicator("Array fill", overlay=false)
values = array.new_float(5, 0)
array.fill(values, 9, 1, 3)
plot(array.get(values, 1), "Filled index")
plot(array.get(values, 3), "Untouched index")
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- value: any; required: true; default: not specified. Value to search.
Returns: bool
```
myArr = array.new_float(0)
hasVal = array.includes(myArr, 5)
```

### 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.
- id: Array<int|float>; required: true; default: not specified. Numeric array handle.
Returns: Array<int|float>
```
arr = array.from(-3, 2, -1)
absArr = array.abs(arr)
plot(array.get(absArr, 0), { title: "abs[0]", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: bool
```
flags = array.new_bool(0)
array.push(flags, true)
array.push(flags, true)
allOk = array.every(flags)
```

### 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.
- id: Array<bool>; required: true; default: not specified. Boolean array handle.
Returns: bool
```
flags = array.from(false, true, false)
anyOk = array.some(flags)
plot(anyOk ? 1 : 0, { title: "any true", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Sorted array handle.
- value: float; required: true; default: not specified. Numeric value to search.
Returns: int
```
arr = array.new_float(0)
array.push(arr, 1)
array.push(arr, 3)
array.push(arr, 5)
idx = array.binary_search(arr, 3)
```

### 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.
- id: Array; required: true; default: not specified. Sorted array handle.
- value: float; required: true; default: not specified. Numeric value to search.
Returns: int
```
arr = array.from(-2, 0, 1, 5, 9)
idx = array.binary_search_leftmost(arr, 3)
plot(idx, { title: "leftmost", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Sorted array handle.
- value: float; required: true; default: not specified. Numeric value to search.
Returns: int
```
arr = array.from(-2, 0, 1, 5, 9)
idx = array.binary_search_rightmost(arr, 3)
plot(idx, { title: "rightmost", pane: "oscillator" })
```

### 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.
- v1..vn: any; required: true; default: not specified. Values to seed into a new array.
Returns: Array
```
arr = array.from(10, 20, 30)
second = array.get(arr, 1)
```

### 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.
- target: Array; required: true; default: not specified. Array that receives elements.
- source: Array; required: true; default: not specified. Array to append from.
Returns: Array (the mutated target)
```
a = array.from(1, 2)
b = array.from(3, 4)
merged = array.concat(a, b)
plot(array.size(merged), { title: "concat size", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: float
```
arr = array.from(2, 5, 9)
plot(array.range(arr), { title: "array range", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- biased: bool; required: false; default: true. true = population (÷n), false = sample (÷n-1).
Returns: float
```
arr = array.from(1, 2, 3)
plot(array.stdev(arr), { title: "array stdev", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- biased: bool; required: false; default: true. true = population (÷n), false = sample (÷n-1).
Returns: float
```
arr = array.from(1, 2, 3)
plot(array.variance(arr), { title: "array variance", pane: "oscillator" })
```

### 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.
- a: Array; required: true; default: not specified. First array.
- b: Array; required: true; default: not specified. Second array.
- biased: bool; required: false; default: true. true = population (÷n), false = sample (÷n-1).
Returns: float
```
a = array.from(1, 2, 3)
b = array.from(2, 4, 6)
plot(array.covariance(a, b), { title: "array cov", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: float
```
arr = array.from(1, 5, 3)
plot(array.median(arr), { title: "array median", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: float
```
arr = array.from(1, 2, 2, 3)
plot(array.mode(arr), { title: "array mode", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- percentage: float; required: true; default: not specified. Percentile 0..100.
Returns: float
```
arr = array.from(1, 2, 3, 4)
plot(array.percentile_nearest_rank(arr, 75), { title: "array p75 nr", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- percentage: float; required: true; default: not specified. Percentile 0..100.
Returns: float
```
arr = array.from(1, 2, 3, 4)
plot(array.percentile_linear_interpolation(arr, 75), { title: "array p75 li", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- index: int; required: true; default: not specified. Index of the element to rank.
Returns: float
```
arr = array.from(1, 2, 3, 4)
plot(array.percentrank(arr, 3), { title: "array percentrank", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
- order: string; required: false; default: not specified. "asc" or "desc".
Returns: Array
```
arr = array.from(30, 10, 20)
idx = array.sort_indices(arr, "asc")
plot(array.get(idx, 0), { title: "first sorted index", pane: "oscillator" })
```

### 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.
- id: Array; required: true; default: not specified. Array handle.
Returns: Array
```
arr = array.from(10, 12, 14)
z = array.standardize(arr)
plot(array.get(z, 0), { title: "z[0]", pane: "oscillator" })
```

### 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.
Returns: Map
```
var map<string, float> levels = map.new<string, float>()
map.put(levels, "support", low)
```
Aliases: dictionary, alerta.map.new

### 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.
- id: map; required: true; default: not specified. Map handle.
- key: any; required: true; default: not specified. Key to insert or update.
- value: any; required: true; default: not specified. Value to associate with the key.
Returns: void
```
var map<string, float> m = map.new<string, float>()
map.put(m, "support", low)
```
Aliases: alerta.map.put

### 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.
- id: map; required: true; default: not specified. Map handle.
- key: any; required: true; default: not specified. Key to look up.
Returns: any (na if missing)
```
levels = map.new()
map.put(levels, "support", low)
support = map.get(levels, "support")
```
Aliases: alerta.map.get

### 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.
- id: map; required: true; default: not specified. Map handle.
Returns: int
```
levels = map.new()
map.put(levels, "support", low)
n = map.size(levels)
```
Aliases: alerta.map.size

### 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.
- id: map; required: true; default: not specified. Map handle.
- key: any; required: true; default: not specified. Key to check.
Returns: bool
```
levels = map.new()
map.put(levels, "support", low)
if map.contains(levels, "support")
    label.new(bar_index, high, "has support")
```
Aliases: alerta.map.contains

### 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.
- id: map; required: true; default: not specified. Map handle.
Returns: array
```
levels = map.new()
map.put(levels, "support", low)
ks = map.keys(levels)
for k in ks
    label.new(bar_index, high, k)
```
Aliases: alerta.map.keys

### 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.
- id: map; required: true; default: not specified. Map handle.
Returns: array
```
levels = map.new()
map.put(levels, "support", low)
vs = map.values(levels)
```
Aliases: alerta.map.values

### 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.
- id: map; required: true; default: not specified. Map handle.
- key: any; required: true; default: not specified. Key to remove.
Returns: any (na if missing)
```
levels = map.new()
map.put(levels, "support", low)
map.remove(levels, "support")
```
Aliases: alerta.map.remove

### 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.
- id: map; required: true; default: not specified. Source map handle.
Returns: map
```
levels = map.new()
map.put(levels, "support", low)
snapshot = map.copy(levels)
```
Aliases: alerta.map.copy

### 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.
- id: map; required: true; default: not specified. Destination map.
- id2: map; required: true; default: not specified. Source map.
Returns: void
```
levels = map.new()
extras = map.new()
map.put(extras, "resistance", high)
map.put_all(levels, extras)
```
Aliases: alerta.map.put_all

### 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.
- id: map; required: true; default: not specified. Map handle.
Returns: void
```
levels = map.new()
map.put(levels, "support", low)
map.clear(levels)
```
Aliases: alerta.map.clear

### 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.
- rows: int; required: false; default: not specified. Number of rows. Default: 0.
- columns: int; required: false; default: not specified. Number of columns. Default: 0.
- value: any; required: not specified; default: not specified. Initial value for all elements.
Returns: Matrix ID (string)
```
const matId = matrix.new(3, 3, 0)
```
Aliases: matrix

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- row: int; required: true; default: not specified. Row index (0-based).
- column: int; required: true; default: not specified. Column index (0-based).
Returns: any
```
matId = matrix.new(3, 3, 0)
val = matrix.get(matId, 0, 0)
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- row: int; required: true; default: not specified. Row index (0-based).
- column: int; required: true; default: not specified. Column index (0-based).
- value: any; required: true; default: not specified. Value to set.
Returns: void
```
matId = matrix.new(3, 3, 0)
matrix.set(matId, 0, 0, 100)
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: int
```
matId = matrix.new(3, 3, 0)
r = matrix.rows(matId)
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: int
```
matId = matrix.new(3, 3, 0)
c = matrix.columns(matId)
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: Matrix ID (string)
```
m = matrix.new(2, 2, 1)
c = matrix.copy(m)
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: int
```
m = matrix.new(2, 3, 0)
count = matrix.elements_count(m)
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- value: any; required: true; default: not specified. Fill value.
- from_row: int; required: false; default: 0. Start row (inclusive).
- to_row: int; required: false; default: not specified. End row (EXCLUSIVE). Omitted = last row.
- from_column: int; required: false; default: 0. Start column (inclusive).
- to_column: int; required: false; default: not specified. End column (EXCLUSIVE). Omitted = last column.
Returns: void
```
indicator("Matrix fill", overlay=false)
m = matrix.new<float>(3, 3, 0.0)
matrix.fill(m, 7, 0, 2, 0, 2)
plot(matrix.get(m, 0, 0), "Filled cell")
plot(matrix.get(m, 2, 2), "Untouched cell")
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- row: int; required: true; default: not specified. Row index.
Returns: Array
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 1, 9)
r = matrix.row(m, 0)
plot(array.get(r, 1), { title: "row[1]", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- column: int; required: true; default: not specified. Column index.
Returns: Array
```
m = matrix.new(2, 2, 0)
matrix.set(m, 1, 0, 5)
c = matrix.col(m, 0)
plot(array.get(c, 1), { title: "col[1]", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: Matrix ID (string)
```
m = matrix.new(2, 3, 1)
t = matrix.transpose(m)
plot(matrix.rows(t), { title: "t rows", pane: "oscillator" })
```

### 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.
- a: string; required: true; default: not specified. Left matrix.
- b: string|float; required: true; default: not specified. Right matrix or scalar.
Returns: Matrix ID (string)
```
a = matrix.new(2, 2, 1)
b = matrix.new(2, 2, 2)
s = matrix.sum(a, b)
plot(matrix.get(s, 0, 0), { title: "sum00", pane: "oscillator" })
```

### 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.
- a: string; required: true; default: not specified. Left matrix.
- b: string|float; required: true; default: not specified. Right matrix or scalar.
Returns: Matrix ID (string)
```
a = matrix.new(2, 2, 5)
b = matrix.new(2, 2, 3)
d = matrix.diff(a, b)
plot(matrix.get(d, 0, 0), { title: "diff00", pane: "oscillator" })
```

### 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.
- a: string; required: true; default: not specified. Left matrix.
- b: string|float; required: true; default: not specified. Right matrix or scalar.
Returns: Matrix ID (string)
```
a = matrix.new(2, 2, 2)
m = matrix.mult(a, 3)
plot(matrix.get(m, 0, 0), { title: "mult00", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: float
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 4)
matrix.set(m, 1, 1, 6)
plot(matrix.trace(m), { title: "trace", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: float
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 1)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 3)
matrix.set(m, 1, 1, 4)
plot(matrix.avg(m), { title: "avg", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: float
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 4)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 3)
matrix.set(m, 1, 1, 1)
plot(matrix.min(m), { title: "min", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: float
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 4)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 3)
matrix.set(m, 1, 1, 1)
plot(matrix.max(m), { title: "max", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: float
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 1)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 3)
matrix.set(m, 1, 1, 4)
plot(matrix.median(m), { title: "median", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: float
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 0)
matrix.set(m, 0, 1, 0)
matrix.set(m, 1, 0, 1)
matrix.set(m, 1, 1, 1)
plot(matrix.mode(m), { title: "mode", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0)
plot(matrix.is_square(m) ? 1 : 0, { title: "is_square", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: float
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 1)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 3)
matrix.set(m, 1, 1, 4)
plot(matrix.det(m), { title: "det", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: Matrix ID (string), or na when the matrix cannot be inverted
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 4)
matrix.set(m, 0, 1, 7)
matrix.set(m, 1, 0, 2)
matrix.set(m, 1, 1, 6)
mi = matrix.inv(m)
plot(matrix.get(mi, 0, 0), { title: "inv00", pane: "oscillator" })
```
Singular or non-square at the current bar → na, not a stopped script.

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: int
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 1)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 2)
matrix.set(m, 1, 1, 4)
plot(matrix.rank(m), { title: "rank", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: Matrix ID (string)
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 1)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 3)
matrix.set(m, 1, 1, 4)
mp = matrix.pinv(m)
plot(matrix.get(mp, 0, 0), { title: "pinv00", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Square matrix ID.
- power: int; required: true; default: not specified. Non-negative integer exponent.
Returns: Matrix ID (string)
```
m = matrix.new(2, 2, 1)
p = matrix.pow(m, 3)
plot(matrix.get(p, 0, 0), { title: "pow00", pane: "oscillator" })
```

### 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.
- a: string; required: true; default: not specified. First matrix.
- b: string; required: true; default: not specified. Second matrix.
Returns: Matrix ID (string)
```
a = matrix.new(1, 2, 1)
b = matrix.new(1, 2, 2)
c = matrix.concat(a, b)
plot(matrix.rows(c), { title: "concat rows", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- fromRow: int; required: false; default: not specified. Start row (inclusive). Default: 0.
- toRow: int; required: false; default: not specified. End row (exclusive). Default: the row count.
- fromCol: int; required: false; default: not specified. Start col (inclusive). Default: 0.
- toCol: int; required: false; default: not specified. End col (exclusive). Default: the column count.
Returns: Matrix ID (string)
```
m = matrix.new(2, 2, 1)
s = matrix.submatrix(m, 0, 1, 0, 2)
plot(matrix.elements_count(s), { title: "sub elems", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- rows: int; required: true; default: not specified. New rows.
- cols: int; required: true; default: not specified. New cols.
Returns: void
```
m = matrix.new(2, 2, 1)
matrix.reshape(m, 1, 4)
plot(matrix.columns(m), { title: "reshape cols", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: void
```
m = matrix.new(2, 2, 0)
if barstate.isfirst
    matrix.set(m, 0, 0, 1)
    matrix.set(m, 1, 0, 9)
    matrix.reverse(m)
plot(matrix.get(m, 0, 0), { title: "rev00", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- column: int; required: not specified; default: not specified. Sort key column. Defaults to 0.
- order: sort_order; required: not specified; default: not specified. Use `order.ascending` or `order.descending`.
Returns: void
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 3)
matrix.set(m, 0, 1, 4)
matrix.set(m, 1, 0, 1)
matrix.set(m, 1, 1, 2)
matrix.sort(m)
plot(matrix.get(m, 0, 0), { title: "sorted first", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- a: int; required: true; default: not specified. First row index.
- b: int; required: true; default: not specified. Second row index.
Returns: void
```
m = matrix.new(2, 2, 0)
if barstate.isfirst
    matrix.set(m, 0, 0, 1)
    matrix.set(m, 1, 0, 2)
    matrix.swap_rows(m, 0, 1)
plot(matrix.get(m, 0, 0), { title: "swapr", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- a: int; required: true; default: not specified. First column index.
- b: int; required: true; default: not specified. Second column index.
Returns: void
```
m = matrix.new(2, 2, 0)
if barstate.isfirst
    matrix.set(m, 0, 0, 1)
    matrix.set(m, 0, 1, 2)
    matrix.swap_columns(m, 0, 1)
plot(matrix.get(m, 0, 0), { title: "swapc", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- index: int; required: false; default: not specified. Insert position. Default: after the last row.
- rowArray: Array; required: false; default: not specified. Array handle with row values. Default: a row of na.
Returns: void
```
m = matrix.new(1, 2, 0)
r = array.from(5, 6)
if barstate.isfirst
    matrix.add_row(m, 1, r)
plot(matrix.rows(m), { title: "rows+", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- index: int; required: false; default: not specified. Row index. Default: the last row.
Returns: Array
```
m = matrix.new(2, 2, 0)
if barstate.isfirst
    matrix.remove_row(m, 0)
plot(matrix.rows(m), { title: "rows-", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- index: int; required: false; default: not specified. Insert position. Default: after the last column.
- colArray: Array; required: false; default: not specified. Array handle with column values. Default: a column of na.
Returns: void
```
m = matrix.new(2, 1, 0)
c = array.from(7, 8)
if barstate.isfirst
    matrix.add_col(m, 1, c)
plot(matrix.columns(m), { title: "cols+", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
- index: int; required: false; default: not specified. Column index. Default: the last column.
Returns: Array
```
m = matrix.new(2, 2, 0)
if barstate.isfirst
    matrix.remove_col(m, 0)
plot(matrix.columns(m), { title: "cols-", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 1)
matrix.set(m, 1, 1, 1)
plot(matrix.is_identity(m) ? 1 : 0, { title: "identity", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 2)
matrix.set(m, 1, 1, 3)
plot(matrix.is_diagonal(m) ? 1 : 0, { title: "diag", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 3)
plot(matrix.is_antidiagonal(m) ? 1 : 0, { title: "anti", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 1)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 0, 2)
matrix.set(m, 1, 1, 1)
plot(matrix.is_symmetric(m) ? 1 : 0, { title: "sym", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0)
plot(matrix.is_zero(m) ? 1 : 0, { title: "zero", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 1)
plot(matrix.is_binary(m) ? 1 : 0, { title: "binary", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0)
matrix.set(m, 0, 0, 1)
matrix.set(m, 0, 1, 2)
matrix.set(m, 1, 1, 3)
plot(matrix.is_triangular(m) ? 1 : 0, { title: "tri", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0)
plot(matrix.is_antisymmetric(m) ? 1 : 0, { title: "anti", pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Matrix ID.
Returns: bool
```
m = matrix.new(2, 2, 0.5)
plot(matrix.is_stochastic(m) ? 1 : 0, { title: "stoch", pane: "oscillator" })
```

### 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.
- a: Matrix; required: true; default: not specified. Left matrix.
- b: Matrix; required: true; default: not specified. Right matrix.
Returns: Matrix
```
a = matrix.new(2, 2, 1)
b = matrix.new(2, 2, 2)
k = matrix.kron(a, b)
plot(matrix.rows(k), { pane: "oscillator" })
```

### 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.
- id: string; required: true; default: not specified. Square matrix ID.
Returns: Array<float> (descending)
```
m = matrix.new<float>(3, 3, 0.0)
matrix.set(m, 0, 0, 2.0)
ev = matrix.eigenvalues(m)
largest = array.get(ev, 0)
```

### 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.
- id: string; required: true; default: not specified. Square matrix ID.
Returns: matrix (columns = eigenvectors)
```
m = matrix.new<float>(3, 3, 0.0)
vecs = matrix.eigenvectors(m)
firstVecX = matrix.get(vecs, 0, 0)
```

### 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.
- position: string; required: true; default: not specified. "top_right", "middle_right", "bottom_center", etc.
- columns: int; required: true; default: not specified. Number of columns.
- rows: int; required: true; default: not specified. Number of rows.
- bgColor: string; required: not specified; default: not specified. Table background color.
- frameColor: string; required: not specified; default: not specified. Table frame color.
- frameWidth: int; required: not specified; default: not specified. Table frame width.
- borderColor: string; required: not specified; default: not specified. Cell border color.
- borderWidth: int; required: not specified; default: not specified. Cell border width.
- force_overlay: bool; required: not specified; default: not specified. Pine v6: draw on the main pane even from an oscillator script.
Returns: string (Table ID)
```
var t = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(t, 0, 0, "Hello", text_color=chart.fg_color)
```
Aliases: table

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- text: string; required: not specified; default: not specified. Text to display in the cell. Optional; the default is an empty string.
- width: int; required: not specified; default: not specified. Cell width as a % of the pane; 0 (default) fits the text.
- height: int; required: not specified; default: not specified. Cell height as a % of the pane; 0 (default) fits the text.
- textColor: string; required: not specified; default: not specified. Text color. Defaults to color.black (#363A45).
- textAlign: string; required: not specified; default: not specified. Text horizontal align.
- textValign: string; required: not specified; default: not specified. Text vertical align.
- textSize: int; required: not specified; default: not specified. Text size: size.tiny (8 px) / small (10) / normal (14, the default) / large (20) / huge (36), or an int size.
- bgColor: string; required: not specified; default: not specified. Cell background color.
- tooltip: string; required: not specified; default: not specified. Tooltip text shown on hover.
- text_font_family: string; required: not specified; default: not specified. Cell text font family.
- text_formatting: const; required: not specified; default: not specified. Pine v6: text.format_bold / text.format_italic / text.format_none (combine with +). Bold is drawn bold; cell text is regular otherwise.
Returns: void
```
t = table.new("top_right", 2, 2)
table.cell(t, 0, 0, "Current Price")
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- bgcolor: string; required: true; default: not specified. Cell background color.
Returns: void
```
var t = table.new(position.top_right, 1, 1)
if barstate.islast
    table.cell(t, 0, 0, "Background color", text_color=color.white)
    table.cell_set_bgcolor(t, 0, 0, color.blue)
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- text: string; required: true; default: not specified. New text value.
Returns: void
```
t = table.new("top_right", 2, 2)
table.cell(t, 0, 0, "A")
table.cell_set_text(t, 0, 0, "B")
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- text_color: string; required: true; default: not specified. Text color.
Returns: void
```
t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "X")
table.cell_set_text_color(t, 0, 0, "#22c55e")
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- text_halign: string; required: true; default: not specified. "left", "center", or "right".
Returns: void
```
t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "X")
table.cell_set_text_halign(t, 0, 0, "right")
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- text_size: int; required: true; default: not specified. Text size.
Returns: void
```
t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "X")
table.cell_set_text_size(t, 0, 0, 14)
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- text_valign: string; required: true; default: not specified. "top", "center", or "bottom".
Returns: void
```
t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "X")
table.cell_set_text_valign(t, 0, 0, "center")
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- tooltip: string; required: true; default: not specified. Tooltip text.
Returns: void
```
t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "X")
table.cell_set_tooltip(t, 0, 0, "tooltip")
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- width: int; required: true; default: not specified. Cell width.
Returns: void
```
t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "X")
table.cell_set_width(t, 0, 0, 120)
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- column: int; required: true; default: not specified. Column index (0-based).
- row: int; required: true; default: not specified. Row index (0-based).
- height: int; required: true; default: not specified. Cell height.
Returns: void
```
t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "X")
table.cell_set_height(t, 0, 0, 24)
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- start_column: int; required: not specified; default: not specified. Range start column.
- start_row: int; required: not specified; default: not specified. Range start row.
- end_column: int; required: not specified; default: not specified. Range end column.
- end_row: int; required: not specified; default: not specified. Range end row.
Returns: void
```
var t = table.new(position.top_right, 2, 1)
if barstate.islast
    table.cell(t, 0, 0, "Keep", text_color=chart.fg_color)
    table.cell(t, 1, 0, "Clear")
    table.clear(t, 1, 0, 1, 0)
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
Returns: void
```
indicator("table.delete", overlay=false)
var object = table.new(position.top_right, 1, 1)
if barstate.isfirst
    table.cell(object, 0, 0, "Example", text_color=chart.fg_color)
if bar_index == 10
    table.delete(object)
plot(array.size(table.all), "table objects remaining")
```

### 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.
- table_id: string; required: true; default: not specified. ID of the table.
- start_column: int; required: true; default: not specified. Range start column.
- start_row: int; required: true; default: not specified. Range start row.
- end_column: int; required: true; default: not specified. Range end column.
- end_row: int; required: true; default: not specified. Range end row.
Returns: void
```
t = table.new("top_right", 2, 2)
table.cell(t, 0, 0, "A")
table.merge_cells(t, 0, 0, 1, 0)
```

### 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.
- expr: any; required: true; default: not specified. Value being matched. May be omitted for boolean-chain style (each case is a boolean condition).
Returns: any
```
preset = "Default"
int length = switch preset
    "Scalping" => 10
    "Default"  => 14
    "Swing"    => 21
    => 14  // default arm — fires when no pattern matches

// Subject-less form: each case is a condition.
painting = true
color tone = switch
    not painting  => na
    close > open  => color.green
    => color.red

// An arm may open an indented block; its last statement is the value.
float share = switch math.sign(close - open)
    1 =>
        float total = math.sum(volume, 20)
        total > 0 ? volume / total : na
    -1 => 0.0
    => na
```
Aliases: alerta.switch

### 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.
- param = default: any; required: false; default: not specified. Optional parameter with default value. Default is re-evaluated on each call where the slot is missing.
- name = value (at the call site): any; required: false; default: not specified. Binds to the parameter of that name regardless of position. Unfilled slots fall back to their declared defaults.
Returns: any
```
safeDiv(float num, float den, float fallback = 0.0) =>
    den != 0 ? num / den : fallback

f(a, b = a * 2) =>
    a + b
plot(f(5))  // 15

// Named argument skips the middle slot, which keeps its default.
band(series float src, simple int len = 20, simple float mult = 2.0) =>
    ta.sma(src, len) + mult * ta.stdev(src, len)
plot(band(close, mult = 3.0))
```

### 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.
- positional: any; required: false; default: not specified. Fills fields in declaration order, left to right.
- field = value: any; required: false; default: not specified. Fills that field by name, in any position. Fields left unset keep their declared default.
Returns: instance of the type
```
type Sess
    float hi   = 0.0
    float lo   = 0.0
    bool  live = true

method widen(Sess self, float px) =>
    self.hi := math.max(self.hi, px)
    self.lo := math.min(self.lo, px)
    self

var array<Sess> all = array.new<Sess>()
if bar_index == 0
    all.push(Sess.new(high, live = false))

if all.size() > 0
    Sess s = all.get(0)
    s.widen(close)
plot(all.size() > 0 ? all.get(0).hi : na, { title: "Session high" })
```

### 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.
Returns: string
```
len = input.int(14, "Length", tooltip = '''The indicator's lookback.
Longer values react "slower".''')
plot(ta.rsi(close, len), { pane: "oscillator" })
```

### 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.
- name: identifier; required: true; default: not specified. Target variable. Must already be declared.
- expr: any; required: true; default: not specified. Right-hand side; combined with the existing value via the implied operator.
Returns: void
```
var int count = 0
for i = 0 to 9
    count += 1

// Equivalent to:
// count := count + 1
```

### 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()`).
- T: type; required: true; default: not specified. Element type: int, float, string, bool, color.
Returns: Array<T> | Matrix<T> | Map<T>
```
var array<float> buf = array.new<float>()
var array<int>   cnt = array.new<int>(9, 0)
array.push(buf, close)
// Older typed-suffix form (still supported):
// var buf2 = array.new_float()
```
A method called on a collection variable that holds na answers as its function form does: `a.size()` is 0, `a.indexof(x)` is -1 and `a.includes(x)` is false, exactly like `array.size(a)`, `array.indexof(a, x)` and `array.includes(a, x)`.
Aliases: alerta.array.new<T>

### 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.
- name: string; required: false; default: not specified. Name/title of the input parameter. Pine alias: title.
- defaultValue: any; required: false; default: not specified. Default value for the input. Pine aliases: defval, def.
- options: object; required: false; default: not specified. { min, max, step, options, type } constraints. Pine aliases include minval/maxval/type.
Returns: any
```
length = input(20, title="Length")
useTr = input(true, title="Use TR", type=bool)
plot(sma(close, length))
```
Aliases: setting, parameter

### 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.
- condition: bool or series bool; required: true; default: not specified. Condition to evaluate.
- trueValue: any; required: true; default: not specified. Value returned when condition is true.
- falseValue: any; required: true; default: not specified. Value returned when condition is false.
Returns: any or series any
```
barColor = iff(close > open, color.green, color.red)
plot(close, { color: barColor })
```

### 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.
- val: any; required: true; default: not specified. Value to check.
Returns: series bool
```
if (na(sma(close, 20))) {
  // Handle missing data during warmup
}
```
Aliases: isnan, isnull

### 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.
- val: any; required: true; default: not specified. Value to check.
- replacement: any; required: not specified; default: 0. Replacement value.
Returns: series any
```
const safeSma = nz(sma(close, 20), close)
```
Aliases: coalesce

### 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.
- source: series any; required: true; default: not specified. Input value or series.
Returns: series any
```
raw = close > open ? close : na
safe = fixnan(raw)
plot(safe)
```

### 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.
- value: any; required: true; default: not specified. Value to inspect.
Returns: string
```
t = typeof(close)
if barstate.islast
    label.new(bar_index, high, t)
```

### 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.
- message: string; required: true; default: not specified. Error text.
Returns: void
```
if (close <= 0)
  runtime.error("Invalid close value")
```
To report a problem without stopping the script, use log.warning or log.error instead.

### 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.
- value: any; required: true; default: not specified. Value to cast.
Returns: bool or series bool
```
isUp = bool(close - open)
plot(isUp ? close : na)
```

### 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.
- value: any; required: true; default: not specified. Value to cast.
Returns: int or series int
```
i = int(1.9)
plot(i, { pane: "oscillator" })
```

### 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.
- value: any; required: true; default: not specified. Value to cast.
Returns: float or series float
```
f = float("2.5")
plot(f, { pane: "oscillator" })
```

### 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.
- value: any; required: true; default: not specified. Value to cast.
Returns: string or series string
```
txt = string(close)
if barstate.islast
    label.new(bar_index, high, txt)
```

### 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.
- value: any; required: true; default: not specified. Value to cast.
Returns: color or series color
```
c = color("#00ff99")
plot(close, { color: c })
```

### 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.
- baseColor: color; required: true; default: not specified. Base color.
- transparency: int; required: true; default: not specified. Transparency in range 0..100.
Returns: color
```
c = color.new(color.green, 70)
plot(close, "Close", color = c)
// Per-bar transparency: opaque on rising bars, faint on falling ones
plot(open, "Open", color = color.new(color.blue, close > open ? 0 : 80))
```
Aliases: color.new

### 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.
- r: int; required: true; default: not specified. Red channel (0..255).
- g: int; required: true; default: not specified. Green channel (0..255).
- b: int; required: true; default: not specified. Blue channel (0..255).
- transparency: int; required: false; default: 0. Transparency 0..100.
Returns: color
```
c = color.rgb(255, 140, 0, 20)
plot(close, { color: c })
```
Aliases: color.rgb

### 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.
- source: series float; required: true; default: not specified. Source value.
- min: float; required: true; default: not specified. Minimum bound.
- max: float; required: true; default: not specified. Maximum bound.
- colorA: color; required: true; default: not specified. Color at min.
- colorB: color; required: true; default: not specified. Color at max.
Returns: series color
```
v = rsi(close, 14)
grad = color.from_gradient(v, 0, 100, color.red, color.green)
plot(v, { color: grad, pane: "oscillator" })
```
Aliases: color.from_gradient

### 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.
- colorValue: color; required: true; default: not specified. Input color.
Returns: int
```
r = color.r(color.green)
plot(r, { pane: "oscillator" })
```
Aliases: color.r

### 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.
- colorValue: color; required: true; default: not specified. Input color.
Returns: int
```
g = color.g(color.green)
plot(g, { pane: "oscillator" })
```
Aliases: color.g

### 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.
- colorValue: color; required: true; default: not specified. Input color.
Returns: int
```
b = color.b(color.green)
plot(b, { pane: "oscillator" })
```
Aliases: color.b

### 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.
- colorValue: color; required: true; default: not specified. Input color.
Returns: int
```
c = color.new(color.green, 60)
t = color.t(c)
plot(t, { pane: "oscillator" })
```
Aliases: color.t

### 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.
- x: series float; required: true; default: not specified. Value.
Returns: series float
```
const a = abs(close - open)
```
Aliases: math.abs

### 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.
- x: series float; required: true; default: not specified. Value 1.
- y: series float; required: true; default: not specified. Value 2.
Returns: series float
```
const m = min(open, close)
```
Aliases: math.min

### 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.
- x: series float; required: true; default: not specified. Value 1.
- y: series float; required: true; default: not specified. Value 2.
Returns: series float
```
const m = max(open, close)
```
Aliases: math.max

### 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.
- x: series float; required: true; default: not specified. Value to round.
- precision: series int; required: false; default: not specified. Decimal places to keep. Omitted = round to an integer.
Returns: series float
```
const r = round(1.5)
r2 = math.round(close / 7, 2)
plot(r2, { title: "two decimals" })
```
Aliases: math.round

### alerta.fixed
https://www.alertachart.com/alertascript/reference/builtins/fixed
Signature: fixed(val, precision)
Format a number to fixed decimal places.
- val: series float; required: true; default: not specified. Value to format.
- precision: int; required: not specified; default: 2. Number of decimal places.
Returns: series string
```
const priceStr = fixed(close, 2)
```
Aliases: toFixed

### 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.
- x: series float; required: true; default: not specified. Value.
Returns: series float
```
const sq = sqrt(16)
```
Aliases: math.sqrt

### 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.
- x: series float; required: true; default: not specified. Base.
- y: series float; required: true; default: not specified. Exponent.
Returns: series float
```
const p = pow(2, 3)
```
Aliases: math.pow

### 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.
- x: series float; required: true; default: not specified. Value.
Returns: series float
```
const l = log(close)
```
Aliases: math.log

### 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.
- x: series float; required: true; default: not specified. Input value.
Returns: series float
```
v = exp(1)
plot(v, { pane: "oscillator" })
```
Aliases: math.exp

### 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.
- x: series float; required: true; default: not specified. Input value.
Returns: series float
```
v = ceil(1.2)
plot(v, { pane: "oscillator" })
```
Aliases: math.ceil

### 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.
- x: series float; required: true; default: not specified. Input value.
Returns: series float
```
v = floor(1.8)
plot(v, { pane: "oscillator" })
```
Aliases: math.floor

### 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.
- a: series float; required: true; default: not specified. First value.
- b: series float; required: true; default: not specified. Second value.
Returns: series float
```
m = avg(open, close)
plot(m)
```
Aliases: math.avg

### 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.
- x: series float; required: true; default: not specified. Angle in radians.
Returns: series float
```
v = sin(close)
plot(v, { pane: "oscillator" })
```
Aliases: math.sin

### 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.
- x: series float; required: true; default: not specified. Angle in radians.
Returns: series float
```
v = cos(close)
plot(v, { pane: "oscillator" })
```
Aliases: math.cos

### 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.
- x: series float; required: true; default: not specified. Angle in radians.
Returns: series float
```
v = tan(close)
plot(v, { pane: "oscillator" })
```
Aliases: math.tan

### 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.
- x: series float; required: true; default: not specified. Domain -1..1.
Returns: series float
```
v = asin(0.5)
plot(v, { pane: "oscillator" })
```
Aliases: math.asin

### 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.
- x: series float; required: true; default: not specified. Domain -1..1.
Returns: series float
```
v = acos(0.5)
plot(v, { pane: "oscillator" })
```
Aliases: math.acos

### 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.
- x: series float; required: true; default: not specified. Input value.
Returns: series float
```
v = atan(close)
plot(v, { pane: "oscillator" })
```
Aliases: math.atan

### 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.
- x: series float; required: true; default: not specified. Input value.
Returns: series float
```
sg = sign(close - open)
plot(sg, { pane: "oscillator" })
```
Aliases: math.sign

### 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.
- x: series float; required: true; default: not specified. Input value > 0.
Returns: series float
```
v = log10(close)
plot(v, { pane: "oscillator" })
```
Aliases: math.log10

### 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.
- min: float; required: false; default: not specified. Lower bound (default 0).
- max: float; required: false; default: not specified. Upper bound (default 1).
- seed: int; required: false; default: not specified. Optional seed. The same seed reproduces the same sequence; omitting it draws from the unseeded stream.
Returns: float
```
r = random(0, 1)
repeatable = random(0, 1, 42)
plot(r, { pane: "oscillator" })
plot(repeatable, { pane: "oscillator" })
```
Aliases: math.random

### 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.
- x: series float; required: true; default: not specified. Input value.
Returns: series float
```
v = round_to_mintick(close)
plot(v)
```
Aliases: math.round_to_mintick

### 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.
- source: series float; required: true; default: not specified. Source series.
- length: int; required: true; default: not specified. Window length.
Returns: series float
```
v = math.sum(close, 14)
plot(v, { pane: "oscillator" })
```

### 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.
- x: series float; required: true; default: not specified. Radians.
Returns: series float
```
deg = todegrees(3.14159)
plot(deg, { pane: "oscillator" })
```
Aliases: math.todegrees

### 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.
- x: series float; required: true; default: not specified. Degrees.
Returns: series float
```
rad = toradians(180)
plot(rad, { pane: "oscillator" })
```
Aliases: math.toradians

### 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.
- source: series string; required: true; default: not specified. Source string.
- target: series string; required: true; default: not specified. String to search for.
Returns: series bool
```
indicator("String Contains Example")
// Check if current asset is Bitcoin based
const hasBTC = str.contains(syminfo.tickerid, "BTC")
if hasBTC and barstate.islast
    label.new(bar_index, high, "This is a Bitcoin pair!")
```
Aliases: str.contains

### 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.
- source: series string; required: true; default: not specified. The string.
Returns: series int
```
indicator("String Length Example")
// Filter out short ticket names
const len = str.length(syminfo.tickerid)
plot(len, { title: "Ticker Length" })
```
Aliases: str.length

### 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.
- source: series string; required: true; default: not specified. The string.
- begin: series int; required: true; default: not specified. Start index.
- end: series int; required: false; default: not specified. End index (exclusive).
Returns: series string
```
indicator("Ticker prefix")
prefix = str.substring(syminfo.tickerid, 0, 3)
if barstate.islast
    label.new(bar_index, high, prefix)
```
Aliases: str.substring

### 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.
- source: series string; required: true; default: not specified. Source string.
- target: series string; required: true; default: not specified. Target to replace.
- replacement: series string; required: true; default: not specified. Replacement string.
- occurrence: series int; required: false; default: not specified. Which occurrence of target to replace, counting from 0 (the first). The source comes back unchanged when there are fewer. Default 0.
Returns: series string
```
indicator("Replace Example")
// Remove BINANCE: prefix from the symbol
const cleanSymbol = str.replace(syminfo.tickerid, "BINANCE:", "")
if barstate.islast
    label.new(bar_index, high, cleanSymbol)
```
Aliases: str.replace

### 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.
- source: series string; required: true; default: not specified. Source string.
- target: series string; required: true; default: not specified. Target to replace.
- replacement: series string; required: true; default: not specified. Replacement string.
Returns: series string
```
const clean = str.replace_all(syminfo.tickerid, ":", "_")
```
Aliases: str.replace_all

### 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.
- source: series string; required: true; default: not specified. Source string.
- separator: series string; required: true; default: not specified. Separator string.
Returns: array<string>
```
indicator("Split example")
parts = str.split("10,20,30", ",")
fastLength = int(str.tonumber(array.get(parts, 0)))
plot(ta.sma(close, fastLength), "SMA from text")
```
Aliases: str.split

### 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.
- source: series string; required: true; default: not specified. Source string.
Returns: series string
```
const l = str.lower(syminfo.tickerid)
```
Aliases: str.lower

### 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.
- source: series string; required: true; default: not specified. Source string.
Returns: series string
```
const u = str.upper(syminfo.tickerid)
```
Aliases: str.upper

### 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.
- time: series int; required: true; default: not specified. UNIX time in milliseconds.
- format: series string; required: false; default: not specified. Pattern, default "yyyy-MM-dd'T'HH:mm:ssZ".
- timezone: series string; required: false; default: not specified. IANA timezone, "UTC" or "GMT±N". Defaults to syminfo.timezone.
Returns: series string
```
indicator("Bar time", overlay=true)
if barstate.islast
    label.new(bar_index, high, str.format_time(time, "yyyy-MM-dd HH:mm", "America/New_York"))
```
Aliases: str.format_time

### 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.
- source: series string; required: true; default: not specified. Source string.
- prefix: series string; required: true; default: not specified. Prefix.
Returns: series bool
```
const isBinance = str.startswith(syminfo.tickerid, "BINANCE")
```
Aliases: str.startswith

### 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.
- source: series string; required: true; default: not specified. Source string.
- suffix: series string; required: true; default: not specified. Suffix.
Returns: series bool
```
indicator("Ends With Demo")
// Check if it is a Tether pair
const isUSDT = str.endswith(syminfo.tickerid, "USDT")
if isUSDT
    plot(close, { color: color.green })
```
Aliases: str.endswith

### 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.
- source: series string; required: true; default: not specified. Source string.
Returns: series string
```
const t = str.trim("  hello  ")
```
Aliases: str.trim

### 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.
- source: series string; required: true; default: not specified. Source string.
- target: series string; required: true; default: not specified. Target string.
Returns: series int
```
const idx = str.pos(syminfo.tickerid, ":")
```
Aliases: str.pos, indexof

### 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.
- source: series string; required: true; default: not specified. Source string.
- regex: series string; required: true; default: not specified. Regex pattern.
Returns: series string
```
m = str.match("BTCUSDT", "[A-Z]+")
if barstate.islast
    label.new(bar_index, high, nz(m, "na"))
```
Aliases: str.match

### 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.
- source: series string; required: true; default: not specified. Numeric string.
Returns: series float
```
v = str.tonumber("123.45")
plot(v, { pane: "oscillator" })
```
Aliases: str.tonumber

### 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.
- value: any; required: true; default: not specified. Value to format as string.
- format: string; required: false; default: not specified. Optional Pine format pattern, e.g. "#.00", "+#.00;-#.00", or format.mintick.
Returns: series string
```
txt = str.tostring(close, format.mintick)
if barstate.islast
    label.new(bar_index, high, txt)
```
Aliases: str.tostring, tostring

### 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.
- template: series string; required: true; default: not specified. Template text with placeholders like {0} or {0,number,#.##}.
- arg0..n: any; required: false; default: not specified. Values injected into placeholders.
Returns: series string
```
msg = str.format("Close: {0,number,#.##}", close)
if barstate.islast
    label.new(bar_index, high, msg)
```
Aliases: str.format

### 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.
- title: string; required: true; default: not specified. Library title.
- overlay: bool; required: false; default: not specified. Whether library helpers default to drawing on the main chart (informational; the engine ignores this for the library header itself).
- dynamic_requests: bool; required: false; default: not specified. When true allows callers to invoke `request.*` family from within exported functions (Pine v6).
Returns: void
```
library("My Toolkit", overlay=true)
export hl2avg(simple int len) =>
    ta.sma(hl2, len)
```
Use only one script header: indicator OR strategy OR library OR study.
Pine v6 `export` prefix declares a function callable from importing scripts. The keyword is accepted; in the script itself the function works as a normal function.

### 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.
- title: string; required: true; default: not specified. Title of the indicator.
- shorttitle: string; required: not specified; default: not specified. Short title displayed on the chart (the script pane's header).
- overlay: bool; required: not specified; default: false. If true, will be drawn on main chart pane.
- format: string; required: not specified; default: not specified. How values are written on the script pane's price scale and in its legend: format.volume (K / M / B), format.percent (a % suffix), format.price / format.inherit (the chart's own).
- precision: int; required: not specified; default: not specified. Decimals of the values on the script pane's price scale and in its legend (0-16).
- max_labels_count: int; required: not specified; default: not specified. Max number of labels allowed.
- max_lines_count: int; required: not specified; default: not specified. Max number of lines allowed.
- max_boxes_count: int; required: not specified; default: not specified. Max number of boxes allowed.
- max_polylines_count: int; required: not specified; default: not specified. Max number of polylines allowed (Pine v6).
- max_bars_back: int; required: not specified; default: not specified. Accepted for compatibility and has no effect: every bar of a series' history can be referenced.
- explicit_plot_zorder: bool; required: not specified; default: not specified. Accepted for compatibility; it does not change the drawing order.
- timeframe: string; required: not specified; default: not specified. Accepted for compatibility; the script runs on the chart's timeframe. Use request.security to read another timeframe.
- timeframe_gaps: bool; required: not specified; default: not specified. Accepted for compatibility; it has no effect because timeframe has none.
- behind_chart: bool; required: not specified; default: not specified. Accepted for compatibility; it does not change where the script is drawn.
- calc_bars_count: int; required: not specified; default: not specified. Accepted for compatibility; the script is calculated over every loaded bar.
- dynamic_requests: bool; required: not specified; default: not specified. Accepted for compatibility: request.* calls inside functions, loops and if blocks, and with a symbol or timeframe that changes from bar to bar, work whether or not it is set.
- scale: string; required: not specified; default: not specified. Price scale the script is drawn against: scale.right, scale.left or scale.none (an overlay on its own hidden scale, e.g. volume columns under the candles). Named only here: listed last so positional arguments keep their places.
Returns: void
```
indicator("My RSI", overlay=false)
plot(rsi(close, 14), { pane: "oscillator" })
```

### 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.
- title: string; required: true; default: not specified. Title of the strategy.
- shorttitle: string; required: not specified; default: not specified. Short title.
- overlay: bool; required: not specified; default: true. Overlay on main chart.
- initial_capital: number; required: not specified; default: 10000. Backtest starting capital.
- default_qty_value: number; required: not specified; default: 1. Default position size.
- default_qty_type: string; required: not specified; default: strategy.fixed. Default quantity type. Pine v6: strategy.fixed (default_qty_value contracts) | strategy.contracts | strategy.cash (default_qty_value of cash per entry) | strategy.percent_of_equity (default_qty_value % of equity per entry, sized at the signal bar's close).
- currency: string; required: not specified; default: currency.NONE. Account currency. currency.NONE (default) is the symbol's own currency (USDT on BTCUSDT); no FX conversion is applied.
- pyramiding: number; required: not specified; default: 0. Maximum entries in same direction.
- commission_type: string; required: not specified; default: percent. Commission mode.
- commission_value: number; required: not specified; default: 0. Commission amount.
- slippage: number; required: not specified; default: 0. Per-order slippage in ticks.
- process_orders_on_close: bool; required: not specified; default: false. Pine v6: fill market-on-close orders at the closing price of the same bar.
- calc_on_order_fills: bool; required: not specified; default: false. Accepted for compatibility. The strategy is calculated once per bar; a fill does not trigger another calculation on the same bar.
- calc_on_every_tick: bool; required: not specified; default: false. Accepted for compatibility. On a live chart a strategy is recalculated while the bar forms whether or not this is set; historical bars are calculated once.
- close_entries_rule: string; required: not specified; default: FIFO. How stacked entries are unwound by exit-by-contract orders. FIFO (default) or ANY.
- margin_long: number; required: not specified; default: 100. Required margin (%) for long positions, 0..100.
- margin_short: number; required: not specified; default: 100. Required margin (%) for short positions, 0..100.
- max_lines_count: number; required: not specified; default: 50. Max live line.new objects (50..500).
- max_labels_count: number; required: not specified; default: 50. Max live label.new objects (50..500).
- max_boxes_count: number; required: not specified; default: 50. Max live box.new objects (50..500).
- max_polylines_count: number; required: not specified; default: 50. Max live polyline.new objects (1..100).
- max_bars_back: number; required: not specified; default: not specified. Accepted for compatibility and has no effect: every bar of a series' history can be referenced.
- risk_free_rate: number; required: not specified; default: 2.0. Accepted for compatibility; the Strategy Report has no Sharpe or Sortino ratio, so it changes nothing.
- use_bar_magnifier: bool; required: not specified; default: false. Accepted for compatibility. Fills are simulated on the chart's own bars (see the note on the order within a bar); lower-timeframe data is not used.
- fill_orders_on_standard_ohlc: bool; required: not specified; default: false. Accepted for compatibility: strategies always run and fill on the standard OHLC bars, also when the chart draws Heikin Ashi candles.
- scale: string; required: not specified; default: not specified. Price scale the strategy is drawn against: scale.right, scale.left or scale.none. Named only here: listed last so positional arguments keep their places.
Returns: void
```
strategy("Trend Strategy", overlay=true)
if bar_index == 1
  strategy.entry("Long", "long")
```
Only one script header is allowed: indicator OR strategy OR study.
Orders fill in the order the price reaches them within a bar, as on TradingView: market orders at the open (a close first, then an entry), then every resting limit, stop and trailing order along the path open → nearer extreme → farther extreme → close. An entry filled on the way arms the exits placed with it for the rest of that bar, and an exit filled on the way lets a resting entry fill later in the bar. A bar whose low is nearer the open than its high reaches a stop below the price before a target above it.
On a live chart the forming bar follows the path the price really took, so live fills match the order of the ticks. Each fill can fire the strategy's order-fill alert, also when it happened between two updates of the chart.

### 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.
- var: series; required: true; default: not specified. Series whose history budget is being declared.
- num: int; required: true; default: not specified. Requested history depth.
Returns: void
```
v = close
max_bars_back(v, 500)
plot(v)
```

### 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.
Returns: float
Value: 0.6180339887498948
```
indicator("Fibonacci Retracements", overlay=true)
const swing = highest(high, 50) - lowest(low, 50)
const fib618 = highest(high, 50) - swing * math.rphi
plot(fib618, { title: "61.8% Level", color: "#F59E0B" })
```
Aliases: math.rphi, reciprocal golden ratio

### 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.
Returns: string
```
indicator("Currency Label", overlay=true)
drawTable("cur", 0, 0, "Currency: " + syminfo.currency, { position: "top_left" })
```
Aliases: syminfo.currency

### 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.
Returns: string
```
indicator("Base Asset", overlay=true)
drawTable("base", 0, 0, syminfo.basecurrency, { position: "top_left" })
```
Aliases: syminfo.basecurrency

### 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.
Returns: string
```
indicator("Symbol Info", overlay=true)
drawTable("tz", 0, 0, "TZ: " + syminfo.timezone, { position: "top_left" })
```
Aliases: syminfo.timezone

### 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.
Returns: string
```
indicator("Asset Type", overlay=true)
const isCrypto = syminfo.type == "crypto"
bgcolor(isCrypto ? "rgba(59,130,246,0.03)" : "rgba(245,158,11,0.03)")
```
Aliases: syminfo.type

### 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.
Returns: string
```
indicator("Symbol Info", overlay=true)
drawTable("desc", 0, 0, syminfo.description, { position: "top_left" })
```
Aliases: syminfo.description

### 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.
Returns: string
```
indicator("Session Info", overlay=true)
drawTable("sess", 0, 0, "Session: " + syminfo.session, { position: "top_left" })
```
Aliases: syminfo.session

### 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.
Returns: float
```
indicator("Dollar Value", overlay=true)
const dollarMove = atr(14) * syminfo.pointvalue
drawTable("pv", 0, 0, "ATR $: " + fixed(dollarMove, 2), { position: "top_right" })
```
Aliases: syminfo.pointvalue

### 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.
Returns: string
```
indicator("Volume Type", overlay=true)
drawTable("vt", 0, 0, "Vol type: " + syminfo.volumetype, { position: "top_left" })
```
Aliases: syminfo.volumetype

### 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.
Returns: string
```
indicator("Country", overlay=true)
drawTable("c", 0, 0, "Listed in: " + syminfo.country, { position: "top_right" })
```
Aliases: syminfo.country

### 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.
Returns: string
```
indicator("Sector", overlay=true)
drawTable("s", 0, 0, syminfo.sector, { position: "top_right" })
```
Aliases: syminfo.sector

### 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.
Returns: string
```
indicator("Industry", overlay=true)
drawTable("i", 0, 0, syminfo.industry, { position: "top_right" })
```
Aliases: syminfo.industry

### 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.
Returns: float
```
indicator("Market cap", overlay=false)
shares = syminfo.shares_outstanding_total
plot(na(shares) ? na : close * shares, "Market cap")
```
Requires outstanding-share metadata from a supported stock data source; otherwise returns na.
Aliases: syminfo.shares_outstanding_total

### 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.
Returns: float
```
indicator("Float", overlay=false)
plot(nz(syminfo.shares_outstanding_float, syminfo.shares_outstanding_total), "Shares")
```
Always na: the company profile AlertaChart carries has no float figure, so the example draws nothing.
Aliases: syminfo.shares_outstanding_float

### 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.
Returns: int
```
indicator("Employees", overlay=false)
plot(na(syminfo.employees) ? 0 : syminfo.employees, "Employees")
```
Aliases: syminfo.employees

### 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.
Returns: int
```
indicator("Shareholders", overlay=false)
plot(na(syminfo.shareholders) ? 0 : syminfo.shareholders, "Shareholders")
```
Aliases: syminfo.shareholders

### 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.
Returns: int
```
indicator("TF Multiplier", overlay=true)
drawTable("tf", 0, 0, "TF x" + str.tostring(timeframe.multiplier), { position: "top_left" })
```
Aliases: timeframe.multiplier

### 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.
Returns: bool
```
indicator("TF Type", overlay=true)
if timeframe.isminutes
  drawTable("tf", 0, 0, "Intraday (mins)", { position: "top_left" })
```
Aliases: timeframe.isminutes

### 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.
Returns: bool
```
indicator("TF Type", overlay=true)
if timeframe.isseconds
  drawTable("tf", 0, 0, "Sub-minute chart", { position: "top_left" })
```
Aliases: timeframe.isseconds

### 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.
Returns: bool
```
indicator("Long-Term Signal", overlay=true)
if timeframe.isdwm
  const trend = close > sma(close, 50) ? "BULL" : "BEAR"
  drawTable("ltt", 0, 0, trend, { position: "top_left" })
```
Aliases: timeframe.isdwm

### 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.
Returns: string
Value: regular
```
inSession = time("D", session.regular)
```
Aliases: alerta.session.regular

### 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.
Returns: string
Value: extended
```
inSession = time("D", session.extended)
```
Aliases: alerta.session.extended

### 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.
Returns: series<bool>
```
ema20 = ta.ema(close, 20)
plotshape(session.ismarket and ta.crossover(close, ema20), style=shape.triangleup)
```
Aliases: alerta.session.ismarket

### 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.
Returns: series<bool>
```
if session.ispremarket
    bgcolor(color.new(color.blue, 90))
```
Requires an equity chart with premarket bars; no highlight is expected on 24/7 crypto.
Aliases: alerta.session.ispremarket

### 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.
Returns: series<bool>
```
if session.ispostmarket
    bgcolor(color.new(color.purple, 90))
```
Requires an equity chart with postmarket bars; no highlight is expected on 24/7 crypto.
Aliases: alerta.session.ispostmarket

### 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.
Returns: series<bool>
```
if session.isfirstbar
    label.new(bar_index, high, "start")
```
Aliases: alerta.session.isfirstbar

### 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.
Returns: series<bool>
```
if session.islastbar
    label.new(bar_index, high, "end")
```
Aliases: alerta.session.islastbar

### 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.
- prefix: string; required: true; default: not specified. Exchange / data provider prefix (e.g. "BINANCE").
- ticker: string; required: true; default: not specified. Symbol identifier (e.g. "BTCUSDT").
- session: string; required: not specified; default: not specified. session.regular | session.extended.
- adjustment: string; required: not specified; default: not specified. adjustment.none | adjustment.dividends | adjustment.splits.
- backadjustment: string; required: not specified; default: not specified. Pine v6: backadjustment.inherit | on | off. Continuous-futures back-adjustment.
- settlement_as_close: string; required: not specified; default: not specified. Pine v6: settlement_as_close.inherit | on | off. Futures settlement-as-close for 1D+ TFs.
Returns: string
```
sym = ticker.new("BINANCE", "BTCUSDT")
drawTable("sym", 0, 0, sym, { position: "top_right" })
```
Aliases: alerta.ticker.new

### 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.
- tickerid: string; required: true; default: not specified. Source ticker ID.
- session: string; required: not specified; default: not specified. New session.
- adjustment: string; required: not specified; default: not specified. New adjustment.
- backadjustment: string; required: not specified; default: not specified. Pine v6: backadjustment.inherit | on | off.
- settlement_as_close: string; required: not specified; default: not specified. Pine v6: settlement_as_close.inherit | on | off.
Returns: string
```
sym = ticker.modify(syminfo.tickerid, session.extended)
```
Aliases: alerta.ticker.modify

### 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.
- symbol: string; required: true; default: not specified. Source ticker ID.
Returns: string
```
ha = ticker.heikinashi(syminfo.tickerid)
drawTable("ha", 0, 0, ha, { position: "top_right" })
```
Aliases: alerta.ticker.heikinashi

### 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.
- symbol: string; required: true; default: not specified. Source ticker ID.
- style: string; required: not specified; default: not specified. "ATR" or "Traditional".
- arg: float; required: not specified; default: not specified. Brick size.
Returns: string
```
r = ticker.renko(syminfo.tickerid, "ATR", 14)
```
Aliases: alerta.ticker.renko

### 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.
- symbol: string; required: true; default: not specified. Source ticker ID.
- lines: int; required: not specified; default: not specified. Number of lines (default 3).
Returns: string
```
lb = ticker.linebreak(syminfo.tickerid, 3)
```
Aliases: alerta.ticker.linebreak

### 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.
- symbol: string; required: true; default: not specified. Source ticker ID.
- reversal: float; required: not specified; default: not specified. Reversal amount (ATR multiple).
Returns: string
```
k = ticker.kagi(syminfo.tickerid, 1.0)
```
Aliases: alerta.ticker.kagi

### 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.
- symbol: string; required: true; default: not specified. Source ticker ID.
- source: string; required: not specified; default: not specified. "high/low" or "close".
- style: string; required: not specified; default: not specified. Box-sizing style.
- boxSize: float; required: not specified; default: not specified. Box size.
- reversal: int; required: not specified; default: not specified. Reversal in boxes.
Returns: string
```
pf = ticker.pointfigure(syminfo.tickerid, "close", "Traditional", 1.0, 3)
```
Aliases: alerta.ticker.pointfigure

### 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.
- from_tickerid: string; required: true; default: not specified. Reference ticker.
- symbol: string; required: true; default: not specified. New symbol to apply the same feed type to.
Returns: string
```
ethHA = ticker.inherit(ticker.heikinashi(syminfo.tickerid), "BINANCE:ETHUSDT")
```
Aliases: alerta.ticker.inherit

### 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.
- symbol: string; required: not specified; default: not specified. Source ticker (defaults to syminfo.tickerid).
Returns: string
```
std = ticker.standard(syminfo.tickerid)
```
Aliases: alerta.ticker.standard

### 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.
Returns: int
```
ps = ticker.pricescale()
```
Aliases: alerta.ticker.pricescale

### 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.
Returns: float
```
t = ticker.mintick()
```
Aliases: alerta.ticker.mintick

### 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.
Returns: color
```
label.new(bar_index, high, "tag", color=chart.fg_color)
```
Aliases: alerta.chart.fg_color

### 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.
Returns: color
```
bgcolor(chart.bg_color)
```
Aliases: alerta.chart.bg_color

### 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.
Returns: bool
```
if not chart.is_standard
    runtime.error("This script only runs on standard candles")
```
Aliases: alerta.chart.is_standard

### 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.
Returns: int
```
startMs = chart.left_visible_bar_time
```
Aliases: alerta.chart.left_visible_bar_time

### 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.
Returns: int
```
endMs = chart.right_visible_bar_time
```
Aliases: alerta.chart.right_visible_bar_time

### 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.
Returns: string
Value: percent_of_equity
```
strategy("Demo", default_qty_type = strategy.percent_of_equity, default_qty_value = 10)
```
Aliases: alerta.strategy.percent_of_equity

### 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.
Returns: string
Value: cash
```
strategy("Demo", default_qty_type = strategy.cash, default_qty_value = 1000)
```
Aliases: alerta.strategy.cash

### 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.
Returns: string
Value: fixed
```
strategy("Demo", default_qty_type = strategy.fixed, default_qty_value = 1)
```
Aliases: alerta.strategy.fixed

### 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.
Returns: string
Value: contracts
```
strategy("Demo", default_qty_type = strategy.contracts, default_qty_value = 1)
```
Aliases: alerta.strategy.contracts

### 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.
Returns: string
Value: none
```
strategy("strategy.oca.none", overlay=false)
if bar_index == 3
    strategy.entry("A", strategy.long, qty=1, oca_name="group", oca_type=strategy.oca.none)
    strategy.entry("B", strategy.long, qty=1, stop=high, oca_name="group", oca_type=strategy.oca.none)
if bar_index == 10
    strategy.close_all()
plot(strategy.position_size, "Position size")
```
Aliases: alerta.strategy.oca.none

### 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.
Returns: string
Value: cancel
```
strategy("strategy.oca.cancel", overlay=false)
if bar_index == 3
    strategy.entry("A", strategy.long, qty=1, oca_name="group", oca_type=strategy.oca.cancel)
    strategy.entry("B", strategy.long, qty=1, stop=high, oca_name="group", oca_type=strategy.oca.cancel)
if bar_index == 10
    strategy.close_all()
plot(strategy.position_size, "Position size")
```
Aliases: alerta.strategy.oca.cancel

### 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.
Returns: string
Value: reduce
```
strategy("strategy.oca.reduce", overlay=false)
if bar_index == 3
    strategy.entry("A", strategy.long, qty=1, oca_name="group", oca_type=strategy.oca.reduce)
    strategy.entry("B", strategy.long, qty=1, stop=high, oca_name="group", oca_type=strategy.oca.reduce)
if bar_index == 10
    strategy.close_all()
plot(strategy.position_size, "Position size")
```
Aliases: alerta.strategy.oca.reduce

### 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.
Returns: string
```
name = strategy.position_entry_name
```
Aliases: alerta.strategy.position_entry_name

### 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.
Returns: float
```
maxSz = strategy.position_size_max
```
Aliases: alerta.strategy.position_size_max

### 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.
Returns: float
```
maxAll = strategy.max_contracts_held_all
```
Aliases: alerta.strategy.max_contracts_held_all

### 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.
Returns: float
```
maxL = strategy.max_contracts_held_long
```
Aliases: alerta.strategy.max_contracts_held_long

### 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.
Returns: float
```
maxS = strategy.max_contracts_held_short
```
Aliases: alerta.strategy.max_contracts_held_short

### 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.
Returns: enum
```
enum Side
    Long  = "long"
    Short = "short"
    Flat

state = Side.Long
memberCount = array.size(Side.all())
```
Aliases: EnumName.all

### 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.
Returns: library
```
import TradingView/ta/7 as ta7
plot(ta7.rsi(close, 14))
```

### 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.
Returns: string
Value: adjustment.none
```
sym = ticker.new(syminfo.prefix, syminfo.ticker, session.regular, adjustment.none)
```
Aliases: alerta.adjustment.none

### 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.
Returns: string
Value: adjustment.splits
```
sym = ticker.new(syminfo.prefix, syminfo.ticker, session.regular, adjustment.splits)
```
Aliases: alerta.adjustment.splits

### 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.
Returns: string
Value: adjustment.dividends
```
sym = ticker.new(syminfo.prefix, syminfo.ticker, session.regular, adjustment.dividends)
```
Aliases: alerta.adjustment.dividends

### 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.
Returns: string
Value: backadjustment.inherit
```
sym = ticker.new("CME_MINI", "ES1!", session.regular, adjustment.none, backadjustment.inherit)
```
Aliases: alerta.backadjustment.inherit

### 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.
Returns: string
Value: backadjustment.on
```
sym = ticker.new("CME_MINI", "ES1!", session.regular, adjustment.none, backadjustment.on)
```
Aliases: alerta.backadjustment.on

### 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.
Returns: string
Value: backadjustment.off
```
sym = ticker.new("CME_MINI", "ES1!", session.regular, adjustment.none, backadjustment.off)
```
Aliases: alerta.backadjustment.off

### 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.
Returns: string
Value: settlement_as_close.inherit
```
sym = ticker.modify(syminfo.tickerid, session.regular, adjustment.none, backadjustment.inherit, settlement_as_close.inherit)
```
Aliases: alerta.settlement_as_close.inherit

### 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.
Returns: string
Value: settlement_as_close.on
```
sym = ticker.modify(syminfo.tickerid, session.regular, adjustment.none, backadjustment.inherit, settlement_as_close.on)
```
Aliases: alerta.settlement_as_close.on

### 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.
Returns: string
Value: settlement_as_close.off
```
sym = ticker.modify(syminfo.tickerid, session.regular, adjustment.none, backadjustment.inherit, settlement_as_close.off)
```
Aliases: alerta.settlement_as_close.off

### 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.
Returns: string
Value: default
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "x")
table.cell_set_text_font_family(t, 0, 0, font.family_default)
```
Aliases: alerta.font.family_default

### 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.
Returns: string
Value: monospace
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "x")
table.cell_set_text_font_family(t, 0, 0, font.family_monospace)
```
Aliases: alerta.font.family_monospace

### 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.
Returns: string
Value: none
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "x")
table.cell_set_text_formatting(t, 0, 0, text.format_none)
```
Aliases: alerta.text.format_none

### 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.
Returns: string
Value: bold
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "x")
table.cell_set_text_formatting(t, 0, 0, text.format_bold)
```
Aliases: alerta.text.format_bold

### 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.
Returns: string
Value: italic
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "x")
table.cell_set_text_formatting(t, 0, 0, text.format_italic)
```
Aliases: alerta.text.format_italic

### 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.
Returns: string
Value: left
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "x")
table.cell_set_text_halign(t, 0, 0, text.align_left)
```
Aliases: alerta.text.align_left

### 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.
Returns: string
Value: center
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "x")
table.cell_set_text_halign(t, 0, 0, text.align_center)
```
Aliases: alerta.text.align_center

### 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.
Returns: string
Value: right
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "x")
table.cell_set_text_halign(t, 0, 0, text.align_right)
```
Aliases: alerta.text.align_right

### 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.
Returns: string
Value: top
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_text(b, "aligned")
box.set_text_valign(b, text.align_top)
```
Aliases: alerta.text.align_top

### 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.
Returns: string
Value: bottom
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_text(b, "aligned")
box.set_text_valign(b, text.align_bottom)
```
Aliases: alerta.text.align_bottom

### 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.
Returns: string
Value: auto
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_text(b, "wrapped")
box.set_text_wrap(b, text.wrap_auto)
```
Aliases: alerta.text.wrap_auto

### 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.
Returns: string
Value: none
```
b = box.new(bar_index - 5, high, bar_index, low)
box.set_text(b, "wrapped")
box.set_text_wrap(b, text.wrap_none)
```
Aliases: alerta.text.wrap_none

### 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.
- table_id: table; required: true; default: not specified. Table handle.
- column: int; required: true; default: not specified. Cell column (0-indexed).
- row: int; required: true; default: not specified. Cell row (0-indexed).
- text_font_family: string; required: true; default: not specified. font.family_default | font.family_monospace.
Returns: void
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "Δ")
table.cell_set_text_font_family(t, 0, 0, font.family_monospace)
```
Aliases: alerta.table.cell_set_text_font_family

### 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.
- table_id: table; required: true; default: not specified. Table handle.
- column: int; required: true; default: not specified. Cell column.
- row: int; required: true; default: not specified. Cell row.
- text_formatting: string; required: true; default: not specified. text.format_none | text.format_bold | text.format_italic.
Returns: void
```
var t = table.new("top_right", 1, 1)
table.cell(t, 0, 0, "PnL")
table.cell_set_text_formatting(t, 0, 0, text.format_bold)
```
Aliases: alerta.table.cell_set_text_formatting

### 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.
Returns: series float
```
plot(ta.ema(hlcc4, 14))
```
Aliases: alerta.hlcc4

### 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.
Returns: series float
```
if not na(ask)
    label.new(bar_index, ask, "Ask: " + str.tostring(ask))
```
Always na on AlertaChart, so the example draws nothing.
Aliases: alerta.ask

### 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.
Returns: series float
```
if not na(bid)
    label.new(bar_index, bid, "Bid: " + str.tostring(bid))
```
Always na on AlertaChart, so the example draws nothing.
Aliases: alerta.bid

### 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.
Returns: series int
```
plot(last_bar_time, { pane: "oscillator" })
```
Aliases: alerta.last_bar_time

### 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.
Returns: series int
```
isFridaySession = dayofweek(time_tradingday) == 6
```
Aliases: alerta.time_tradingday

### 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.
Returns: series int
```
minutesSinceLastBar = (timenow - last_bar_time) / 60000
label.new(bar_index, high, str.tostring(minutesSinceLastBar) + " min ago")
```
Aliases: alerta.timenow

### 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.
Returns: qualifier
```
const string TITLE = "My Indicator"
const int LEN = 14
```

### 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.
Returns: qualifier
```
simple int fastLen = input.int(12, "Fast")
plot(ta.ema(close, fastLen))
```

### 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.
Returns: qualifier
```
series float ema14 = ta.ema(close, 14)
plot(ema14)
```

### 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.
Returns: type
```
indicator("Bar delta")
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.delta(), "Bar delta")
```

### 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.
Returns: type
```
footprint fp = request.footprint(10)
volume_row poc = na(fp) ? na : fp.poc()
plot(na(poc) ? na : poc.up_price(), "POC top")
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
Returns: series float
```
indicator("Buy volume")
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.buy_volume(), "Buy volume", color = color.teal)
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
Returns: series float
```
indicator("Sell volume")
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.sell_volume(), "Sell volume", color = color.red)
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
Returns: series float
```
indicator("Footprint volume")
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.total_volume(), "Footprint volume")
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
Returns: series float
```
indicator("Footprint delta")
footprint fp = request.footprint(10)
float d = na(fp) ? na : fp.delta()
plot(d, "Delta", style = plot.style_columns, color = d >= 0 ? color.teal : color.red)
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
Returns: volume_row — na when the bar has no volume
```
footprint fp = request.footprint(10)
volume_row poc = na(fp) ? na : fp.poc()
plot(na(poc) ? na : (poc.up_price() + poc.down_price()) / 2, "POC")
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
Returns: volume_row
```
footprint fp = request.footprint(10, 70)
plot(na(fp) ? na : fp.vah().up_price(), "VAH")
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
Returns: volume_row
```
footprint fp = request.footprint(10, 70)
plot(na(fp) ? na : fp.val().down_price(), "VAL")
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
Returns: array<volume_row>
```
indicator("Buy imbalances")
footprint fp = request.footprint(10)
int buyImb = 0
if not na(fp)
    for r in fp.rows()
        buyImb += r.has_buy_imbalance() ? 1 : 0
plot(buyImb, "Buy imbalances")
```

### 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.
- id: footprint; required: true; default: not specified. A footprint from request.footprint().
- price: series float; required: true; default: not specified. The price to look up.
Returns: volume_row — na outside the bar's rows
```
indicator("Delta at the close")
footprint fp = request.footprint(10)
volume_row atClose = na(fp) ? na : fp.get_row_by_price(close)
plot(na(atClose) ? na : atClose.delta(), "Delta at the close")
```

### 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.
- id: volume_row; required: true; default: not specified. A row of a footprint.
Returns: series float
```
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.poc().up_price(), "POC top")
```

### 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.
- id: volume_row; required: true; default: not specified. A row of a footprint.
Returns: series float
```
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.poc().down_price(), "POC bottom")
```

### 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.
- id: volume_row; required: true; default: not specified. A row of a footprint.
Returns: series float
```
indicator("POC buy volume")
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.poc().buy_volume(), "POC buy volume")
```

### 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.
- id: volume_row; required: true; default: not specified. A row of a footprint.
Returns: series float
```
indicator("POC sell volume")
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.poc().sell_volume(), "POC sell volume")
```

### 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.
- id: volume_row; required: true; default: not specified. A row of a footprint.
Returns: series float
```
indicator("POC volume")
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.poc().total_volume(), "POC volume")
```

### 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.
- id: volume_row; required: true; default: not specified. A row of a footprint.
Returns: series float
```
indicator("POC delta")
footprint fp = request.footprint(10)
plot(na(fp) ? na : fp.poc().delta(), "POC delta")
```

### 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.
- id: volume_row; required: true; default: not specified. A row of a footprint.
Returns: series bool
```
indicator("POC buy imbalance")
footprint fp = request.footprint(10, 70, 300)
plot(na(fp) ? na : (fp.poc().has_buy_imbalance() ? 1 : 0), "POC buy imbalance")
```

### 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.
- id: volume_row; required: true; default: not specified. A row of a footprint.
Returns: series bool
```
indicator("POC sell imbalance")
footprint fp = request.footprint(10, 70, 300)
plot(na(fp) ? na : (fp.poc().has_sell_imbalance() ? 1 : 0), "POC sell imbalance")
```

### 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.
Returns: const int
Value: 2
```
//@version=6
indicator("Monday Highlight", overlay=true)
isMonday = dayofweek == dayofweek.monday
bgcolor(isMonday ? color.new(color.blue, 85) : na)
```
Aliases: dayofweek.sunday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday, dayofweek.saturday

### 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.
Returns: simple string
```
isSameSymbol = syminfo.tickerid == syminfo.main_tickerid
```
Aliases: alerta.syminfo.main_tickerid

### 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.
Returns: simple string
```
isChartTf = timeframe.period == timeframe.main_period
```
Aliases: timeframe.isticks

### 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.
- from: simple string; required: true; default: not specified. Source currency code (e.g. currency.USD).
- to: simple string; required: true; default: not specified. Target currency code.
- ignore_invalid_currency: bool; required: not specified; default: not specified. Pine v6: return na instead of raising when the pair has no rate.
Returns: series float
```
indicator("EUR close", overlay=false)
rate = request.currency_rate(currency.USD, currency.EUR)
plot(close * rate, "Close in EUR")
```
Requires the requested currency-rate data; unavailable rates return na.
Aliases: alerta.request.currency_rate

### 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.
- country_code: simple string; required: true; default: not specified. Two-letter country code, e.g. "US".
- field: simple string; required: true; default: not specified. Series code, e.g. "GDP", "IRYY", "INTR", "UR".
- gaps: bool; required: not specified; default: not specified. barmerge.gaps_on shows the value only on the bar it arrives.
- ignore_invalid_symbol: bool; required: not specified; default: not specified. Return na instead of raising for an unavailable series.
Returns: series float
```
indicator("US inflation", overlay=false)
plot(request.economic("US", "IRYY"), "Inflation YoY %")
```
Requires the requested economic series; unavailable series return na.
Aliases: alerta.request.economic

### 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.
- message: any; required: true; default: not specified. Value to convert to a readable diagnostic message, or a str.format template followed by its values.
Returns: void
```
//@version=6
indicator("Inspect a value")
if barstate.islast
    log.info("Last close: " + str.tostring(close))
if volume == 0
    log.warning("No volume on bar " + str.tostring(bar_index))
if high < low
    log.error("High below low on bar " + str.tostring(bar_index))
plot(close)
```
Pine's template form `log.info("close {0} on bar {1}", close, bar_index)` is filled in as str.format fills it. A series value — close, or a string read with request.security — is written as it stands on the bar that logs it.
Aliases: log.warning, log.error

### 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.
- source: string; required: true; default: not specified. Text to repeat.
- repeat: int; required: true; default: not specified. Number of repetitions. A fractional count is rounded down and a negative one counts as zero.
- separator: string; required: false; default: "". Text inserted between copies; no separator is appended after the last copy.
Returns: string
```
//@version=6
indicator("Repeat text")
message = str.repeat("BTC", 3, " / ")
if barstate.islast
    log.info(message)
plot(close)
```
A repeat count of zero produces an empty string.

### 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.
Returns: series bool
```
//@version=6
indicator("Historical boundary")
plotshape(barstate.islastconfirmedhistory, style = shape.circle)
plot(close)
```

### 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.
Returns: string
```
//@version=6
indicator("Symbol root")
if barstate.islast
    log.info(syminfo.root)
plot(close)
```
Root extraction follows AlertaChart symbol metadata and may differ from another provider’s contract naming.

### 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.
Returns: series float
```
//@version=6
strategy("Average entry")
if bar_index == 10
    strategy.entry("Long", strategy.long)
plot(strategy.position_size != 0 ? strategy.position_avg_price : na)
```
Use inside a strategy() script. This is a simulation value, not an exchange account balance or execution price.

### 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.
Returns: series float
```
//@version=6
strategy("Realized profit", overlay = false)
if bar_index == 10
    strategy.entry("Long", strategy.long)
if bar_index == 20
    strategy.close("Long")
plot(strategy.netprofit)
```
Use inside a strategy() script. Strategy results depend on the available bars and the simulator’s fill and cost settings.

### 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.
Returns: chart.point type
```
//@version=6
indicator("Chart point", overlay = true)
if barstate.islast
    chart.point point = chart.point.now(close)
    label.new(point, "Last price")
```
chart.point is a type and namespace, not a function to call directly. Choose time-based or index-based coordinates to match the drawing’s xloc setting.

### 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.
Returns: series float
```
//@version=6
indicator("Open price")
plot(open)
```

### 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.
Returns: series float
```
//@version=6
indicator("High price")
plot(high)
```

### 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.
Returns: series float
```
//@version=6
indicator("Low price")
plot(low)
```

### 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.
Returns: series float
```
//@version=6
indicator("Close price")
plot(close)
```

### 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.
Returns: series float
```
//@version=6
indicator("Bar volume")
plot(volume)
```

### 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.
Returns: series float
```
//@version=6
indicator("Median price")
plot(hl2)
```

### 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.
Returns: series float
```
//@version=6
indicator("Typical price")
plot(hlc3)
```

### 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.
Returns: series float
```
//@version=6
indicator("Average price")
plot(ohlc4)
```

### 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.
Returns: int
```
//@version=6
indicator("Last bar")
plotshape(bar_index == last_bar_index, style = shape.circle)
```

### 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.
Returns: int
```
//@version=6
indicator("Price scale")
if barstate.islast
    log.info(str.tostring(syminfo.pricescale))
plot(close)
```

### 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.
Returns: language construct
```
//@version=6
indicator("Conditional block")
if close > open
    log.info("Up bar")
```

### 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.
Returns: language construct
```
//@version=6
indicator("Persistent variable")
var float previous = na
previous := close
plot(previous)
```

### 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.
Returns: language construct
```
//@version=6
indicator("Intrabar-persistent variable")
varip int updates = 0
if barstate.isnew
    updates := 0
updates += 1
plot(updates)
```

### 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.
Returns: language construct
```
//@version=6
indicator("User-defined type")
type Level
    float price = 0.0
Level current = Level.new(close)
plot(current.price)
```

### 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.
Returns: language construct
```
library("Example")
export double(float value) =>
    value * 2
```

### 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.
Returns: language construct
```
//@version=6
indicator("Local names and shadowing")
average(float source, int length = 20) =>
    ta.ema(source, length)
plot(average(close))
```

### 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.
Returns: series int
```
//@version=6
indicator("Bar index")
plot(bar_index)
```

### 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.
Returns: series bool
```
//@version=6
indicator("Session open", overlay = true)
var float sessionOpen = na
if session.isfirstbar_regular
    sessionOpen := open
plot(sessionOpen, "Regular session open")
```
Aliases: alerta.session.isfirstbar_regular

### 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.
Returns: series bool
```
//@version=6
indicator("Session close", overlay = true)
var float sessionClose = na
if session.islastbar_regular
    sessionClose := close
plot(sessionClose, "Regular session close")
plot(close, "Close")
```
Aliases: alerta.session.islastbar_regular

### 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.
Returns: int
```
//@version=6
indicator("Price step")
plot(syminfo.minmove / syminfo.pricescale, "Price step")
```
Aliases: alerta.syminfo.minmove

### 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.
Returns: simple bool
```
//@version=6
indicator("Chart type check")
plot(chart.is_heikinashi ? 1 : 0, "Heikin Ashi chart")
```
Aliases: alerta.chart.is_heikinashi

### 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.
Returns: simple bool
```
//@version=6
indicator("Chart type check")
plot(chart.is_renko ? 1 : 0, "Renko chart")
```
Aliases: alerta.chart.is_renko

### 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.
Returns: simple bool
```
//@version=6
indicator("Chart type check")
plot(chart.is_kagi ? 1 : 0, "Kagi chart")
```
Aliases: alerta.chart.is_kagi

### 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.
Returns: simple bool
```
//@version=6
indicator("Chart type check")
plot(chart.is_linebreak ? 1 : 0, "Line Break chart")
```
Aliases: alerta.chart.is_linebreak

### 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.
Returns: simple bool
```
//@version=6
indicator("Chart type check")
plot(chart.is_pnf ? 1 : 0, "Point & Figure chart")
```
Aliases: alerta.chart.is_pnf

### 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.
Returns: simple bool
```
//@version=6
indicator("Chart type check")
plot(chart.is_range ? 1 : 0, "Range chart")
```
Aliases: alerta.chart.is_range

### 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.
- string: string; required: true; default: not specified. Text to measure.
- size: int; required: false; default: not specified. Font size; accepted for compatibility.
Returns: int
```
//@version=6
indicator("Text width")
plot(str.length_in_pixels("Hello", 12), "Width (px)")
```
Aliases: alerta.str.length_in_pixels

### 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.
Returns: array<linefill>
```
//@version=6
indicator("Linefill count", overlay = true)
var line a = line.new(bar_index, low, bar_index + 1, low)
var line b = line.new(bar_index, high, bar_index + 1, high)
var linefill f = linefill.new(a, b, color.new(color.blue, 80))
if barstate.islast
    log.info("linefills: " + str.tostring(array.size(linefill.all)))
plot(close)
```
Aliases: alerta.linefill.all

### 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.
- value: float; required: true; default: not specified. Amount in the symbol's currency.
Returns: series float
```
//@version=6
strategy("Account currency")
plot(strategy.convert_to_account(close), "Close in account currency")
```

### 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.
- value: float; required: true; default: not specified. Amount in the account currency.
Returns: series float
```
//@version=6
strategy("Risk sizing")
riskCash = strategy.convert_to_symbol(100)
if bar_index == 10
    strategy.entry("L", strategy.long, qty = riskCash / close)
plot(close)
```

### 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.
Returns: int
```
//@version=6
strategy("Closed trades")
if bar_index % 20 == 0
    strategy.entry("L", strategy.long)
if bar_index % 20 == 10
    strategy.close("L")
plot(strategy.closedtrades - strategy.closedtrades.first_index, "Listed trades")
```

### 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.
Returns: the value offset bars back, or na
```
//@version=6
indicator("History in a function")
// x[1] inside a function is the value at its previous CALL
prevCall(float x) =>
    x[1]
float atPrevCall = na
if bar_index % 2 == 0
    atPrevCall := prevCall(bar_index)
plot(atPrevCall, "bar_index at the previous call")
plot(bar_index[1], "bar_index one bar ago")
```
Inside a function the history of its parameters and local variables counts the function's calls, not the chart's bars: x[1] is the value x had at the previous call. A function called on every bar sees no difference; one called only on some bars — inside an if block or on one side of a ternary — looks back to its previous call. A script-level variable read inside the function keeps its bar history.
A ta.* call inside such a function follows the same rule for what the function computes: ta.sma(close * 2, 3) averages close * 2 at the function's last three calls, while ta.sma(close, 3) — over the chart's own series — is the average of the last three bars.
The history operator is not an array index: array.get reads an element of an array, history reads earlier bars.

### 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.
Returns: const bool
Value: false
```
//@version=6
indicator("Constant example")
selected = barmerge.gaps_off
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const bool
Value: true
```
//@version=6
indicator("Constant example")
selected = barmerge.gaps_on
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const bool
Value: false
```
//@version=6
indicator("Constant example")
selected = barmerge.lookahead_off
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const bool
Value: true
```
//@version=6
indicator("Constant example")
selected = barmerge.lookahead_on
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: AED
```
//@version=6
indicator("Constant example")
selected = currency.AED
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: ARS
```
//@version=6
indicator("Constant example")
selected = currency.ARS
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: AUD
```
//@version=6
indicator("Constant example")
selected = currency.AUD
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: BRL
```
//@version=6
indicator("Constant example")
selected = currency.BRL
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: BTC
```
//@version=6
indicator("Constant example")
selected = currency.BTC
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: CAD
```
//@version=6
indicator("Constant example")
selected = currency.CAD
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: CHF
```
//@version=6
indicator("Constant example")
selected = currency.CHF
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: CNY
```
//@version=6
indicator("Constant example")
selected = currency.CNY
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: DKK
```
//@version=6
indicator("Constant example")
selected = currency.DKK
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: ETH
```
//@version=6
indicator("Constant example")
selected = currency.ETH
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: EUR
```
//@version=6
indicator("Constant example")
selected = currency.EUR
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: GBP
```
//@version=6
indicator("Constant example")
selected = currency.GBP
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: HKD
```
//@version=6
indicator("Constant example")
selected = currency.HKD
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: IDR
```
//@version=6
indicator("Constant example")
selected = currency.IDR
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: ILS
```
//@version=6
indicator("Constant example")
selected = currency.ILS
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: INR
```
//@version=6
indicator("Constant example")
selected = currency.INR
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: JPY
```
//@version=6
indicator("Constant example")
selected = currency.JPY
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: KRW
```
//@version=6
indicator("Constant example")
selected = currency.KRW
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: MXN
```
//@version=6
indicator("Constant example")
selected = currency.MXN
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: MYR
```
//@version=6
indicator("Constant example")
selected = currency.MYR
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: NOK
```
//@version=6
indicator("Constant example")
selected = currency.NOK
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: NONE
```
//@version=6
indicator("Constant example")
selected = currency.NONE
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: NZD
```
//@version=6
indicator("Constant example")
selected = currency.NZD
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: PHP
```
//@version=6
indicator("Constant example")
selected = currency.PHP
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: PLN
```
//@version=6
indicator("Constant example")
selected = currency.PLN
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: RUB
```
//@version=6
indicator("Constant example")
selected = currency.RUB
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: SAR
```
//@version=6
indicator("Constant example")
selected = currency.SAR
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: SEK
```
//@version=6
indicator("Constant example")
selected = currency.SEK
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: SGD
```
//@version=6
indicator("Constant example")
selected = currency.SGD
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: THB
```
//@version=6
indicator("Constant example")
selected = currency.THB
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: TRY
```
//@version=6
indicator("Constant example")
selected = currency.TRY
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: TWD
```
//@version=6
indicator("Constant example")
selected = currency.TWD
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: USD
```
//@version=6
indicator("Constant example")
selected = currency.USD
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: USDC
```
//@version=6
indicator("Constant example")
selected = currency.USDC
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: USDT
```
//@version=6
indicator("Constant example")
selected = currency.USDT
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: VND
```
//@version=6
indicator("Constant example")
selected = currency.VND
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: ZAR
```
//@version=6
indicator("Constant example")
selected = currency.ZAR
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const int
Value: 6
```
//@version=6
indicator("Constant example")
selected = dayofweek.friday
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const int
Value: 7
```
//@version=6
indicator("Constant example")
selected = dayofweek.saturday
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const int
Value: 1
```
//@version=6
indicator("Constant example")
selected = dayofweek.sunday
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const int
Value: 5
```
//@version=6
indicator("Constant example")
selected = dayofweek.thursday
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const int
Value: 3
```
//@version=6
indicator("Constant example")
selected = dayofweek.tuesday
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const int
Value: 4
```
//@version=6
indicator("Constant example")
selected = dayofweek.wednesday
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: inherit
```
//@version=6
indicator("Constant example")
selected = format.inherit
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: mintick
```
//@version=6
indicator("Constant example")
selected = format.mintick
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: percent
```
//@version=6
indicator("Constant example")
selected = format.percent
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: price
```
//@version=6
indicator("Constant example")
selected = format.price
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: volume
```
//@version=6
indicator("Constant example")
selected = format.volume
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: ANY
```
//@version=6
indicator("Constant example")
selected = strategy.close_entries_rule.ANY
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: FIFO
```
//@version=6
indicator("Constant example")
selected = strategy.close_entries_rule.FIFO
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: cash_per_contract
```
//@version=6
indicator("Constant example")
selected = strategy.commission.cash_per_contract
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: cash_per_order
```
//@version=6
indicator("Constant example")
selected = strategy.commission.cash_per_order
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: percent
```
//@version=6
indicator("Constant example")
selected = strategy.commission.percent
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: all
```
//@version=6
indicator("Constant example")
selected = strategy.direction.all
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: long
```
//@version=6
indicator("Constant example")
selected = strategy.direction.long
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: short
```
//@version=6
indicator("Constant example")
selected = strategy.direction.short
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: long
```
//@version=6
indicator("Constant example")
selected = strategy.long
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: short
```
//@version=6
indicator("Constant example")
selected = strategy.short
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: xloc.bar_index
```
//@version=6
indicator("Constant example")
selected = xloc.bar_index
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: xloc.bar_time
```
//@version=6
indicator("Constant example")
selected = xloc.bar_time
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: yloc.abovebar
```
//@version=6
indicator("Constant example")
selected = yloc.abovebar
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: yloc.belowbar
```
//@version=6
indicator("Constant example")
selected = yloc.belowbar
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: yloc.price
```
//@version=6
indicator("Constant example")
selected = yloc.price
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #00bcd4
```
//@version=6
indicator("Constant example")
selected = color.aqua
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #363a45
```
//@version=6
indicator("Constant example")
selected = color.black
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #2196f3
```
//@version=6
indicator("Constant example")
selected = color.blue
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #e040fb
```
//@version=6
indicator("Constant example")
selected = color.fuchsia
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #787b86
```
//@version=6
indicator("Constant example")
selected = color.gray
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #4caf50
```
//@version=6
indicator("Constant example")
selected = color.green
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #00e676
```
//@version=6
indicator("Constant example")
selected = color.lime
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #880e4f
```
//@version=6
indicator("Constant example")
selected = color.maroon
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #311b92
```
//@version=6
indicator("Constant example")
selected = color.navy
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #808000
```
//@version=6
indicator("Constant example")
selected = color.olive
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #ff9800
```
//@version=6
indicator("Constant example")
selected = color.orange
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #9c27b0
```
//@version=6
indicator("Constant example")
selected = color.purple
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #f23645
```
//@version=6
indicator("Constant example")
selected = color.red
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #b2b5be
```
//@version=6
indicator("Constant example")
selected = color.silver
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #089981
```
//@version=6
indicator("Constant example")
selected = color.teal
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #ffffff
```
//@version=6
indicator("Constant example")
selected = color.white
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: #fdd835
```
//@version=6
indicator("Constant example")
selected = color.yellow
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const float
Value: 3.141592653589793
```
//@version=6
indicator("Constant example")
selected = math.pi
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.
Aliases: math.PI

### 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.
Returns: const float
Value: 2.718281828459045
```
//@version=6
indicator("Constant example")
selected = math.e
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.
Aliases: math.E

### 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.
Returns: const float
Value: 1.618033988749895
```
//@version=6
indicator("Constant example")
selected = math.phi
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: line
```
//@version=6
indicator("Constant example")
selected = plot.style_line
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: stepline
```
//@version=6
indicator("Constant example")
selected = plot.style_stepline
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: steplinebr
```
//@version=6
indicator("Constant example")
selected = plot.style_steplinebr
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: stepline_diamond
```
//@version=6
indicator("Constant example")
selected = plot.style_stepline_diamond
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: histogram
```
//@version=6
indicator("Constant example")
selected = plot.style_histogram
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: columns
```
//@version=6
indicator("Constant example")
selected = plot.style_columns
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: area
```
//@version=6
indicator("Constant example")
selected = plot.style_area
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: circles
```
//@version=6
indicator("Constant example")
selected = plot.style_circles
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: cross
```
//@version=6
indicator("Constant example")
selected = plot.style_cross
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: linebr
```
//@version=6
indicator("Constant example")
selected = plot.style_linebr
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: levels
```
//@version=6
indicator("Constant example")
selected = plot.style_levels
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: areabr
```
//@version=6
indicator("Constant example")
selected = plot.style_areabr
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: solid
```
//@version=6
indicator("Constant example")
selected = plot.linestyle_solid
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: dotted
```
//@version=6
indicator("Constant example")
selected = plot.linestyle_dotted
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: dashed
```
//@version=6
indicator("Constant example")
selected = plot.linestyle_dashed
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: line
```
//@version=6
indicator("Constant example")
selected = style.line
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: stepline
```
//@version=6
indicator("Constant example")
selected = style.stepline
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: histogram
```
//@version=6
indicator("Constant example")
selected = style.histogram
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: columns
```
//@version=6
indicator("Constant example")
selected = style.columns
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: area
```
//@version=6
indicator("Constant example")
selected = style.area
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: circles
```
//@version=6
indicator("Constant example")
selected = style.circles
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: cross
```
//@version=6
indicator("Constant example")
selected = style.cross
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: xcross
```
//@version=6
indicator("Constant example")
selected = style.xcross
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: abovebar
```
//@version=6
indicator("Constant example")
selected = location.abovebar
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: belowbar
```
//@version=6
indicator("Constant example")
selected = location.belowbar
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: top
```
//@version=6
indicator("Constant example")
selected = location.top
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: bottom
```
//@version=6
indicator("Constant example")
selected = location.bottom
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: absolute
```
//@version=6
indicator("Constant example")
selected = location.absolute
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: auto
```
//@version=6
indicator("Constant example")
selected = size.auto
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: tiny
```
//@version=6
indicator("Constant example")
selected = size.tiny
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: small
```
//@version=6
indicator("Constant example")
selected = size.small
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: normal
```
//@version=6
indicator("Constant example")
selected = size.normal
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: large
```
//@version=6
indicator("Constant example")
selected = size.large
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: huge
```
//@version=6
indicator("Constant example")
selected = size.huge
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: xcross
```
//@version=6
indicator("Constant example")
selected = shape.xcross
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: cross
```
//@version=6
indicator("Constant example")
selected = shape.cross
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: triangleup
```
//@version=6
indicator("Constant example")
selected = shape.triangleup
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: triangledown
```
//@version=6
indicator("Constant example")
selected = shape.triangledown
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: flag
```
//@version=6
indicator("Constant example")
selected = shape.flag
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: circle
```
//@version=6
indicator("Constant example")
selected = shape.circle
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: arrowup
```
//@version=6
indicator("Constant example")
selected = shape.arrowup
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: arrowdown
```
//@version=6
indicator("Constant example")
selected = shape.arrowdown
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: labelup
```
//@version=6
indicator("Constant example")
selected = shape.labelup
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: labeldown
```
//@version=6
indicator("Constant example")
selected = shape.labeldown
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: square
```
//@version=6
indicator("Constant example")
selected = shape.square
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: diamond
```
//@version=6
indicator("Constant example")
selected = shape.diamond
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: solid
```
//@version=6
indicator("Constant example")
selected = line.style_solid
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: dashed
```
//@version=6
indicator("Constant example")
selected = line.style_dashed
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: dotted
```
//@version=6
indicator("Constant example")
selected = line.style_dotted
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: arrow_left
```
//@version=6
indicator("Constant example")
selected = line.style_arrow_left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: arrow_right
```
//@version=6
indicator("Constant example")
selected = line.style_arrow_right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: arrow_both
```
//@version=6
indicator("Constant example")
selected = line.style_arrow_both
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: solid
```
//@version=6
indicator("Constant example")
selected = hline.style_solid
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: dashed
```
//@version=6
indicator("Constant example")
selected = hline.style_dashed
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: dotted
```
//@version=6
indicator("Constant example")
selected = hline.style_dotted
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: top_right
```
//@version=6
indicator("Constant example")
selected = position.top_right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: top_left
```
//@version=6
indicator("Constant example")
selected = position.top_left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: bottom_right
```
//@version=6
indicator("Constant example")
selected = position.bottom_right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: bottom_left
```
//@version=6
indicator("Constant example")
selected = position.bottom_left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: bottom_center
```
//@version=6
indicator("Constant example")
selected = position.bottom_center
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: top_center
```
//@version=6
indicator("Constant example")
selected = position.top_center
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: middle_right
```
//@version=6
indicator("Constant example")
selected = position.middle_right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: middle_left
```
//@version=6
indicator("Constant example")
selected = position.middle_left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: middle_center
```
//@version=6
indicator("Constant example")
selected = position.middle_center
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: asc
```
//@version=6
indicator("Constant example")
selected = order.ascending
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: desc
```
//@version=6
indicator("Constant example")
selected = order.descending
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: left
```
//@version=6
indicator("Constant example")
selected = scale.left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: none
```
//@version=6
indicator("Constant example")
selected = scale.none
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: right
```
//@version=6
indicator("Constant example")
selected = scale.right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: none
```
//@version=6
indicator("Constant example")
selected = display.none
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: all
```
//@version=6
indicator("Constant example")
selected = display.all
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: pane
```
//@version=6
indicator("Constant example")
selected = display.pane
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: price_scale
```
//@version=6
indicator("Constant example")
selected = display.price_scale
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: data_window
```
//@version=6
indicator("Constant example")
selected = display.data_window
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: status_line
```
//@version=6
indicator("Constant example")
selected = display.status_line
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: none
```
//@version=6
indicator("Constant example")
selected = extend.none
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: left
```
//@version=6
indicator("Constant example")
selected = extend.left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: right
```
//@version=6
indicator("Constant example")
selected = extend.right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: both
```
//@version=6
indicator("Constant example")
selected = extend.both
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_up
```
//@version=6
indicator("Constant example")
selected = label.style_label_up
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_down
```
//@version=6
indicator("Constant example")
selected = label.style_label_down
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_left
```
//@version=6
indicator("Constant example")
selected = label.style_label_left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_right
```
//@version=6
indicator("Constant example")
selected = label.style_label_right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_center
```
//@version=6
indicator("Constant example")
selected = label.style_label_center
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_lower_left
```
//@version=6
indicator("Constant example")
selected = label.style_label_lower_left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_lower_right
```
//@version=6
indicator("Constant example")
selected = label.style_label_lower_right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_upper_left
```
//@version=6
indicator("Constant example")
selected = label.style_label_upper_left
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: label_upper_right
```
//@version=6
indicator("Constant example")
selected = label.style_label_upper_right
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: triangleup
```
//@version=6
indicator("Constant example")
selected = label.style_triangleup
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: triangledown
```
//@version=6
indicator("Constant example")
selected = label.style_triangledown
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: xcross
```
//@version=6
indicator("Constant example")
selected = label.style_xcross
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: cross
```
//@version=6
indicator("Constant example")
selected = label.style_cross
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: flag
```
//@version=6
indicator("Constant example")
selected = label.style_flag
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: circle
```
//@version=6
indicator("Constant example")
selected = label.style_circle
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: arrowup
```
//@version=6
indicator("Constant example")
selected = label.style_arrowup
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: arrowdown
```
//@version=6
indicator("Constant example")
selected = label.style_arrowdown
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: square
```
//@version=6
indicator("Constant example")
selected = label.style_square
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: diamond
```
//@version=6
indicator("Constant example")
selected = label.style_diamond
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: text_outline
```
//@version=6
indicator("Constant example")
selected = label.style_text_outline
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: none
```
//@version=6
indicator("Constant example")
selected = label.style_none
plot(close)
```
The value comes from AlertaScript's own constant table. A recognized option is not a promise that every data source supports it or that it behaves exactly as in Pine — check the entry of the function that takes it.

### 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.
Returns: const string
Value: once_per_bar
```
//@version=6
indicator("Constant example")
selected = alert.freq_once_per_bar
plot(close)
```
Script alerts run while the chart and script are active; these constants do not by themselves create an alarm that keeps running when the chart is closed.

### 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.
Returns: const string
Value: once_per_bar_close
```
//@version=6
indicator("Constant example")
selected = alert.freq_once_per_bar_close
plot(close)
```
Script alerts run while the chart and script are active; these constants do not by themselves create an alarm that keeps running when the chart is closed.

### 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.
Returns: const string
Value: all
```
//@version=6
indicator("Constant example")
selected = alert.freq_all
plot(close)
```
Script alerts run while the chart and script are active; these constants do not by themselves create an alarm that keeps running when the chart is closed.