Operaton Javadocs 2.2 API
Packages
Package
Description
Process application registration and lifecycle management API.
Java client for subscribing to external tasks from an Operaton instance and communicating task results back.
Pluggable backoff strategies for handling task subscription failures and retries.
Exception types specific to external task client communication and processing errors.
Internal implementation classes for the external task client.
Request and response interceptors for HTTP communication with the Operaton engine.
Authentication interceptor implementations for the external task client.
Internal implementation classes for HTTP interceptors.
Service provider interfaces for extending external task client behavior.
External task data transfer objects and handling interfaces.
Internal implementation classes for external task handling.
Data transfer objects for external task representations.
Topic subscription management for external tasks.
Internal implementation classes for topic subscriptions.
Data transfer objects for topic subscriptions.
Variable serialization and format handling for external task variables.
Internal implementation classes for variable serialization.
Variable format handlers for JSON, XML, and other serialization formats.
JSON variable format implementations.
Serializable variable format implementations.
XML variable format implementations.
Variable mappers for converting between Java types and serialized forms.
Variable type definitions for the external task client.
Internal variable value implementations.
Variable value types for use with the external task client.
Process engine container integration API for runtime environments.
Core DMN engine interfaces for parsing and evaluating DMN decision models and decisions.
Listener and event interfaces for observing DMN decision evaluation progress.
Default implementation of the DMN engine configuration and decision evaluation logic.
Internal implementations of DMN decision evaluation listeners and event publishing.
Integration with expression language providers for evaluating decision table expressions.
Core handlers for evaluating decision tables, literal expressions, and their logic.
Handlers for applying DMN hit policies (First, Unique, Any, Collect, Rule Order) to matched decision table rules.
Collects and tracks metrics during DMN decision evaluation for monitoring and performance analysis.
Service Provider Interface (SPI) for extending the DMN engine with custom implementations.
SPI for providing expression language implementations and resolving script engines for DMN evaluation.
SPI for registering and providing custom hit policy handlers.
SPI for registering and providing custom DMN element transformation handlers.
SPI for registering and providing custom data type transformers for DMN decision values.
Transformation of parsed DMN model elements into executable decision structures.
Data type transformers for converting values to and from DMN type definitions (String, Integer, Long, Double, Boolean, Date).
Public SPI for DMN engine extensions: configuration factory and metric collector interfaces.
FEEL (Friendly Enough Expression Language) engine API for evaluating DMN expressions.
JUEL-based FEEL engine implementation providing expression evaluation and error handling.
JUEL expression language integration for FEEL evaluation, including context factories, function mappers, and type converters.
Transformation of FEEL expressions to JUEL syntax for evaluation via JUEL engine.
Scala-based FEEL engine implementation providing native expression evaluation with Scala semantics.
Custom function providers and transformers for Scala FEEL expressions.
Builder for creating custom FEEL functions in Scala FEEL expressions.
Integration with Spin for mapping custom data types in Scala FEEL expressions.
Public API of the Operaton engine for BPM and workflow execution.
Resource-based authorization API for process engine access control.
API for managing long-running asynchronous batch operations.
Historic query API for completed and ongoing batch operations.
CDI integration for the Operaton process engine.
CDI qualifiers and interceptor annotations for process engine integration.
CDI qualifiers for process engine event observation.
Backward compatibility support for legacy process engine APIs in CDI environments.
Implementation of CDI process engine integration.
Internal implementation of annotation-based process integration.
Internal CDI scoping and context management for business processes.
CDI-aware expression language resolution for process engine.
Internal CDI event and listener infrastructure for process lifecycle events.
Utility classes for CDI integration with the process engine.
Jakarta Faces integration for process engine.
Utilities for propagating process engine context across thread boundaries.
Interfaces used to include Java code in a process as the behavior of an activity
or as a listener to process events with
JavaDelegates.Builder API for evaluating DMN decisions through the process engine.
Engine-specific runtime exceptions extending
ProcessEngineException.CMMN-specific runtime exceptions for case management errors.
DMN-specific runtime exceptions for decision evaluation errors.
External task API for decoupled service task execution.
Saved query filter API.
Classes related to the
FormService.Process engine health check API for monitoring engine status independent of runtime.
Classes related to the
HistoryService.Classes related to the
IdentityService.API implementation classes, which shouldn't directly be used by end-users.
Ant task support for schema creation and process deployment.
Internal process application management implementation.
Internal batch processing infrastructure.
Builder infrastructure for constructing batch operations.
Batch process and decision instance deletion handlers.
Batch external task retry handler.
Batch historic instance cleanup handler.
Core batch job processing infrastructure.
Batch message correlation handler.
Batch removal time update handlers.
Batch process instance variable update handler.
Batch variable set handler.
Top-level BPMN engine implementation package containing the core execution model and integration points for BPMN 2.0 processes.
Activity behavior implementations for BPMN constructs, including service tasks, gateways, events, and subprocess executions.
Internal delegate execution wrappers for invoking Java delegates and expression evaluations within the BPMN execution context.
BPMN process definition deployer that parses BPMN 2.0 XML and persists process definitions into the engine's repository.
BPMN diagram interchange (DI) processing for reading and interpreting graphical layout information from BPMN models.
BPMN helper utilities providing support for error boundary events, compensation, and escalation handling in process execution.
Built-in execution and task listener implementations for responding to process and task lifecycle events.
BPMN 2.0 XML parser that transforms BPMN process definitions into the engine's internal process definition model.
Business calendar implementations for timer resolution and due date calculation.
Engine configuration infrastructure including core configuration classes and transaction handling.
Authorization configuration and checker implementations wired during engine startup.
JTA transaction manager integration for engine configuration.
Multi-tenancy configuration and tenant isolation implementations.
Standalone (non-managed) transaction context configuration.
Command pattern implementations for all engine service operations.
Commands for creating and managing batch operations.
Commands for setting removal times on batch historic data.
Commands for batch variable updates.
Commands for Optimize history export queries.
Top-level CMMN (Case Management Model and Notation) implementation mirroring the BPMN impl structure
for case management services.
Case plan item behavior implementations defining execution semantics for CMMN elements.
Command implementations for the CMMN service API, encapsulating operations on case instances,
case plan items, and case definitions within the case engine service.
Delegate execution wrappers for CMMN case task invocations, providing interfaces for user tasks,
service tasks, and human task implementations within a case context.
Case definition deployer that parses CMMN XML artifacts and transforms them into the executable
internal case model representation stored in the repository.
Persistence entities for case instances, executions, and definitions.
Persistence entities specific to case definition repository, managing deployed case definitions
and their access from the repository.
Runtime persistence entities for case execution state, tracking active case instances and plan item instances
during case execution.
CMMN execution runtime providing the core case lifecycle management.
Element handlers used during CMMN XML parsing to construct the internal case model from CMMN XML artifacts.
Built-in case execution listener implementations providing default behavior for case lifecycle events.
Internal CMMN model representation derived from parsed XML, providing the executable model
of a case definition used by the case execution engine.
Atomic CMMN operations applied during case lifecycle transitions, enabling step-by-step progression
through case plan item state changes and case execution flow.
Transformation logic that converts the parsed CMMN model into the executable internal case model,
resolving references and preparing the model for runtime execution.
Thread-local engine context management providing access to the current command context,
process application, and engine configuration.
Core model and execution abstractions shared by BPMN and CMMN engines.
Core delegate execution types shared between BPMN and CMMN engines.
Element handler SPI for parsing model elements in BPMN and CMMN formats.
Base execution abstraction represented by
CoreExecution.Base element model abstractions including
CoreModelElement, properties, and property keys.Core execution operations shared between BPMN and CMMN engines.
Core model transformer base classes for BPMN and CMMN.
Variable handling infrastructure for the core engine.
Variable event types and dispatching infrastructure.
Input and output variable mapping infrastructure.
Parameter value providers for input and output variable mappings.
Variable scope abstraction represented by
AbstractVariableScope.Database abstraction layer providing entity persistence and session management.
Entity manager coordinating flush and dirty-tracking of cached entities.
First-level entity cache (identity map) for the current command execution.
Insert, update, and delete operation types applied during entity manager flush.
Comparators for ordering database insert and update operations by entity type.
MyBatis-backed SQL session implementation for entity persistence.
Internal delegate execution infrastructure for BPMN task and listener execution.
Engine diagnostic and introspection utilities for monitoring and debugging.
Password hashing, digest utilities, and encryption infrastructure.
DMN integration within the BPMN process engine.
Batch processing for DMN decision reevaluation operations.
DMN decision evaluation command implementations.
DMN engine configuration and initialization.
DMN decision definition deployer for parsing and registering DMN models.
Expression language support for DMN decision evaluation.
DMN decision definition persistence entities.
DMN decision definition persistence repositories.
DMN decision invocation and execution handling.
DMN decision evaluation result representation and handling.
DMN model transformer for converting DMN definitions into engine-executable forms.
Expression Language integration bridging JUEL and the process engine.
Built-in error code constants and exception code infrastructure for engine exceptions.
Internal engine event dispatching and handling infrastructure.
Internal external task service implementations for long-polling task workers.
Internal filter service implementations for creating and managing task and process instance filters.
Internal form service implementation coordinating form data retrieval, processing, and validation across the engine.
Form deployment handling that detects and registers embedded and external form references during process deployment.
Form rendering engines providing multiple template formats including HTML and Freemarker-based form generation.
Persistence entity implementations for storing Operaton form metadata including form keys and deployment associations.
Form field and form data handler implementations managing form processing for both start and user task forms.
Built-in form field type implementations including string, long, boolean, date, and enum field types.
Built-in form field validator implementations including required, min, max, and other constraint validators.
Internal health service implementation for engine diagnostics and monitoring.
History event infrastructure and processing.
History event types and entity classes.
History event handler implementations.
History event parsing and deserialization.
History event production.
History event transformation.
Identity service implementation and read-only identity provider SPI.
Database-backed identity provider implementation.
Incident management implementations for handling and resolving business process incidents.
Command interceptor chain infrastructure for request processing.
Job executor infrastructure for asynchronous job execution and timer handling.
Job executor support for automatic history cleanup operations.
JSON serialization and conversion utilities used internally by the engine.
Internal management service implementations for job definitions, metrics queries, and resource monitoring.
Metrics collection infrastructure for engine telemetry and monitoring.
DMN-specific metrics collection for decision evaluation tracking.
Metrics configuration parser for reading and processing metric definitions.
Metrics reporter implementations for publishing collected metrics.
Metrics utility classes for collection and calculation.
Migration execution infrastructure.
Batch migration execution.
In-memory representation of migrating process instances.
Parser for reconstructing migrating instance trees.
Migration plan and instance validation.
Validators for migration plan activity mappings.
Validators for runtime instance state during migration.
Validators for individual migration instructions.
Mock infrastructure for test support within the engine.
Operation log producer for audit events.
Internal Optimize history export implementations for business process analytics.
Top-level persistence infrastructure shared across all entity types.
Deployment cache and deployer SPI for process, case, and decision resources.
In-memory cache of deployed process, case, and decision definitions and their parsed models.
MyBatis entity classes mapping to engine database tables.
Query entities and mappers for Optimize history export.
Utility classes supporting persistence entity implementations.
Engine plugin implementations and infrastructure.
Process Virtual Machine (PVM) — core execution engine abstraction providing process definition models
and runtime representations.
Behavior interfaces and delegation patterns for PVM activity execution.
Internal process definition model representing the parsed and validated structure of a BPMN process.
Runtime state of executing PVM instances, capturing the execution path and variable scope at each step.
Atomic PVM operations that advance execution state through the process model.
Internal repository service command implementations.
Internal runtime service command implementations for process execution and message correlation.
Internal scripting service implementation providing script execution and lifecycle management across the engine.
Script engine resolution and caching infrastructure supporting multiple scripting languages and implementations.
Script environment providing process variables and execution context as script bindings for script evaluation.
Internal task service and task filter implementations.
Task delegate execution infrastructure.
Task listener execution infrastructure.
Internal telemetry collection and reporting for process engine usage analytics.
Telemetry data transfer objects for usage analytics reporting.
Test support infrastructure for engine integration tests.
Tree walker and visitor utilities for traversing activity instance hierarchies.
General-purpose utility classes for engine implementation.
I/O utility classes for stream and file handling.
XML utility classes for DOM and namespace handling.
Internal variable service implementation managing variable storage, retrieval, and lifecycle throughout process execution.
Variable change event listener dispatching infrastructure notifying subscribers of variable lifecycle events.
Variable value serializer registry and built-in serializer implementations for persisting and deserializing variable values.
XML parsing infrastructure using SAX for BPMN and process definition loading.
Classes related to the
ManagementService.Process instance migration API for moving running instances between process definitions.
Classes related to the querying entities in the engine.
Classes related to the
RepositoryService.REST API resource interfaces that define the contract for accessing the Operaton engine via HTTP endpoints.
Caching infrastructure for REST resources and responses.
Data transfer objects (DTOs) for REST request and response payloads across the engine API.
DTOs for authorization and access control resources.
DTOs for batch operation resources and responses.
DTOs for condition evaluation resources.
Converter classes for transforming between engine domain objects and REST DTOs.
DTOs for DMN (Decision Model and Notation) decision definition and evaluation resources.
DTOs for external task and external task worker resources.
DTOs for historic engine data including completed process instances, tasks, and variables.
DTOs for historic batch operation data.
DTOs for historic batch removal time calculations.
DTOs for Optimize integration and historic process data analytics.
DTOs for identity and group management resources.
DTOs for engine management and administration resources including jobs and metrics.
DTOs for message and signal correlation resources.
DTOs for engine metrics and monitoring data.
DTOs for process instance migration and plan generation resources.
DTOs for repository resources including deployments, process definitions, and decision definitions.
DTOs for runtime engine data including process instances, tasks, and executions.
DTOs for async batch operation requests related to process instance runtime management.
DTOs for process instance modification resources.
DTOs for user task resources and task-related operations.
DTOs for telemetry and data collection resources.
Exception mappers that translate engine exceptions into REST error responses.
JAX-RS request and response filters for REST API processing.
Hypertext Application Language (HAL) representation types for HATEOAS REST responses.
HAL link cache infrastructure for performance optimization.
HAL representation types for CMMN case definition resources.
HAL representation types for group and identity resources.
HAL representation types for identity link resources.
HAL representation types for process definition resources.
HAL representation types for task resources.
HAL representation types for tenant resources.
HAL representation types for user and identity resources.
REST resource interfaces for historic engine data queries and analysis.
Implementation classes for REST resource interfaces, handling engine integration and request processing.
JAX-RS application configuration and setup for the REST API.
Implementation of historic data REST resources and queries.
Optimize integration implementation for process analytics and reporting.
Web application bootstrap and initialization configuration.
JSON and HTTP response mappers for REST API serialization.
REST resource interfaces for authentication and authorization.
Implementation of authentication and authorization providers.
Service provider interfaces for REST extension points and plugin mechanisms.
REST resource interfaces for nested sub-resources within parent resources.
REST resource interfaces for authorization sub-resources.
Implementation of authorization sub-resource handlers.
REST resource interfaces for batch operation sub-resources.
Implementation of batch operation sub-resource handlers.
REST resource interfaces for external task sub-resources.
Implementation of external task sub-resource handlers.
REST resource interfaces for historic data sub-resources.
Implementation of historic data sub-resource handlers.
REST resource interfaces for identity and group sub-resources.
Implementation of identity and group sub-resource handlers.
Base implementation classes for sub-resource handlers.
REST resource interfaces for management and administration sub-resources.
REST resource interfaces for metrics and monitoring sub-resources.
REST resource interfaces for repository and deployment sub-resources.
Implementation of repository and deployment sub-resource handlers.
REST resource interfaces for runtime process and execution sub-resources.
Implementation of runtime process and execution sub-resource handlers.
REST resource interfaces for task sub-resources including variables, attachments, and identity links.
Implementation of task sub-resource handlers.
Utility classes for REST API processing, conversion, and helper functions.
Classes related to the
RuntimeService.Service provider interfaces for process engine configuration and extension.
Spring Framework integration for the Operaton process engine.
Spring annotations for process engine integration.
Spring application context integration for the process engine.
Spring component support for process engine integration.
Spring AOP integration for process engine annotation handling.
Utility classes for Spring AOP pointcut and method matching.
Spring XML configuration namespace support for process engine.
Spring job executor implementation for asynchronous task processing.
Spring registry for process engine state handlers.
Spring custom scope implementation for process instances.
Spring container support for managed process engine instantiation.
Classes related to the
TaskService.Data transfer objects for the legacy telemetry API and local diagnostics data.
Helper classes for testing processes.
Typed variable value API, providing factories (
Variables) and value containers
(TypedValue) for process variables.Context access for variable resolution during process execution.
Internal implementation of variable API.
Internal implementation of variable context.
Internal implementations of variable types.
Internal implementations of variable value types.
Fluent builders for constructing complex variable values.
Variable type system for declaring and managing value types.
Public API for variable values, including
TypedValue, specialized value types,
and ObjectValue for complex objects.Public API for fluent builders to construct complex variable values.
LDAP-backed read-only identity provider implementation for user and group queries.
Plugin integration for LDAP identity provider via
LdapIdentityProviderPlugin.Utility classes for LDAP identity provider operations including certificate and logging support.
JUEL (Java Unified Expression Language) implementation for expression evaluation in Operaton processes.
BPMN 2.0 model API providing access to
BpmnModelInstance and element interfaces for all BPMN element types.Fluent builder API for programmatically constructing BPMN 2.0 process models.
Internal implementation of the BPMN 2.0 model API.
Internal implementation of BPMN element types.
Internal implementation of BPMN diagram interchange (BPMNDI) element types.
Internal implementation of diagram common (DC) element types.
Internal implementation of diagram interchange (DI) element types.
Internal implementation of Operaton-specific BPMN extensions.
Public API for BPMN 2.0 element types.
Public API for BPMN diagram interchange (BPMNDI) element types.
Public API for diagram common (DC) element types.
Public API for diagram interchange (DI) element types.
Public API for Operaton-specific BPMN extensions.
CMMN 1.1 model API providing access to
CmmnModelInstance and element interfaces for all CMMN element types.Internal implementation of the CMMN 1.1 model API.
Internal implementation of CMMN element types.
Internal implementation of Operaton-specific CMMN extensions.
Public API for CMMN 1.1 element types.
Public API for Operaton-specific CMMN extensions.
DMN 1.3 model API providing access to
DmnModelInstance and element interfaces for all DMN element types.Internal implementation of the DMN 1.3 model API.
Internal implementation of DMN element types.
Public API for DMN 1.3 element types.
Generic XML model framework providing core APIs for creating and manipulating XML-based model instances.
Internal implementation of the generic XML model framework.
Internal implementation of model element instances and the DOM document abstraction layer.
XML parsing infrastructure for loading and parsing model files.
Internal implementation of model element types and type metadata.
Implementation of XML attribute handling and type conversion for model elements.
Implementation of child element handling and containment relationships.
Implementation of element references and relationship resolution.
Utility classes and helper methods for XML model operations.
Internal implementation of model validation, including validation result aggregation and reporting.
Public API for model element instances and DOM document abstractions.
Test utilities and helper classes for XML model testing.
Assertion helpers for model element and document validation in tests.
Public API for model element types, attributes, child elements, and references.
Public API for XML attribute definitions and type conversion.
Public API for child element definitions and containment relationships.
Public API for element reference definitions.
Public API for model validation, including custom validators and validation results.
Quarkus extension for the Operaton process engine.
Event handlers for the Quarkus Operaton extension.
Internal implementation classes for the Quarkus extension.
Spring Boot auto-configuration for the Operaton process engine.
Spring Boot Actuator integration for Operaton health and metrics.
Spring Boot starter annotations for the Operaton process engine.
Spring Boot starter configuration classes for the Operaton process engine.
Spring Boot conditional configuration classes.
ID generator configuration for the Spring Boot Operaton starter.
Internal implementation classes for process engine configuration.
Custom configuration implementations for the Operaton process engine.
Spring application event classes for the Operaton process engine lifecycle.
JDBC and database configuration for the Spring Boot Operaton starter.
Plugin and extension registration for the Spring Boot Operaton starter.
Configuration properties classes for the Spring Boot Operaton starter.
Spring Boot auto-configuration for the Operaton REST API.
Service provider interfaces for extending the REST API configuration.
Spring Boot ApplicationRunner integration for the Operaton process engine.
OAuth 2 security integration for the Operaton REST API.
Internal implementation classes for OAuth 2 security.
OAuth 2 security plugins for Operaton web applications.
OAuth 2 security plugin for the Operaton Admin application.
OAuth 2 security plugin for the Operaton Cockpit application.
OAuth 2 security plugin for the Operaton Tasklist application.
OAuth 2 security plugin for the Operaton Welcome application.
Spin data format integration for the Spring Boot Operaton starter.
Telemetry and monitoring integration for the Spring Boot Operaton starter.
Utility classes for the Spring Boot Operaton starter.
Convenience aggregator for Spring Boot Operaton web application dependencies.
HTTP servlet filters for the Operaton web application.
Logging abstraction backed by SLF4J, providing specialized logger classes via
BaseLogger.Shared utility classes for string, I/O, collection, and reflection operations across Operaton.
Caching utilities for improving performance of frequently accessed operations.
Connector public API, providing entry points (
Connectors) and core interfaces
(org.operaton.connect.ConnectorRequest, org.operaton.connect.ConnectorResponse).HTTP connector public API using Apache HttpClient.
Internal implementation of the HTTP connector.
Internal utilities for HTTP connector implementation.
SOAP-over-HTTP connector public API built on the HTTP connector.
Internal implementation of the SOAP-over-HTTP connector.
Internal implementation of the connector API.
Implementation of the Connect connector framework integration via
ConnectProcessEnginePlugin.Connector SPI for implementing custom connectors via
Connector, configuration,
and provider interfaces.Spin data format public API, providing
Spin and DataFormats
for JSON and XML processing.Internal implementation of the Spin data format API.
Jackson-based JSON data format implementation.
Jackson JSON data format provider and reader/writer implementations.
JSONPath query support for Jackson JSON data format.
Logging infrastructure for Spin data format implementation.
Internal utilities for Spin data format implementation.
DOM-based XML data format implementation.
DOM XML data format provider and reader/writer implementations.
SPI for DOM XML data format customization.
XPath query support for DOM XML data format.
Internal utilities for DOM XML data format implementation.
JSON data format API for processing JSON data.
Implementation of Spin data format framework integration via
SpinProcessEnginePlugin.FEEL expression language integration with Spin data format handling.
Spin-based variable value types and builders for process engine variables.
Spin variable type definitions for JSON and XML data format handling.
Implementation of Spin variable types for JSON and XML serialization.
Spin variable value interfaces for JSON and XML data formats.
Builder interfaces for constructing Spin variable values with JSON and XML data.
Implementation of Spin variable values for JSON and XML data handling.
Builder implementations for constructing Spin variable values.
Scripting support for Spin data formats.
Spin data format SPI for implementing custom data formats via
DataFormat,
provider, and configuration interfaces.XML data format API for processing XML data.
FreeMarker-backed form and template engine for Operaton Forms.