1. Open the Click on any of the sections to expand them. The corresponding flow units get displayed.
   
2. These units can be dragged and dropped into the flow diagram to modify the flow.
   

1. General

1. Units in this category control flow logic. They manage decisions, loops, and process structure.
   
2. Click on the section to expand it. The following units are available under this section:
   
1. Decision/For-Each Unit
   
2. Repeat Until Unit

1.1 Decision/For-Each Unit

1. Purpose:
   
1. The Decision/ForEach Unit is a control-flow component in the Flow Designer that enables conditional execution and iteration within an automation flow. The decision function evaluates defined conditions and routes the flow based on true/false outcomes. The For-Each function goes through every item in a list one by one and runs the set of steps you’ve defined for each item.
2. How it works:
   
1. The flow checks a Boolean condition (e.g., if X > 10).
   
2. Based on the result:
   
1. True path → Executes one branch.
   
2. False path → Executes another branch.
   
3. Use case:
   
1. If the customer's age ≥ 18, proceed to payment; otherwise, display an error message.
   
4. Visual Representation:

1.2 Repeat Until

1. Purpose:
   
1. The Repeat Until Unit runs a set of steps repeatedly until a specific condition is met. It keeps looping while the condition is false and stops automatically when the condition becomes true.
   
2. How it works:
1. The loop starts unconditionally (it always runs at least once).
2. After each iteration, it checks the condition.
3. If the condition is met, the loop stops; otherwise, it repeats.
3. Use Case:
1. Repeat sending a request until the server responds with success.
2. Condition: response == success.
   
4. Visual Representation:

2. Calls

1. These units communicate with external systems or services. They send or receive data outside the flow that belongs here.
2. Click on the section to expand it. The following units are available under this section:
   
1. System Call Unit
   
2. Expansion Call Unit
   
3. HTTP Call Unit
   
4. FTP Call Unit
   

2.1 System Call Unit

1. Purpose: The System Call Unit is an action unit in the Flow Editor/Designer that enables you to invoke internal system-level services or platform operations during execution. This unit is used to perform predefined system actions, retrieve system data, or trigger platform functionalities that are not exposed through external connectors.
2. What it does: 
   
1. Executes a system-level command or invokes an API provided by the OS.
2. Common actions include:
1. Reading/writing files.
2. Executing shell commands.
3. Accessing environment variables.
4. Interacting with hardware or system resources.
3. How it works:
   
1. Trigger Point in Flow:
1. When the process reaches the System Call Unit, it pauses the normal flow and executes a predefined system-level command or script.
   
2. Command Execution:
1. The unit sends a request to the OS or system API.
2. This could be:
1. A shell command (ls, mkdir, rm).
2. A script (.sh, .bat, PowerShell).
3. An executable or binary.
   
3. Input/Output Handling:
1. Input: Parameters passed from the workflow (e.g., file path, environment variables).
2. Output: Captures the result (success/failure, return code, or output text) and makes it available for the next steps in the flow.
4. Error Handling:
1. If the system call fails (e.g., permission denied, file not found), the unit can:
1. Retry.
   
2. Branch to an error-handling path.
   
3. Log the error for debugging.
   
4. Common Use case:
   
1. Calling a REST API to fetch data.
2. Triggering a microservice or external script.
3. Executing a command-line utility from the workflow.
   
4. Automation: Run a script on the server (bash, PowerShell).
5. File Management: Move or delete files in a directory.
6. Integration: Call an external executable or system utility.
   
5. Visual Representation:

2.2 Expansion Call Unit

1. Purpose: The Expansion Call Unit is an action unit in the Flow Editor/Designer that allows a flow to invoke extension or expansion services to perform advanced, customizable, or domain-specific operations beyond core system capabilities. This unit is used to call externally defined expansion logic or add-on services that extend the application’s functionality.
2. What it does:
   
1. Takes an input object (like a document, a collection, or a structured dataset).
2. Expands it into smaller units or elements so that each can be processed individually.
3. Often used before a For-Each Unit, because once expanded, you can iterate over the individual parts.
3. How it works:
   
1. Input: A complex entity (e.g., a document with multiple sections, a ZIP file with multiple files, or a JSON with nested arrays).
2. Expansion: Breaks down the entity into its components:
1. Pages of a document.
2. Files inside a folder or archive.
3. Records inside a dataset.
3. Output: A list or collection of items that can be passed to subsequent steps (like For-Each).
4. Use case:
   
1. Document Processing: Expand a PDF into individual pages for OCR.
2. Data Pipelines: Expand a JSON array into individual records for transformation.
3. Batch Operations: Expand a ZIP archive into separate files for upload.
   
5. Visual Representation:

2.3 HTTP Call Unit

1. Purpose: An HTTP Call Unit in a flow diagram is used to make HTTP requests to external services or APIs as part of your workflow. It’s a way to integrate your process with web-based systems.
2. What it does:
   
1. Sends an HTTP request (GET, POST, PUT, DELETE, etc.) to a specified URL.
2. Receives the response (status code, headers, body) and passes it to the next step in the flow.
3. How it works:
   
1. Configure Request:
1. Method: GET, POST, PUT, DELETE.
2. URL: Endpoint of the API or service.
3. Headers: Authentication tokens, content type, etc.
4. Body: Data payload (for POST/PUT).
2. Execute Call:
1. The unit sends the request over the network.
2. Waits for the response from the server.
3. Handle Response:
1. Captures status code (e.g., 200 OK, 404 Not Found).
2. Parses response body (JSON, XML, text).
3. Stores or passes data to the next steps.
4. Error Handling:
1. Retry on failure.
2. Branch based on status code (e.g., success vs. error).
4. Use case:
   
1. Document Workflow: Call an OCR API to process a scanned document.
2. Integration: Send data to a REST API for storage or analytics.
3. Notification: Trigger a webhook to alert another system.
   
5. Visual Representation:

2.4 FTP Call Unit

1. Purpose: The FTP Call Unit is an action unit in the Flow Editor/Designer that enables a flow to connect to an FTP/SFTP server to perform file-based operations during execution. This unit allows automation flows to securely transfer, retrieve, or manage files between the platform and external file servers.
2. What it does:
1. Connects to an FTP server using credentials (host, username, password).
2. Executes file operations such as:
1. Upload files from the local system to the FTP server.
2. Download files from the FTP server to the local system.
3. List files in a directory.
4. Delete or move files on the server.
3. How it works:
   
1. Configuration:
1. FTP server address (e.g., ftp://example.com).
2. Authentication details (username, password, or secure token).
3. Optional: Port number, passive/active mode.
2. Action Selection:
1. Choose operation: Upload, Download, List, Delete.
3. Execution:
1. Establishes a connection to the FTP server.
2. Performs the selected operation.
3. Returns status (success/failure) and optionally file metadata.
4. Error Handling:
1. Handles network issues, authentication failures, or missing files.
2. Can retry or branch to the error-handling step.
4. Use case:
   
1. Document Workflow: Upload processed documents to an FTP server for archival.
2. Integration: Download input files from an FTP server for further processing.
3. Batch Jobs: Move files from FTP to cloud storage.
5. Visual Representation:

3. Delegate

3.1 Component Unit

1. Purpose: A Component Unit in a flow diagram represents a self-contained, reusable block of logic that performs a specific task. You can reuse it whenever needed within a larger process, much like using a pre-built piece in a puzzle.
   
2. What it does:
1. Calls another reusable component or subflow.
   
2. Encapsulates a set of steps or logic into a single unit.
3. Can be reused across multiple flows.
4. Accepts input parameters and returns output results.
3. How it works:
   
1. Definition:
1. A component is created separately with its own flow logic.
2. It is designed to perform a specific task (e.g., validating data or processing a document).
2. Invocation:
1. The main flow calls the Component Unit.
2. Passes required inputs (e.g., document ID, user info).
3. Waits for the component to finish and return outputs.
3. Benefits:
1. Modularity: Breaks complex workflows into smaller, manageable pieces.
2. Reusability: Common tasks can be reused without duplication.
3. Maintainability: Easier to update one component than multiple flows.
4. Use case:
   
1. Document Workflow: A component for OCR processing.
2. Integration: A component for API authentication.
3. Business Logic: A component for invoice validation.
5. Visual Representation:

3.2 Automation Unit

1. Purpose: An Automation Unit in a flow diagram represents a step where the workflow performs an automated action without manual intervention. It’s designed to execute predefined tasks using scripts, bots, or automation services.
   
2. What it does:
   
1. It triggers an automated action without manual intervention.
   
2. Executes repetitive or rule-based tasks automatically.
   
3. Can interact with:
1. Applications (e.g., ERP, CRM).
2. Files and folders (move, rename, delete).
3. APIs (send/receive data).
4. System commands (run scripts).
3. How it works:
   
1. Trigger: The flow reaches the Automation Unit.
2. Action Execution:
1. Runs a script or automation logic (e.g., RPA bot, macro).
2. Uses configured inputs (file paths, credentials, parameters).
3. Output Handling:
1. Returns success/failure status.
2. Passes processed data to the next step.
4. Error Handling:
1. Retry or branch to error-handling logic if automation fails.
4. Use case:
   
1. Document Workflow: Automatically convert files to PDF.
2. Data Processing: Extract data from spreadsheets and upload to a database.
3. System Tasks: Schedule backups or clean temporary files.
5. Visual Representation:

3.3 Flow Unit

1. Purpose: A Flow Unit in a flow diagram is the basic building block that represents a single step or action in a process. It’s the smallest executable element in a workflow and defines what happens at that point in the flow.  
2. What it does:
   
1. Represents one logical operation in the process.
2. Can perform:
1. Data transformation.
2. Decision-making.
3. External calls (API, FTP, HTTP).
4. Automation tasks.
3. Connects to other units to form a complete workflow.
3. Use case:
   
1. Each Flow Unit handles one specific task.
   
2. Accepts inputs and produces outputs.
4. Visual Representation:

3.4 Queue Unit

1. Purpose: A Queue Unit in a flow diagram manages asynchronous processing by placing transactional messages into a queue for later handling. This unit helps to process where messages need to be processed in sequence or by different systems.
2. What it does:
   
1. Adds items to a queue for background or deferred processing.
2. Allows decoupling between the main flow and downstream tasks.
3. Supports load balancing and parallel processing.
3. How it works:
   
1. Input: The main flow generates a message or data packet (e.g., document ID, payload).
2. Queue Operation:
1. Pushes the item into a queue (e.g., message queue, job queue).
2. The queue can be in systems like RabbitMQ, Azure Service Bus, AWS SQS, or internal workflow queues.
3. Downstream Processing: Another process or worker pulls items from the queue and processes them asynchronously.
4. Benefits:
   
1. Improves scalability.
   
2. Handles spikes in workload.
3. Ensures reliability (items stay in the queue until processed).
4. Use case:
   
1. Document Workflow: Queue documents for OCR processing by background workers.
2. Integration: Queue API requests for batch processing.
3. Event Handling: Queue notifications for asynchronous delivery.
5. Visual Representation:

4. Transformation

1. Units here convert data from one form or structure to another. They handle mapping, transformation languages, or custom code to shape data.
   
2. Click on the section to expand it. The following units are available under this section:
   
1. Mapping Unit
   
2. Java Class Unit
   
3. JSONata Unit
   
4. XSLT Unit

4.1 Mapping Unit

1. Purpose: The Mapping Unit is an action unit in the Flow Editor/Designer that enables a flow to transform, map, and structure data between different formats or schemas during execution.
2. What it does:
   
1. Converts input data into the required output format.
2. Maps fields between:
1. Different data models (e.g., JSON → XML).
2. Different systems (e.g., ERP → CRM).
3. Can apply transformations (e.g., rename fields, change data types, apply formulas).
3. How it works:
   
1. Input: Data from a previous step (e.g., API response, database record).
2. Mapping Logic:
1. Define source fields and target fields.
2. Apply transformations if needed (e.g., amount * 1.18 for tax).
3. Output: Structured data ready for the next unit (e.g., HTTP Call, Component Unit).
4. Use case:
   
1. API Integration: Map fields from an external API response to your internal schema.
2. Document Workflow: Map extracted OCR data to a standardized format.
3. Data Migration: Convert legacy system data to the new system format.
5. Visual Representation:

4.2 Java Class Unit

1. Purpose: A Java Class Unit in a flow diagram represents a step where the workflow invokes custom Java logic packaged as a class. This is commonly used to extend the functionality of built-in units by writing Java code. This unit allows developers to integrate custom-built Java classes into automation flows to perform advanced processing, validation, or business logic that cannot be handled through standard flow units.
2. What it does:
   
1. Executes custom business logic written in Java.
2. Allows developers to:
1. Perform complex calculations.
2. Integrate with external libraries.
3. Implement custom transformations or validations.
3. How it works:
   
1. Configuration:
1. Specify the Java class name and method to call.
2. Provide input parameters from the flow.
3. Define expected output variables.
2. Execution:
1. The flow engine loads the Java class (usually from a JAR or classpath).
2. Invokes the specified method with mapped inputs.
3. Captures the return value and passes it to the next unit.
3. Benefits:
1. Flexibility: Add logic that is not available in standard units.
2. Reusability: Use the same Java class across multiple flows.
3. Performance: Java code runs natively, often faster than scripting.
4. Use case:
   
1. Document Workflow: Custom parsing of metadata from documents.
2. Integration: Apply encryption/decryption using Java libraries.
3. Business Logic: Validate invoice data with complex rules.
5. Visual Representation:

4.3 JSONata Unit

1. Purpose: The JSONata Unit is an action unit in the Flow Editor/Designer that enables a flow to query, transform, and manipulate JSON data using JSONata expression language. This unit lets you convert data without writing custom code, making it ideal for handling complex JSON structures.
2. What it does:
   
1. Applies JSONata expressions to: 
   
1. Extract specific fields from JSON.
2. Transform JSON into a new structure.
3. Perform calculations or conditional logic on JSON data.
   
2. Outputs the transformed JSON for the next step in the flow.
3. How it works:
   
1. Input: JSON data from a previous step (e.g., API response, document metadata).
2. Expression: Define a JSONata expression (e.g., Account.Order.Product.(Price * Quantity)).
3. Execution: The unit evaluates the expression against the input JSON.
4. Output: Returns the transformed or filtered JSON.
4. Use case:
   
1. API Integration: Extract only required fields from a large JSON response.
2. Data Mapping: Convert nested JSON into a flat structure for easier processing.
3. Business Logic: Calculate totals or apply conditions within JSON data.
5. Visual Representation:

4.4 XSLT Unit

1. Purpose: The XSLT Unit is an action unit in the Flow Editor/Designer that enables you to transform XML data using XSLT (Extensible Stylesheet Language Transformations) during execution. It allows complex XML transformations, mappings, and restructuring to be performed efficiently using standardized XSLT templates.
2. What it does:
   
1. Applies an XSLT stylesheet to an XML input.
2. Produces a transformed output (XML, HTML, or text).
3. Enables complex data restructuring, filtering, and formatting.
3. How it works:
   
1. Input: XML data from a previous step (e.g., API response, document metadata)
   
2. XSLT Stylesheet: Defines transformation rules (match patterns, templates).
   
3. Execution: The XSLT processor applies the stylesheet to the XML.
4. Output: Transformed data ready for the next unit (e.g., Mapping Unit, HTTP Call).
4. Use case:
   
1. Document Workflow: Convert XML-based invoice data into a standardized XML schema.
2. Integration: Transform XML from one system to match another system’s format.
3. Presentation: Convert XML into HTML for display.
5. Visual Representation:

1. Click on the 
   

5. Store Operations

5.1 Key-Value

5.2 Documents

5.3 Database