wuira 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -7,7 +7,108 @@ with the release date and highlight breaking changes explicitly.
 
 ## Unreleased
 
-No changes yet.
+## 0.1.6 — 2026-10-14
+
+### Added
+
+- `wuira.registerCommand("/command", callback)` registers native slash commands,
+  passes parsed arguments as `(...args: string[])` and returns idempotent cleanup.
+  Quoted arguments preserve spaces and empty values. Names are case-insensitive;
+  existing commands are preserved and native hash/proxy entries are cleaned up.
+- Native `AddonSettings` canvas registration, normal JSX `Button` controls and
+  Cell `onMount` lifecycle callbacks with cleanup.
+- Generic `FrameMover` drag proxies and `KeybindCapture` hover-to-bind overlays.
+  Both stop editing in combat; protected actions remain configured outside combat.
+- `KnownSpells` caches learned player spellbook IDs, with rank-aware `Has`,
+  event-driven `onChange` subscriptions and disposal. World entry, level,
+  training and talent events refresh the list; reading it never polls the book.
+- `Cell.alpha` accepts fixed opacity or a live visual callback, including on
+  secure buttons. Opacity updates do not enable, disable or rewrite actions.
+- Named `Spells.HolyShock` and `Spells.Exorcism` identifiers.
+- Named Paladin utility spell identifiers: Divine Favor, Lay on Hands, Blessing
+  of Protection, Blessing of Freedom, Voice of Truth, and Hammer of Justice.
+- `TotemTimer` reads player-owned ground effects by spell ID or localized name,
+  matching ranks and passing opaque native durations directly to progress bars.
+  Restricted effect identities are not inspected or guessed.
+- `SecureButton`, a Cell-compatible JSX primitive backed by Forever's native
+  `SecureActionButtonTemplate`. Supports static spell, item, existing macro,
+  action-slot and target actions, a selected mouse button, and one visual child.
+  Native click handlers are preserved; actions execute on mouse release.
+  Protected trees must mount outside combat; visibility and unmount are deferred
+  until combat ends. Click-cast presets are not included yet.
+- Secure buttons accept temporary `binding` overrides with native key labels,
+  radial `cooldown` sources and a native completion flash through `finishGlow`.
+  Overrides are removed on unmount without changing saved key bindings.
+- `SpellSource` exposes localized secure actions, textures and cooldowns that
+  ignore the global cooldown. Added Judgement, Holy Strike and Consecration IDs.
+- `BlizzardUI.SkinMicroMenu()` styles Forever's existing micro menu with a flat
+  panel, muted icons and accent highlights. Native click handlers, tooltips,
+  notifications and layout remain owned by the game; styling waits during combat.
+- `wuira/skins` with `MicroBar` and a shared `NativeSkin` adapter. `render` receives
+  the adapter, including `mount(view, anchor)` and `OnHover`; custom mounts are
+  disposed with the skin without replacing native button scripts.
+- Generic `HoverTracker` secure trigger/popup frames, configurable auto-hide delay
+  and extra hover regions. Addons own layout, launcher presentation and themes.
+- Explicit action-slot capture/clear/restore APIs and opt-in empty native bars.
+  New backups require a manual reload before the explicit clear command. Native bar
+  descendants, event/update managers, and action UI registrations are disabled;
+  suppression runs independently of slot operations. Clear/restore never run
+  from world-entry or cursor events; refused calls are reported without automatic
+  retries. A restore command re-enables the stock UI after manual reload. No replacement bar
+  is created. Unsupported action types and conflicting restores are rejected.
+- Resource `onChange` subscriptions with unsubscribe callbacks. Widgets and
+  observers share one lazy native event listener per resource, reading its
+  current value once per event. Secret amounts never reach user callbacks.
+- `Mana.UseRegenTimer()` and its `RegenTimer` accessory: a cast-driven five-second
+  window followed by estimated two-second sweeps kept alive by mana events.
+  Full readable mana stops the clock; native alpha curves mask full secret mana.
+  Unmount cancels timers and detaches the accessory without stopping other users.
+
+### Fixed
+
+- Preserve saved entries in initially empty Store records when loading a new
+  registry; Lua's empty-table ambiguity no longer resets custom binding maps.
+- Honor explicit non-top-left anchors on a Cell's child, allowing thin overlays
+  to sit on the bottom edge of a progress bar.
+
+## 0.1.5 — 2026-10-14
+
+### Added
+
+- Event-driven `.When(value => boolean)` source conditions. Inactive bindings
+  hide their visual and skip writes; secret inputs never reach callbacks.
+  Repeated conditions combine with AND, and fresh `.Value` reads remain unchanged.
+- Opt-in `HP.UseHealPrediction()` and `HP.UseAbsorbPrediction()` channels,
+  with lazy allocation, capability checks, and optional event subscriptions.
+- Independently styled healing and shield overlays on HP progress bars,
+  including direct native handling of secret amounts and clipping at bar bounds.
+- Opt-in `BlizzardUI.Hide` for stock action bars and player/target/focus frames,
+  with combat deferral and a restore callback, preserving native event handlers.
+- Cell visibility predicates and live label text, with cleanup on unmount.
+- Timer activity flags and cast/channel spell names for conditional UI rows.
+- Public `Spells` enum with named Paladin Seal spell IDs.
+- Player swing countdown sources for main-hand, off-hand, and ranged attacks,
+  driven by Forever's native swing events and native StatusBar timer animation.
+- Explicit unknown timing before the first readable event, secret-value guards,
+  weapon-change resets, and source disposal.
+- Label and Icon primitives, with event-driven texture sources.
+- Native duration sources for aura timers, spell/global cooldowns, and cast/channel
+  countdowns. Selected aura icons share the aura source's selection policy.
+
+### Fixed
+
+- Initialize native timer and swing bars with a normalized 0–1 range instead
+  of the default resource range.
+- Mount lifecycle now runs datasource binding cleanup callbacks on unmount.
+
+### Validation and limitations
+
+- Lua tests cover conditional activation/reactivation, secret callback guards,
+  optional prediction reads/events, overlay placement, and unmount cleanup.
+- Prediction amounts require the client's native unit APIs. Incoming healing
+  is raw (not reduced by heal-absorb debuffs); overheal is visually clipped.
+  HP overrides are incompatible with prediction overlays. In-game prediction
+  visuals still need validation in Forever.
 
 ## 0.1.4 — 2026-10-14
 

package/README.md

@@ -94,6 +94,353 @@ function App() {
 wuira.Mount(App);
 ```
 
+### Conditional sources and health predictions
+
+```tsx
+import { UI } from "wuira";
+import { ProgressBar } from "wuira/ui";
+import { HP, Unit } from "wuira/datasources";
+
+const hp = new HP(Unit.Player)
+    .UseHealPrediction()
+    .UseAbsorbPrediction()
+    .When(value => value >= 20); // Current health points, not a percentage.
+
+const view = (
+    <ProgressBar width={220} height={24} source={hp}
+        healPrediction={{ texture: "blizzard", color: { r: 0.4, g: 1, b: 0.5, a: 0.5 } }}
+        absorbPrediction={{ texture: "solid", color: { r: 0.8, g: 0.9, b: 1, a: 0.55 } }} />
+);
+```
+
+Configure sources before mounting. `.When()` filters native binding updates using
+the source's own value; repeated calls combine with AND. A false condition hides
+the bound bar and suppresses writes until a relevant event makes it true again.
+The basic health events remain subscribed so the source can reactivate; there is
+no health polling. Predicates should depend on this source's event-driven state,
+not unrelated mutable values. `.Value` remains a fresh, checked snapshot rather
+than a filtered subscription. Secret values never reach condition callbacks:
+a conditional binding becomes inactive until readable data returns. Without a
+condition, opaque values continue directly to native widgets.
+
+Each prediction channel is allocated and its event registered only when explicitly
+enabled and supported. No prediction snapshots are cached. Access
+`hp.HealPrediction?.Value` and `hp.AbsorbPrediction?.Value` when readable, or check
+the channel's `IsAvailable` flag. Direct reads retain the usual secret-value guard.
+The APIs provide incoming healing and existing damage-absorb shields, not a
+forecast of future damage. The adapter uses
+[Blizzard's unit prediction APIs](https://github.com/Gethe/wow-ui-source/blob/live/Interface/AddOns/Blizzard_APIDocumentationGenerated/UnitDocumentation.lua).
+
+Enabled channels draw by default; `healPrediction={false}` or
+`absorbPrediction={false}` suppresses an individual overlay. Incoming healing starts
+at the native health-fill edge and clips at the bar boundary. Shields overlay
+inward from the opposite edge, remaining visible even at full health. Both accept
+independent textures/colors and support horizontal, vertical, and reversed bars.
+There is no arithmetic on secret health or prediction amounts. Raw incoming heals
+are not reduced by heal-absorb debuffs; overheal is visually clipped. Prediction
+overlays require the native health scale, so min/max/current overrides are rejected.
+Prediction reads pause while the parent HP condition is inactive. The renderer
+cleans up the overlays and resource subscriptions on unmount.
+
+### Slash commands
+
+```ts
+import { wuira } from "wuira";
+
+const unregister = wuira.registerCommand("/myaddon", (...args: string[]) => {
+    console.log("Arguments:", ...args);
+});
+
+// /myaddon arg1 arg2 arg3 passes three string arguments.
+// /myaddon alone calls the callback with no arguments.
+// Call unregister() when the command is no longer needed.
+```
+
+Command names start with a slash and a letter, followed by letters, digits,
+underscores or hyphens. Names are case-insensitive and cannot replace an existing
+command. Register aliases separately with the same callback.
+
+Arguments are separated by whitespace and retain their case. Single or double
+quotes group words into one argument; `""` passes an empty string. Within quotes,
+a backslash can escape the matching quote or another backslash. An unclosed quote
+reports an error without calling the callback. Argument counts are unrestricted;
+validate required arguments inside your callback.
+
+### Addon settings and editing tools
+
+Register a normal JSX view in Forever's native addon settings list:
+
+```tsx
+import { UI, AddonSettings } from "wuira";
+import { FlowLayout, Button, Label } from "wuira/ui";
+
+const settings = new AddonSettings("MyAddon", () => (
+    <FlowLayout width={560} height={300} padding={20} gap={12}>
+        <Label height={28} text="MyAddon settings" />
+        <Button width={180} height={32} onClick={() => console.log("Settings opened")}>
+            <Label text="Example control" align="CENTER" />
+        </Button>
+    </FlowLayout>
+));
+settings.Open();
+```
+
+`Cell.onMount` receives the configured native frame and may return an unmount
+cleanup. `FrameMover` provides a drag proxy with screen-center coordinates
+(positive y down). `KeybindCapture` provides hover-to-bind overlays, modifier keys,
+Delete/Backspace clearing, and an Escape callback. These tools stop editing in
+combat. Addons own mode controls, saved positions, binding conflict policy and
+rebuilding protected buttons outside combat.
+
+### Learned spells
+
+`KnownSpells` keeps a cached snapshot of learned player spellbook IDs. It refreshes
+on world entry, level, training and talent events without polling. Named entries
+in `Spells` are numeric IDs; `Has` also matches a representative ID against learned
+ranks by localized name. Future and inactive-spec spellbook entries are excluded.
+
+```ts
+import { Spells } from "wuira";
+import { KnownSpells } from "wuira/datasources";
+
+const known = new KnownSpells();
+const spellIds = known.Value; // readonly number[], read from the cache
+const canJudge = known.Has(Spells.Judgement);
+const stop = known.onChange(ids => console.log("Learned spells:", ids.length));
+// On disposal: stop(); known.Dispose();
+```
+
+Protected button trees must be rebuilt outside combat; applications can defer a
+changed selection until `PLAYER_REGEN_ENABLED`. `Cell.alpha` changes appearance
+without changing a button's protected action or its interaction state.
+
+### Empty native action bars
+
+This is opt-in and removes real action-slot assignments, not just their visuals.
+Declare a character-specific backup variable in the addon's TOC:
+
+```text
+## SavedVariablesPerCharacter: MyAddonActionBarBackup
+```
+
+```ts
+import { ActionBars } from "wuira";
+
+ActionBars.InstallEmptyMode({
+    addon: "MyAddon",
+    variable: "MyAddonActionBarBackup",
+    clearCommand: "/myaddonclearbars",
+    restoreCommand: "/myaddonrestorebars",
+});
+```
+
+The first world entry captures supported spell, item, and macro assignments.
+Use `/reload` to persist a new backup, then `/myaddonclearbars` outside combat to
+clear the 180 action slots used by the installed Forever implementation. Slot
+changes run directly from the command, never from world-entry or cursor events.
+Independently, initialization hides stock bars, removes their descendant event/update handlers, disables their
+shared action-bar event managers, and detaches native action UI registrations.
+It does not create a replacement bar or remove key-binding assignments.
+Changes wait until combat ends, and a busy cursor blocks slot changes.
+
+The restore command puts assignments back into empty or identical slots. Use
+`/reload` afterwards to restore native handlers and visibility. The stock bars
+remain enabled on future loads. A refused slot operation leaves bar suppression
+active and is not automatically retried. Blocked/forbidden native calls report
+their API name in the local console; command execution does not bypass client restrictions.
+Unsupported action types, secret slot data, uncovered assignments, and conflicting
+restores stop the operation. `Capture()`, `Clear(backup)`, and `Restore(backup)` are
+also available for applications that manage their own persistence and lifecycle.
+
+### Secure action buttons
+
+`SecureButton` extends Cell's descriptor and props, including size, positioning,
+decorations and one child. Mount it like any other component:
+
+```tsx
+import { UI, wuira } from "wuira";
+import { SecureButton, Label } from "wuira/ui";
+
+wuira.Mount(() => (
+    <SecureButton width={80} height={24}
+        action={{ type: "spell", spell: 635, unit: "player" }}>
+        <Label text="Holy Light" align="CENTER" />
+    </SecureButton>
+));
+```
+
+Supported actions are `{ type: "spell", spell, unit? }`,
+`{ type: "item", item, unit? }`, `{ type: "macro", macro }`,
+`{ type: "action", slot, unit? }` and `{ type: "target", unit }`.
+Spell and macro references accept IDs/indices or names. Items accept an ID
+(converted to `item:ID`) or the native item string. Macros refer to existing
+game macros, not arbitrary Lua callbacks or generated macro text.
+
+The default is left-button release; `button="RightButton"` selects another
+button. Secure buttons always receive mouse input, while visual children remain
+click-through by default. Omitting `action` creates an inert secure button.
+
+Actions and units are static mount-time attributes. Changing the descriptor
+later does not rewrite them. Mounting a protected tree during combat raises an
+error before any frame is created. Visibility changes and unmount requests wait
+until combat ends, including changes to ancestors containing secure buttons.
+Click-cast presets are not provided by this primitive yet. The native action mapping
+follows [Forever's secure templates](https://github.com/Gethe/wow-ui-source/blob/forever/Interface/AddOns/Blizzard_FrameXML/SecureTemplates.lua).
+
+For an icon action with a radial cooldown and temporary key binding:
+
+```tsx
+import { Spells } from "wuira";
+import { SpellSource } from "wuira/datasources";
+import { Icon } from "wuira/ui";
+
+const judgement = new SpellSource(Spells.Judgement);
+const button = (
+    <SecureButton width={40} height={40} action={judgement.Action}
+        binding="1" cooldown={judgement.Cooldown} finishGlow>
+        <Icon textureSource={judgement.Texture} />
+    </SecureButton>
+);
+```
+
+`binding` temporarily routes the key to this native button and adds its label;
+`showHotkey={false}` suppresses the label. Unmount removes the override and leaves
+saved bindings intact. The radial widget owns countdown timing and the short
+completion flash, including opaque combat durations. `SpellSource.Cooldown`
+ignores the GCD so unrelated casts do not trigger a completion flash.
+
+### Native skins
+
+Skin Forever's existing character, professions, spellbook and other micro-menu
+buttons while keeping the game's click handlers, tooltips and notifications:
+
+```tsx
+import { UI } from "wuira";
+import { MicroBar } from "wuira/skins";
+import { Cell, Background } from "wuira/ui";
+
+const micro = new MicroBar();
+micro.render(bar => {
+    bar.Style({
+        background: { r: 0.035, g: 0.045, b: 0.065, a: 0.9 },
+        accent: { r: 0.4, g: 0.75, b: 1 },
+        padding: 6,
+    });
+    bar.mount(() => (
+        <Cell width={12} height={2} decorations={{
+            background: new Background({ color: { r: 0.4, g: 0.75, b: 1 } }),
+        }} />
+    ), "TOP");
+    bar.OnHover(hovered => console.log("Micro menu hover:", hovered));
+    return bar;
+});
+```
+
+`render` receives the skin adapter once its game-owned frame is ready. The same
+object exposes `Frame`, `Style`, `OnHover`, and `mount`; mounts become children of
+the native frame and are released by `Dispose()`. Native clicks, events and
+tooltips remain intact. Rendering waits until combat ends.
+
+`HoverTracker` supplies generic secure trigger/popup frames and auto-hide regions;
+the addon owns their visuals, contents and positioning. Compact menu launchers
+and themes belong in the consuming UI rather than the framework. Hover callbacks
+are ordinary addon callbacks; use secure hover visibility for protected panels.
+
+`BlizzardUI.SkinMicroMenu(options)` is also available for styling alone. Stopping
+styling hides its added panel; reload restores original native textures.
+
+### Resource observation and mana regen
+
+Resource changes can also be observed without mounting a widget:
+
+```ts
+const mana = new Mana(Unit.Player).UseRegenTimer();
+const unsubscribe = mana.onChange(value => console.log(value));
+// Call unsubscribe() when this consumer is removed.
+```
+
+`onChange` reports future readable value changes, with no initial callback.
+It honors `.When()` and never sends secret values to user code. Native bar
+bindings still accept secret values directly. Bars, observers, and the regen
+accessory share one lazy native event listener; it unregisters when the last
+consumer detaches. `.Value` is still available for a one-time read.
+
+`mana.RegenTimer` can be bound to a thin `ProgressBar`. Its `Phase` is
+`fiveSecondRule`, `estimatedTick`, or `inactive`. Successful mana-cost casts
+start/restart a five-second window, followed by estimated two-second cycles.
+Mana events keep those cycles alive without resetting a running cycle. No
+server tick clock is exposed: this is an estimate, including when the cost is
+secret. Zero-cost casts do not restart the window. The native widget animates
+the fill; one-shot callbacks handle phase transitions, with no Lua frame polling.
+Full readable mana cancels the clock. When mana is secret, a native step curve
+hides full mana visually; Lua cannot use that hidden result to dispose the timer,
+so the estimate stops when mana events cease. The frame is reused on the next
+cast. Configure this player-only accessory before mounting.
+
+### Native aura, cooldown, and cast timers
+
+```tsx
+import { UI, Spells } from "wuira";
+import { FlowLayout, ProgressBar, Icon, Label } from "wuira/ui";
+import { AuraTimer, GlobalCooldown, CastTimer, Unit } from "wuira/datasources";
+
+const aura = new AuraTimer(Unit.Player, { spellIds: [Spells.SealOfRighteousness], filter: "HELPFUL" });
+const gcd = new GlobalCooldown();
+const cast = new CastTimer(Unit.Player);
+
+function Timers() {
+    return (
+        <FlowLayout width={200} height={94} direction="vertical" gap={2}>
+            <Icon width={24} height={24} textureSource={aura.Texture} />
+            <ProgressBar height={24} source={aura}><Label text="Aura" /></ProgressBar>
+            <ProgressBar height={18} source={gcd} />
+            <ProgressBar height={22} source={cast} />
+        </FlowLayout>
+    );
+}
+```
+
+These timers pass opaque native duration objects to `SetTimerDuration`; they do
+not calculate restricted durations in Lua. `SpellCooldown(spellId)` tracks a
+specific spell, and `GlobalCooldown` supplies the GCD identifier internally.
+`CastTimer` follows casts and channels. `AuraTimer` resolves localized spell names
+and exposes an associated `Texture` source, with status indicating active,
+inactive, restricted, or unavailable data. Aura access still follows the client's
+restrictions; missing readable data is not reconstructed from combat events.
+`Label` and `Icon` are visual Cells. Application code supplies which spells to
+track; native API declarations and reads remain in wuira.
+
+### Swing timers
+
+```tsx
+import { UI, wuira } from "wuira";
+import { ProgressBar } from "wuira/ui";
+import { SwingTimer, SwingHand } from "wuira/datasources";
+
+const mainHand = new SwingTimer(SwingHand.MainHand);
+const view = wuira.Mount(<ProgressBar width={200} height={12} source={mainHand} />);
+
+// Other choices: SwingHand.OffHand and SwingHand.Ranged.
+// mainHand.Value: remaining seconds; Max.Value: duration; Percent.Value: remaining percent.
+// When removing the feature:
+if (view !== undefined) wuira.Unmount(view);
+mainHand.Dispose();
+```
+
+This source follows the player's `PLAYER_SWING(duration, swingType)` events.
+It does not reconstruct swings from the combat log or track enemy attack cycles.
+`HasTiming` is false until the first readable event and after a weapon/world reset;
+zero before that event is not evidence of a synchronized swing. After a recorded
+cycle expires, remaining time reaches zero. Secret payloads block datasource
+computation until a readable event or reset arrives.
+
+Native progress binding uses `C_DurationUtil` and `StatusBar:SetTimerDuration`,
+with no Lua per-frame animation. Range/current overrides are not supported for
+this binding. Unmount detaches each bar; call `Dispose()` to stop the source's
+event listener when its owning feature ends. Support is capability-checked;
+actual timing still needs validation in Forever. The adapter follows the
+[Forever swing API definition](https://github.com/Gethe/wow-ui-source/blob/bd2470aed543f72697a044e989285b6c83e63f73/Interface/AddOns/Blizzard_APIDocumentationGenerated/SwingTimerDocumentation.lua).
+
 ### Group members
 
 ```ts

package/lib/Spells.d.ts

@@ -0,0 +1,21 @@
+/** Representative spell IDs; aura sources resolve localized names across ranks. */
+export declare enum Spells {
+    Judgement = 20271,
+    HolyStrike = 679,
+    Consecration = 26573,
+    HolyShock = 20473,
+    Exorcism = 879,
+    DivineFavor = 20216,
+    LayOnHands = 633,
+    BlessingOfProtection = 1022,
+    BlessingOfFreedom = 1044,
+    VoiceOfTruth = 1310897,
+    HammerOfJustice = 853,
+    SealOfRighteousness = 21084,
+    SealOfTheCrusader = 21082,
+    SealOfCommand = 20375,
+    SealOfJustice = 20164,
+    SealOfLight = 20165,
+    SealOfWisdom = 20166,
+    SealOfFury = 20163
+}

package/lib/Spells.lua

@@ -0,0 +1,41 @@
+--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
+local ____exports = {}
+--- Representative spell IDs; aura sources resolve localized names across ranks.
+____exports.Spells = ____exports.Spells or ({})
+____exports.Spells.Judgement = 20271
+____exports.Spells[____exports.Spells.Judgement] = "Judgement"
+____exports.Spells.HolyStrike = 679
+____exports.Spells[____exports.Spells.HolyStrike] = "HolyStrike"
+____exports.Spells.Consecration = 26573
+____exports.Spells[____exports.Spells.Consecration] = "Consecration"
+____exports.Spells.HolyShock = 20473
+____exports.Spells[____exports.Spells.HolyShock] = "HolyShock"
+____exports.Spells.Exorcism = 879
+____exports.Spells[____exports.Spells.Exorcism] = "Exorcism"
+____exports.Spells.DivineFavor = 20216
+____exports.Spells[____exports.Spells.DivineFavor] = "DivineFavor"
+____exports.Spells.LayOnHands = 633
+____exports.Spells[____exports.Spells.LayOnHands] = "LayOnHands"
+____exports.Spells.BlessingOfProtection = 1022
+____exports.Spells[____exports.Spells.BlessingOfProtection] = "BlessingOfProtection"
+____exports.Spells.BlessingOfFreedom = 1044
+____exports.Spells[____exports.Spells.BlessingOfFreedom] = "BlessingOfFreedom"
+____exports.Spells.VoiceOfTruth = 1310897
+____exports.Spells[____exports.Spells.VoiceOfTruth] = "VoiceOfTruth"
+____exports.Spells.HammerOfJustice = 853
+____exports.Spells[____exports.Spells.HammerOfJustice] = "HammerOfJustice"
+____exports.Spells.SealOfRighteousness = 21084
+____exports.Spells[____exports.Spells.SealOfRighteousness] = "SealOfRighteousness"
+____exports.Spells.SealOfTheCrusader = 21082
+____exports.Spells[____exports.Spells.SealOfTheCrusader] = "SealOfTheCrusader"
+____exports.Spells.SealOfCommand = 20375
+____exports.Spells[____exports.Spells.SealOfCommand] = "SealOfCommand"
+____exports.Spells.SealOfJustice = 20164
+____exports.Spells[____exports.Spells.SealOfJustice] = "SealOfJustice"
+____exports.Spells.SealOfLight = 20165
+____exports.Spells[____exports.Spells.SealOfLight] = "SealOfLight"
+____exports.Spells.SealOfWisdom = 20166
+____exports.Spells[____exports.Spells.SealOfWisdom] = "SealOfWisdom"
+____exports.Spells.SealOfFury = 20163
+____exports.Spells[____exports.Spells.SealOfFury] = "SealOfFury"
+return ____exports

package/lib/datasources/AuraTimer.d.ts

@@ -0,0 +1,21 @@
+import { TimerSource } from "./TimerSource";
+import { TextureSource } from "./TextureSource";
+import { UnitSource } from "./UnitSource";
+import type { UnitInput } from "./UnitSource";
+export interface AuraTimerOptions {
+    /** Spell IDs resolve to localized names, so different ranks share a lookup. */
+    spellIds: readonly number[];
+    filter?: "HELPFUL" | "HARMFUL" | "HELPFUL|PLAYER" | "HARMFUL|PLAYER";
+}
+export type AuraTimerStatus = "active" | "inactive" | "restricted" | "unavailable";
+/** Selected aura duration and icon; selection policy belongs to the application. */
+export declare class AuraTimer extends TimerSource {
+    private readonly options;
+    readonly target: UnitSource;
+    readonly Texture: TextureSource;
+    private status;
+    constructor(unit: UnitInput, options: AuraTimerOptions);
+    get Status(): AuraTimerStatus;
+    private ReadAura;
+    private ReadDuration;
+}