You are building an automation ("workflow") for NoriaFlow (also called Noria), a hosted visual no-code workflow and custom bot builder. A workflow is a graph of triggers, actions, conditions, flow-control and data nodes; use the live catalog below instead of assuming which providers or options exist.

NOTE if this text reaches you as an uploaded/attached file: your interface may show only a TRUNCATED PREVIEW of it — that is a display limit, not a sign the file is incomplete. The actual file contains everything below in full: the format spec, the rules, the complete node catalog, and a "# WHAT TO BUILD" section at the end. Use your file search/read tool to load the full content before doing anything else. Never ask the user to re-paste the catalog or their request — it is already in this file; search it first.

# QUICK CAPABILITY REGISTRY (READ BEFORE ASSESSING FEASIBILITY)
This compact index is generated from the same authorable node definitions as the full catalog below.
Before claiming that Noria cannot build something, find the relevant node here, then read its full entry in the detailed catalog section below. Do not infer that a capability is absent merely because there is no provider-specific node.
EXTERNAL API FALLBACK: action.http.request can call an external service even when Noria has no dedicated node for that provider. It supports GET, POST, PUT, PATCH and DELETE, Bearer/Basic/API-key authentication, custom headers, query parameters and a JSON body. Therefore, the absence of a provider-specific node (for example Roblox) does NOT mean its HTTP API cannot be used.
INCOMING HTTP FALLBACK: trigger.webhook lets an external service start a workflow and publishes the request body, headers, query parameters and method.
## TRIGGER
- trigger.twitch.chat_message — Chat Message: Fires when a chat message is received.
- trigger.twitch.new_follower — New Follower: Fires when someone follows the channel.
- trigger.twitch.new_sub — New Subscription: Fires when someone subscribes to the channel.
- trigger.twitch.resub — Re-subscription Message: Fires when a viewer shares a re-subscription message in chat.
- trigger.twitch.gift_sub — Gift Subscription: Fires when a subscription is gifted.
- trigger.twitch.bits — Bits Cheered: Fires when someone cheers bits.
- trigger.twitch.raid — Raid Received: Fires when another channel raids.
- trigger.twitch.stream_online — Stream Goes Live: Fires when the stream goes online.
- trigger.twitch.stream_offline — Stream Goes Offline: Fires when the stream ends.
- trigger.twitch.channel_point_redeem — Channel Point Redeemed: Fires when a viewer redeems a channel point reward.
- trigger.twitch.ban — User Banned / Timed Out: Fires when a user is banned or timed out.
- trigger.twitch.channel_update — Stream Info Changed: Fires when the title, category or language of the stream changes.
- trigger.twitch.ad_break — Ad Break Started: Fires when an ad break begins — the moment to post "brb, ads".
- trigger.twitch.hype_train_begin — Hype Train Started: Fires when a hype train begins.
- trigger.twitch.hype_train_end — Hype Train Ended: Fires when a hype train finishes, with the level it reached.
- trigger.twitch.poll_end — Poll Ended: Fires when a poll closes, with the final vote counts.
- trigger.twitch.prediction_end — Prediction Resolved: Fires when a prediction is resolved or cancelled.
- trigger.twitch.goal_end — Goal Ended: Fires when a creator goal finishes — reached or not.
- trigger.twitch.sub_end — Subscription Ended: Fires when someone's subscription lapses.
- trigger.twitch.redemption_update — Redemption Updated: Fires when a channel point redemption is fulfilled or refunded.
- trigger.youtube.stream_went_live — Stream Goes Live: Fires when the channel starts a live broadcast on YouTube.
- trigger.youtube.new_video — New Video: Fires when the channel uploads a new video.
- trigger.fivem.status_changed — Server status changed: Run when the server becomes reachable or unreachable.
- trigger.fivem.player_count_changed — Player count changed: Run when the number of connected players changes.
- trigger.fivem.player_joined — Player joined: Run when a player appears in the public player list.
- trigger.fivem.player_left — Player left: Run when a player disappears from the public player list.
- trigger.minecraft.status_changed — Server status changed: Run when the server becomes reachable or unreachable.
- trigger.minecraft.player_count_changed — Player count changed: Run when the public player count changes.
- trigger.discord.message — Discord — Message: Trigger when a message is sent in a Discord channel.
- trigger.discord.member — Discord — Member: Trigger when a member joins, leaves, or receives a role.
- trigger.discord.voice — Discord — Voice Channel: Trigger when a member joins or disconnects from voice, starts streaming, or mutes.
- trigger.discord.reaction — Discord — Reaction: Trigger when a reaction is added to or removed from a message.
- trigger.discord.slash_command — Discord — Slash Command: Trigger when a slash command is used — define options to pass arguments (user, text, number…).
- trigger.discord.message_edit — Discord — Message Edited: Trigger when a message is edited in a Discord channel.
- trigger.discord.message_delete — Discord — Message Deleted: Trigger when a message is deleted in a Discord channel.
- trigger.discord.automod_action — Discord — AutoMod Blocked Something: Trigger when Discord's built-in AutoMod acts on a message.
- trigger.discord.channel — Discord — Channel Created / Updated / Deleted: Trigger when a channel is created, renamed, deleted, or its pins change.
- trigger.discord.role — Discord — Role Created / Updated / Deleted: Trigger when a role is created, changed, or deleted.
- trigger.discord.thread — Discord — Thread Created / Updated / Deleted: Trigger when a thread or forum post is created, changed, or deleted.
- trigger.discord.invite — Discord — Invite Created / Deleted: Trigger when someone creates or revokes an invite link.
- trigger.discord.scheduled_event — Discord — Scheduled Event: Trigger when a scheduled event is created, changed, cancelled, or someone RSVPs.
- trigger.discord.automod_rule — Discord — AutoMod Rule Changed: Trigger when an AutoMod rule is created, edited, or removed.
- trigger.discord.audit_log — Discord — Audit Log Entry: Trigger when something is recorded in the server audit log (who kicked, banned, deleted…).
- trigger.discord.poll_vote — Discord — Poll Vote: Trigger when someone votes on (or withdraws a vote from) a poll.
- trigger.discord.button — Discord — Button Click: Trigger when a user clicks a button component on a message.
- trigger.discord.select_menu — Discord — Select Menu: Trigger when a user picks option(s) from a select menu component.
- trigger.discord.modal_submit — Discord — Modal Submitted: Trigger when a user submits a modal (form) — read its fields and reply to the submission.
- trigger.discord.ticket — Discord — Ticket Event: Continue a workflow when the built-in Ticket Panel opens, claims, closes or updates a ticket.
- trigger.discord.self_role — Discord — Self Role Event: Continue a workflow after the built-in Self Role panel grants or removes a role.
- trigger.discord.giveaway — Discord — Giveaway Event: Continue a workflow when someone enters, withdraws, or when the built-in Giveaway draw ends.
- trigger.discord.guild_ban — Discord — Ban / Unban: Trigger when a user is banned or unbanned from the server.
- trigger.webhook — Webhook: Trigger workflow via HTTP request.
- trigger.schedule — Schedule: Run workflow on a cron schedule.
- trigger.manual — Manual Trigger: Manually trigger this workflow from the dashboard.
## ACTION
- action.youtube.list_videos — Get Videos: Get public video details by video ID.
- action.youtube.list_channels — Get Channels: Get public channel details by ID, handle, or legacy username.
- action.youtube.search — Search YouTube: Search public YouTube videos, channels, and playlists (costs 100× a normal read — avoid running it on a short schedule).
- action.youtube.list_playlists — Get Playlists: List public playlists for a channel or by playlist ID.
- action.youtube.list_playlist_items — Get Playlist Items: List the videos and resources contained in a public playlist.
- action.youtube.list_comment_threads — Get Comment Threads: List public top-level comments and their replies.
- action.youtube.list_comments — Get Comment Replies: List the replies under one comment thread.
- action.youtube.list_video_categories — Get Video Categories: Look up YouTube category names for a region.
- action.resend.get_emails — Retrieve a list of emails: Retrieve a list of emails.
- action.resend.post_emails — Send an email: Send an email.
- action.resend.get_emails_email_id — Retrieve a single email: Retrieve a single email.
- action.roblox.get_status — Get experience status: Check that Noria can reach this experience and that its Open Cloud key is valid.
- action.roblox.publish_message — Publish cross-server message: Publish a message to every live server subscribed to an Open Cloud topic.
- action.roblox.restart_servers — Restart experience servers: Request a graceful restart of the live servers in this experience.
- action.fivem.get_status — Get server status: Read live status and the privacy-safe player list.
- action.fivem.announce — Announce in game: Send a server-wide chat message through RCON.
- action.fivem.kick_player — Kick player: Disconnect a player by server ID with an optional reason.
- action.fivem.manage_resource — Manage resource: Start, stop or restart one FiveM resource.
- action.fivem.run_command — Run RCON command: Advanced escape hatch for an existing FiveM server command.
- action.minecraft.get_status — Get server status: Read status, MOTD, version and player count with the native Minecraft ping protocol.
- action.minecraft.announce — Announce in game: Broadcast a message through Minecraft RCON.
- action.minecraft.whitelist_player — Manage whitelist: Add or remove a player from the whitelist.
- action.minecraft.moderate_player — Moderate player: Kick, ban or pardon a player.
- action.minecraft.run_command — Run RCON command: Advanced escape hatch for an existing Minecraft command.
- action.discord — Discord Action: Perform any Discord action — send messages, manage members, reply to commands. Operations: send_message, send_embed, send_dm, delete_message, react, reply_interaction, followup_interaction, open_modal, add_role, remove_role, kick, ban, unban, timeout, set_nickname, voice_mute, voice_deafen, set_roles, edit_message, pin_message, unpin_message, remove_reaction, remove_all_reactions, bulk_delete, crosspost, get_message, list_messages, end_poll, get_poll_voters, get_reactors, list_pins, get_member, get_guild_info, list_members, search_members, list_channels, get_user, check_ban, list_audit_log, list_active_threads, bulk_ban, update_automod_rule, list_roles, update_role, get_channel, set_channel_permission, clear_channel_permission, list_channel_invites, follow_channel, list_thread_members, join_thread, leave_thread, list_archived_threads, create_channel, delete_channel, create_thread, create_invite, move_to_voice, disconnect_voice, remove_timeout, create_role, delete_role, create_event, delete_event, list_events, create_automod_rule, delete_automod_rule, list_automod_rules, create_webhook, execute_webhook, delete_webhook, archive_thread, lock_thread, add_thread_member, remove_thread_member, create_emoji, delete_emoji, update_channel, update_guild, prune_guild, list_bans, list_invites, delete_invite, get_role, preview_prune, list_emojis, pause_invites, show_typing, list_channel_webhooks, list_voice_members.
- action.twitch — Twitch Action: Perform any Twitch action — send chat, moderate, update stream, create clips. Operations: send_chat, send_announcement, timeout_user, ban_user, unban_user, clear_chat, update_title, create_clip, send_shoutout, update_redemption_status, update_chat_settings, get_chat_settings, get_stream_info, get_followers, get_chatters, start_raid, cancel_raid, create_poll, end_poll, create_prediction, end_prediction, create_reward, update_reward, delete_reward, list_rewards, list_redemptions, get_channel_info, start_commercial, get_ad_schedule, snooze_next_ad.
- action.http.request — HTTP Request: Make an HTTP request to any API or URL.
- action.email.send — Send Email: Send an email via SMTP.
- action.discord.welcome — Welcome & Goodbye: Attach to a Member trigger: greets arrivals in a channel or privately, hands them their starting roles, and posts a goodbye when they leave — no other nodes needed.
- action.discord.autoresponder — Auto Responder: Attach to a Message trigger: when a message contains one of your phrases, the bot answers, reacts or writes privately — with a cooldown so it never spams.
- action.discord.self_role — Self Role: Post a message where members get a role by clicking a button, picking from a dropdown, or reacting with an emoji (your choice) — no other nodes needed.
- action.discord.giveaway — Giveaway: Post a giveaway members enter by clicking a button or reacting, then automatically pick and announce winners when it ends — no other nodes needed.
- action.discord.leveling — Leveling: Attach to a Message trigger: awards XP per message, tracks levels automatically, announces level-ups and can grant roles at chosen levels — no other nodes needed.
- action.discord.word_filter — Word Filter: Attach to a Message trigger: deletes messages containing any banned word, and can warn, timeout and log the author — no other nodes needed.
- action.discord.ticket_panel — Ticket Panel: Post a message where members open a private ticket channel by clicking a button. Support staff get Close plus optional Claim, Hold, Escalate, Priority and Transcript controls. No other nodes needed.
## CONDITION
- condition.if — If / Else: Branch the workflow based on a condition.
- condition.switch — Switch: Route workflow through one of several cases.
- condition.filter — Filter: Continue only if a condition passes, otherwise stop.
## LOGIC
- logic.delay — Delay: Pause briefly (up to 5 min) before the next node. For longer or restart-proof waits, use the Wait node instead.
- logic.loop — For Each / Repeat: Run a step once per item in a list, or a fixed number of times. The Item branch runs once PER iteration (with {{loop.item}} / {{loop.index}} / {{loop.iteration}}), then the Done branch runs with the aggregated results.
- logic.cooldown — Cooldown: Let this run through at most once every N seconds — great for anti-spam. While still cooling down, the Blocked branch runs instead.
- logic.subworkflow — Call Workflow: Run another one of your workflows and pass its result downstream. The Error branch runs if the called workflow fails.
- logic.wait_event — Wait: Pause the workflow WITHOUT holding a worker — until a matching event arrives, or a duration elapses — then continue. Unlike Delay, this survives restarts and can wait hours or days. The event/timer payload becomes this node's output.
- logic.signal_wait — Signal / Cancel Wait: Wake up (or cancel) ANOTHER workflow run that is paused in a Wait node, by its correlation key — e.g. an "/endgiveaway" command ending the wait a "/giveaway" command started.
## TRANSFORM
- transform.set_variable — Create Value: Give a simple name to text, a number or information from a previous step, then reuse it later in this run.
- transform.store — Durable Store: Get / set / increment / delete a value that persists across executions (counters, leaderboards, flags — scoped to you).
- transform.record — Memory: Remember information for future runs, or use information that was saved earlier.
- transform.collection — Collection: A durable list that grows across runs — collect entries (giveaway sign-ups, a waitlist, a queue), block duplicates atomically, then list, count, pick a random (or bonus-weighted) winner, remove or clear them. Scoped to you; optional expiry and size cap.
- transform.leaderboard — Scores: Durable scores with a REAL Top-N ranking — points, XP, levels, “top chatters”. Add or increment a member’s score, then read the top, a score, or a rank. Scoped to you; optional expiry.
- transform.template — Text Template: Build a string using {{node.field}} interpolation.
- transform.json_parse — JSON Parse: Parse a JSON string into an object.
- transform.json_stringify — JSON Stringify: Convert an object to a JSON string.
- transform.math — Math: Perform an arithmetic operation on two numbers.
- transform.extract — Extract Field: Extract one or more nested fields from an object using dot-paths — each becomes its own named value.
- transform.merge — Merge Objects: Merge two objects into one.
- transform.split_text — Split Text: Split a string by a delimiter into an array.
- transform.list — List: Transform a list — map, filter, sort, group, reduce, aggregate, pick at random and more — with {{item}} expressions.
- transform.expression — Compute: Evaluate one or more expressions — build an object { a: x, b: y }, an array [x, y], or compute values like price * qty, each under its own name.
- transform.regex — Regex: Extract (with capture groups), replace, or test text with a regular expression.
- transform.date — Date: Date math — now, add or subtract a duration, the difference between two dates, format, or compare. Can output a Unix timestamp or a ready Discord <t:…> tag for live countdowns.

You output a single JSON object in this exact shape:

{
  "name": "A short workflow name",
  "nodes": [
    { "id": "<your own short label>", "type": "<a node type from the catalog>", "config": { ...fields... } }
  ],
  "connections": [
    ["<from node id>", "<to node id>"],
    ["<condition node id>", "<to node id>", "true"],          // 3rd item = which output to leave from
    ["<message node id>", "<to node id>", "on_button:join"]   // …including a button on that message
  ]
}

- "id" is a label YOU choose (e.g. "trigger", "save", "reply"). Use it in "connections".
- "type" MUST be one of the node types listed in the catalog below — nothing else.
- "config" holds that node's fields (see each node's "config:" in the catalog). Omit fields you don't need.
- "connections" wires nodes in flow order. Positions are computed for you — never send them.
- The optional 3rd item is the OUTPUT you leave from. Omit it for the normal path. Use it for:
  a condition ("true" / "false"), an error path ("error"), a multi-event trigger
  ("on_member_leave"), or a button/menu click ("on_button:<custom_id>", "on_select:<custom_id>",
  "on_select:<custom_id>:<option value>"). Each node's outputs are listed in the catalog.

RULES (follow all of them):
1. At least one trigger. A workflow MAY have several (e.g. a slash command to open a giveaway + a button click to join + a schedule to draw the winner) — each trigger starts its own branch, all in ONE workflow. Every non-trigger node must be reachable from a trigger via "connections".
2. VARIABLES ARE SCOPED — this is the #1 cause of broken workflows. A variable exists at a node ONLY if some node UPSTREAM of it publishes that variable. Each catalog entry lists exactly what it publishes ("variables it publishes"). Before you write {{x}} in a node, check that a node connected before it publishes x.
   - Write them SHORT when only ONE upstream node could publish that name: {{user_id}}, {{content}} — not {{trigger.user_id}} or {{node_1.user_id}}.
   - SEVERAL node TYPES publish the SAME generic name: {{result}} (transform.math / list / expression / regex / date / collection / leaderboard), {{value}} (transform.store / extract / set_variable, and a select-menu click), {{count}} (transform.collection / leaderboard / list / split_text). If TWO OR MORE of these sit upstream of the same node, a bare {{result}}/{{value}}/{{count}} is AMBIGUOUS — Noria silently resolves it to whichever ran LAST, which is very likely not the one you mean. Never rely on that. Instead:
     a) BEST — give one of them a stable name via its "outputAs" config field (e.g. set outputAs to "winners" on the Collection node that draws them), then reference {{winners}} downstream; or
     b) use the QUALIFIED form {{yourNodeId.field}} — e.g. {{draw.result}} — using the exact "id" you gave that node in "nodes". It always points at that specific node. (When the field turns out to have a single producer anyway, the import simplifies it back to the short name — the binding never changes.)
   - Better still, often you don't need several of these nodes at all: Set Data, Extract Field, Compute and Regex (extract) each hold SEVERAL name→value rows in ONE node, and every row's "name" is already a stable variable you chose. Need 3 values out of one object? That is ONE Extract Field node with 3 rows — never a chain of 3.
   - A trigger only publishes ITS OWN list: trigger.discord.message gives {{content}}/{{author_id}} (NOT {{user_id}}); trigger.discord.slash_command gives {{user_id}}/{{command_name}} (NOT {{content}}).
   - Each branch has its own trigger, so a variable from one branch does NOT exist in another.
   - Always available anywhere: {{timestamp}}, {{workflow_name}}, {{execution_id}}.
   - If the value you need isn't published upstream, you cannot have it — restructure, don't invent a name.
3. For Discord/Twitch actions use the single "action.discord" / "action.twitch" node and set config.actionType (e.g. "send_message", "reply_interaction", "ban"). Do not invent per-action types.
4. Slash command arguments: define them in the trigger's "commandOptions" (each {name,type,required}); each becomes a variable {{option_NAME}} (e.g. an option named "prize" → {{option_prize}}). Names must be unique WITHIN one command (Discord rejects duplicates, and two options with the same name would collide on the same {{option_NAME}}).
5. For a Condition node, add a 3rd item to the connection to pick the branch: ["check", "next", "true"] or [..., "false"].
6. NEVER INVENT AN ID. You cannot know the user's real Discord server, channel, role or user IDs, and a made-up number breaks the workflow. For any "Server"/guildId, channel, role or user field:
   - Prefer a {{variable}} from the trigger when one exists ({{channel_id}}, {{user_id}}, {{guild_id}}…).
   - Otherwise OMIT the field entirely (or ""). Noria fills the server from the trigger / the workflow default (Settings → Connections), and the user picks the channel in the editor.
   - NEVER write a literal snowflake like "123456789012345678", and never invent a placeholder like "YOUR_CHANNEL_ID".
7. Same if you are asked to fix a workflow: leave server/channel/role/user fields as they are (empty is CORRECT — the user finishes those in the editor). Only fix what you were asked to fix.
8. Discord embeds & buttons — the #1 source of invalid output. Copy these shapes EXACTLY:
   - Embed "color" is an INTEGER (e.g. 5793266). NEVER a hex string like "#5865F2".
   - Every button/menu MUST be wrapped in an Action Row. Correct:
     "components": [{ "type": 1, "components": [
        { "type": 2, "style": 3, "label": "Accept", "custom_id": "accept_rules" }
     ]}]
     WRONG: a bare { "type": "button", "style": "success" } at the top level.
   - "type" and "style" are INTEGERS (button=2, menu=3; style 1=primary 2=secondary 3=success 4=danger 5=link).
     Never use names ("button", "success").
9. REACTING TO A BUTTON / MENU — the node that SENDS the message is the node the click comes back to.
   Do NOT add a trigger.discord.button / trigger.discord.select_menu node. Instead connect FROM the sending
   node using the component's handle as the 3rd item:
     nodes:       { "id": "announce", "type": "action.discord", "config": { "actionType": "send_message",
                    "content": "Join!", "components": [{"type":1,"components":[
                      {"type":2,"style":3,"label":"Join","custom_id":"join"}]}] } },
                  { "id": "confirm",  "type": "action.discord", "config": { "actionType": "reply_interaction",
                    "content": "You're in, <@{{user_id}}>!" } }
     connections: [["announce", "confirm", "on_button:join"]]
   The click branch publishes {{user_id}}, {{username}}, {{custom_id}}, {{channel_id}}, {{message_id}},
   {{interaction_id}} (+ {{value}}/{{values}} for a menu). Reply to it with actionType "reply_interaction".
   A menu option can have its own branch: ["menu_node", "target", "on_select:role_pick:red"].
   WITHOUT that 3rd item the connection fires immediately when the message is SENT — not when it is clicked.
   Every custom_id MUST be unique across the WHOLE workflow, even on different messages/nodes — a click can only
   ever route to ONE of them, so reusing "join" (or any id) on a second message means the second one never fires.
   FORM MODALS: connect the sending message DIRECTLY to an action.discord with actionType "open_modal" on the
   button handle: ["announce", "open_form", "on_button:apply"]. Put the form object in config.openModal and
   interactionId "{{interaction_id}}" on that action. Then use a SEPARATE trigger.discord.modal_submit with
   modalId containing the SAME form custom_id; connect that trigger to the actions that process {{fields}} /
   {{field_<custom_id>}}. Never put a transform/condition between the button and open_modal: Discord requires
   the modal to be the immediate response to the click.
10. Noria is strictly no-code. Build everything with the visual nodes in the catalog; never write or generate executable code.
11. STORE KEYS MUST BE UNIQUE ACROSS DIFFERENT DATA KINDS. Collection (a list), Record (an object), Leaderboard (a ranked set), and Durable Store / Cooldown (both a single value) all share ONE Redis key per user — NOT scoped by which node uses it. Reusing the same "key" text across two DIFFERENT kinds (even for the same feature) crashes at runtime with a "WRONGTYPE" error the moment both run — e.g. a giveaway's Collection (join list) and its Record (saved state) must use DIFFERENT keys, such as "giveaway:list:{{channel_id}}" and "giveaway:record:{{channel_id}}". Sharing a key is fine within the SAME kind — two Collection nodes (that's the normal way to read/write the same list), or a Durable Store and a Cooldown together (both are plain values).
12. Return ONLY the JSON object. No explanation, no markdown fences.

EXAMPLE — /giveaway posts a message with a Join button; clicking it enters you (no duplicates).
Study the connections and where each variable comes from — that is what most models get wrong.

{
  "name": "Giveaway",
  "nodes": [
    { "id": "open", "type": "trigger.discord.slash_command",
      "config": { "command": "giveaway",
        "commandOptions": [{ "name": "prize", "type": "string", "required": true }] } },
    { "id": "announce", "type": "action.discord",
      "config": { "actionType": "send_message",
        "content": "🎉 Giveaway: {{option_prize}} — click to join!",
        "components": [{ "type": 1, "components": [
          { "type": 2, "style": 3, "label": "Join", "custom_id": "giveaway_join" } ] }] } },
    { "id": "join", "type": "transform.collection",
      "config": { "operation": "add_unique", "key": "giveaway:{{channel_id}}",
        "value": "{{user_id}}", "ttlSeconds": 86400 } },
    { "id": "confirm", "type": "action.discord",
      "config": { "actionType": "reply_interaction", "interactionId": "{{interaction_id}}",
        "content": "You're in!" } }
  ],
  "connections": [
    ["open", "announce"],
    ["announce", "join", "on_button:giveaway_join"],
    ["join", "confirm"]
  ]
}

Why it works:
- {{option_prize}} in "announce": "open" is upstream and declares the option "prize".
- ["announce", "join", "on_button:giveaway_join"] runs "join" ON THE CLICK, not when the message is sent.
  There is NO trigger node for the button — the sending node IS the entry point.
- {{user_id}} / {{channel_id}} / {{interaction_id}} in "join" and "confirm": published by that click branch.
  ({{user_id}} would NOT exist there if the branch came from trigger.discord.message — that one publishes
  {{author_id}} instead. Always check the catalog.)

RECIPES (proven visual-only patterns that fit in ONE workflow with several triggers):

Giveaway (see the EXAMPLE above for the exact JSON)
- Open it: trigger.discord.slash_command "giveaway" → action.discord "send_message" carrying a Join button.
- Join (dedup!): connect FROM the announce node on "on_button:<custom_id>" → transform.collection { operation: "add_unique", key: "giveaway:{{channel_id}}", value: "{{user_id}}", ttlSeconds: 86400 } → condition.if on "{{added}}" → true: reply_interaction "You're in!"; false: "You already joined."
- Draw the winner: trigger.schedule (or a Delay after opening) → transform.collection { operation: "random", key: "giveaway:<the same key>" } → action.discord "send_message" "🎉 Winner: <@{{result}}>". Use sampleSize > 1 for several winners. NOTE: a schedule branch has NO {{channel_id}} — it publishes only {{timestamp}}/{{next_run}} — so write the key literally there, or use a fixed key from the start.
- Reroll: trigger.discord.slash_command "reroll" → transform.collection random on the same key → announce.

Application form:
- trigger → action.discord "send_message" with a button custom_id "apply" → connect
  ["message", "open_form", "on_button:apply"] where open_form is action.discord { actionType: "open_modal",
  interactionId: "{{interaction_id}}", openModal: { title, custom_id: "application_form", fields: [...] } }.
- A separate trigger.discord.modal_submit { modalId: ["application_form"] } handles submission. Its fields are
  available as {{fields}} and individually as {{field_<custom_id>}} (for example {{field_age}}).

Role menu: action.discord "send_message" with a select menu (custom_id "roles") → one branch per option: ["msg", "give_mod", "on_select:roles:mod"], ["msg", "give_vip", "on_select:roles:vip"] → each branch = action.discord "add_role" on {{user_id}}.

Live participant count: transform.collection { operation: "count" } → put {{count}} in the message; use action.discord "edit_message" to update the original announcement.

XP / levels: trigger.discord.message → transform.leaderboard { operation: "increment", key: "xp:{{guild_id}}", member: "{{author_id}}", amount: 10 }; "/top" → transform.leaderboard "top" → an embed.

# CURRENT CATALOG STATUS
Generated automatically from the same plugin manifests and node schemas used by the editor and runtime.
Authorable now: 232 capabilities across 114 node types (120 schema-driven operations).
Planned, excluded and unavailable capabilities are omitted automatically. Partial/experimental/deprecated capabilities are explicitly labelled; prefer fully supported capabilities unless the request requires otherwise.
- Discord: 97 actions, 23 triggers; 17 partial
- Fivem: 5 actions, 4 triggers
- Minecraft: 5 actions, 2 triggers
- Resend: 3 actions
- Roblox: 3 actions
- Twitch: 30 actions, 20 triggers; 7 partial
- Youtube: 8 actions, 2 triggers; 9 partial

# NODE CATALOG

## TRIGGERS (start a workflow — one or MORE; each begins its own branch in the same workflow)

  trigger.twitch.chat_message — Chat Message [needs twitch]
    Fires when a chat message is received
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - prefix (list of strings) — Only trigger if message starts with any of these
    - keyword (list of strings) — Only trigger if message contains any of these keywords
    - firstMessageOnly (true/false) — Fire only the FIRST time a viewer ever chats in your channel — perfect for welcome messages
    - modsOnly (true/false) — Only trigger for messages from moderators
    - subsOnly (true/false) — Only trigger for messages from subscribers
    - vipsOnly (true/false) — Only trigger for messages from VIPs
    - fromUser (list of strings) — Only trigger for messages from any of these usernames
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{message_id}}, {{content}}, {{user_id}}, {{username}}, {{display_name}}, {{channel}}, {{color}}, {{is_mod}}, {{is_subscriber}}, {{is_vip}}, {{is_broadcaster}}, {{badges}}, {{bits}}

  trigger.twitch.new_follower — New Follower [needs twitch]
    Fires when someone follows the channel
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{display_name}}, {{followed_at}}

  trigger.twitch.new_sub — New Subscription [needs twitch]
    Fires when someone subscribes to the channel
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - ignoreGifts (true/false) — Skip subs that were gifted (the Gift Subscription trigger covers those)
    - minimumTier (one of: 1000 | 2000 | 3000) — Only trigger for subs at or above this tier
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{display_name}}, {{tier}}, {{is_gift}}, {{message}}, {{streak_months}}, {{cumulative_months}}

  trigger.twitch.resub — Re-subscription Message [needs twitch]
    Fires when a viewer shares a re-subscription message in chat
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - minimumMonths (number (also accepts {{variables}})) — Only trigger for resubs of at least this many cumulative months (milestones!)
    - minimumTier (one of: 1000 | 2000 | 3000) — Only trigger for resubs at or above this tier
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{display_name}}, {{tier}}, {{is_gift}}, {{message}}, {{streak_months}}, {{cumulative_months}}

  trigger.twitch.gift_sub — Gift Subscription [needs twitch]
    Fires when a subscription is gifted
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - minimumGifts (number (also accepts {{variables}})) — Only trigger for gift batches of at least this size
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{gifter_id}}, {{gifter_username}}, {{tier}}, {{total_gifted}}

  trigger.twitch.bits — Bits Cheered [needs twitch]
    Fires when someone cheers bits
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - minimumBits (number (also accepts {{variables}}))
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{bits_used}}, {{chat_message}}

  trigger.twitch.raid — Raid Received [needs twitch]
    Fires when another channel raids
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - minimumViewers (number (also accepts {{variables}}))
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{from_broadcaster_id}}, {{from_broadcaster_name}}, {{viewer_count}}

  trigger.twitch.stream_online — Stream Goes Live [needs twitch]
    Fires when the stream goes online
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{stream_id}}, {{broadcaster_id}}, {{broadcaster_login}}, {{broadcaster_name}}, {{broadcaster_avatar}}, {{stream_url}}, {{thumbnail_url}}, {{game_id}}, {{game_name}}, {{game_thumbnail}}, {{title}}, {{started_at}}, {{language}}

  trigger.twitch.stream_offline — Stream Goes Offline [needs twitch]
    Fires when the stream ends
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{broadcaster_id}}, {{broadcaster_name}}

  trigger.twitch.channel_point_redeem — Channel Point Redeemed [needs twitch]
    Fires when a viewer redeems a channel point reward
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - rewardFilter (list of strings) — Only trigger for any of these rewards
    - minimumCost (number (also accepts {{variables}})) — Only trigger for rewards costing at least this many points
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{redemption_id}}, {{reward_id}}, {{reward_title}}, {{reward_cost}}, {{user_id}}, {{username}}, {{user_input}}, {{redeemed_at}}, {{status}}

  trigger.twitch.ban — User Banned / Timed Out [needs twitch]
    Fires when a user is banned or timed out
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - banType (one of: permanent | timeout) — Leave empty to trigger on both
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{moderator_id}}, {{moderator_username}}, {{reason}}, {{ends_at}}, {{is_permanent}}

  trigger.twitch.channel_update — Stream Info Changed [needs twitch]
    Fires when the title, category or language of the stream changes
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - gameFilter (list of strings) — Only trigger when switching TO one of these categories
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{broadcaster_id}}, {{broadcaster_name}}, {{title}}, {{game_id}}, {{game_name}}, {{language}}, {{content_labels}}

  trigger.twitch.ad_break — Ad Break Started [needs twitch]
    Fires when an ad break begins — the moment to post "brb, ads"
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{broadcaster_id}}, {{duration_seconds}}, {{is_automatic}}, {{started_at}}, {{requester_id}}, {{requester_username}}

  trigger.twitch.hype_train_begin — Hype Train Started [needs twitch]
    Fires when a hype train begins
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{hype_train_id}}, {{level}}, {{total}}, {{goal}}, {{started_at}}, {{ended_at}}, {{expires_at}}, {{cooldown_ends_at}}, {{top_contributions}}

  trigger.twitch.hype_train_end — Hype Train Ended [needs twitch]
    Fires when a hype train finishes, with the level it reached
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - minimumLevel (number (also accepts {{variables}})) — Only trigger if the train reached at least this level
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{hype_train_id}}, {{level}}, {{total}}, {{goal}}, {{started_at}}, {{ended_at}}, {{expires_at}}, {{cooldown_ends_at}}, {{top_contributions}}

  trigger.twitch.poll_end — Poll Ended [needs twitch]
    Fires when a poll closes, with the final vote counts
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{poll_id}}, {{title}}, {{status}}, {{choices}}, {{started_at}}, {{ended_at}}

  trigger.twitch.prediction_end — Prediction Resolved [needs twitch]
    Fires when a prediction is resolved or cancelled
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{prediction_id}}, {{title}}, {{status}}, {{winning_outcome_id}}, {{outcomes}}, {{started_at}}, {{ended_at}}

  trigger.twitch.goal_end — Goal Ended [needs twitch]
    Fires when a creator goal finishes — reached or not
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - achievedOnly (true/false) — Skip goals that ended without hitting their target
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{goal_id}}, {{goal_type}}, {{description}}, {{is_achieved}}, {{current_amount}}, {{target_amount}}, {{started_at}}, {{ended_at}}

  trigger.twitch.sub_end — Subscription Ended [needs twitch]
    Fires when someone's subscription lapses
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{display_name}}, {{tier}}, {{is_gift}}

  trigger.twitch.redemption_update — Redemption Updated [needs twitch]
    Fires when a channel point redemption is fulfilled or refunded
    config:
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Triggers only on your connected Twitch channel.
    - redemptionStatus (one of: fulfilled | canceled) — Leave empty to trigger on both
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{redemption_id}}, {{reward_id}}, {{reward_title}}, {{reward_cost}}, {{user_id}}, {{username}}, {{user_input}}, {{status}}, {{redeemed_at}}

  trigger.youtube.stream_went_live — Stream Goes Live [PARTIAL — YouTube does not push a dedicated went-live event; Flowmatic classifies WebSub video notifications with Data API metadata.]
    Fires when the channel starts a live broadcast on YouTube
    config:
    - channel* (text, supports {{variables}}) — The channel to watch — paste its @handle or URL.
    - titleContains (text, supports {{variables}}) — Only fire when the stream title contains this text
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{videoId}}, {{videoUrl}}, {{title}}, {{description}}, {{channelId}}, {{channelTitle}}, {{thumbnailUrl}}, {{publishedAt}}, {{isLive}}, {{isShort}}

  trigger.youtube.new_video — New Video
    Fires when the channel uploads a new video
    config:
    - channel* (text, supports {{variables}}) — The channel to watch — paste its @handle or URL.
    - titleContains (text, supports {{variables}}) — Only fire when the video title contains this text
    - ignoreShorts (true/false) — Skip Shorts (videos ~60s or shorter)
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{videoId}}, {{videoUrl}}, {{title}}, {{description}}, {{channelId}}, {{channelTitle}}, {{thumbnailUrl}}, {{publishedAt}}, {{isLive}}, {{isShort}}

  trigger.fivem.status_changed — Server status changed [needs fivem]
    Run when the server becomes reachable or unreachable.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{connection_id}}, {{server_name}}, {{online}}, {{player_count}}, {{max_players}}, {{player}}

  trigger.fivem.player_count_changed — Player count changed [needs fivem]
    Run when the number of connected players changes.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{connection_id}}, {{server_name}}, {{online}}, {{player_count}}, {{max_players}}, {{player}}

  trigger.fivem.player_joined — Player joined [needs fivem]
    Run when a player appears in the public player list.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{connection_id}}, {{server_name}}, {{online}}, {{player_count}}, {{max_players}}, {{player}}

  trigger.fivem.player_left — Player left [needs fivem]
    Run when a player disappears from the public player list.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{connection_id}}, {{server_name}}, {{online}}, {{player_count}}, {{max_players}}, {{player}}

  trigger.minecraft.status_changed — Server status changed [needs minecraft]
    Run when the server becomes reachable or unreachable.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a minecraft server connected in Noria.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{connection_id}}, {{server_name}}, {{online}}, {{player_count}}, {{max_players}}, {{version}}, {{motd}}

  trigger.minecraft.player_count_changed — Player count changed [needs minecraft]
    Run when the public player count changes.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a minecraft server connected in Noria.
    flow outputs (connect from these) → on_event
    variables it publishes (usable downstream) → {{connection_id}}, {{server_name}}, {{online}}, {{player_count}}, {{max_players}}, {{version}}, {{motd}}

  trigger.discord.message — Discord — Message [needs discord]
    Trigger when a message is sent in a Discord channel
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId (Discord channel ID(s)) — Only trigger in any of these channels
    - roleFilter (Discord role ID(s)) — Only trigger if the author has any of these roles
    - prefix (list of strings) — Only trigger if message starts with any of these
    - keyword (list of strings) — Only trigger if message contains any of these words
    - fromUserId (Discord user ID (accepts {{variables}})) — Only trigger for messages from any of these users
    - ignoreBots (true/false) — Skip messages sent by bots (recommended to avoid loops)
    flow outputs (connect from these) → on_message
    variables it publishes (usable downstream) → {{message_id}}, {{content}}, {{author_id}}, {{author_username}}, {{author_display_name}}, {{author_avatar}}, {{is_bot}}, {{channel_id}}, {{channel_name}}, {{guild_id}}, {{timestamp}}, {{jump_url}}, {{attachment_count}}, {{attachments}}, {{ref_message_id}}, {{mentions}}, {{mention_roles}}, {{member_roles}}, {{command}}, {{arg_1}}, {{arg_2}}, {{arg_3}}, {{args_text}}, {{args_text_no_mentions}}, {{first_mention_id}}, {{first_mention_username}}, {{second_mention_id}}, {{second_mention_username}}, {{first_role_id}}, {{first_role_name}}, {{first_channel_mention}}

  trigger.discord.member — Discord — Member [needs discord]
    Trigger when a member joins, leaves, or receives a role
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - roleFilter (Discord role ID(s)) — Restrict Role Assigned event to any of these roles
    - ignoreBots (true/false) — Skip bot accounts joining/leaving
    flow outputs (connect from these) → on_member_join, on_member_leave, on_role_assigned
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{display_name}}, {{avatar}}, {{is_bot}}, {{guild_id}}, {{guild_name}}, {{role_id}}, {{role_name}}, {{roles}}, {{joined_at}}, {{timestamp}}

  trigger.discord.voice — Discord — Voice Channel [needs discord]
    Trigger when a member joins or disconnects from voice, starts streaming, or mutes
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelFilter (Discord channel ID(s)) — Only trigger for any of these voice channels
    - muteAction (one of: mute | unmute) — Leave empty to trigger on both mute and unmute
    - userFilter (Discord user ID (accepts {{variables}})) — Only trigger for any of these users
    - ignoreBots (true/false) — Skip bot accounts joining/leaving/moving voice channels
    flow outputs (connect from these) → on_voice_join, on_member_disconnect, on_voice_streaming_start, on_voice_mute_update, on_voice_move
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{guild_id}}, {{channel_id}}, {{channel_name}}, {{old_channel_id}}, {{new_channel_id}}, {{old_channel_name}}, {{new_channel_name}}, {{self_muted}}, {{self_deaf}}, {{is_streaming}}, {{video}}, {{is_bot}}, {{member_roles}}, {{timestamp}}

  trigger.discord.reaction — Discord — Reaction [needs discord]
    Trigger when a reaction is added to or removed from a message
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId (Discord channel ID(s)) — Only trigger in any of these channels
    - emojiFilter (list of strings) — Only trigger for any of these emojis
    - messageIdFilter (list of strings) — Only trigger for reactions on any of these messages (reaction-roles!)
    flow outputs (connect from these) → on_reaction_add, on_reaction_remove
    variables it publishes (usable downstream) → {{event}}, {{emoji}}, {{emoji_id}}, {{is_custom}}, {{user_id}}, {{username}}, {{message_id}}, {{channel_id}}, {{guild_id}}, {{count}}, {{timestamp}}

  trigger.discord.slash_command — Discord — Slash Command [needs discord]
    Trigger when a slash command is used — define options to pass arguments (user, text, number…)
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - command* (text, supports {{variables}}) — Slash command name (without /)
    - description (text, supports {{variables}})
    - accessMode (one of: recommended | roles | everyone) — Recommended protection adapts automatically to sensitive actions connected below
    - commandOptions (list of {name, type: string|user|number|boolean, required}) — Define arguments users can pass — each becomes available as {{option_NAME}}
    - roleFilter (Discord role ID(s)) — Optionally require one of these roles too
    - channelFilter (Discord channel ID(s)) — Only allow this command in any of these channels
    flow outputs (connect from these) → on_slash_command
    variables it publishes (usable downstream) → {{interaction_id}}, {{command_name}}, {{user_id}}, {{username}}, {{channel_id}}, {{guild_id}}, {{member_roles}}, {{member_permissions}}, {{interaction_token}}, {{timestamp}}
    + one variable per command option → an option named "prize" publishes {{option_prize}}

  trigger.discord.message_edit — Discord — Message Edited [needs discord]
    Trigger when a message is edited in a Discord channel
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId (Discord channel ID(s)) — Only trigger in any of these channels
    - keyword (list of strings) — Only trigger if new content contains any of these words
    flow outputs (connect from these) → on_message_edit
    variables it publishes (usable downstream) → {{message_id}}, {{content}}, {{old_content}}, {{channel_id}}, {{guild_id}}, {{author_id}}, {{author_username}}, {{edited_at}}, {{jump_url}}, {{member_roles}}

  trigger.discord.message_delete — Discord — Message Deleted [needs discord]
    Trigger when a message is deleted in a Discord channel
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId (Discord channel ID(s)) — Only trigger in any of these channels
    - keyword (list of strings) — Only trigger if the deleted message contained any of these words
    flow outputs (connect from these) → on_message_delete
    variables it publishes (usable downstream) → {{message_id}}, {{channel_id}}, {{guild_id}}, {{author_id}}, {{author_username}}, {{content}}, {{deleted_at}}, {{member_roles}}

  trigger.discord.automod_action — Discord — AutoMod Blocked Something [needs discord]
    Trigger when Discord's built-in AutoMod acts on a message
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - ruleName (list of strings) — Only trigger for these AutoMod rules (by name). Empty = any rule.
    flow outputs (connect from these) → on_automod_action
    variables it publishes (usable downstream) → {{rule_id}}, {{rule_name}}, {{action_type}}, {{user_id}}, {{guild_id}}, {{channel_id}}, {{content}}, {{matched_keyword}}, {{matched_content}}, {{alert_message_id}}, {{timestamp}}

  trigger.discord.channel — Discord — Channel Created / Updated / Deleted [needs discord]
    Trigger when a channel is created, renamed, deleted, or its pins change
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId (Discord channel ID(s)) — Only these channels. Empty = any channel in the server.
    - channelTypeFilter (list of strings) — Only these types: text, voice, category, announcement, forum, stage, media.
    flow outputs (connect from these) → on_channel_create, on_channel_update, on_channel_delete, on_channel_pins_update
    variables it publishes (usable downstream) → {{channel_id}}, {{channel_name}}, {{channel_type}}, {{guild_id}}, {{parent_id}}, {{position}}, {{topic}}, {{nsfw}}, {{old_channel_name}}, {{old_topic}}, {{created_at}}, {{timestamp}}

  trigger.discord.role — Discord — Role Created / Updated / Deleted [needs discord]
    Trigger when a role is created, changed, or deleted
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - roleFilter (Discord role ID(s)) — Only these roles. Empty = any role in the server.
    flow outputs (connect from these) → on_role_create, on_role_update, on_role_delete
    variables it publishes (usable downstream) → {{role_id}}, {{role_name}}, {{role_color}}, {{guild_id}}, {{position}}, {{hoist}}, {{mentionable}}, {{managed}}, {{old_role_name}}, {{timestamp}}

  trigger.discord.thread — Discord — Thread Created / Updated / Deleted [needs discord]
    Trigger when a thread or forum post is created, changed, or deleted
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - parentChannelId (Discord channel ID(s)) — Only threads opened in these channels — e.g. one forum. Empty = anywhere.
    flow outputs (connect from these) → on_thread_create, on_thread_update, on_thread_delete
    variables it publishes (usable downstream) → {{thread_id}}, {{thread_name}}, {{parent_id}}, {{guild_id}}, {{owner_id}}, {{archived}}, {{locked}}, {{message_count}}, {{old_thread_name}}, {{created_at}}, {{timestamp}}

  trigger.discord.invite — Discord — Invite Created / Deleted [needs discord]
    Trigger when someone creates or revokes an invite link
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId (Discord channel ID(s)) — Only invites pointing at these channels.
    flow outputs (connect from these) → on_invite_create, on_invite_delete
    variables it publishes (usable downstream) → {{code}}, {{invite_url}}, {{channel_id}}, {{guild_id}}, {{inviter_id}}, {{inviter_username}}, {{max_uses}}, {{max_age}}, {{temporary}}, {{expires_at}}, {{timestamp}}

  trigger.discord.scheduled_event — Discord — Scheduled Event [needs discord]
    Trigger when a scheduled event is created, changed, cancelled, or someone RSVPs
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - eventIdFilter (list of strings) — Only these scheduled events. Empty = every event in the server.
    flow outputs (connect from these) → on_scheduled_event_create, on_scheduled_event_update, on_scheduled_event_delete, on_scheduled_event_user_add, on_scheduled_event_user_remove
    variables it publishes (usable downstream) → {{event_id}}, {{event_name}}, {{event_description}}, {{guild_id}}, {{channel_id}}, {{location}}, {{creator_id}}, {{status}}, {{start_time}}, {{end_time}}, {{user_count}}, {{user_id}}, {{timestamp}}

  trigger.discord.automod_rule — Discord — AutoMod Rule Changed [needs discord]
    Trigger when an AutoMod rule is created, edited, or removed
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - ruleName (list of strings) — Only these rules (by name). Empty = any rule.
    flow outputs (connect from these) → on_automod_rule_create, on_automod_rule_update, on_automod_rule_delete
    variables it publishes (usable downstream) → {{rule_id}}, {{rule_name}}, {{guild_id}}, {{creator_id}}, {{enabled}}, {{trigger_type}}, {{keywords}}, {{exempt_role_ids}}, {{exempt_channel_ids}}, {{timestamp}}

  trigger.discord.audit_log — Discord — Audit Log Entry [needs discord]
    Trigger when something is recorded in the server audit log (who kicked, banned, deleted…)
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - actionFilter (list of strings) — Only these audit actions. Empty = every administrative action in the server.
    - executorFilter (Discord user ID (accepts {{variables}})) — Only when one of these people performed the action.
    flow outputs (connect from these) → on_audit_log
    variables it publishes (usable downstream) → {{action}}, {{action_id}}, {{executor_id}}, {{executor_username}}, {{target_id}}, {{target_type}}, {{reason}}, {{changes}}, {{changed_keys}}, {{entry_id}}, {{guild_id}}, {{timestamp}}

  trigger.discord.poll_vote — Discord — Poll Vote [needs discord]
    Trigger when someone votes on (or withdraws a vote from) a poll
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId (Discord channel ID(s)) — Only trigger for polls in any of these channels
    - messageId (text, supports {{variables}}) — Only trigger for one specific poll — wire {{message_id}} from the action that posted it.
    flow outputs (connect from these) → on_poll_vote_add, on_poll_vote_remove
    variables it publishes (usable downstream) → {{message_id}}, {{channel_id}}, {{guild_id}}, {{user_id}}, {{answer_id}}, {{timestamp}}

  trigger.discord.button — Discord — Button Click [needs discord]
    Trigger when a user clicks a button component on a message
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - buttonId (list of strings) — Pick the button this answers — one your message steps create. Leave empty to answer every button.
    - roleFilter (Discord role ID(s)) — Only trigger if the user has any of these roles
    - openModal (In AI authoring JSON, write a REAL object with this exact shape: { "title": string, "custom_id": string, "fields": [{ "custom_id": string, "label": string, "style": "short"|"paragraph", "required"?: boolean, "placeholder"?: string, "min"?: number, "max"?: number }] }. Do NOT stringify/double-escape it; the importer converts it to the editor stored format. min/max are text-input length bounds (NOT minLength/maxLength). Pair it with a "Discord — Modal Submitted" trigger matching the same custom_id.) — When set, clicking the button OPENS this form instead of running the flow below. Handle the submission with a "Discord — Modal Submitted" trigger (match custom_id).
    flow outputs (connect from these) → on_button
    variables it publishes (usable downstream) → {{interaction_id}}, {{custom_id}}, {{user_id}}, {{username}}, {{channel_id}}, {{guild_id}}, {{message_id}}, {{member_roles}}, {{interaction_token}}, {{timestamp}}

  trigger.discord.select_menu — Discord — Select Menu [needs discord]
    Trigger when a user picks option(s) from a select menu component
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - menuId (list of strings) — Pick the menu this answers — one your message steps create. Leave empty to answer every menu.
    - roleFilter (Discord role ID(s)) — Only trigger if the user has any of these roles
    flow outputs (connect from these) → on_select_menu
    variables it publishes (usable downstream) → {{interaction_id}}, {{custom_id}}, {{values}}, {{value}}, {{user_id}}, {{username}}, {{channel_id}}, {{guild_id}}, {{message_id}}, {{member_roles}}, {{interaction_token}}, {{timestamp}}

  trigger.discord.modal_submit — Discord — Modal Submitted [needs discord]
    Trigger when a user submits a modal (form) — read its fields and reply to the submission
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - modalId (list of strings) — Pick the form this answers — the one your "Open a Form" step creates. Leave empty to answer every form.
    flow outputs (connect from these) → on_modal_submit
    variables it publishes (usable downstream) → {{interaction_id}}, {{custom_id}}, {{fields}}, {{user_id}}, {{username}}, {{channel_id}}, {{guild_id}}, {{member_roles}}, {{interaction_token}}, {{timestamp}}

  trigger.discord.ticket — Discord — Ticket Event [needs discord] [PARTIAL — Official Discord Gateway event mapping pending.]
    Continue a workflow when the built-in Ticket Panel opens, claims, closes or updates a ticket.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - event* (one of: opened | claimed | released | closed | held | resumed | escalated | priority_changed)
    - panelNodeId (text, supports {{variables}}) — Optional internal filter used by detached Ticket blocks. Leave empty to listen to every Ticket Panel in this server.
    flow outputs (connect from these) → on_ticket
    variables it publishes (usable downstream) → {{ticket_event}}, {{ticket_channel_id}}, {{ticket_opener_id}}, {{ticket_staff_id}}, {{ticket_type}}, {{ticket_priority}}, {{ticket_form_fields}}, {{ticket_panel_node_id}}, {{guild_id}}

  trigger.discord.self_role — Discord — Self Role Event [needs discord] [PARTIAL — Official Discord Gateway event mapping pending.]
    Continue a workflow after the built-in Self Role panel grants or removes a role.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - event* (one of: granted | removed)
    - recipeNodeId (Discord role ID) — Internal filter used by detached Self Role blocks. Leave empty to listen to every Self Role panel in this server.
    flow outputs (connect from these) → on_self_role
    variables it publishes (usable downstream) → {{self_role_event}}, {{role_id}}, {{role_name}}, {{user_id}}, {{message_id}}, {{self_role_node_id}}, {{guild_id}}

  trigger.discord.giveaway — Discord — Giveaway Event [needs discord] [PARTIAL — Official Discord Gateway event mapping pending.]
    Continue a workflow when someone enters, withdraws, or when the built-in Giveaway draw ends.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - event* (one of: entered | withdrawn | ended)
    - recipeNodeId (text, supports {{variables}}) — Internal filter used by detached Giveaway blocks. Leave empty to listen to every Giveaway in this server.
    flow outputs (connect from these) → on_giveaway
    variables it publishes (usable downstream) → {{giveaway_event}}, {{user_id}}, {{winner_ids}}, {{winner_count}}, {{entry_count}}, {{prize}}, {{message_id}}, {{channel_id}}, {{giveaway_node_id}}, {{guild_id}}

  trigger.discord.guild_ban — Discord — Ban / Unban [needs discord]
    Trigger when a user is banned or unbanned from the server
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    flow outputs (connect from these) → on_ban, on_unban
    variables it publishes (usable downstream) → {{user_id}}, {{username}}, {{guild_id}}, {{guild_name}}, {{reason}}, {{timestamp}}

  trigger.webhook — Webhook
    Trigger workflow via HTTP request
    config:
    - method (one of:  | POST | GET | PUT)
    - secret (text, supports {{variables}}) — Validate X-Webhook-Secret header
    flow outputs (connect from these) → on_request
    variables it publishes (usable downstream) → {{body}}, {{headers}}, {{query}}, {{method}}, {{ip}}, {{requestBody}}, {{requestHeaders}}, {{receivedAt}}

  trigger.schedule — Schedule
    Run workflow on a cron schedule
    config:
    - cron* (cron expression) — Choose a frequency, time and days visually.
    - timezone (IANA timezone) — e.g. Europe/Paris
    - runOnce (true/false)
    flow outputs (connect from these) → on_tick
    variables it publishes (usable downstream) → {{timestamp}}, {{next_run}}, {{fired_at}}

  trigger.manual — Manual Trigger
    Manually trigger this workflow from the dashboard
    config:
    - payload (JSON value (object or array))
    flow outputs (connect from these) → on_trigger
    variables it publishes (usable downstream) → {{timestamp}}, {{payload}}

## ACTIONS (do something)

  action.youtube.list_videos — Get Videos [PARTIAL — Public API-key mode is implemented; OAuth-only and partner parameters remain listed by the missing-field coverage report.]
    Get public video details by video ID
    config:
    - part* (text, supports {{variables}}) — Comma-separated YouTube resource parts to return.
    - id* (text, supports {{variables}}) — One or more comma-separated video IDs.
    - maxResults (number (also accepts {{variables}}))
    - pageToken (text, supports {{variables}}) — Use nextPageToken from a previous execution.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{kind}}, {{etag}}, {{nextPageToken}}, {{prevPageToken}}, {{pageInfo}}, {{items}}

  action.youtube.list_channels — Get Channels [PARTIAL — Public API-key mode is implemented; OAuth-only and partner parameters remain listed by the missing-field coverage report.]
    Get public channel details by ID, handle, or legacy username
    config:
    - part* (text, supports {{variables}}) — Comma-separated YouTube resource parts to return.
    - id (text, supports {{variables}}) — One or more comma-separated channel IDs.
    - forHandle (text, supports {{variables}})
    - forUsername (text, supports {{variables}})
    - maxResults (number (also accepts {{variables}}))
    - pageToken (text, supports {{variables}}) — Use nextPageToken from a previous execution.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{kind}}, {{etag}}, {{nextPageToken}}, {{prevPageToken}}, {{pageInfo}}, {{items}}

  action.youtube.search — Search YouTube [PARTIAL — Public API-key mode is implemented; OAuth-only and partner parameters remain listed by the missing-field coverage report.]
    Search public YouTube videos, channels, and playlists (costs 100× a normal read — avoid running it on a short schedule)
    config:
    - q* (text, supports {{variables}})
    - type (one of: video | channel | playlist | )
    - order (one of: relevance | date | rating | title | viewCount)
    - channelId (text, supports {{variables}})
    - publishedAfter (text, supports {{variables}})
    - publishedBefore (text, supports {{variables}})
    - regionCode (text, supports {{variables}})
    - relevanceLanguage (text, supports {{variables}})
    - maxResults (number (also accepts {{variables}}))
    - pageToken (text, supports {{variables}}) — Use nextPageToken from a previous execution.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{kind}}, {{etag}}, {{nextPageToken}}, {{prevPageToken}}, {{pageInfo}}, {{items}}

  action.youtube.list_playlists — Get Playlists [PARTIAL — Public API-key mode is implemented; OAuth-only and partner parameters remain listed by the missing-field coverage report.]
    List public playlists for a channel or by playlist ID
    config:
    - part* (text, supports {{variables}}) — Comma-separated YouTube resource parts to return.
    - channelId (text, supports {{variables}})
    - id (text, supports {{variables}}) — One or more comma-separated playlist IDs.
    - maxResults (number (also accepts {{variables}}))
    - pageToken (text, supports {{variables}}) — Use nextPageToken from a previous execution.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{kind}}, {{etag}}, {{nextPageToken}}, {{prevPageToken}}, {{pageInfo}}, {{items}}

  action.youtube.list_playlist_items — Get Playlist Items [PARTIAL — Public API-key mode is implemented; OAuth-only and partner parameters remain listed by the missing-field coverage report.]
    List the videos and resources contained in a public playlist
    config:
    - part* (text, supports {{variables}}) — Comma-separated YouTube resource parts to return.
    - playlistId* (text, supports {{variables}})
    - videoId (text, supports {{variables}})
    - maxResults (number (also accepts {{variables}}))
    - pageToken (text, supports {{variables}}) — Use nextPageToken from a previous execution.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{kind}}, {{etag}}, {{nextPageToken}}, {{prevPageToken}}, {{pageInfo}}, {{items}}

  action.youtube.list_comment_threads — Get Comment Threads [PARTIAL — Public API-key mode is implemented; OAuth-only and partner parameters remain listed by the missing-field coverage report.]
    List public top-level comments and their replies
    config:
    - part* (text, supports {{variables}}) — Comma-separated YouTube resource parts to return.
    - videoId (text, supports {{variables}})
    - channelId (text, supports {{variables}})
    - allThreadsRelatedToChannelId (text, supports {{variables}})
    - searchTerms (text, supports {{variables}})
    - order (one of: time | relevance)
    - maxResults (number (also accepts {{variables}}))
    - pageToken (text, supports {{variables}}) — Use nextPageToken from a previous execution.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{kind}}, {{etag}}, {{nextPageToken}}, {{prevPageToken}}, {{pageInfo}}, {{items}}

  action.youtube.list_comments — Get Comment Replies [PARTIAL — Public API-key mode is implemented; OAuth-only and partner parameters remain listed by the missing-field coverage report.]
    List the replies under one comment thread
    config:
    - part* (text, supports {{variables}}) — Comma-separated YouTube resource parts to return.
    - parentId* (text, supports {{variables}}) — The top-level comment whose replies you want — the id from Get Comment Threads.
    - maxResults (number (also accepts {{variables}}))
    - pageToken (text, supports {{variables}}) — Use nextPageToken from a previous execution.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{kind}}, {{etag}}, {{nextPageToken}}, {{prevPageToken}}, {{pageInfo}}, {{items}}

  action.youtube.list_video_categories — Get Video Categories [PARTIAL — Public API-key mode is implemented; OAuth-only and partner parameters remain listed by the missing-field coverage report.]
    Look up YouTube category names for a region
    config:
    - part* (text, supports {{variables}}) — Comma-separated YouTube resource parts to return.
    - regionCode (text, supports {{variables}}) — Two-letter country code. Categories differ per region.
    - id (text, supports {{variables}}) — Look up specific categories instead of the whole list.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{kind}}, {{etag}}, {{nextPageToken}}, {{prevPageToken}}, {{pageInfo}}, {{items}}

  action.resend.get_emails — Retrieve a list of emails
    Retrieve a list of emails
    config:
    - token* (text, supports {{variables}}) — Your Resend API key
    - limit (number (also accepts {{variables}}))
    - after (text, supports {{variables}})
    - before (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{object}}, {{has_more}}, {{data}}

  action.resend.post_emails — Send an email
    Send an email
    config:
    - token* (text, supports {{variables}}) — Your Resend API key
    - from* (text, supports {{variables}}) — Sender email address. To include a friendly name, use the format "Your Name <sender@domain.com>".
    - to* (list of strings) — Add up to 50 recipient addresses. Press Enter after each address.
    - subject* (text, supports {{variables}}) — Email subject.
    - bcc (list of strings) — Optional hidden recipients. Press Enter after each address.
    - cc (list of strings) — Optional copied recipients. Press Enter after each address.
    - reply_to (list of strings) — Optional reply-to addresses. Press Enter after each address.
    - html (text, supports {{variables}}) — The HTML version of the message.
    - text (text, supports {{variables}}) — The plain-text version of the message.
    - template (nested object built with guided visual fields; follow the field description for allowed keys) — Optional template settings. Add an "id" text field and, when needed, a nested "variables" object.
    - headers (nested object built with guided visual fields; follow the field description for allowed keys) — Optional custom headers as named text fields.
    - scheduled_at (text, supports {{variables}}) — Schedule email to be sent later. The date should be in ISO 8601 format.
    - attachments (list built with guided visual rows; follow the field description for each item shape) — Add one object per file. Allowed fields: "filename" plus either "path" (URL) or "content" (inline/base64), and optional "content_type".
    - tags (list built with guided visual rows; follow the field description for each item shape) — Add one object per tag with a "name" and a "value" text field.
    - topic_id (text, supports {{variables}}) — The topic ID to scope the email to. If the recipient is a contact and opted-in to the topic, the email is sent. If opted-out, the email is not sent. If the recipient is not a contact, the email is sent if the topic's default subscription is opt_in.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{id}}

  action.resend.get_emails_email_id — Retrieve a single email
    Retrieve a single email
    config:
    - token* (text, supports {{variables}}) — Your Resend API key
    - email_id* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{object}}, {{id}}, {{message_id}}, {{to}}, {{from}}, {{created_at}}, {{subject}}, {{html}}, {{text}}, {{bcc}}, {{cc}}, {{reply_to}}, {{last_event}}

  action.roblox.get_status — Get experience status [needs roblox]
    Check that Noria can reach this experience and that its Open Cloud key is valid.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a roblox server connected in Noria.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{status}}

  action.roblox.publish_message — Publish cross-server message [needs roblox]
    Publish a message to every live server subscribed to an Open Cloud topic.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a roblox server connected in Noria.
    - topic* (text, supports {{variables}})
    - message* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{status}}

  action.roblox.restart_servers — Restart experience servers [needs roblox]
    Request a graceful restart of the live servers in this experience.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a roblox server connected in Noria.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{status}}

  action.fivem.get_status — Get server status [needs fivem]
    Read live status and the privacy-safe player list.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{players}}

  action.fivem.announce — Announce in game [needs fivem]
    Send a server-wide chat message through RCON.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    - message* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{players}}

  action.fivem.kick_player — Kick player [needs fivem]
    Disconnect a player by server ID with an optional reason.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    - playerId* (text, supports {{variables}})
    - reason (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{players}}

  action.fivem.manage_resource — Manage resource [needs fivem]
    Start, stop or restart one FiveM resource.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    - mode* (one of: restart | start | stop)
    - resource* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{players}}

  action.fivem.run_command — Run RCON command [needs fivem]
    Advanced escape hatch for an existing FiveM server command.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a fivem server connected in Noria.
    - command* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{players}}

  action.minecraft.get_status — Get server status [needs minecraft]
    Read status, MOTD, version and player count with the native Minecraft ping protocol.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a minecraft server connected in Noria.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{version}}, {{motd}}

  action.minecraft.announce — Announce in game [needs minecraft]
    Broadcast a message through Minecraft RCON.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a minecraft server connected in Noria.
    - message* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{version}}, {{motd}}

  action.minecraft.whitelist_player — Manage whitelist [needs minecraft]
    Add or remove a player from the whitelist.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a minecraft server connected in Noria.
    - mode* (one of: add | remove)
    - player* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{version}}, {{motd}}

  action.minecraft.moderate_player — Moderate player [needs minecraft]
    Kick, ban or pardon a player.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a minecraft server connected in Noria.
    - mode* (one of: kick | ban | pardon)
    - player* (text, supports {{variables}})
    - reason (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{version}}, {{motd}}

  action.minecraft.run_command — Run RCON command [needs minecraft]
    Advanced escape hatch for an existing Minecraft command.
    config:
    - connectionId* (a real Noria game-server connection id; never invent it — leave it empty so the user picks a connected server in the editor) — Pick a minecraft server connected in Noria.
    - command* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{success}}, {{connection_id}}, {{operation}}, {{message}}, {{online}}, {{player_count}}, {{max_players}}, {{version}}, {{motd}}

  action.discord — Discord Action [needs discord]
    Perform any Discord action — send messages, manage members, reply to commands
    available actionType operations (use these exact values):
      - send_message (Send Message · Messages) — Post a message in a channel.
      - send_embed (Send Embed · Messages) — Post a rich embed card in a channel.
      - send_dm (Send Direct Message · Messages) — Send a private message to a member.
      - delete_message (Delete Message · Messages) — Delete a message from a channel.
      - react (Add Reaction · Messages) — Add an emoji reaction to a message.
      - reply_interaction (Reply to Slash Command · Interactions)
      - followup_interaction (Followup Message · Interactions)
      - open_modal (Open a Form Modal · Interactions) — Open a form when a button is clicked.
      - add_role (Add Role · Roles) — Give a role to a member.
      - remove_role (Remove Role · Roles) — Take a role away from a member.
      - kick (Kick Member · Moderation) — Remove a member from the server.
      - ban (Ban Member · Moderation) — Ban a member from the server.
      - unban (Unban User · Moderation)
      - timeout (Timeout Member · Moderation) — Mute a member for a set time.
      - set_nickname (Set Nickname · Members)
      - voice_mute (Server Mute / Unmute · Voice)
      - voice_deafen (Server Deafen / Undeafen · Voice)
      - set_roles (Set Member Roles (replace all) · Roles)
      - edit_message (Edit Message · Messages)
      - pin_message (Pin Message · Messages)
      - unpin_message (Unpin Message · Messages)
      - remove_reaction (Remove Reaction · Messages)
      - remove_all_reactions (Remove All Reactions · Messages)
      - bulk_delete (Bulk Delete (purge) · Messages)
      - crosspost (Crosspost (publish) · Messages)
      - get_message (Get Message · Messages)
      - list_messages (Get Recent Messages · Messages) [PARTIAL — Reads a single page (up to 100 messages) positioned before, after or around a message id. Automatic multi-page walking is not exposed.]
      - end_poll (End Poll · Messages)
      - get_poll_voters (Get Poll Voters · Messages) [PARTIAL — Reads a single page of voters (up to 100) for one answer.]
      - get_reactors (Get Reactors · Messages) [PARTIAL — Reads a single page (up to 100 reactors) for one emoji. Cursor paging beyond one page is not exposed.]
      - list_pins (List Pinned Messages · Messages) [PARTIAL — Reads a single page of pinned messages.]
      - get_member (Get Member · Members) — Look up a member and their roles.
      - get_guild_info (Get Server Info · Administration)
      - list_members (List Members · Members) [PARTIAL — Reads a single page (up to 1000 members). Walking the whole list of a large server is not exposed.]
      - search_members (Search Members · Members) [PARTIAL — Matches on the START of a username or nickname — Discord offers no full-text member search.]
      - list_channels (List Channels · Channels)
      - get_user (Get User · Members)
      - check_ban (Check If Banned · Moderation)
      - list_audit_log (Read Audit Log · Moderation) [PARTIAL — Reads a single page (up to 100 entries), optionally narrowed to one action type.]
      - list_active_threads (List Active Threads · Threads)
      - bulk_ban (Ban Multiple Members · Moderation)
      - update_automod_rule (Update AutoMod Rule · Moderation) [PARTIAL — Covers enabling/disabling a rule and replacing its keyword list. Trigger type and action list are not exposed — changing those rewrites what the rule fundamentally is.]
      - list_roles (List Roles · Roles)
      - update_role (Update Role · Roles) [PARTIAL — Renames a role and updates its colour, hoist and mentionable flags. Editing a role's permission bitfield is intentionally out of scope.]
      - get_channel (Get Channel Info · Channels)
      - set_channel_permission (Set Channel Permission · Channels)
      - clear_channel_permission (Reset Channel Permission · Channels)
      - list_channel_invites (List Channel Invites · Channels)
      - follow_channel (Follow Announcement Channel · Channels)
      - list_thread_members (List Thread Members · Threads) [PARTIAL — Reads a single page (up to 100 thread members).]
      - join_thread (Join Thread · Threads)
      - leave_thread (Leave Thread · Threads)
      - list_archived_threads (List Archived Threads · Threads) [PARTIAL — Public archived threads only, one page. Private archived threads need a separate endpoint and permission.]
      - create_channel (Create Channel · Channels) — Create a new text or voice channel.
      - delete_channel (Delete Channel · Channels)
      - create_thread (Create Thread · Threads)
      - create_invite (Create Invite · Channels)
      - move_to_voice (Move to Voice · Voice)
      - disconnect_voice (Disconnect from Voice · Voice)
      - remove_timeout (Remove Timeout · Moderation)
      - create_role (Create Role · Roles)
      - delete_role (Delete Role · Roles)
      - create_event (Create Scheduled Event · Scheduled events)
      - delete_event (Delete Scheduled Event · Scheduled events)
      - list_events (List Scheduled Events · Scheduled events)
      - create_automod_rule (Create AutoMod Rule · Moderation)
      - delete_automod_rule (Delete AutoMod Rule · Moderation)
      - list_automod_rules (List AutoMod Rules · Moderation)
      - create_webhook (Create Webhook · Webhooks)
      - execute_webhook (Execute Webhook · Webhooks)
      - delete_webhook (Delete Webhook · Webhooks)
      - archive_thread (Archive Thread · Threads)
      - lock_thread (Lock Thread · Threads)
      - add_thread_member (Add Thread Member · Threads)
      - remove_thread_member (Remove Thread Member · Threads)
      - create_emoji (Create Emoji · Administration)
      - delete_emoji (Delete Emoji · Administration)
      - update_channel (Update Channel · Channels)
      - update_guild (Update Server · Administration) [PARTIAL — Covers the name, description and the two safety settings a raid response needs (verification level, explicit content filter). Icons, banners, system/rules channels and community features are not exposed — they are one-off setup, not automation.]
      - prune_guild (Prune Members · Members)
      - list_bans (List Bans · Moderation)
      - list_invites (List Invites · Channels)
      - delete_invite (Delete Invite · Channels)
      - get_role (Get Role · Roles)
      - preview_prune (Preview Inactive Members · Members)
      - list_emojis (List Emojis · Administration) [PARTIAL — Returns each emoji's identity and flags (id, name, animated, managed, available). The uploader and the role allow-list are documented but omitted — a workflow branches on which emoji exists, not on who added it.]
      - pause_invites (Pause Invites & DMs (raid shield) · Moderation)
      - show_typing (Show Typing · Channels)
      - list_channel_webhooks (List Channel Webhooks · Webhooks) [PARTIAL — Returns each webhook's id, name, type and channel. The webhook TOKEN and its full URL are withheld on purpose — they are bearer credentials, and every value a step outputs is visible in run logs and Available Data.]
      - list_voice_members (List Voice Channel Members · Voice)
    config:
    - actionType* (one of: send_message | send_embed | send_dm | delete_message | react | reply_interaction | followup_interaction | open_modal | add_role | remove_role | kick | ban | unban | timeout | set_nickname | voice_mute | voice_deafen | set_roles | edit_message | pin_message | unpin_message | remove_reaction | remove_all_reactions | bulk_delete | crosspost | get_message | list_messages | end_poll | get_poll_voters | get_reactors | list_pins | get_member | get_guild_info | list_members | search_members | list_channels | get_user | check_ban | list_audit_log | list_active_threads | bulk_ban | update_automod_rule | list_roles | update_role | get_channel | set_channel_permission | clear_channel_permission | list_channel_invites | follow_channel | list_thread_members | join_thread | leave_thread | list_archived_threads | create_channel | delete_channel | create_thread | create_invite | move_to_voice | disconnect_voice | remove_timeout | create_role | delete_role | create_event | delete_event | list_events | create_automod_rule | delete_automod_rule | list_automod_rules | create_webhook | execute_webhook | delete_webhook | archive_thread | lock_thread | add_thread_member | remove_thread_member | create_emoji | delete_emoji | update_channel | update_guild | prune_guild | list_bans | list_invites | delete_invite | get_role | preview_prune | list_emojis | pause_invites | show_typing | list_channel_webhooks | list_voice_members)
    - guildId (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default) (only when actionType=send_message/send_embed/delete_message/react/add_role/remove_role/kick/ban/unban/timeout/set_nickname/create_channel/delete_channel/create_thread/create_invite/move_to_voice/disconnect_voice/remove_timeout/create_role/delete_role/voice_mute/voice_deafen/set_roles/create_event/delete_event/list_events/create_automod_rule/delete_automod_rule/list_automod_rules/create_emoji/delete_emoji/update_guild/prune_guild/list_bans/list_invites/delete_invite/get_member/list_roles/update_role/get_guild_info/list_members/search_members/list_channels/check_ban/bulk_ban/list_audit_log/list_active_threads/update_automod_rule/get_role/preview_prune/list_emojis/pause_invites/list_voice_members)
    - channelId* when actionType=send_message|send_embed|delete_message|react|edit_message|pin_message|unpin_message|remove_reaction|remove_all_reactions|delete_channel|create_thread|create_invite|bulk_delete|crosspost|get_message|list_messages|create_webhook|update_channel|get_channel|set_channel_permission|clear_channel_permission|end_poll|get_poll_voters|get_reactors|list_pins|list_channel_invites|follow_channel|list_archived_threads|show_typing|list_channel_webhooks|list_voice_members (Discord channel ID) — Pick a channel by name — or switch to "Custom" to use {{channel_id}} from the trigger (only when actionType=send_message/send_embed/delete_message/react/edit_message/pin_message/unpin_message/remove_reaction/remove_all_reactions/delete_channel/create_thread/create_invite/bulk_delete/crosspost/get_message/list_messages/create_webhook/update_channel/get_channel/set_channel_permission/clear_channel_permission/end_poll/get_poll_voters/get_reactors/list_pins/list_channel_invites/follow_channel/list_archived_threads/show_typing/list_channel_webhooks/list_voice_members)
    - userId* when actionType=send_dm|add_role|remove_role|kick|ban|unban|timeout|set_nickname|move_to_voice|disconnect_voice|remove_timeout|voice_mute|voice_deafen|set_roles|get_member|add_thread_member|remove_thread_member|get_user|check_ban (Discord user ID (accepts {{variables}})) (only when actionType=send_dm/add_role/remove_role/kick/ban/unban/timeout/set_nickname/move_to_voice/disconnect_voice/remove_timeout/voice_mute/voice_deafen/set_roles/get_member/add_thread_member/remove_thread_member/get_user/check_ban)
    - roleId* when actionType=add_role|remove_role|delete_role|update_role|get_role (Discord role ID) (only when actionType=add_role/remove_role/delete_role/update_role/get_role)
    - content* when actionType=execute_webhook (text, supports {{variables}}) (only when actionType=send_message/send_dm/reply_interaction/followup_interaction/execute_webhook)
    - autoUpdate (true/false) — On: edit the same Discord message. Off: send a new message on every run. (only when actionType=send_message)
    - replyToAuthor (true/false) — Automatically reply to the message that triggered this workflow (uses {{message_id}}) (only when actionType=send_message)
    - tts (true/false) — Discord reads the message aloud to members who have the channel open. Use it for rare alerts only — it is easy to find annoying. (only when actionType=send_message)
    - suppressEmbeds (true/false) — Prevent Discord from auto-expanding URLs in the message (only when actionType=send_message)
    - suppressNotifications (true/false) — Send without triggering a push notification for the recipients (only when actionType=send_message)
    - deleteAfterSeconds (text, supports {{variables}}) — Automatically delete this message after N seconds (max 300) (only when actionType=send_message)
    - embeds (list of Discord embed objects. EXACT shape: [{"title": string, "description": string, "color": INTEGER (decimal, e.g. 5793266 — NOT a hex string like "#5865F2"), "url": string, "footer": {"text": string}, "thumbnail": {"url": string}, "image": {"url": string}, "author": {"name": string}, "fields": [{"name": string, "value": string, "inline": true|false}]}]) (only when actionType=send_message/send_dm/reply_interaction/followup_interaction/edit_message)
    - components (list of Discord ACTION ROWS. EXACT shape: [{"type": 1, "components": [ …buttons/menu… ]}] — every button/menu MUST sit inside a row (type 1); never put one at the top level. Button: {"type": 2, "style": 1|2|3|4|5 (1=primary, 2=secondary, 3=success/green, 4=danger/red, 5=link — INTEGERS, never names like "success"), "label": string, "custom_id": string (required unless style=5), "url": string (ONLY when style=5), "emoji": {"name": "👍"}}. Select menu: {"type": 3, "custom_id": string, "placeholder": string, "options": [{"label": string, "value": string}]} (max 5 buttons per row; a menu needs its own row). The custom_id becomes an OUTPUT HANDLE on THIS node (on_button:<custom_id>) — that is how you react to the click. Do NOT add a separate trigger node for it.) (only when actionType=send_message/reply_interaction/followup_interaction/edit_message)
    - componentsMode (one of: preserve | replace | disable_all | remove_all) (only when actionType=edit_message)
    - replyTo (text, supports {{variables}}) — Reply to a specific message — overrides "Reply to Author" (only when actionType=send_message/send_embed)
    - files (list of strings) — Public link(s) to files to attach — one per entry (only when actionType=send_message/send_embed/send_dm/reply_interaction/followup_interaction)
    - allowedMentions (one of:  | none | users | users_roles | all) (only when actionType=send_message/send_embed/send_dm/reply_interaction/followup_interaction)
    - pollQuestion (text, supports {{variables}}) (only when actionType=send_message)
    - pollAnswers (list of strings) — 2–10 answers, one per entry (only when actionType=send_message)
    - pollDurationHours (text, supports {{variables}}) (only when actionType=send_message)
    - embedId (text, supports {{variables}}) — Give this embed a unique ID — every execution edits the same Discord message (only when actionType=send_embed)
    - title (text, supports {{variables}}) — Bold heading at the top of the card. Up to 256 characters. (only when actionType=send_embed)
    - url (text, supports {{variables}}) — Makes the embed title clickable. (only when actionType=send_embed)
    - description (text, supports {{variables}}) — Main text of the card. Supports Discord markdown and variables. Up to 4096 characters. (only when actionType=send_embed)
    - color (text, supports {{variables}}) — Colour of the stripe on the left edge of the card — a quick way to tell alerts, info and success apart. (only when actionType=send_embed)
    - footer (text, supports {{variables}}) — Small grey line at the bottom of the card — good for a source, a timestamp or a hint. (only when actionType=send_embed)
    - thumbnail (text, supports {{variables}}) — Small picture in the top-right corner of the card, e.g. a user avatar or a logo. (only when actionType=send_embed)
    - image (text, supports {{variables}}) — Large picture displayed full-width under the text. (only when actionType=send_embed)
    - fields (list of {name, value, inline: true|false}) (only when actionType=send_embed)
    - authorName (text, supports {{variables}}) — Small name line above the title, usually the person or service the card is about. (only when actionType=send_embed)
    - authorUrl (text, supports {{variables}}) — Makes the author name clickable. (only when actionType=send_embed)
    - authorIcon (text, supports {{variables}}) — Tiny round picture next to the author name. (only when actionType=send_embed)
    - footerIcon (text, supports {{variables}}) — Tiny picture next to the footer text. (only when actionType=send_embed)
    - timestamp (true/false) (only when actionType=send_embed)
    - messageId* when actionType=delete_message|react|edit_message|pin_message|unpin_message|remove_reaction|remove_all_reactions|crosspost|get_message|end_poll|get_poll_voters|get_reactors (text, supports {{variables}}) (only when actionType=delete_message/react/edit_message/pin_message/unpin_message/remove_reaction/remove_all_reactions/crosspost/get_message/create_thread/end_poll/get_poll_voters/get_reactors)
    - count (text, supports {{variables}}) — Bulk-delete the N most recent messages (skips messages older than 14 days) (only when actionType=bulk_delete)
    - emoji* when actionType=react|remove_reaction|get_reactors (text, supports {{variables}}) (only when actionType=react/remove_reaction/get_reactors)
    - interactionId* (text, supports {{variables}}) (only when actionType=reply_interaction/followup_interaction/open_modal)
    - openModal* when actionType=open_modal (In AI authoring JSON, write a REAL object with this exact shape: { "title": string, "custom_id": string, "fields": [{ "custom_id": string, "label": string, "style": "short"|"paragraph", "required"?: boolean, "placeholder"?: string, "min"?: number, "max"?: number }] }. Do NOT stringify/double-escape it; the importer converts it to the editor stored format. min/max are text-input length bounds (NOT minLength/maxLength). Pair it with a "Discord — Modal Submitted" trigger matching the same custom_id.) — The form opened by the button click. Connect this action DIRECTLY from a message button output, then handle its submission with a Discord — Modal Submitted trigger using the same custom ID. (only when actionType=open_modal)
    - ephemeral (true/false) (only when actionType=reply_interaction/followup_interaction/send_message)
    - reason (text, supports {{variables}}) — Shown in the server's audit log (only when actionType=add_role/remove_role/kick/ban/timeout/voice_mute/voice_deafen/set_roles/delete_channel/create_role/delete_role/update_role/set_channel_permission/clear_channel_permission/follow_channel/bulk_ban)
    - mute (true/false) — Server-mute the member in voice; uncheck to unmute (only when actionType=voice_mute)
    - deaf (true/false) — Server-deafen the member in voice; uncheck to undeafen (only when actionType=voice_deafen)
    - roleIds (Discord role ID(s)) — Replace the member’s roles with these (leave empty to remove all roles) (only when actionType=set_roles)
    - durationMinutes (text, supports {{variables}}) (only when actionType=timeout)
    - deleteMessageSeconds (text, supports {{variables}}) (only when actionType=ban)
    - nickname* when actionType=set_nickname (text, supports {{variables}}) (only when actionType=set_nickname)
    - newContent (text, supports {{variables}}) (only when actionType=edit_message)
    - targetUserId (Discord user ID (accepts {{variables}})) — Leave empty to remove all reactions of this emoji (only when actionType=remove_reaction)
    - channelName* (text, supports {{variables}}) — Discord lowercases text channel names and replaces spaces with dashes. Variables work, e.g. ticket-{{author_username}}. (only when actionType=create_channel)
    - channelType* (one of: text | voice) (only when actionType=create_channel)
    - categoryId (Discord category channel ID (a channel PARENT, not a message target) — omit unless a specific category id is known) — Create the channel under this category. Leave empty for the top level. (only when actionType=create_channel)
    - topic (text, supports {{variables}}) — Short line shown next to the channel name and in its header. Ignored for voice channels. (only when actionType=create_channel/update_channel)
    - nsfw (true/false) — Marks the channel as age-restricted: members must confirm they are 18+ before reading it. (only when actionType=create_channel)
    - slowmode (text, supports {{variables}}) — Minimum wait between two messages from the same member. 0 turns it off; up to 21600 (6 hours). (only when actionType=create_channel)
    - bitrate (number (also accepts {{variables}})) — Audio quality of a voice channel. 64000 is the default; higher values need a boosted server. (only when actionType=create_channel)
    - userLimit (number (also accepts {{variables}})) — Maximum number of people who can join the voice channel at once. (only when actionType=create_channel)
    - threadName* (text, supports {{variables}}) (only when actionType=create_thread)
    - autoArchiveDuration (one of: 60 | 1440 | 4320 | 10080) (only when actionType=create_thread)
    - inviteMaxAge (text, supports {{variables}}) — 0 = never expires (only when actionType=create_invite)
    - inviteMaxUses (text, supports {{variables}}) — 0 = unlimited (only when actionType=create_invite)
    - voiceChannelId* (Discord channel ID) — Pick a voice channel or use the channel produced by an earlier step. (only when actionType=move_to_voice)
    - roleName* (text, supports {{variables}}) (only when actionType=create_role)
    - roleColor (text, supports {{variables}}) — Hex color for the role (only when actionType=create_role/update_role)
    - hoist (true/false) (only when actionType=create_role/update_role)
    - mentionable (true/false) (only when actionType=create_role/update_role)
    - eventName* (text, supports {{variables}}) (only when actionType=create_event)
    - eventEntityType* (one of: external | voice) (only when actionType=create_event)
    - eventStartTime* (text, supports {{variables}}) (only when actionType=create_event)
    - eventEndTime* when eventEntityType=external (text, supports {{variables}}) (only when actionType=create_event)
    - eventChannelId* when eventEntityType=voice (Discord channel ID) (only when actionType=create_event)
    - eventLocation* when eventEntityType=external (text, supports {{variables}}) (only when actionType=create_event)
    - eventDescription (text, supports {{variables}}) (only when actionType=create_event)
    - eventId* (text, supports {{variables}}) (only when actionType=delete_event)
    - automodName* when actionType=create_automod_rule (text, supports {{variables}}) (only when actionType=create_automod_rule/update_automod_rule)
    - automodKeywords* when actionType=create_automod_rule (list of strings) — For Update, setting this REPLACES the rule's whole keyword list. (only when actionType=create_automod_rule/update_automod_rule)
    - automodRuleId* when actionType=delete_automod_rule|update_automod_rule (text, supports {{variables}}) (only when actionType=delete_automod_rule/update_automod_rule)
    - webhookName* (text, supports {{variables}}) (only when actionType=create_webhook)
    - webhookUrl* (text, supports {{variables}}) (only when actionType=execute_webhook)
    - webhookUsername (text, supports {{variables}}) (only when actionType=execute_webhook)
    - webhookAvatarUrl (text, supports {{variables}}) (only when actionType=execute_webhook)
    - webhookId* (text, supports {{variables}}) (only when actionType=delete_webhook)
    - threadId* (text, supports {{variables}}) (only when actionType=archive_thread/lock_thread/add_thread_member/remove_thread_member/list_thread_members/join_thread/leave_thread)
    - archived (true/false) — On: the thread is hidden from the channel list until someone posts in it. Off: it is brought back as an active thread. (only when actionType=archive_thread)
    - locked (true/false) — On: only moderators can post or reopen the thread. Off: members can write in it again. (only when actionType=lock_thread)
    - emojiName* (text, supports {{variables}}) (only when actionType=create_emoji)
    - emojiImageUrl* (text, supports {{variables}}) (only when actionType=create_emoji)
    - emojiId* (text, supports {{variables}}) (only when actionType=delete_emoji)
    - newName* when actionType=update_guild (text, supports {{variables}}) (only when actionType=update_channel/update_guild/update_role)
    - pruneDays (text, supports {{variables}}) (only when actionType=prune_guild/preview_prune)
    - pruneIncludeRoleIds (Discord role ID(s)) (only when actionType=preview_prune)
    - pauseInvitesMinutes (text, supports {{variables}}) (only when actionType=pause_invites)
    - pauseDmsMinutes (text, supports {{variables}}) (only when actionType=pause_invites)
    - inviteCode* (text, supports {{variables}}) (only when actionType=delete_invite)
    - messageLimit (text, supports {{variables}}) — Newest first. Discord allows 1–100 per read; anything larger is capped. (only when actionType=list_messages)
    - beforeMessageId (text, supports {{variables}}) — Only messages older than this one — use it to walk further back a page at a time. (only when actionType=list_messages)
    - permissionTargetType (one of: role | member) (only when actionType=set_channel_permission/clear_channel_permission)
    - permissionRoleId* when actionType=set_channel_permission|clear_channel_permission (Discord role ID) (only when actionType=set_channel_permission/clear_channel_permission)
    - permissionUserId* when permissionTargetType=member (Discord user ID (accepts {{variables}})) (only when permissionTargetType=member)
    - permissionAllow (list of one of: ViewChannel | SendMessages | ReadMessageHistory | ManageMessages | EmbedLinks | AttachFiles | AddReactions | UseExternalEmojis | MentionEveryone | SendMessagesInThreads | CreatePublicThreads | CreatePrivateThreads | ManageThreads | UseApplicationCommands | Connect | Speak | Stream | MuteMembers | DeafenMembers | MoveMembers) (only when actionType=set_channel_permission)
    - permissionDeny (list of one of: ViewChannel | SendMessages | ReadMessageHistory | ManageMessages | EmbedLinks | AttachFiles | AddReactions | UseExternalEmojis | MentionEveryone | SendMessagesInThreads | CreatePublicThreads | CreatePrivateThreads | ManageThreads | UseApplicationCommands | Connect | Speak | Stream | MuteMembers | DeafenMembers | MoveMembers) (only when actionType=set_channel_permission)
    - pollAnswerId* when actionType=get_poll_voters (text, supports {{variables}}) — 1 for the poll's first answer, 2 for the second, and so on. (only when actionType=get_poll_voters)
    - voterLimit (text, supports {{variables}}) — Discord returns at most 100 voters per read. (only when actionType=get_poll_voters)
    - reactorLimit (text, supports {{variables}}) — Discord returns at most 100 per read. (only when actionType=get_reactors)
    - pinLimit (text, supports {{variables}}) — Discord allows up to 50 pinned messages per channel. (only when actionType=list_pins)
    - afterMessageId (text, supports {{variables}}) — Only messages NEWER than this one — for catching up in order. (only when actionType=list_messages)
    - aroundMessageId (text, supports {{variables}}) — The messages surrounding this one — handy for reporting context. (only when actionType=list_messages)
    - messageIds (list of strings) — Leave empty to delete the most recent N instead. (only when actionType=bulk_delete)
    - threadMemberLimit (text, supports {{variables}}) (only when actionType=list_thread_members)
    - threadLimit (text, supports {{variables}}) (only when actionType=list_archived_threads)
    - followTargetChannelId* when actionType=follow_channel (Discord channel ID) (only when actionType=follow_channel)
    - guildDescription (text, supports {{variables}}) (only when actionType=update_guild)
    - memberLimit (text, supports {{variables}}) — Discord returns at most 1000 per read. (only when actionType=list_members/search_members)
    - memberQuery* when actionType=search_members (text, supports {{variables}}) (only when actionType=search_members)
    - auditAction (text, supports {{variables}}) (only when actionType=list_audit_log)
    - auditLimit (text, supports {{variables}}) — Discord returns at most 100 per read. (only when actionType=list_audit_log)
    - userIds* when actionType=bulk_ban (Discord user ID (accepts {{variables}})) (only when actionType=bulk_ban)
    - automodEnabled (one of:  | yes | no) (only when actionType=update_automod_rule)
    - verificationLevel (one of:  | none | low | medium | high | highest) (only when actionType=update_guild)
    - explicitContentFilter (one of:  | disabled | members_without_roles | all_members) (only when actionType=update_guild)
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{message_id}}, {{channel_id}}, {{guild_id}}, {{delivery}}, {{content}}, {{author_id}}, {{author}}, {{timestamp}}, {{jump_url}}, {{pinned}}, {{attachment_count}}, {{user_id}}, {{channel_name}}, {{thread_id}}, {{thread_name}}, {{invite_code}}, {{invite_url}}, {{role_id}}, {{role_name}}, {{event_id}}, {{event_name}}, {{events}}, {{rule_id}}, {{rule_name}}, {{rules}}, {{webhook_id}}, {{webhook_url}}, {{emoji_id}}, {{emoji_name}}, {{pruned}}, {{bans}}, {{invites}}, {{would_prune}}, {{color}}, {{position}}, {{hoist}}, {{mentionable}}, {{managed}}, {{member_count}}, {{emojis}}, {{invites_disabled_until}}, {{dms_disabled_until}}, {{webhooks}}, {{member_ids}}, {{is_empty}}, {{members}}, {{messages}}, {{message_count}}, {{member_id}}, {{username}}, {{display_name}}, {{nickname}}, {{avatar}}, {{joined_at}}, {{premium_since}}, {{is_boosting}}, {{is_bot}}, {{timed_out_until}}, {{role_ids}}, {{role_names}}, {{top_role_id}}, {{top_role_name}}, {{roles}}, {{channel_type}}, {{channel_topic}}, {{channel_nsfw}}, {{channel_parent_id}}, {{channel_position}}, {{channel_slowmode}}, {{target_id}}, {{target_type}}, {{allow}}, {{deny}}, {{poll_question}}, {{poll_total_votes}}, {{poll_answers}}, {{voters}}, {{voter_count}}, {{reactors}}, {{reactor_count}}, {{pins}}, {{pin_count}}, {{threads}}, {{has_more}}, {{target_channel_id}}, {{guild_name}}, {{owner_id}}, {{boost_tier}}, {{boost_count}}, {{verification_level}}, {{channels}}, {{is_banned}}, {{entries}}, {{entry_count}}, {{thread_count}}, {{banned}}, {{failed}}, {{banned_ids}}, {{enabled}}
    + INTERACTIONS: giving this node a button/menu ALSO turns it into a trigger. For a component with "custom_id": "join" it gains the flow outputs on_button:join (a click) — or, for a menu, on_select:join and on_select:join:<option value> (that exact option). Connect FROM one of those (3rd item of the connection) to react to the click. That branch publishes {{custom_id}}, {{user_id}}, {{username}}, {{channel_id}}, {{guild_id}}, {{message_id}}, {{interaction_id}}, {{member_roles}} — and for a menu {{value}} (chosen option) + {{values}}. custom_id must be unique across the WHOLE workflow (not just this node) — a click can only route to ONE owner, so reusing an id on a second message/node means the second one never fires.
    + FORM MODAL: use actionType "open_modal" and config.openModal. Connect it DIRECTLY from the sending message on_button:<custom_id> output; Discord requires a modal as the immediate click response. Then add a separate trigger.discord.modal_submit whose modalId contains the same form custom_id. The submission publishes {{fields}} plus {{field_<field custom_id>}} for every input.

  action.twitch — Twitch Action [needs twitch]
    Perform any Twitch action — send chat, moderate, update stream, create clips
    available actionType operations (use these exact values):
      - send_chat (Send Chat Message · Chat) — Post a message in your Twitch chat.
      - send_announcement (Send Announcement · Chat) — Post a highlighted announcement in chat.
      - timeout_user (Timeout User · Moderation) — Time out a viewer for a set time.
      - ban_user (Ban User · Moderation) — Ban a viewer from your chat.
      - unban_user (Unban User · Moderation)
      - clear_chat (Clear Chat · Chat)
      - update_title (Update Stream Info · Stream) [PARTIAL — Covers title, category, tags, language and stream delay. Content classification labels and the branded-content flag are not exposed — both carry compliance consequences that belong in a deliberate visit to the Twitch dashboard, not an automation.] — Change your stream title or category.
      - create_clip (Create Clip · Stream)
      - send_shoutout (Send Shoutout · Chat)
      - update_redemption_status (Update Redemption Status · Channel Points)
      - update_chat_settings (Update Chat Settings · Moderation) [PARTIAL — Covers follower, slow, emote, subscriber and unique-chat modes. The non-moderator chat delay is intentionally not exposed.]
      - get_chat_settings (Get Chat Settings · Moderation)
      - get_stream_info (Get Stream Info · Stream) — Check if you are live and read stream stats.
      - get_followers (Get Followers · Community) — Check whether a viewer follows you.
      - get_chatters (Get Chatters · Community)
      - start_raid (Start Raid · Stream)
      - cancel_raid (Cancel Raid · Stream)
      - create_poll (Create Poll · Engagement)
      - end_poll (End Poll · Engagement)
      - create_prediction (Create Prediction · Engagement)
      - end_prediction (End Prediction · Engagement)
      - create_reward (Create Channel Point Reward · Channel Points) [PARTIAL — Manages rewards created through Noria only — Twitch does not allow an app to edit rewards made elsewhere.]
      - update_reward (Update Channel Point Reward · Channel Points) [PARTIAL — Manages rewards created through Noria only — Twitch does not allow an app to edit rewards made elsewhere.]
      - delete_reward (Delete Channel Point Reward · Channel Points) [PARTIAL — Manages rewards created through Noria only — Twitch does not allow an app to delete rewards made elsewhere.]
      - list_rewards (List Channel Point Rewards · Channel Points) [PARTIAL — Lists the rewards Noria manages. Rewards created elsewhere are not returned.]
      - list_redemptions (List Reward Redemptions · Channel Points) [PARTIAL — Reads a single page (up to 50) of one reward's queue.]
      - get_channel_info (Get Channel Info · Stream)
      - start_commercial (Start Commercial · Stream)
      - get_ad_schedule (Get Ad Schedule · Stream)
      - snooze_next_ad (Snooze Next Ad · Stream)
    config:
    - actionType* (one of: send_chat | send_announcement | timeout_user | ban_user | unban_user | clear_chat | update_title | create_clip | send_shoutout | update_redemption_status | update_chat_settings | get_chat_settings | get_stream_info | get_followers | get_chatters | start_raid | cancel_raid | create_poll | end_poll | create_prediction | end_prediction | create_reward | update_reward | delete_reward | list_rewards | list_redemptions | get_channel_info | start_commercial | get_ad_schedule | snooze_next_ad)
    - channel* (the connected Twitch account; omit this field — Noria fills it from the workflow settings) — Actions are always performed on your connected Twitch channel — you cannot target another channel from here.
    - message* when actionType=send_chat|send_announcement (text, supports {{variables}}) (only when actionType=send_chat/send_announcement)
    - replyTo (text, supports {{variables}}) — Quote-reply to a specific chat message (only when actionType=send_chat)
    - color (one of: primary | blue | green | orange | purple) (only when actionType=send_announcement)
    - userId* when actionType=timeout_user|ban_user|unban_user (text, supports {{variables}}) (only when actionType=timeout_user/ban_user/unban_user)
    - durationSeconds (text, supports {{variables}}) (only when actionType=timeout_user)
    - reason (text, supports {{variables}}) (only when actionType=timeout_user/ban_user)
    - title (text, supports {{variables}}) (only when actionType=update_title)
    - gameName (text, supports {{variables}}) (only when actionType=update_title)
    - tags (list of strings) — Up to 10 tags. Replaces the current tags. (only when actionType=update_title)
    - language (text, supports {{variables}}) — A two-letter language code, e.g. "en" or "fr". (only when actionType=update_title)
    - delaySeconds (text, supports {{variables}}) — Partner-only. 0 to 900 seconds. (only when actionType=update_title)
    - targetBroadcasterId (text, supports {{variables}}) (only when actionType=send_shoutout/start_raid/get_channel_info)
    - emoteMode (one of:  | on | off) (only when actionType=update_chat_settings)
    - followerMode (one of:  | on | off) (only when actionType=update_chat_settings)
    - followerModeDuration (text, supports {{variables}}) — Only applies when followers-only is switched On. 0 = any follower. (only when actionType=update_chat_settings)
    - slowMode (one of:  | on | off) (only when actionType=update_chat_settings)
    - slowModeWaitTime (text, supports {{variables}}) — Only applies when slow mode is switched On. 3 to 120 seconds. (only when actionType=update_chat_settings)
    - subscriberMode (one of:  | on | off) (only when actionType=update_chat_settings)
    - uniqueChatMode (one of:  | on | off) (only when actionType=update_chat_settings)
    - followerLimit (text, supports {{variables}}) — Twitch returns at most 100 per read. Ignored when you check a single viewer below. (only when actionType=get_followers)
    - chatterLimit (text, supports {{variables}}) — Twitch returns at most 1000 per read. (only when actionType=get_chatters)
    - pollTitle* when actionType=create_poll (text, supports {{variables}}) (only when actionType=create_poll)
    - pollChoices* when actionType=create_poll (list of strings) — 2 to 5 choices, one per entry. (only when actionType=create_poll)
    - pollDurationSeconds (text, supports {{variables}}) — 15 to 1800 seconds. Empty = 120. (only when actionType=create_poll)
    - pollPointsVoting (true/false) — Viewers can spend channel points to cast additional votes. Leave off for a one-person-one-vote poll. (only when actionType=create_poll)
    - pollPointsPerVote (text, supports {{variables}}) — Only applies when channel-point voting is on. (only when actionType=create_poll)
    - pollId* when actionType=end_poll (text, supports {{variables}}) (only when actionType=end_poll)
    - pollEndStatus (one of: TERMINATED | ARCHIVED) (only when actionType=end_poll)
    - predictionTitle* when actionType=create_prediction (text, supports {{variables}}) (only when actionType=create_prediction)
    - predictionOutcomes* when actionType=create_prediction (list of strings) — 2 to 10 outcomes, one per entry. (only when actionType=create_prediction)
    - predictionWindowSeconds (text, supports {{variables}}) — 30 to 1800 seconds. Empty = 120. (only when actionType=create_prediction)
    - predictionId* when actionType=end_prediction (text, supports {{variables}}) (only when actionType=end_prediction)
    - predictionEndStatus (one of: RESOLVED | LOCKED | CANCELED) (only when actionType=end_prediction)
    - winningOutcomeId (text, supports {{variables}}) (only when actionType=end_prediction)
    - rewardTitle* when actionType=create_reward (text, supports {{variables}}) (only when actionType=create_reward/update_reward)
    - rewardCost* when actionType=create_reward (text, supports {{variables}}) (only when actionType=create_reward/update_reward)
    - rewardPrompt (text, supports {{variables}}) — Shown under the reward. Filling this in asks the viewer to type something when redeeming. (only when actionType=create_reward/update_reward)
    - rewardUserInputRequired (true/false) — The redemption opens a text box on Twitch; what the viewer types arrives as the redemption input in your workflow. (only when actionType=create_reward)
    - rewardBackgroundColor (text, supports {{variables}}) (only when actionType=create_reward)
    - rewardCooldownSeconds (text, supports {{variables}}) — 0 = no cooldown. (only when actionType=create_reward/update_reward)
    - rewardMaxPerStream (text, supports {{variables}}) (only when actionType=create_reward)
    - rewardMaxPerUserPerStream (text, supports {{variables}}) (only when actionType=create_reward)
    - rewardEnabled (one of:  | yes | no) (only when actionType=update_reward)
    - rewardPaused (one of:  | yes | no) (only when actionType=update_reward)
    - rewardId* when actionType=update_reward|delete_reward|list_redemptions|update_redemption_status (text, supports {{variables}}) (only when actionType=update_reward/delete_reward/list_redemptions/update_redemption_status)
    - redemptionStatus (one of: UNFULFILLED | FULFILLED | CANCELED) (only when actionType=list_redemptions)
    - redemptionLimit (text, supports {{variables}}) — Twitch returns at most 50 per read. (only when actionType=list_redemptions)
    - commercialLength (one of: 30 | 60 | 90 | 120 | 180) (only when actionType=start_commercial)
    - redemptionId* when actionType=update_redemption_status (text, supports {{variables}}) (only when actionType=update_redemption_status)
    - status (one of: FULFILLED | CANCELED) (only when actionType=update_redemption_status)
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{channel}}, {{message}}, {{sent}}, {{clip_id}}, {{clip_url}}, {{reply_to}}, {{userId}}, {{durationSeconds}}, {{title}}, {{targetBroadcasterId}}, {{rewardId}}, {{redemptionId}}, {{status}}, {{is_live}}, {{viewer_count}}, {{game_name}}, {{game_id}}, {{started_at}}, {{stream_id}}, {{thumbnail_url}}, {{language}}, {{is_follower}}, {{followed_at}}, {{total}}, {{followers}}, {{chatters}}, {{follower_mode}}, {{slow_mode}}, {{emote_mode}}, {{subscriber_mode}}, {{unique_chat_mode}}, {{poll_id}}, {{choices}}, {{prediction_id}}, {{outcomes}}, {{to_broadcaster_id}}, {{created_at}}, {{is_mature}}, {{reward_id}}, {{cost}}, {{is_enabled}}, {{is_paused}}, {{rewards}}, {{redemptions}}, {{redemption_count}}, {{broadcaster_id}}, {{broadcaster_name}}, {{tags}}, {{delay}}, {{next_ad_at}}, {{last_ad_at}}, {{preroll_free_time}}, {{snooze_count}}, {{snooze_refresh_at}}, {{length}}, {{retry_after}}

  action.http.request — HTTP Request
    Make an HTTP request to any API or URL
    config:
    - url* (text, supports {{variables}})
    - method* (one of: GET | POST | PUT | PATCH | DELETE)
    - authType (one of: none | bearer | basic | apiKey) — Adds the right Authorization/API-key header for you — no need to type it into Headers by hand.
    - authToken* when authType=bearer (text, supports {{variables}}) (only when authType=bearer)
    - authUsername (text, supports {{variables}}) (only when authType=basic)
    - authPassword (text, supports {{variables}}) (only when authType=basic)
    - authHeaderName (text, supports {{variables}}) (only when authType=apiKey)
    - authHeaderValue* when authType=apiKey (text, supports {{variables}}) (only when authType=apiKey)
    - headers (object of key/value pairs, e.g. {"Authorization": "Bearer {{token}}"}) — HTTP headers (e.g. Authorization, Content-Type)
    - body (object of key/value pairs, e.g. {"Authorization": "Bearer {{token}}"}) — JSON body fields to send in the request
    - params (object of key/value pairs, e.g. {"Authorization": "Bearer {{token}}"}) — URL query parameters (?key=value)
    - timeout (number (also accepts {{variables}})) — Max wait time in ms (default 10000)
    - responseField (text, supports {{variables}}) — Dot-path to extract from response, e.g. data.items.0.name
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{status}}, {{body}}, {{headers}}, {{responseStatus}}, {{responseBody}}, {{responseHeaders}}

  action.email.send — Send Email
    Send an email via SMTP
    config:
    - to* (text, supports {{variables}})
    - cc (text, supports {{variables}})
    - subject* (text, supports {{variables}})
    - body* (text, supports {{variables}})
    - isHtml (true/false) — Treat the body as HTML so links, bold text and layout render in the inbox. Off sends plain text.
    - attachments (array of { filename, url } (url is fetched & attached) or { filename, content } (inline text/base64) — e.g. [{"filename":"report.pdf","url":"{{file_url}}"}]) — Each attachment is a filename plus either a URL (fetched & attached) or inline content.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{message_id}}, {{sent}}, {{to}}, {{subject}}

  action.discord.welcome — Welcome & Goodbye
    Attach to a Member trigger: greets arrivals in a channel or privately, hands them their starting roles, and posts a goodbye when they leave — no other nodes needed.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - ignoreBots (true/false) — On by default — a bot added to the server does not get greeted or given roles.
    - welcomeChannelId (Discord channel ID) — Where arrivals are greeted. Leave empty to skip the public greeting — a private one and the starting roles still work.
    - welcomeMessage (text, supports {{variables}})
    - welcomeAsEmbed (true/false) — Post it as an embed card instead of plain text. Required if you want a banner image or the member's avatar shown.
    - welcomeTitle (text, supports {{variables}}) (only when welcomeAsEmbed=true)
    - welcomeImageUrl (text, supports {{variables}}) — Shown at the bottom of the embed. Leave empty for no banner. (only when welcomeAsEmbed=true)
    - showAvatar (true/false) — Puts the joining member's avatar in the embed's corner. (only when welcomeAsEmbed=true)
    - dmWelcome (true/false) — Sends the same text as a direct message. A member with DMs closed simply does not get one — the public greeting still happens.
    - autoRoleIds (Discord role ID(s)) — Handed out the moment someone joins — a starter role, a colour, an opt-in default.
    - goodbyeChannelId (Discord channel ID) — Where departures are announced. Leave empty to say nothing when someone leaves.
    - goodbyeMessage (text, supports {{variables}})
    - deleteWelcomeOnLeave (true/false) — Deletes the greeting posted when they joined, so a channel of welcomes only ever shows members who are still here.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{posted}}, {{event}}

  action.discord.autoresponder — Auto Responder
    Attach to a Message trigger: when a message contains one of your phrases, the bot answers, reacts or writes privately — with a cooldown so it never spams.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - phrases* (list of strings) — The message sets this off if it matches any of these.
    - matchMode (one of: contains | exact | starts_with | word | regex) — "Contains" is the usual choice. "Whole word" stops "hi" firing inside "this". "Search pattern" takes regex syntax, for the rare case the other four cannot express.
    - caseSensitive (true/false) — Off by default, so "Hello" and "hello" are the same phrase.
    - responseType (one of: message | dm | reaction)
    - responses* when responseType=message|dm (list of strings) (only when responseType=message/dm)
    - reactionEmoji* when responseType=reaction (text, supports {{variables}}) (only when responseType=reaction)
    - channelIds (Discord channel ID(s)) — Leave empty to listen everywhere the trigger fires.
    - exemptRoleIds (Discord role ID(s)) — Members holding any of these never set it off — useful for staff testing phrases.
    - ignoreBots (true/false) — On by default. Two auto responders answering each other is the classic way to flood a channel.
    - cooldownSeconds (number (also accepts {{variables}})) — 0 = answer every single time. Otherwise it stays quiet for this long after answering.
    - cooldownScope (one of: channel | member | server) — Per channel is the usual choice: one answer per channel, but two channels can each get theirs.
    - chancePercent (number (also accepts {{variables}})) — 100 = always. Lower it for a rare easter egg that stays funny because it is not guaranteed.
    - deleteTrigger (true/false) — Turns the responder into a "say this instead" rule.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{matched}}, {{matched_phrase}}, {{response}}

  action.discord.self_role — Self Role
    Post a message where members get a role by clicking a button, picking from a dropdown, or reacting with an emoji (your choice) — no other nodes needed.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId* (Discord channel ID) — Where the role-picker message is posted.
    - interactionType* (one of: button | select | reaction) — Buttons show a label per role. A dropdown fits the same roles on one line and lets members set all of theirs in one go. Emoji reactions are the classic react-to-get-a-role style.
    - roles* (array of {"roleId": string, "label"?: string, "emoji"?: string} — one row per role. "roleId" is a real Discord role id (snowflake), NOT a role name — you cannot invent one; leave the array empty if no role id is known and tell the user to pick roles in the editor. Which of "label" (button text, optional — defaults to the role's current name) or "emoji" is used depends on this node's sibling "interactionType" field: "button" uses "label"; "select" uses "label" plus an OPTIONAL "emoji"; "reaction" uses "emoji", which is then required.) — One row per role. Click (or react) to get it, click/react again to remove it.
    - selectPlaceholder (text, supports {{variables}}) — The greyed-out text shown on the closed dropdown. Leave empty for Discord's default. (only when interactionType=select)
    - introText (text, supports {{variables}})
    - requiredRoleId (Discord role ID) — Only members with this role can use the panel. Leave empty to let anyone respond.
    - exclusive (true/false) — Picking a new role removes any other role from this list first (radio-button style). In dropdown mode Discord itself stops a member selecting a second one.
    - maxRoles (number (also accepts {{variables}})) — 0 = no limit. Otherwise a member can hold at most this many of the roles on this panel at once.
    - grantMessage (text, supports {{variables}})
    - removeMessage (text, supports {{variables}})
    - logChannelId (Discord channel ID) — Leave empty to skip logging. Otherwise posts a line there whenever a member grants or removes a role via this panel.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{message_id}}

  action.discord.giveaway — Giveaway
    Post a giveaway members enter by clicking a button or reacting, then automatically pick and announce winners when it ends — no other nodes needed.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId* (Discord channel ID) — Where the giveaway is posted.
    - prize* (text, supports {{variables}}) — What the winner(s) get. Shown in the giveaway post and the winner announcement.
    - duration* (text, supports {{variables}})
    - winnerCount* (number (also accepts {{variables}})) — How many entrants are picked when the giveaway ends.
    - entryStyle* (one of: button | reaction) — Buttons give an instant "you're entered" reply. Emoji reactions are the classic giveaway-bot style.
    - entryEmoji* when entryStyle=reaction (text, supports {{variables}}) — The emoji members react with to enter. (only when entryStyle=reaction)
    - requiredRoleId (Discord role ID) — Only members with this role can enter. Leave empty to let anyone enter.
    - minAccountAgeDays (number (also accepts {{variables}})) — 0 = no limit. Otherwise a Discord account created more recently than this cannot enter — the usual defence against throwaway accounts farming a giveaway.
    - minServerAgeDays (number (also accepts {{variables}})) — 0 = no limit. Otherwise a member who joined more recently than this cannot enter, so the prize goes to the community rather than to people who joined for it.
    - bonusEntryRoleIds (Discord role ID(s)) — Members holding any of these get extra entries, so they are likelier to win — boosters, subscribers, veterans. They can still only win once.
    - bonusEntries (number (also accepts {{variables}})) — How many entries a bonus role is worth. 2 = double odds. Holding several bonus roles still counts once, not once per role.
    - announceText (text, supports {{variables}})
    - winnerMessage (text, supports {{variables}})
    - noWinnersMessage (text, supports {{variables}})
    - announceChannelId (Discord channel ID) — Leave empty to announce in the same channel as the giveaway post.
    - dmWinners (true/false) — Send each winner the winner-announcement text as a direct message too. A winner with DMs closed simply doesn't get one — everyone else still does.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{message_id}}

  action.discord.leveling — Leveling
    Attach to a Message trigger: awards XP per message, tracks levels automatically, announces level-ups and can grant roles at chosen levels — no other nodes needed.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default) — XP is tracked separately per server.
    - xpAmount* (number (also accepts {{variables}})) — The exact amount, or the MINIMUM of a range if "Maximum XP" below is also set.
    - xpAmountMax (number (also accepts {{variables}}))
    - xpPerLevel* (number (also accepts {{variables}}))
    - cooldownSeconds (number (also accepts {{variables}})) — A member only earns XP once per this many seconds, however often they message.
    - excludedChannelIds (Discord channel ID(s)) — Messages in these channels never earn XP — e.g. a #bot-commands or #rules channel.
    - announceChannelId (Discord channel ID) — Leave empty to announce in the same channel the message was sent in. Ignored when "Silent level-ups" is on.
    - levelUpMessage (text, supports {{variables}})
    - silent (true/false) — Grant role rewards without posting a level-up announcement anywhere.
    - noXpRoleIds (Discord role ID(s)) — Members holding any of these never gain XP — e.g. a muted role, or bots given a role.
    - xpBoostRoleIds (Discord role ID(s)) — Members holding any of these earn more per message — boosters, subscribers, veterans.
    - xpBoostMultiplier (number (also accepts {{variables}})) — What "Bonus XP roles" multiply the award by. 2 = double. Holding several bonus roles still multiplies once, not once per role.
    - roleRewards (array of {"level": number, "roleId": string} — one row per role reward. "roleId" is a real Discord role id (snowflake), NOT a role name — you cannot invent one; leave the array empty if no role id is known and tell the user to pick roles in the editor.) — Grant a role the first time a member reaches each level.
    - stackRoleRewards (true/false) — On (default): a member collects every reward role they pass. Off: reaching a new reward level swaps the previous one out, so a member wears only their highest rank.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{xp}}, {{level}}, {{leveled_up}}, {{rank}}

  action.discord.word_filter — Word Filter
    Attach to a Message trigger: deletes messages containing any banned word, and can warn, timeout and log the author — no other nodes needed.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - bannedWords* (list of strings) — The message is deleted if it contains any of these (not case-sensitive).
    - deleteMessage (true/false) — Remove the offending message from the channel. Turn off to only warn or log without deleting.
    - exemptRoleIds (Discord role ID(s)) — Members with any of these roles bypass the filter entirely — e.g. moderators.
    - exemptChannelIds (Discord channel ID(s)) — The filter never runs in these channels — e.g. an NSFW or mod-chat channel.
    - warnMessage (text, supports {{variables}})
    - timeoutMinutes (number (also accepts {{variables}})) — 0 = no timeout. Otherwise the author is timed out for this long.
    - logChannelId (Discord channel ID) — Leave empty to skip logging. Otherwise posts the author, channel and matched word there.
    - matchWholeWord (true/false) — Off (default): "ass" also matches inside "class". On: only matches "ass" as a standalone word.
    - allowedPhrases (list of strings) — A message containing one of these is never filtered, even if a banned word appears inside it.
    - catchEvasion (true/false) — Also matches when a banned word is written with digits, accents, repeats or separators — "b4dw0rd", "b a d w o r d", "bâdword", "baaadword".
    - warnDeleteAfterSeconds (number (also accepts {{variables}})) — 0 keeps the warning in the channel for good. Otherwise it disappears on its own after this long.
    - dmWarning (true/false) — Sends the same warning text to the member privately, so the reason survives the channel warning being removed. A member with DMs closed simply does not get one.
    - countStrikes (true/false) — Remembers how many times each member has tripped the filter, and lets the punishment grow with the count instead of staying flat.
    - strikeExpiryHours (number (also accepts {{variables}})) — 0 = strikes never expire. Otherwise a member's count resets once they go this long without tripping the filter. (only when countStrikes=true)
    - timeoutScaling (one of: flat | multiply | double) — Applies to "Timeout duration" above. Ignored when that is 0. (only when countStrikes=true)
    - kickAtStrike (number (also accepts {{variables}})) — 0 = never kick. Otherwise the member is kicked once they reach this many strikes. (only when countStrikes=true)
    - banAtStrike (number (also accepts {{variables}})) — 0 = never ban. Otherwise the member is banned once they reach this many strikes. Checked before the kick, so a member never gets kicked on the way to a ban. (only when countStrikes=true)
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{matched}}, {{matched_word}}, {{strikes}}

  action.discord.ticket_panel — Ticket Panel
    Post a message where members open a private ticket channel by clicking a button. Support staff get Close plus optional Claim, Hold, Escalate, Priority and Transcript controls. No other nodes needed.
    config:
    - guildId* (Discord server ID; usually omit this field or leave it empty so Noria uses the trigger server or workflow default)
    - channelId* (Discord channel ID) — Where the ticket panel message is posted.
    - supportRoleIds* (Discord role ID(s)) — These roles can see and close every ticket.
    - panelText (text, supports {{variables}})
    - panelAsEmbed (true/false) — Post the panel message inside an embed card instead of plain text.
    - panelTitle (text, supports {{variables}}) — Title shown at the top of the panel embed. (only when panelAsEmbed=true)
    - buttonLabel (text, supports {{variables}}) — Used as the panel's only button when no ticket types are configured below.
    - buttonEmoji (text, supports {{variables}}) — Optional emoji shown before the default ticket button label.
    - buttonStyle (one of: primary | secondary | success | danger) — Same four styles as a normal Discord button.
    - ticketOpenMode (one of: direct | form) — A modal can collect up to five answers before the ticket channel is created.
    - openModal* when ticketOpenMode=form (In AI authoring JSON, write a REAL object with this exact shape: { "title": string, "custom_id": string, "fields": [{ "custom_id": string, "label": string, "style": "short"|"paragraph", "required"?: boolean, "placeholder"?: string, "min"?: number, "max"?: number }] }. Do NOT stringify/double-escape it; the importer converts it to the editor stored format. min/max are text-input length bounds (NOT minLength/maxLength). Pair it with a "Discord — Modal Submitted" trigger matching the same custom_id.) — Questions shown before opening the ticket. Answers are available in messages as {{field_FIELD_ID}}. (only when ticketOpenMode=form)
    - ticketTypes (array of {"label": string, "categoryId"?: string, "supportRoleIds"?: string[]} — one row per ticket-panel button (e.g. "Bug Report", "Billing"). "categoryId"/"supportRoleIds" are real Discord ids (snowflakes), NOT names — you cannot invent them; leave them out of a row (or leave the whole array empty for a single default ticket type) if no id is known and tell the user to pick them in the editor.) — Optional — add a row per ticket type (e.g. "Bug Report", "Billing") to post one configurable button each, routed to its own category and support roles. Leave empty for a single default button.
    - ticketNameTemplate (text, supports {{variables}})
    - welcomeMessage (text, supports {{variables}})
    - welcomeAsEmbed (true/false) — Post the welcome message inside an embed card instead of plain text.
    - embedColor (text, supports {{variables}}) — Accent color used when the panel/welcome messages are sent as embeds.
    - oneTicketPerUser (true/false) — Stop a member opening a second ticket while one is already open.
    - claimMode (one of: free | optional | required) — Required claim keeps the ticket visible to the support team but unlocks replies only for the moderator who claims it.
    - categoryId (Discord category channel ID (a channel PARENT, not a message target) — omit unless a specific category id is known)
    - logChannelId (Discord channel ID) — Leave empty to skip logging. Otherwise posts a line there whenever a ticket is opened or closed.
    - ticketFeatures (list of one of: hold | escalate | transcript | priority)
    - escalationRoleIds* when ticketFeatures=escalate (Discord role ID(s)) — Pinged in the ticket channel when a staff member clicks Escalate. They are not given access — add them to Support roles too if they need to read the ticket. (only when ticketFeatures=escalate)
    - transcriptChannelId (Discord channel ID) (only when ticketFeatures=transcript)
    - transcriptOnClose (true/false) — Closing deletes the channel for good. Turn this on to post the conversation as a text file first — it works whether or not staff have the Transcript button.
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{message_id}}

## CONDITIONS (branch the flow)

  condition.if — If / Else
    Branch the workflow based on a condition
    config:
    - operator* (one of: equals | not_equals | contains | not_contains | starts_with | ends_with | greater_than | less_than | gte | lte | is_empty | is_not_empty | is_true | is_false | is_number | is_string | regex | in | not_in | has_any_role | has_all_roles | has_no_role | expression)
    - conditionGroup* when operator=group (a visual AND/OR tree the UI builds — do NOT author this field directly. Use operator "expression" instead and write the condition in the "expression" field.) — Combine one or more checks with AND/OR. (only when operator=group)
    - leftOperand* (text, supports {{variables}}) (only when operator=equals/not_equals/contains/not_contains/starts_with/ends_with/greater_than/less_than/gte/lte/is_empty/is_not_empty/is_true/is_false/is_number/is_string/regex/in/not_in/has_any_role/has_all_roles/has_no_role)
    - rightOperand* when operator=equals|not_equals|contains|not_contains|starts_with|ends_with|greater_than|less_than|gte|lte|regex (text, supports {{variables}}) (only when operator=equals/not_equals/contains/not_contains/starts_with/ends_with/greater_than/less_than/gte/lte/regex)
    - rightValues* when operator=in|not_in|has_any_role|has_all_roles|has_no_role (list of strings) — Add the allowed values or the role IDs to look for. (only when operator=in/not_in/has_any_role/has_all_roles/has_no_role)
    - expression* (text, supports {{variables}}) — A yes/no formula. Reference data with {{name}} or bare names; supports + - * / , comparisons, && || !, in, and functions like length(), includes(), round(). (only when operator=expression)
    - caseSensitive (true/false) — On: "Hello" and "hello" are different values. Off: letter case is ignored when comparing. (only when operator=equals/not_equals/contains/not_contains/starts_with/ends_with/greater_than/less_than/gte/lte/is_empty/is_not_empty/is_true/is_false/is_number/is_string/regex/in/not_in/has_any_role/has_all_roles/has_no_role/group)
    flow outputs (connect from these) → true, false
    variables it publishes (usable downstream) → {{result}}

  condition.switch — Switch
    Route workflow through one of several cases
    config:
    - mode (one of: value | expression) — Expression mode: each case is a condition (e.g. {{amount}} > 100); the first true one wins.
    - value* (text, supports {{variables}})
    - cases* when mode=expression (list of {"value": string}. EACH case becomes its own OUTPUT — connect a "connections" entry FROM this node using that case's 0-based index as the branch: ["switch_node_id", "target", "case_0"] for the first case, "case_1" for the second, etc. In "value" mode each "value" is compared for equality; in "expression" mode each "value" is itself a true/false expression (first one true wins) — same syntax as a Condition's Expression field. No case matches → falls through to the "default" branch.) — Add as many as you need — each gets its own output. The first matching case wins.
    flow outputs (connect from these) → default
    variables it publishes (usable downstream) → {{value}}, {{branch}}

  condition.filter — Filter
    Continue only if a condition passes, otherwise stop
    config:
    - field* (text, supports {{variables}}) (only when operator=equals/not_equals/contains/not_contains/starts_with/ends_with/greater_than/less_than/gte/lte/is_empty/is_not_empty/is_true/is_false/is_number/is_string/regex/in/not_in/has_any_role/has_all_roles/has_no_role)
    - operator* (one of: equals | not_equals | contains | not_contains | starts_with | ends_with | greater_than | less_than | gte | lte | is_empty | is_not_empty | is_true | is_false | is_number | is_string | regex | in | not_in | has_any_role | has_all_roles | has_no_role | expression)
    - value* when operator=equals|not_equals|contains|not_contains|starts_with|ends_with|greater_than|less_than|gte|lte|regex (text, supports {{variables}}) (only when operator=equals/not_equals/contains/not_contains/starts_with/ends_with/greater_than/less_than/gte/lte/regex)
    - valueList* when operator=in|not_in|has_any_role|has_all_roles|has_no_role (list of strings) — Passes if Value is any of these (or, for role-check operators, the role IDs to look for) (only when operator=in/not_in/has_any_role/has_all_roles/has_no_role)
    - expression* (text, supports {{variables}}) — A yes/no formula — the branch passes when it comes out true. Reference data with {{name}}; supports arithmetic, comparisons, && || !, in, and functions. (only when operator=expression)
    - caseSensitive (true/false) — On: "Hello" and "hello" are different values. Off: letter case is ignored when comparing. (only when operator=equals/not_equals/contains/not_contains/starts_with/ends_with/greater_than/less_than/gte/lte/is_empty/is_not_empty/is_true/is_false/is_number/is_string/regex/in/not_in/has_any_role/has_all_roles/has_no_role)
    variables it publishes (usable downstream) → {{pass}}, {{stopped}}, {{passed}}

## LOGIC (control flow)

  logic.delay — Delay
    Pause briefly (up to 5 min) before the next node. For longer or restart-proof waits, use the Wait node instead.
    config:
    - duration* (text, supports {{variables}}) — Up to 300 seconds (5 min). Need longer, or a wait that survives restarts? Use the Wait node.
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{delayed}}

  logic.loop — For Each / Repeat
    Run a step once per item in a list, or a fixed number of times. The Item branch runs once PER iteration (with {{loop.item}} / {{loop.index}} / {{loop.iteration}}), then the Done branch runs with the aggregated results.
    config:
    - mode (one of: items | repeat) — Defaults to "for each item" when left unset (existing workflows keep working unchanged).
    - array* (a STRING that is either a {{variable}} reference to an upstream array, or a literal JSON array, e.g. "{{trigger.body.items}}" or "[\"Paris\",\"Tokyo\"]" — never a real JS array value on this field)
    - count* (text, supports {{variables}}) (only when mode=repeat)
    - maxIter (number (also accepts {{variables}})) — Safety cap on the number of repeats (default 1000).
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{item}}, {{index}}, {{iteration}}, {{items}}, {{results}}, {{count}}

  logic.cooldown — Cooldown
    Let this run through at most once every N seconds — great for anti-spam. While still cooling down, the Blocked branch runs instead.
    config:
    - key* (text, supports {{variables}}) — One independent cooldown per unique value. Per user: {{user_id}} · per channel: {{channel_id}} · a fixed word (e.g. "global") = one shared cooldown for everyone.
    - seconds* (text, supports {{variables}})
    variables it publishes (usable downstream) → {{pass}}, {{blocked}}, {{allowed}}

  logic.subworkflow — Call Workflow
    Run another one of your workflows and pass its result downstream. The Error branch runs if the called workflow fails.
    config:
    - workflowId* (workflow id) — Pick one of your workflows. It runs inline and returns its final output.
    - input (text, supports {{variables}}) — Data passed to the called workflow as its trigger. JSON or an expression. Leave blank to forward the current trigger data.
    flow outputs (connect from these) → done, error

  logic.wait_event — Wait
    Pause the workflow WITHOUT holding a worker — until a matching event arrives, or a duration elapses — then continue. Unlike Delay, this survives restarts and can wait hours or days. The event/timer payload becomes this node's output.
    config:
    - mode* (one of: timer | event) — Duration: pause for a set time, then continue. Event: pause until something with a matching key happens (e.g. a button click), then continue with its data.
    - eventKey (text, supports {{variables}}) — A correlation key a later event carries to resume THIS paused run (e.g. a button custom_id). (only when mode=event)
    - timeoutSeconds (text, supports {{variables}}) — For a duration wait: how long to pause. For an event wait: optional auto-resume if no event arrives in time. Plain number = seconds, or write a duration like "1h30m" / "2 days".
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{timed_out}}, {{cancelled}}

  logic.signal_wait — Signal / Cancel Wait
    Wake up (or cancel) ANOTHER workflow run that is paused in a Wait node, by its correlation key — e.g. an "/endgiveaway" command ending the wait a "/giveaway" command started.
    config:
    - targetKey* (text, supports {{variables}})
    - action* (one of: signal | cancel) — Both continue the other workflow down its Wait node's single "Continue" output — Cancel additionally sets {{cancelled}} to true there, so the other workflow can tell a real signal apart from a cancel (e.g. with an If node right after its Wait).
    - payload (object of key/value pairs, e.g. {"Authorization": "Bearer {{token}}"})
    variables it publishes (usable downstream) → {{signaled}}, {{not_found}}, {{found}}

## TRANSFORM (shape / store data)

  transform.set_variable — Create Value
    Give a simple name to text, a number or information from a previous step, then reuse it later in this run
    config:
    - values (object of name/value pairs, e.g. {"winner": "{{drawn}}", "prize": "{{option_prize}}"}. EACH KEY becomes its own OUTPUT VARIABLE on THIS node — {{winner}}, {{prize}} — directly usable by any later node, no dot-path needed. One node can hold several values; you do not need a separate Set Data node per value. Keys must be valid identifiers (letters/digits/underscore, start with a letter or _) and must not repeat a name already published earlier in the same branch.)
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{value}}

  transform.store — Durable Store
    Get / set / increment / delete a value that persists across executions (counters, leaderboards, flags — scoped to you)
    config:
    - operation* (one of: get | set | increment | delete)
    - key* (text, supports {{variables}} — a durable-store key; reuse the SAME key across nodes of the SAME kind (e.g. two Collection nodes reading/writing the same list), but give it a DIFFERENT key from any node of a DIFFERENT kind, even for the same feature (see rule 11)) — A unique name for this value. Scope it so each user/server keeps its own: per user "points:{{user_id}}", per member in a server "xp:{{guild_id}}:{{user_id}}". The same key always reads/writes the same stored value.
    - value* when operation=set (text, supports {{variables}})
    - amount (text, supports {{variables}})
    - ttl (text, supports {{variables}})
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{value}}, {{storage_key}}, {{storage_kind}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{value}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{value}} — see rule 2.
    + KEY MUST BE UNIQUE ACROSS DIFFERENT KINDS: this is a single value — its "key" must be DIFFERENT from any key used by a Memory (object), Collection (list), Scores (ranked set) node, even for the same feature (a giveaway's join-list and its saved state need separate keys, e.g. "giveaway:list:{{channel_id}}" vs "giveaway:record:{{channel_id}}"). Sharing a key with another node of the SAME kind (e.g. two Collections) is fine. Reusing a key across DIFFERENT kinds throws a runtime error ("WRONGTYPE") the moment both run. See rule 11.

  transform.record — Memory
    Remember information for future runs, or use information that was saved earlier
    config:
    - operation* (one of: get | get_field | upsert_fields | increment_field | append_unique | remove_from_array | compare_and_set | delete)
    - key* (text, supports {{variables}} — a durable-store key; reuse the SAME key across nodes of the SAME kind (e.g. two Collection nodes reading/writing the same list), but give it a DIFFERENT key from any node of a DIFFERENT kind, even for the same feature (see rule 11)) — Pick an existing memory or create one with a simple name.
    - fields* when operation=upsert_fields (object of key/value pairs, e.g. {"Authorization": "Bearer {{token}}"}) — Add a clear name and value for each piece of information. (only when operation=upsert_fields)
    - field* when operation=get_field|increment_field|append_unique|remove_from_array|compare_and_set (text, supports {{variables}}) (only when operation=get_field/increment_field/append_unique/remove_from_array/compare_and_set)
    - amount (text, supports {{variables}}) (only when operation=increment_field)
    - value* when operation=append_unique|remove_from_array (text, supports {{variables}}) — Add as many Field name / Value rows as needed; every row is stored together as one list item. (only when operation=append_unique/remove_from_array)
    - expected (text, supports {{variables}}) — Leave empty when the field must not exist yet. (only when operation=compare_and_set)
    - newValue (text, supports {{variables}}) (only when operation=compare_and_set)
    - ttlSeconds (text, supports {{variables}}) (only when operation=upsert_fields/increment_field/append_unique/remove_from_array)
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{value}}, {{record}}, {{item}}, {{exists}}, {{created}}, {{updated}}, {{previous_value}}, {{storage_key}}, {{storage_kind}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{value}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{value}} — see rule 2.
    + KEY MUST BE UNIQUE ACROSS DIFFERENT KINDS: this is a object — its "key" must be DIFFERENT from any key used by a Durable Store (single value), Collection (list), Scores (ranked set) node, even for the same feature (a giveaway's join-list and its saved state need separate keys, e.g. "giveaway:list:{{channel_id}}" vs "giveaway:record:{{channel_id}}"). Sharing a key with another node of the SAME kind (e.g. two Collections) is fine. Reusing a key across DIFFERENT kinds throws a runtime error ("WRONGTYPE") the moment both run. See rule 11.

  transform.collection — Collection
    A durable list that grows across runs — collect entries (giveaway sign-ups, a waitlist, a queue), block duplicates atomically, then list, count, pick a random (or bonus-weighted) winner, remove or clear them. Scoped to you; optional expiry and size cap.
    config:
    - operation* (one of: add | add_unique | has | list | count | random | weighted_random | remove | clear)
    - key* (text, supports {{variables}} — a durable-store key; reuse the SAME key across nodes of the SAME kind (e.g. two Collection nodes reading/writing the same list), but give it a DIFFERENT key from any node of a DIFFERENT kind, even for the same feature (see rule 11)) — A unique name — include a variable to keep one per channel/server.
    - value* when operation=add|add_unique|has|remove (text, supports {{variables}}) — The entry to add, check or remove — usually a variable. (only when operation=add/add_unique/has/remove)
    - quantity (text, supports {{variables}}) — Add: how many copies to push at once (bonus entries). Remove: only used when "Remove exactly N" is chosen below. (only when operation=add/remove)
    - sampleSize (text, supports {{variables}}) — Random/Weighted random only — 1 returns the winner itself, more returns a list (no repeats). (only when operation=random/weighted_random)
    - removeMode (one of: all | one | quantity) — A workflow saved before this existed keeps removing every match, unchanged. (only when operation=remove)
    - max (text, supports {{variables}}) (only when operation=add/add_unique)
    - ttlSeconds (text, supports {{variables}}) (only when operation=add/add_unique)
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{result}}, {{count}}, {{added}}, {{exists}}, {{storage_key}}, {{storage_kind}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{result}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{result}} — see rule 2.
    + KEY MUST BE UNIQUE ACROSS DIFFERENT KINDS: this is a list — its "key" must be DIFFERENT from any key used by a Durable Store (single value), Memory (object), Scores (ranked set) node, even for the same feature (a giveaway's join-list and its saved state need separate keys, e.g. "giveaway:list:{{channel_id}}" vs "giveaway:record:{{channel_id}}"). Sharing a key with another node of the SAME kind (e.g. two Collections) is fine. Reusing a key across DIFFERENT kinds throws a runtime error ("WRONGTYPE") the moment both run. See rule 11.

  transform.leaderboard — Scores
    Durable scores with a REAL Top-N ranking — points, XP, levels, “top chatters”. Add or increment a member’s score, then read the top, a score, or a rank. Scoped to you; optional expiry.
    config:
    - operation* (one of: increment | add | top | all | score | rank | remove | clear)
    - key* (text, supports {{variables}} — a durable-store key; reuse the SAME key across nodes of the SAME kind (e.g. two Collection nodes reading/writing the same list), but give it a DIFFERENT key from any node of a DIFFERENT kind, even for the same feature (see rule 11)) — A unique name — scope it per server with a variable (e.g. xp:{{guild_id}}).
    - member* when operation=add|increment|score|rank|remove (text, supports {{variables}}) (only when operation=add/increment/score/rank/remove)
    - amount (text, supports {{variables}}) (only when operation=increment)
    - score* when operation=add (text, supports {{variables}}) (only when operation=add)
    - topN (text, supports {{variables}}) (only when operation=top)
    - order (one of: desc | asc) (only when operation=top/all/rank)
    - ttlSeconds (text, supports {{variables}}) (only when operation=add/increment)
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{result}}, {{count}}, {{storage_key}}, {{storage_kind}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{result}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{result}} — see rule 2.
    + KEY MUST BE UNIQUE ACROSS DIFFERENT KINDS: this is a ranked set — its "key" must be DIFFERENT from any key used by a Durable Store (single value), Memory (object), Collection (list) node, even for the same feature (a giveaway's join-list and its saved state need separate keys, e.g. "giveaway:list:{{channel_id}}" vs "giveaway:record:{{channel_id}}"). Sharing a key with another node of the SAME kind (e.g. two Collections) is fine. Reusing a key across DIFFERENT kinds throws a runtime error ("WRONGTYPE") the moment both run. See rule 11.

  transform.template — Text Template
    Build a string using {{node.field}} interpolation
    config:
    - template* (text, supports {{variables}})
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{text}}

  transform.json_parse — JSON Parse
    Parse a JSON string into an object
    config:
    - field* (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{object}}, {{parsed}}

  transform.json_stringify — JSON Stringify
    Convert an object to a JSON string
    config:
    - field* (text, supports {{variables}})
    - pretty (true/false) — Indent the JSON over several lines so people can read it. Off produces one compact line, best for sending to an API.
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{json}}

  transform.math — Math
    Perform an arithmetic operation on two numbers
    config:
    - a* (text, supports {{variables}})
    - operator* (one of: + | - | * | / | % | **)
    - b* (text, supports {{variables}})
    - round (number (also accepts {{variables}}))
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{result}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{result}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{result}} — see rule 2.

  transform.extract — Extract Field
    Extract one or more nested fields from an object using dot-paths — each becomes its own named value
    config:
    - source* (text, supports {{variables}})
    - rows (array of {"name": string, "path": string, "fallback"?: string} — one row per value to pull out of the sibling "source" field, e.g. [{"name": "winner", "path": "data.user.name"}, {"name": "prize", "path": "data.reward"}]. EACH "name" becomes its own OUTPUT VARIABLE on THIS node — {{winner}}, {{prize}} — no separate Extract Field node per value needed. "path" is a dot path into the source object (e.g. "items.0.title"). Names must be valid identifiers (letters/digits/underscore, start with a letter or _) and must not repeat a name already published earlier in the same branch.)
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{value}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{value}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{value}} — see rule 2.

  transform.merge — Merge Objects
    Merge two objects into one
    config:
    - objectA* (JSON value (object or array))
    - objectB* (JSON value (object or array))
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{merged}}

  transform.split_text — Split Text
    Split a string by a delimiter into an array
    config:
    - text* (text, supports {{variables}})
    - delimiter* (text, supports {{variables}}) — e.g. space, comma, newline (\n)
    - limit (number (also accepts {{variables}}))
    - trim (true/false) — Remove spaces around each part, so "a, b" splits into "a" and "b" rather than "a" and " b".
    flow outputs (connect from these) → done
    variables it publishes (usable downstream) → {{parts}}, {{count}}

  transform.list — List
    Transform a list — map, filter, sort, group, reduce, aggregate, pick at random and more — with {{item}} expressions.
    config:
    - operation* (one of: map | filter | find | sort | unique | group | reduce | aggregate | random | slice | join)
    - items* (a STRING that is either a {{variable}} reference to an upstream array, or a literal JSON array, e.g. "{{trigger.body.items}}" or "[\"Paris\",\"Tokyo\"]" — never a real JS array value on this field) — An expression that resolves to an array.
    - expression* when operation=map|reduce (text, supports {{variables}}) — Worked out once per item. Available: item, index — and acc (the running result so far) when using Reduce. (only when operation=map/reduce)
    - initial (text, supports {{variables}}) — The starting point Reduce builds on — becomes the first "acc" (a number, "" for text, or JSON). (only when operation=reduce)
    - condition* when operation=filter|find (text, supports {{variables}}) — A boolean expression. Available: item, index. (only when operation=filter/find)
    - key* when operation=group (text, supports {{variables}}) — What to read on each item to sort, dedupe or group by. Available: item, index. (only when operation=sort/unique/group)
    - order (one of: asc | desc) (only when operation=sort)
    - func* when operation=aggregate (one of: count | sum | avg | min | max) (only when operation=aggregate)
    - field (text, supports {{variables}}) — The number to read on each item (not needed for Count). (only when operation=aggregate)
    - sampleSize (number (also accepts {{variables}})) — How many random items to pick (default 1, no repeats). 1 returns the item itself; more returns a list. (only when operation=random)
    - start (number (also accepts {{variables}})) (only when operation=slice)
    - end (number (also accepts {{variables}})) (only when operation=slice)
    - separator (text, supports {{variables}}) (only when operation=join)
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{result}}, {{count}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{result}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{result}} — see rule 2.

  transform.expression — Compute
    Evaluate one or more expressions — build an object { a: x, b: y }, an array [x, y], or compute values like price * qty, each under its own name.
    config:
    - rows (array of {"name": string, "formula": string} — one row per computed value, each an independent jexl expression, same syntax as a bare jexl string (e.g. "item.price * item.qty" or "{ name: item.name, total: item.price * item.qty }"). EACH "name" becomes its own OUTPUT VARIABLE on THIS node — {{name}} — no separate Compute node per value needed. Names must be valid identifiers (letters/digits/underscore, start with a letter or _) and must not repeat a name already published earlier in the same branch.)
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{result}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{result}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{result}} — see rule 2.

  transform.regex — Regex
    Extract (with capture groups), replace, or test text with a regular expression.
    config:
    - operation* (one of: extract | replace | match)
    - input* (text, supports {{variables}})
    - rows (array of {"name": string, "pattern": string, "group"?: number} — ONLY used when this node's "operation" is "extract" (ignored/omit for "replace"/"match", which use the sibling "pattern" field instead). One row per value to pull out of the sibling "input", matched using the sibling "flags". "group" (default 0) picks the whole match (0) or a capture group (1, 2, …). EACH "name" becomes its own OUTPUT VARIABLE on THIS node — {{name}} — no separate Regex node per value needed. Names must be valid identifiers (letters/digits/underscore, start with a letter or _) and must not repeat a name already published earlier in the same branch.) (only when operation=extract)
    - pattern* when operation=replace|match (text, supports {{variables}}) — A JavaScript regular expression (no surrounding slashes). (only when operation=replace/match)
    - flags (text, supports {{variables}}) — e.g. g (all matches), i (ignore case).
    - replacement (text, supports {{variables}}) — Use $1, $2… for capture groups. (only when operation=replace)
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{result}}, {{matched}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{result}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{result}} — see rule 2.

  transform.date — Date
    Date math — now, add or subtract a duration, the difference between two dates, format, or compare. Can output a Unix timestamp or a ready Discord <t:…> tag for live countdowns.
    config:
    - operation* (one of: now | add | subtract | diff | format | compare)
    - date* when operation=diff|format|compare (text, supports {{variables}}) — ISO string, unix seconds, or a variable. (only when operation=add/subtract/diff/format/compare)
    - amount* when operation=add|subtract (text, supports {{variables}}) — A number or a variable, e.g. {{option_duration}}. (only when operation=add/subtract)
    - unit (one of: seconds | minutes | hours | days | weeks | months | years) (only when operation=add/subtract/diff)
    - outputFormat (one of: iso | unix | unix_ms | discord) — Pick “Discord timestamp” to post a self-updating time in a message. (only when operation=now/add/subtract)
    - discordStyle (one of: R | t | T | d | D | f | F) — How Discord renders the timestamp. (only when outputFormat=discord)
    - date2* when operation=diff|compare (text, supports {{variables}}) (only when operation=diff/compare)
    - comparison* when operation=compare (one of: before | after | same) (only when operation=compare)
    - format (text, supports {{variables}}) — Tokens: YYYY MM DD HH mm ss (UTC). (only when operation=format)
    - outputAs (text, supports {{variables}})
    flow outputs (connect from these) → done, error
    variables it publishes (usable downstream) → {{result}}
    + STABLE OUTPUT NAME ("Also publish as", config.outputAs): optional — set it to e.g. "winners" and this node ALSO publishes {{winners}} (the exact same value as {{result}}, just a name you chose). Prefer this whenever another node in the same branch ALSO publishes {{result}} — see rule 2.

# WHAT TO BUILD
Describe below what you want the bot to do, then send. The AI will reply with the JSON — paste it back into Noria’s "Import from AI".