Skip to main content
This reference covers every action available in the Elementum automation builder, organized to match the action panel in the UI.
Looking to understand automation concepts? Start with the Automation System guide to learn about event-driven automation and AI integration.

Logic

Logic actions control flow and decision-making in your automations.
Creates a conditional decision point in your automation. Actions nested under If only execute when the specified condition is true.Example:
IF customer_tier = "Enterprise"
  → Send Message to Teams (priority channel)
  → Make Assignment (senior agent)
Common Use Cases:
  • Route high-value customers to priority support
  • Apply different approval thresholds based on amount
  • Trigger escalations for critical issues
  • Customize responses based on customer type
Variables: Outputs a boolean result that downstream actions can reference.
Adds an alternative branch to an If condition. When the preceding condition is false, Elementum evaluates the Otherwise If condition — enabling multi-tier decision trees within a single automation.Example:
IF order_amount > $10,000
  → Start Approval Process (CFO approval)
OTHERWISE IF order_amount > $1,000
  → Start Approval Process (manager approval)
OTHERWISE
  → Update Record Fields (auto-approved)
Common Use Cases:
  • Multi-tier approval workflows
  • Customer service routing based on multiple criteria
  • Pricing logic with different discount tiers
  • Escalation procedures with multiple levels
Variables: Outputs a boolean result for each branch condition.
Loops through a collection of records or data items and runs the same set of actions on each one.Example:
Search Records (today's orders) → Repeat for Each order:
  → Run Calculation (shipping cost)
  → Update Record Fields (add shipping)
  → Send Email Notification (shipping confirmation)
Common Use Cases:
  • Process multiple orders in a single automation run
  • Send notifications to multiple users
  • Update a batch of records with the same values
  • Save multiple email attachments to a record one by one
Variables: Provides access to the current item in the loop and the loop iteration count.

Records

Record actions manage data creation, updates, and relationships within your system.
Creates a new record in a specified table with field values populated from trigger data or the outputs of previous actions.Example:
Email Received → Create Record (Support Ticket)
  → Fields: Subject, Customer Email, Priority, Description
  → Result: New support ticket ready for assignment
Common Use Cases:
  • Generate support tickets from incoming emails
  • Create project records for new customers
  • Log activities and interactions
  • Generate invoices from completed orders
Variables: Outputs the new record ID and all field values for use in subsequent actions.
Modifies one or more field values on an existing record, typically using outputs from AI actions, calculations, or trigger data.Example:
AI Classification → Update Record Fields (Lead Record)
  → Fields: Lead Score, Priority, Qualification Status
  → Result: Lead record updated with AI insights
Common Use Cases:
  • Apply AI-generated classifications to records
  • Change order status as it progresses through a workflow
  • Update customer information from an external source
  • Record project progress and milestones
Variables: Outputs the updated record with new field values.
Establishes a relationship link between two records, enabling cross-record data access and workflows.Example:
Create Record (Project) → Relate Records
  → Link: New Project → Customer Record
  → Result: Project connected to customer for tracking
Common Use Cases:
  • Link projects to customers
  • Connect orders to customer accounts
  • Associate support tickets with products
  • Create document relationships
Variables: Outputs relationship details and connected record information.
Queries a table and returns records that match your specified criteria, making them available as variables for downstream actions.Example:
Search Records (Customers)
  → Criteria: Email = trigger.sender_email
  → Result: Customer record for follow-up actions
Common Use Cases:
  • Find customer records by email address
  • Locate related orders or projects
  • Identify overdue tasks
  • Find records that need attention or updates
Variables: Outputs matching records with all field data accessible.
Initiates a configured approval workflow for a record, notifying designated approvers and beginning the approval sequence.Example:
Create Record (Purchase Order) → Start Approval Process
  → Approver: Manager (if < $5,000), CFO (if > $5,000)
  → Result: Approval workflow begins with notifications sent to approvers
Common Use Cases:
  • Purchase order approvals
  • Document review processes
  • Budget approval workflows
  • Policy exception requests
Variables: Outputs the approval process ID and current status.
Changes the status of an active approval process based on a decision or condition, advancing or halting the workflow.Example:
Manager Decision → Update Approval Status
  → Status: Approved / Rejected / Pending
  → Result: Workflow advances to next step
Common Use Cases:
  • Process manager decisions
  • Handle approval timeouts
  • Update workflow progress programmatically
  • Trigger post-approval actions
Variables: Outputs the new approval status and workflow state.
Subscribes one or more users to a record so they receive in-platform notifications when the record is modified.Example:
Create Record (High Priority Issue) → Add Watcher
  → Watcher: Department Manager
  → Result: Manager receives updates on issue progress
Common Use Cases:
  • Keep managers informed of critical issues
  • Notify stakeholders of project changes
  • Alert team members to important updates
  • Maintain oversight on sensitive records
Variables: Outputs watcher details and notification preferences.
Applies field-level restrictions on a record, preventing changes to specified fields to protect data integrity after a process completes.Example:
Approval Process Complete → Record Field Locking
  → Lock: Price, Terms, Approval Status
  → Result: Critical fields protected from changes
Common Use Cases:
  • Lock approved contract terms
  • Protect financial calculations after sign-off
  • Secure completed approval decisions
  • Maintain audit trail integrity
Variables: Outputs the locking status and list of protected fields.
Assigns a record or task to a specific user or team, routing work based on criteria like AI classification output, department, or role.Example:
AI Classification → Make Assignment
  → IF category = "Technical" → Assign to Technical Team
  → IF category = "Billing" → Assign to Billing Team
Common Use Cases:
  • Route support tickets to appropriate teams
  • Assign leads to sales representatives
  • Distribute work based on expertise
  • Balance workloads across team members
Variables: Outputs assigned user information and assignment details.
Compiles your data into a formatted Excel or PDF report and makes the file available as a reference for subsequent actions — such as attaching it to a record or sending it by email.
Generate Report does not automatically save the report to a record. Use the Save Attachment action after this step to attach the file to a record.
Example:
End of Month → Generate Report
  → Report Type: Sales Performance Summary
  → Data: Monthly sales, targets, performance metrics
  → Save Attachment (to attach the report to a record)
  → Result: Report file available for use in subsequent actions
Common Use Cases:
  • Monthly performance summaries emailed to stakeholders
  • Project status reports saved to project records
  • Compliance documentation attached to audit records
  • Executive dashboards sent via Teams or email
Workflow Pattern:
Trigger → Generate Report → Save Attachment
  → Result: Report generated and attached to the specified record
Variables:
VariableTypeDescription
generated_reportFileThe generated report file (Excel or PDF) for use in Save Attachment, Send Email, or other file-accepting actions

Elementum Intelligence

Elementum Intelligence actions use AI to analyze, classify, summarize, transform, and search data within your automations.
Passes a task definition and context to a configured AI agent, which works autonomously in a headless environment and returns structured output for use in subsequent actions. This bridges deterministic automation steps with intelligent, autonomous task completion.Configuration:
  • Action Name: Descriptive name for the agent task action
  • AI Agent: Select an existing agent or create a new one for the task
  • Task Definition: Clear description of what the agent should accomplish, including success evaluation criteria (supports value references)
  • Output Type: Choose how the agent returns data:
    • Text: Simple text response from the agent
    • Structured: Define specific output fields for structured data extraction
  • Output Fields (Structured mode): Define the exact fields you want returned, with field names and types
  • Test & Preview: Try out the agent task with real values for any value references before deployment
Example:
Order Approved → Run Agent Task
  → Agent: Research Agent
  → Task: "Research customer {{customer.company}} industry trends and competitive landscape.
           Success: Provide 3-5 key insights relevant to their business"
  → Output Type: Structured
  → Fields: key_insights (list), competitive_threats (text), opportunities (text)
  → Result: Structured insights available for subsequent actions
Workflow Pattern — Structured to Unstructured to Structured:
Record Updated (structured) →
  Run Agent Task (autonomous intelligence) →
  Update Record Fields (structured output) →
  Send Email Notification (structured)
Common Use Cases:
  • Research and analysis tasks requiring reasoning and judgment
  • Complex decision-making beyond simple classification rules
  • Data enrichment requiring external research or synthesis
  • Quality assessment and content evaluation
  • Multi-step problem solving with autonomous action
Headless Environment: Task definitions must be clear and self-contained. Provide all necessary context through value references, since the agent operates without user interaction.Error Handling: Built-in retry logic (up to 3 attempts) if the agent doesn’t return output in the expected format, with error messages passed back to help the agent self-correct.Agent Deletion Protection: When attempting to delete an agent used in automations, you’ll see which automations depend on it with direct links.Variables:
  • run_agent_task.success — Boolean indicating task completion
  • run_agent_task.error_message — Text field with any error details
  • run_agent_task.{custom_fields} — Any custom output fields defined in configuration
For a comprehensive guide on leveraging this action to bridge structured and unstructured workflows, see the Agent Task Automation Guide.
Uses AI to read an uploaded document and extract structured data into fields you define, without requiring manual parsing of the file content.Example:
Contract Upload → AI File Analysis
  → Extract: parties, dates, terms, obligations
  → Result: Structured contract data ready for record creation
Common Use Cases:
  • Extract vendor, amount, and due date from invoice PDFs
  • Pull key terms and parties from contracts
  • Process resume attachments for candidate data
  • Analyze report documents for key metrics
Variables: Outputs structured data extracted from the document, accessible as individual field values.
Uses AI to clean, normalize, and reformat input data — standardizing addresses, phone numbers, company names, and other inconsistent values into a consistent format.Example:
Customer Data Import → Transform Data with AI
  → Transform: Standardize addresses, format phone numbers
  → Result: Clean, consistent customer data
Common Use Cases:
  • Standardize address formats from varied inputs
  • Normalize phone numbers to a consistent format
  • Clean imported data before writing to records
  • Reformat business names for consistent matching
Variables: Outputs the transformed data in the specified format.
Uses AI to assign a category or label to input content based on meaning and context — not just keyword matching — and returns the result with a confidence score.Example:
Support Email → AI Classification
  → Categories: Bug, Feature Request, General Support
  → Result: Email classified with confidence score
Common Use Cases:
  • Categorize incoming support tickets for routing
  • Score or tier leads based on qualification signals
  • Classify documents by type
  • Determine sentiment or priority from customer messages
Variables: Outputs the classification result and confidence score.
Uses AI to distill lengthy input content into a concise summary capturing the key points.Example:
Long Customer Feedback → AI Summarization
  → Result: Brief summary of the customer's main concern and sentiment
Common Use Cases:
  • Summarize customer feedback before creating a support ticket
  • Create executive briefings from long reports
  • Condense meeting notes or email threads
  • Generate a one-line description for a record from free-form input
Variables: Outputs the summary text.

Communication

Communication actions send notifications, messages, and updates to users inside and outside of Elementum.
Sends an in-platform notification about a record to specified users within Elementum, without sending an external email.Example:
Record is Updated (status = "Needs Review") → Send Record Update
  → Recipients: Assigned team members
  → Result: Users notified in-platform with a link to the record
Common Use Cases:
  • Notify a team when a record is ready for review
  • Alert an assignee when a ticket is escalated
  • Inform stakeholders of status changes without external email
  • Prompt users to take action on a record
Variables: Outputs notification delivery status.
Sends a formatted email to up to 25 recipients using dynamic content from automation variables, with support for HTML formatting and multiple file attachment sources.Example:
Support Ticket Created → Send Email Notification
  → To: Customer, Account Manager
  → Subject: "Ticket #{{ticket_number}} - {{issue_summary}}"
  → Content: Professional acknowledgment with next steps
  → Attachments: Generated report PDF
Configuration:
FieldDescription
Action NameA descriptive name for this action
From Display NameThe sender name that appears to recipients
FromThe email address prefix (before @yourdomain.com)
BccRecipients to blind carbon copy (up to 25 total recipients)
SubjectEmail subject line
Notification BodyEmail content with HTML formatting
Email AttachmentsOptional files to include with the email
Email Attachments:
Attachment TypeDescription
RecordAttach files from specific file fields on the trigger record
AttachmentsAttach all files from the attachments block on the trigger record
FileAttach files from file fields available in the workflow context
You can combine multiple attachment types in a single email. For example, attach both a generated report and files from the record’s attachments block.
Total attachment size is limited to 25MB. If attachments exceed this limit, the email will fail to send.
Common Use Cases:
  • Customer confirmations and updates
  • Team notifications and alerts
  • Executive summaries and reports
  • Process completion notifications
For transactional emails only. Marketing use may result in restrictions or loss of access.
Adds a timestamped comment to a record, creating a visible audit trail of what the automation did and why at that step.Example:
AI Classification → Post Comment
  → Comment: "AI classified as {{category}} with {{confidence}}% confidence"
  → Result: Classification decision logged on the record
Common Use Cases:
  • Log AI classification decisions for transparency
  • Document key milestones at each step of a workflow
  • Track approval reasoning
  • Debug automations by tracing variable values at specific steps
Variables: Outputs the comment ID and timestamp.
Posts a message to a Microsoft Teams channel, delivering real-time notifications directly to your team’s collaboration workspace.Example:
High Priority Alert → Send Message to Teams
  → Channel: #critical-alerts
  → Message: "Critical issue: {{issue_description}} - Customer: {{customer_name}}"
Common Use Cases:
  • Critical issue alerts to an on-call channel
  • Project milestone updates for the team
  • Escalation notifications for high-value accounts
  • Status broadcasts after an automation completes
Variables: Outputs message delivery status and channel information.
Triggers an outbound phone call from a configured AI agent to a specified phone number. The call runs asynchronously — the workflow continues immediately without waiting for the call to complete.Configuration:
  • Action Name: Descriptive name for the call action
  • AI Agent: Which agent will conduct the call
  • Phone Service: Phone service provider to place the call
  • Phone Number: Number to call (from a record field, previous action output, or static value)
  • Related Record (optional): Record this call relates to, for context
  • Additional Context (optional): Extra information for the AI agent
  • Default Language: Language for the call conversation
Example:
High Priority Ticket Created → Initiate Call
  → Agent: Support Agent
  → Phone Number: {{customer.phone}}
  → Context: "Follow up on ticket {{ticket_number}}"
  → Result: Agent calls customer while workflow continues
Common Use Cases:
  • Automated appointment reminders
  • Follow-up calls for high-priority support tickets
  • Proactive outreach for critical account updates
  • Post-purchase satisfaction checks
Fire-and-Forget Execution: The workflow does not pause for the call to complete. Use the Agent Conversation Ended trigger in a separate automation to process call outcomes.Variables: Outputs call initiation status and call ID for reference.

Files

File actions process documents, extract text content, and manage file storage on records.
File Size Limits: Elementum supports file uploads up to 250MB per file. This applies to all file operations including attachments, file fields, and API uploads. Note that email attachments have a lower limit of 25MB due to email provider restrictions.
Extracts the text content of an uploaded file and makes it available as a variable for downstream actions. Supports PDF, DOC, DOCX, TXT, CSV, and Excel formats.Example:
Attachment Added → Read File
  → Input: Uploaded contract PDF
  → Output: Full text content for downstream analysis
Common Use Cases:
  • Extract text from contracts before AI analysis
  • Process uploaded reports
  • Read customer-submitted documents
  • Import data from files into record fields
Variables: Outputs the file content as text and file metadata.
Extracts text content from multiple files simultaneously and returns their contents as an array, without needing to loop through individual Read File actions.Example:
Multiple Files Uploaded → Read Bulk File
  → Process: All monthly report files
  → Result: Combined text content from all files
Common Use Cases:
  • Process a batch of monthly reports
  • Handle multiple customer document uploads simultaneously
  • Extract content from a collection of files before analysis
Variables: Outputs an array of file contents and processing results.
Saves a file to the attachments block on a specified record. Files generated or received during an automation — such as generated reports or email attachments — are not persisted automatically; this action is required to attach them.
Use this action after Generate Report to attach the generated file to a record. Without this step, the report exists only as a temporary reference within the automation.
When an email includes multiple attachments, use a Repeat for Each action to save each attachment one by one. This action processes one file at a time.
Example:
Email with PDF → Repeat for Each (attachment)
  → Save Attachment → Attach to: Customer Record
  → Result: Each document stored with the customer
Generate Report Example:
Month End Trigger → Generate Report (Monthly Summary)
  → Save Attachment (attach report to company record)
  → Send Email Notification (with report as attachment)
  → Result: Report saved to record and emailed to stakeholders
Ways Files Get Added to Records:
MethodDescriptionMax Size
Email ReceivedEmail attachments are automatically added when creating records via the Email Received trigger250MB per file
Send API RequestDownload files from external APIs and save them as attachments250MB per file
External APIThird-party systems can add attachments via Elementum API endpoints250MB per file
Manual UploadUsers can manually add attachments in the record layout’s attachments block250MB per file
File FieldsSpecific File Field types store files in designated fields (separate from the attachments block)250MB per file
Common Use Cases:
  • Save generated reports to records
  • Attach contracts with customer records
  • Archive email attachments to the related record
  • Organize file submissions from uploads or external systems
Variables: Outputs attachment details and storage location.
Extracts files from a ZIP archive and makes the individual files available as outputs for subsequent actions.Example:
ZIP File Uploaded → Unzip File
  → Extract: Monthly reports and data files
  → Result: Individual files ready for processing
Common Use Cases:
  • Process batches of documents delivered as a ZIP archive
  • Handle archived file submissions from external systems
  • Extract contents before running AI analysis on individual files
Variables: Outputs a list of extracted files and their contents.

Data

Data actions perform calculations, run scripts, set variables, and invoke other automations.
Executes custom JavaScript in a secure, sandboxed environment. Your code receives named input values and returns a result object that subsequent actions can reference — useful for transformations and logic that built-in actions can’t cover.Configuration:
FieldDescription
Action NameA descriptive name for this action
InputsNamed input values from triggers, previous actions, or static values
CodeJavaScript code that processes inputs and returns a result object
Getting Started:When you add an Execute Script action, the code editor starts with a helpful template:
/**
 * Access your input values from the `input.parameters` object
 * Example:
 *
const {
  recordType,
  id,
  title
} = input.parameters;
**/

return {};
// The value returned from this script will be used as the output of the action
As you add input parameters in the sidebar, they are automatically added to the example destructuring statement in the comments, showing you exactly which variables are available.
Security Model:The script runs in an isolated sandbox with strict constraints:
  • No access to file system, network, or external resources
  • Execution timeout: 10 seconds maximum
  • Statement limit: 50,000 JavaScript statements
  • Console output captured (maximum 20 KB)
Input Structure:
{
  "parameters": {
    "inputName1": value1,
    "inputName2": value2
  }
}
Example:
// Calculate order totals with custom discount logic
const orders = input.parameters.orderData;
const discountTier = input.parameters.customerTier;

const discountRates = {
  "Enterprise": 0.20,
  "Professional": 0.10,
  "Standard": 0.05
};

const discount = discountRates[discountTier] || 0;
const subtotal = orders.reduce((sum, order) => sum + order.amount, 0);
const discountAmount = subtotal * discount;
const total = subtotal - discountAmount;

return {
  subtotal: subtotal,
  discountPercent: discount * 100,
  discountAmount: discountAmount,
  total: total,
  orderCount: orders.length
};
The script must return a JavaScript object. Arrays, null, undefined, and primitive values are not valid return values. Wrap arrays in an object property if needed.
Common Use Cases:
  • Complex data transformations beyond built-in calculations
  • Custom business logic with conditional rules
  • Parsing and restructuring data from external sources
  • Data validation and normalization
  • Aggregating data across multiple records
  • String manipulation and formatting
Variables:
VariableTypeDescription
resultJSONThe object returned by your JavaScript code
textResultTextJSON string representation of the result
Evaluates a mathematical or logical expression using values from triggers or previous actions and returns the computed result.Example:
Order Created → Run Calculation
  → Calculate: (Subtotal × Tax Rate) + Shipping
  → Result: Total order amount with taxes
Common Use Cases:
  • Calculate order totals, taxes, and fees
  • Compute discounts based on quantity or tier
  • Determine shipping costs
  • Evaluate thresholds for conditional logic
Variables: Outputs the calculated value for use in subsequent actions.
Stores a value under a named variable that any subsequent action in the automation can reference.Example:
Run Calculation → Set Variable
  → Variable Name: discount_amount
  → Value: {{calculated_discount}}
  → Usage: Apply discount in subsequent actions
Common Use Cases:
  • Store calculation results for reuse across multiple steps
  • Save an API response value to reference later
  • Capture a derived value to avoid repeating the same logic
Variables: Creates the specified variable for use in later actions.
Invokes a separate named automation as a step in the current workflow, allowing you to reuse shared automation logic without duplicating it.Example:
Record is Updated → Run Automation
  → Automation: "Notify Stakeholders"
  → Result: Stakeholder notification automation executes as part of the current flow
Common Use Cases:
  • Reuse a shared notification or cleanup automation across multiple triggers
  • Break large, complex automations into smaller, maintainable units
  • Invoke a standard sub-process from multiple different entry points
Variables: Outputs the invoked automation’s execution status.

Users

User actions find users and user groups within your system for assignments and notifications.
Queries the user directory and returns users matching your specified criteria, making them available for assignments, notifications, or conditional logic.Example:
Technical Issue → Search Users
  → Criteria: Department = "Engineering"
  → Result: Engineering team members available for assignment
Common Use Cases:
  • Find the right user to assign a record to
  • Look up a user by email for automated assignment
  • Identify team members in a specific department or role
  • Route work based on team membership
Variables:
VariableTypeDescription
usersUser (array)All users matching the search criteria
userUserThe first user found (convenient for single-user lookups)
countNumberTotal count of users matching the criteria
Accessing User Properties:
Sub-PropertyTypeDescription
user.idUser IDThe unique identifier of the user
user.nameTextThe user’s display name
user.emailTextThe user’s email address
To access individual user properties from the users array, use a Repeat for Each action to iterate over the collection. Inside the loop, each item will have access to sub-properties like item.id, item.name, and item.email.
Queries the user group directory and returns groups matching your specified criteria, making them available for team-based assignments and notifications.Example:
Support Ticket Created → Search User Groups
  → Criteria: Group = "Tier 2 Support"
  → Result: Tier 2 Support group available for assignment
Common Use Cases:
  • Assign a record to an entire team rather than a specific user
  • Look up a group by name for dynamic assignment logic
  • Route work to a department based on classification output
Variables: Outputs the matching user groups and their member details.

External

External actions connect your automations to third-party systems and services.
Sends an HTTP request (GET, POST, PUT, or DELETE) to any REST API and returns the response as a variable for downstream actions. Supports multiple authentication methods.Example:
Order Created → Send API Request
  → Endpoint: Inventory Management System
  → Method: GET
  → Request: Check stock levels for order items
  → Result: Current inventory status
Request Types:
  • GET: Retrieve data from external systems
  • POST: Send data to external services
  • PUT: Update records in external systems
  • DELETE: Remove data from external systems
Authorization Types:
TypeDescription
No AuthNo authorization header added to the request
Basic AuthUsername and password encoded as Base64 in the Authorization header
Bearer TokenToken-based authentication with static or dynamic token values
OAuthClient Credentials flow with automatic token caching and refresh
Basic Auth:Enter a username and password. Credentials are encrypted at rest and sent as a Base64-encoded Authorization header with each request.Bearer Token:
OptionDescription
Static TokenEnter a fixed token value (encrypted at rest)
Dynamic ReferenceSelect a value from a previous action or trigger output using the reference picker
The dynamic reference option enables advanced patterns like using a JWT token generated by a prior Execute Script action.OAuth (Client Credentials):
  • OAuth URL: The token endpoint URL
  • Client ID: Your OAuth client identifier (encrypted at rest)
  • Client Secret: Your OAuth client secret (encrypted at rest)
  • Request Type: How credentials are sent — HTTP Basic (Authorization header) or Form URL Encoded (request body)
  • Custom Headers: Additional headers for the token request (optional)
Tokens are automatically cached and refreshed before expiration.Common Use Cases:
  • Check inventory levels
  • Validate addresses
  • Process payments
  • Update CRM systems
  • Sync with accounting software
  • Integrate with REST APIs requiring various authentication methods
Variables:
VariableTypeDescription
responseJSONParsed JSON response body
successBooleanWhether the request succeeded
textResponseTextRaw text response body
statusCodeNumberHTTP status code (e.g., 200, 404, 500)
fileFileDownloaded file (when response type is FILE)
Invokes a pre-built custom function with input parameters, enabling specialized processing and integrations that aren’t covered by built-in actions.Example:
Complex Data → Run Function
  → Function: Custom pricing algorithm
  → Input: Customer data, order details
  → Result: Specialized pricing calculation
Common Use Cases:
  • Specialized business logic not covered by built-in actions
  • Custom integrations with proprietary systems
  • Advanced data processing and analytics
  • Reusable processing routines shared across automations
Variables: Outputs the function result and any computed values.

For design principles, performance strategies, and proven patterns, see Automation Best Practices. For trigger configuration and use cases, see the Automation Triggers Reference.