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. Performs branching logic based on conditions or loops through items in a list. 
   
2. Represents a decision point in the flow where a condition is checked.
   
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. Executes a set of steps repeatedly until a specified 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: A System Call Unit in a flow diagram typically represents a step where the process interacts directly with the operating system or an external system service. It’s often used in automation or workflow tools to perform low-level or system-level operations.
   
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: An Expansion Call Unit in a flow diagram is typically used in document-centric or data-processing workflows where you need to expand a composite object into its constituent components for further processing.
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: An FTP Call Unit in a flow diagram performs File Transfer Protocol (FTP) operations within a workflow. It allows the process to interact with an FTP server to upload, download, or manage files.
   
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 or functionality that can be invoked within a larger workflow. It’s similar to a “subroutine” or “module” in programming, but in the context of process automation or orchestration.
   
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 is used to manage asynchronous processing by placing items into a queue for later handling. It’s common in large-scale or distributed workflows where tasks 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: A Mapping Unit in a flow diagram is used to transform or map data from source to target systems. It’s essential when integrating systems or preparing data for the next step.
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 in platforms that allow extending functionality beyond built-in units by writing Java code.
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: A JSONata Unit in a flow diagram is used for data transformation and querying using the JSONata expression language. JSONata is a lightweight query and transformation language for JSON data, making it ideal for workflows that require manipulating JSON structures. In short, it runs a JSONata expression to transform JSON data.
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: An XSLT Unit in a flow diagram transforms XML data using XSLT (Extensible Stylesheet Language Transformations). This is particularly useful in workflows that involve XML-based systems or require converting XML into another format (HTML, text, or a different XML structure).
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:

5. Store Operations

5.1 Key-Value

5.2 Documents

5.3 Database

1. The Flow Units available under the Flow Unit section are determined by the user’s selected proficiency level.
2. To view or configure units for the advanced level, select Advanced from the Proficiency Level drop-down menu.
3. When the Advanced level is selected, the following types of flow units become available. These units allow for more complex logic, integrations, and data operations compared to the standard level.
1. General
   These units are used to control the flow and logic of a process:
1. Decision/For-Each: Allows conditional branching and iteration over collections or lists of items.
2. Repeat Until: Executes a set of actions repeatedly until a specified condition is met.
2. Calls
   These units are used to invoke external systems, processes, or services:
1. System Call: Executes predefined system-level operations.
2. Expansion Call: Invokes another flow or sub-process to extend the main workflow.
3. HTTP Call: Sends requests to external web services or APIs using HTTP methods (GET, POST, PUT, DELETE, etc.).
4. FTP Call: Transfers files between systems using the File Transfer Protocol.
3. Delegate
   These units delegate tasks or processes to other components or automations:
1. Component: Invokes a reusable system component.
2. Automation: Executes a predefined automation or robotic process.
3. Flow: Triggers another flow within the same or a different project.
4. Queue: Sends data or tasks to a queue for asynchronous processing.
4. Transformation
   These units handle data transformation and mapping:
1. Mapping: Transforms data from one structure or format to another.
2. Java Class: Executes custom Java code for complex logic or transformations.
3. JSONata: Applies JSONata expressions to filter or transform JSON data.
4. XSLT: Transforms XML data using XSLT stylesheets.
5. Store Operations
   These units perform storage and retrieval operations:
1. Key - Value: Reads or writes data in key-value stores.
2. Documents: Manages document-based data structures or repositories.
3. Database: Executes database operations such as queries, inserts, updates, or deletions.