All Classes and Interfaces

Class
Description
 
Abstract class that modifies AbstractSetTaskPropertyCmd to customize validation & logging for Add Identity Link related Commands.
Base class for implementing AdminPlugins.
Base class for implementing plugin REST resources for the admin application.
Base class for implementing an Admin Plugin root resource.
Abstract implementation of the AppPlugin SPI.
A abstract plugin resource class that may be used to implement REST resources which are added to the REST application of the app.
A resource class that provides a plugins restful API.
 
 
 
 
 
 
 
 
 
 
 
Common methods for batch job handlers based on list of ids, providing serialization, configuration instantiation, etc.
 
Denotes an 'activity' in the sense of BPMN 2.0: a parent class for all tasks, subprocess and callActivity.
 
Abstract base class for implementing a BpmnParseListener without being forced to implement all methods provided, which makes the implementation more robust to future changes.
 
 
 
 
 
 
 
Generic ExecutionListener publishing events using the CDI event infrastructure.
 
Abstract base class for implementing a CmmnTransformListener without being forced to implement all methods provided, which make the implementation more robust to future changes.
An implementation of CockpitPlugin that comes with reasonable defaults.
Base class for implementing a plugin REST resource.
A resource class that provides a cockpit plugins restful API.
 
 
 
 
Represents the abstract conditional event definition builder.
 
Deployer responsible to parse resource files and create the proper entities.
 
Created by aakhmerov on 16.09.16.
 
 
 
 
 
Deprecated.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Abstract superclass for all native query types.
 
Abstract implementation of a TypedValueSerializer for ObjectValues.
 
Deployment operation step responsible for parsing and attaching the bpm-platform.xml file.
 
 
Deprecated.
Deprecated.
 
 
 
Adapter class for implementing process engine plugins
Abstract process engine resource that provides instantiations of all REST resources.
 
 
 
 
 
 
AbstractQuery<T extends Query<?,?>,U>
Abstract superclass for all query types.
 
AbstractQueryDto<T extends Query<?,?>>
Defines common query operations, such as sorting options and validation.
 
 
 
 
 
 
 
Base class to unify the getResource(boolean deserialized) and getResourceBinary() methods for several subclasses.
 
 
 
 
 
 
 
 
 
 
 
This base class provides a template method to handle servlet applications annotated with the ProcessApplication.
 
 
 
 
 
 
 
 
 
Abstract command class, meant to encapsulate boilerplate logic for concrete commands that wish to set a property on a task and inherit authorization, multi-tenancy
 
 
 
Deployment operation step that is responsible for starting all process engines declared in a List of ProcessEngineXml files.
 
 
Base class for implementing TasklistPlugins.
Base class for implementing plugin REST resources for the admin application.
Base class for implementing an Tasklist Plugin root resource.
A Filter implementation that can be used to realize basic templating.
 
 
 
 
 
Base class for handling the context of a transaction.
 
Base interceptor class for handling transactions for a command.
Base class for a JTA-based process engine configuration.
 
 
 
 
 
 
 
Abstract query class that adds methods to query for variable values.
 
 
 
 
Base class for implementing WelcomePlugins.
Base class for implementing plugin REST resources for the welcome application.
Base class for implementing a welcome Plugin root resource.
 
 
 
 
 
 
 
 
 
 
 
 
The BPMN element activationCondition of the BPMN tComplexGateway type
The BPMN element activationCondition of the BPMN tComplexGateway type
registers support for handling the annotations in the org.camunda.bpm.engine.annotations package.
simple place to stash the constants used throughout the code
responsible for providing <activiti:annotation-driven/> support.
the idea is that this bean post processor is responsible for registering all beans that have the org.camunda.bpm.engine.annotations.State annotation.
an instance of a bean discovered to both have an org.camunda.bpm.engine.ProcessEngineComponent.ActivitiComponent and one or more org.camunda.bpm.engine.ProcessEngineComponent.ActivitiComponent annotations present.
this class records and manages all known org.camunda.bpm.engine.annotations.State - responding beans in the JVM.
The BPMN activity element
 
 
 
 
 
 
 
 
 
 
Combination of flow scope and execution walker.
Collect the mappings of scopes and executions.
Maps an activity (plain activities + their containing flow scopes) to the scope executions that are executing them.
Tuple of a scope and an execution.
 
The BPMN activity element
Delegate interface for the asyncAfter property update
Delegate interface for the asyncBefore property update.
An activity instance represents an instance of an activity.
 
An activity instance is the instance of an activity
 
 
 
 
 
 
Contains a predefined set of states activity instances may be in during the execution of a process instance.
 
 
 
 
 
 
 
Defines the start behavior for activities.
 
 
 
 
 
Class contains constants that identifies the activity types, which are used by Camunda.
 
 
 
 
 
The admin application.
The rest api exposed by the admin application
 
 
 
 
SPI inteface for plugins to the admin webapplication.
 
 
The admin application service runtime delegate.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This matcher can be used for restricting access to an app.
This class represents the data structure used for collecting information about the application server.
 
 
The service provider interface (SPI) that must be provided by a webapplication plugin.
The holder of registered AppPlugins.
The list of services provided by a camunda webapplication, providing a plugin registry and access to the process engine.
This is an empty service implementation illustrating how to use a plain Java Class as a BPMN 2.0 Service Task delegate.
 
The BPMN artifact element
 
 
Create and destroy artifacts of a given class in a container specific way.
The BPMN artifact element
 
 
 
The BPMN assignment element
The BPMN assignment element
Can be used to qualify events fired when a task is assigned.
 
 
The BPMN association element
 
 
The BPMN tAssociationDirection type
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An invocation of an atomic operation
 
Any type of content that is be associated with a task or with a process instance.
 
 
 
Contains the attachment names of all attachments used by the ProcessApplication deployment OperationSteps.
An attribute.
 
 
 
 
 
Base class for implementing primitive value attributes
 
 
 
A builder for a attribute model reference based on a QName
 
 
 
 
The BPMN auditing element
The BPMN auditing element
Allows to expose the id of the currently authenticated user, his groups and his tenants to the process engine.
Represents an active authentication of a given identity (usually a user).
 
 
Servlet Filter implementation responsible for populating the Authentications.getCurrent() thread-local (ie.
 
 
A provider to handle the authentication of HttpServletRequests.
Serves as DTO to hold the result of an authentication request performed through an AuthenticationProvider.
Wrapper around current authentications.
 
 
 
 
 
 
An Authorization assigns a set of Permissions to an identity to interact with a given Resource.
 
Input for the authorization check algorithm
Command allowing to perform an authorization check
 
 
CommandChecker that uses the AuthorizationManager to perform authorization checks.
 
 
 
Exception thrown by the process engine in case a user tries to interact with a resource in an unauthorized way.
 
 
 
 
 
 
Contains the possible properties that can be used in an AuthorizationQuery.
 
 
 
 
 
The authorization service allows managing Authorizations.
 
Determines the number of jobs to acquire and the time to wait between acquisition cycles by an exponential backoff strategy.
Provides a way to define a back off between fetch and lock requests.
Thrown when you perform an illegal operation or the given data is invalid.
Exception resulting from a bad user request.
Provides Base64 encoding and decoding as defined by RFC 2045.
 
 
 
 
 
The BPMN baseElement element
The BPMN baseElement element
 
 
Provides HTTP Basic Authentication by using the request interceptor api
Represent username\password pair for user verification
A batch represents a number of jobs which execute a number of commands asynchronously.
 
 
For mybatis ExecutorType.BATCH
 
Configuration information on the elements of a batch
 
 
 
 
A batch job handler manages batch jobs based on the configuration BatchJobHandler.
 
Job declaration for batch monitor jobs.
Job handler for batch monitor jobs.
 
The set of built-in Permissions for Batch operations in Camunda Platform.
Query for Batch instances.
 
 
Contains the possible properties that can be used in a BatchQuery.
 
 
 
 
Job declaration for batch seed jobs.
The batch seed job handler is responsible to create all jobs to be executed by the batch.
 
 
 
Additional statistics for a single batch.
 
 
 
 
 
 
 
 
 
 
 
 
The default benchmark aggregator records the duration
 
 
 
 
 
 
Bindings, usually created by a Tree.
Utiliy class
Util class for manipulating bit-flag in ints.
 
 
class for providing Boolean value attributes.
Builder for building BooleanAttributes
 
Transform values of type String into BooleanValue.
 
 
A PrimitiveValue corresponding to the Java type Boolean.
 
Serializes booleans as long values.
 
 
The BPMN boundaryEvent element
The BPMN Boundary Event.
 
The BPMN boundaryEvent element
The DC bounds element
The DC bounds element
Provides access to the camunda BPMN model api.
XML NamespaceContext containing the namespaces used by BPMN 2.0 XML documents.
Helper class for implementing BPMN 2.0 activities, offering convenience methods specific to BPMN 2.0.
Convenience class to access only camunda *BPMN* related Assertions PLUS helper methods.
 
Deployer responsible to parse BPMN 2.0 XML files and create the proper ProcessDefinitionEntitys.
The BPMNDI BPMNDiagram element
The BPMNDI BPMNDiagram element
The BPMNDI BPMNEdge element
The BPMNDI BPMNEdge element
Special exception that can be used to throw a BPMN Error from JavaDelegates and expressions.
 
Helper class handling the propagation of BPMN Errors.
 
The BPMNDI BPMNLabel element
The BPMNDI BPMNLabel element
The BPMNDI BPMNLabelStyle element
The BPMNDI BPMNLabelStyle element
Constants used in the BPMN 2.0 Language (DI + Semantic)
Interface implemented by all elements in a BPMN Model
Shared base class for all BPMN Model Elements.
A RuntimeException in the Bpmn Model.
Implemented by classes which provide access to the BpmnModelInstance and the currently executed FlowElement.
A BPMN 2.0 Model
 
The Bpmn Model
 
Specific parsing of one BPMN 2.0 XML file, created by the BpmnParser.
Exception during the parsing of an BPMN model.
 
Listener which can be registered within the engine to receive events during parsing (and maybe influence it).
 
Parser for BPMN 2.0 process models.
The parser used when parsing BPMN Files
Helper methods to reused for common parsing tasks.
The BPMNDI BPMNPlane element
The BPMNDI BPMNPlane element
Properties of bpmn elements.
The BPMNDI BPMNShape element
The BPMNDI BPMNShape element
 
Provides access to the Camunda Platform services.
Defines the bpm-platform subsystem for Wildfly 8+ application server
 
 
 
 
 
Provides the description and the implementation of the subsystem#add operation.
 
Java API representation of the bpm-platform.xml file.
Implementation of the BpmPlatformXml SPI
Parse implementation for parsing the BpmPlatformXml
A SAX Parser for the bpm-platform.xml file
Tree builder.
Feature enumeration type.
 
The set of built-in exception codes the built-in ExceptionCodeProvider uses to assign a code to a ProcessEngineException.
 
 
 
 
Qualifier annotation for injecting a business key:
Inspired by the CDI implemenation
Producer for the current business key.
 
 
Bean supporting contextual business process management.
Implementation of the BusinessProcessContext-scope.
Can be used to qualify events with details about a ProcessDefinition:
 
Signifies an event that is happening / has happened during the execution of a business process.
The type of a business process event.
 
Declare a bean to be BusinessProcessScoped.
The BPMN businessRuleTask element
 
The BPMN businessRuleTask element
 
A byte array value field what load and save ByteArrayEntity.
 
 
 
A PrimitiveValue corresponding to a Java byte array (byte[]).
 
Simple (thread-safe) LRU cache.
 
This HistoryEventProducer is aware of the DbEntityManager cache and works in combination with the DbHistoryEventHandler.
Cache control filter setting "Cache-Control: no-cache" on all GET requests.
 
A cached entity
 
 
Builds the caches for the DeploymentCache.
 
 
The BPMN callableElement element
 
The BPMN callableElement element
 
 
The BPMN callActivity element
Implementation of the BPMN 2.0 call activity (limited currently to calling a subprocess and not (yet) a global task).
 
The BPMN callActivity element
Represents a callback which should be called after work was done.
The BPMN callConversation element
The BPMN callConversation element
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Custom runtime exception that wraps a checked exception.
 
 
Inspired by: https://groups.google.com/forum/#!msg/camunda-bpm-users/BQHdcLIivzs /iNVix8GkhYAJ (Christoph Berg)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Return the full version string of the present Camunda codebase, or null if it cannot be determined.
 
 
 
The BPMN connector camunda extension element
The BPMN connectorId camunda extension element
The BPMN connectorId camunda extension element
The BPMN connector camunda extension element
The BPMN constraint camunda extension element
The BPMN constraint camunda extension element
 
 
 
 
 
Event class that is fired after Camunda engine startup.
The BPMN camundaEntry camunda extension element
 
 
 
 
 
The BPMN executionListener camunda extension element
The BPMN executionListener camunda extension element
The BPMN expression camunda extension element
 
The BPMN expression camunda extension element
 
 
The BPMN failedJobRetryTimeCycle camunda extension element
The BPMN failedJobRetryTimeCycle camunda extension element
The BPMN field camunda extension element
 
The BPMN field camunda extension element
 
The BPMN formData camunda extension element
The BPMN formData camunda extension element
An object structure representing a Camunda Form used to present forms to users either when starting a process instance or when assigned to a User Task.
 
 
 
 
The BPMN formField camunda extension element
The BPMN formField camunda extension element
The BPMN formProperty camunda extension element
The BPMN formProperty camunda extension element
A CamundaFormRef represents a reference to a deployed Camunda Form.
 
A helper interface for camunda extension elements which hold a generic child element like camunda:inputParameter, camunda:outputParameter and camunda:entry.
A helper interface for camunda extension elements which hold a generic child element like camunda:inputParameter, camunda:outputParameter and camunda:entry.
 
 
The BPMN in camunda extension element
The CMMN in camunda extension element
The BPMN in camunda extension element
 
The BPMN inputOutput camunda extension element
The BPMN inputOutput camunda extension element
The BPMN inputParameter camunda extension element
The BPMN inputParameter camunda extension element
 
 
 
 
 
 
 
 
 
The BPMN camundaList extension element
 
The BPMN camundaMap extension element
The BPMN camundaMap extension element
 
 
 
 
The BPMN out camunda extension element
The CMMN out camunda extension element
The BPMN out camunda extension element
 
The BPMN outputParameter camunda extension element
The BPMN outputParameter camunda extension element
 
The BPMN potentialStarter camunda extension
The BPMN potentialStarter camunda extension
 
The BPMN properties camunda extension element
The BPMN properties camunda extension element
The BPMN property camunda extension element
The BPMN property camunda extension element
 
Class providing static methods returning all the resource classes provided by Camunda Platform.
The BPMN script camunda extension element
 
The BPMN script camunda extension element
 
 
 
The BPMN string camunda extension element
 
The BPMN string camunda extension element
 
 
 
The BPMN taskListener camunda extension element
 
The BPMN taskListener camunda extension element
 
 
The BPMN validation camunda extension element
The BPMN validation camunda extension element
The BPMN value camunda extension element
The BPMN value camunda extension element
 
 
 
 
 
 
See CancelEndEventActivityBehavior: the cancel end event interrupts the scope and performs compensation.
 
The BPMN cancelEventDefinition element
The BPMN cancelEventDefinition element
 
 
 
Validates that the target process definition cannot add a migrating multi-instance body.
 
Validates that the target process definition cannot add a new inner activity to a migrating multi-instance body.
Validates that the target process definition cannot add a remove the inner activity of a migrating multi-instance body.
 
 
 
 
Implementation to create a new CaseInstance using the BPMN 2.0 call activity
 
 
 
 
 
 
 
 
 
 
This is exception is thrown when a specific case definition is not found.
 
 
 
 
 
 
 
 
 
This is exception is thrown when something happens in the execution of a case instance.
Represent a planned item in a case instance.
 
A fluent builder for defining a command to execute for a case execution.
 
 
 
 
 
 
Listener interface implemented by user code which wants to be notified when a state transition happens on a CaseExecution.
Class handling invocations of ExecutionListeners
 
This is exception is thrown when a specific case execution is not found.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This is exception is thrown when a state transition on a case execution is not possible.
 
 
 
A fluent builder to create a new case instance.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This query is currently not public API on purpose.
 
Service which provides access to case instances and case executions.
 
 
 
 
 
 
A variable listener can be defined on a scope in a case model.
 
The BPMN catchEvent element
The BPMN catchEvent element
 
 
The BPMN categoryValue element
The BPMN categoryValue element
The BPMN categoryValueRef element of the BPMN tFlowElement type
 
 
Generic ExecutionListener publishing events using the CDI event infrastructure.
BpmnParseListener registering the CdiEventListener for distributing execution events using the cdi event infrastructure
Deprecated.
ExpressionManager for resolving Cdi-managed beans.
 
Exposes the CdiResolver in a multiple-applications, shared process engine context.
Resolver wrapping an instance of javax.el.ELResolver obtained from the BeanManager.
 
 
 
 
 
A single child element (child Element collection where ChildElementCollection.getMaxOccurs() returns 1.
 
 
 
A collection containing all or a subset of the child elements of a given ModelElementInstance.
 
 
This collection is a view on an the children of a Model Element.
Represents a single Child Element (ie.
The BPMN childLaneSet element of the BPMN tLaneSet type
 
 
 
 
Helper class for bpmn constructs that allow class delegation.
 
 
 
 
 
 
Runtime exception indicating the requested class was not found or an error occurred while loading the class.
 
Scans for bpmn20.xml files in the classpath of the given classloader.
 
Defines a report query for cleanable batches.
 
 
This interface defines the result of Cleanable historic batch report.
 
Defines a report query for cleanable case instances.
 
 
This interface defines the result of Historic finished case instance report.
 
 
Defines a report query for finished decision instances.
 
 
This interface defines the result of Cleanable historic decision instance report.
 
 
 
Defines a report query for cleanable process instances.
 
 
This interface defines the result of Cleanable historic process instance report.
 
 
 
 
 
 
 
 
Request context provides the data of the request and offers methods to change it
 
Client request interceptor makes it possible to apply changes to each request before it is sent to the http server
 
 
 
 
 
 
 
 
 
Convenience class to access camunda *BPMN* and *CMMN* related Assertions PLUS helper methods.
 
 
 
 
Deployer responsible to parse CMMN 1.0 XML files and create the proper CaseDefinitionEntitys.
 
This handler handles an instance of a CmmnElement to create a new activity.
 
 
This context contains necessary information (like caseDefinition) to be accessed by a CmmnHandlerContext.
The producer for CMMN history events.
 
 
 
 
 
 
Implemented by classes which provide access to the CmmnModelInstance and the currently executed CmmnElement.
 
 
 
This is exception is thrown when a CmmnModelInstance is not found.
 
 
 
 
 
 
 
 
 
Exception throw for errors during the transformation of a cmmn model.
 
Listener which can be registered within the engine to receive events during transforming (and maybe influence it).
 
 
Provides access to the camunda cockpit core services.
The cockpit rest api exposed by the application.
A servlet context listener that bootstraps cockpit on a running Camunda Platform.
 
The service provider interface (SPI) that must be provided by a cockpit plugin.
 
 
The CockpitRuntimeDelegate is a delegate to provide the camunda cockpit plugin service.
The BPMN collaboration element
The BPMN collaboration element
 
Maps the decision result to a list of untyped entries.
 
helper/convience methods for working with collections.
 
 
 
 
 
 
This class represents the data structure used for collecting information about executed commands for telemetry data.
Is invoked while executing a command to check if the current operation is allowed on the entity.
 
 
 
Interceptor used for opening the CommandContext and CommandInvocationContext.
Command context lifecycle events
 
 
 
 
The command executor for internal usage/
 
 
 
 
In contrast to CommandContext, this context holds resources that are only valid during execution of a single command (i.e.
 
User comments that form discussions around tasks.
 
 
 
Long running Runnable adapter
AbstractPlatformJobExecutor implementation delegating to a CommonJ WorkManager.
An adapter for wrapping a Runnable as a CommonJ Work instance.
Util class for comparisons.
 
 
The BPMN compensateEventDefinition element
 
The BPMN compensateEventDefinition element
Contains the oddities required by compensation due to the execution structures it creates.
Behavior for a compensation end event.
 
Ensures that event subscriptions are visited in a top-down fashion, i.e.
 
 
 
 
 
 
 
Annotation signaling that a task is to be completed after the annotated method returns.
Can be used to qualify events fired when a task is completed.
 
 
Interceptor for handling the CompleteTask-Annotation
 
 
 
The BPMN 2.0 completionCondition element from the tMultiInstanceLoopCharacteristics type
The BPMN 2.0 completionCondition element from the tMultiInstanceLoopCharacteristics type
 
The BPMN 2.0 complexBehaviorDefinition element
The BPMN 2.0 complexBehaviorDefinition element
The BPMN complexGateway element
 
The BPMN complexGateway element
 
Composite Condition implementation which allows multiple consumers to subscribe to signals with their own SingleConsumerCondition.
A CompositeHistoryEventHandler implementation which additionally adds to the list of HistoryEventHandler the DbHistoryEventHandler which persists events to a database.
 
A HistoryEventHandler implementation which delegates to a list of HistoryEventHandler.
A composite incident handler that handles incidents of a certain type by the multiple handlers.
 
ProcessEnginePlugin that provides composite behavior.
 
 
 
The BPMN condition element of the BPMN tConditionalEventDefinition type
Represents an interface for the condition event behaviors.
Represents the conditional event definition corresponding to the ConditionalEvent defined by the BPMN 2.0 spec.
The BPMN conditionalEventDefinition element
 
The BPMN conditionalEventDefinition element
 
 
A fluent builder for defining conditional start event correlation
 
The BPMN conditionExpression element of the BPMN tSequenceFlow type
 
The BPMN conditionExpression element of the BPMN tSequenceFlow type
 
 
 
The BPMN condition element of the BPMN tConditionalEventDefinition type
 
 
 
 
 
 
Exception is thrown if the connection could not be established
 
Exposes a connector request as variableScope.
 
 
A constant parameter value.
 
 
 
Uses the ProcessEngineService and exposes the default process engine
Uses the BpmPlatform and exposes the default process engine
 
 
 
 
 
Represents a means for associating an execution with a context.
 
 
 
 
 
 
 
The BPMN conversation element
The BPMN conversationAssociation element
The BPMN conversationAssociation element
The BPMN conversation element
The BPMN conversationLink element
The BPMN conversationLink element
The BPMN conversationNode element
The BPMN conversationNode element
 
 
 
 
 
 
 
Defines the base API for the execution of an activity.
 
 
 
 
 
 
 
 
 
The result of a message correlation.
The BPMN correlationKey element
The BPMN correlationKey element
 
 
The BPMN correlationProperty element
The BPMN correlationPropertyBinding element
The BPMN correlationPropertyBinding element
The BPMN correlationProperty element
The BPMN correlationPropertyRef element of the BPMN tCorrelationKey type
The BPMN correlationPropertyRetrievalExpression element
The BPMN correlationPropertyRetrievalExpression element
 
The BPMN correlationSubscription element
The BPMN correlationSubscription element
 
 
Exception that is thrown when an optimistic locking error occurs in CockroachDB, caused by concurrent access to the same data entries by multiple transactions.
A CockroachDB-specific Command interceptor to catch optimistic locking errors (classified as a CrdbTransactionRetryException).
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Creates old engine for the rolling updates.
 
 
 
 
 
 
 
 
Can be used to qualify events fired when a task is created.
 
 
 
 
 
 
 
 
 
CommandContextCloseListener which releases a CDI Creational Context when the command context is closed.
 
 
Provides a parser and evaluator for unix-like cron expressions.
 
Provides basic CSRF protection implementing a Same Origin Standard Header verification (step 1) and a Synchronization Token with a cookie-stored token on the front-end.
 
 
Provides export functionality for exporting a TabularResultSet to CSV (Comma Separated Values).
Allows to access executions and tasks of a managed process instance via dependency injection.
 
 
 
Fluent builder to create a CustomFunction.
 
 
 
 
 
 
 
 
A data association (Input or Output) between a source and a target
The BPMN dataAssociation element
The BPMN dataAssociation element
This class represents the data structure used for collecting information about the connected database.
 
 
In order to distinguish between the used hashed algorithm for the password encryption, as prefix is persisted with the encrypted to the database.
 
 
 
Maps a java object to the data format's internal representation and vice versa.
 
 
 
The BPMN dataInput element
The BPMN dataInputAssociation element
The BPMN dataInputAssociation element
The BPMN dataInput element
The BPMN element dataInputRef of the BPMN tInputSet type
The BPMN dataObject element
The BPMN dataObject element
The BPMN dataObjectReference element
 
The BPMN dataOutput element
The BPMN dataOutputAssociation element
The BPMN dataOutputAssociation element
 
The BPMN dataOutputRefs element of the BPMN tOutputSet type
The BPMN dataPath element of the BPMN tCorrelationPropertyBinding type
The BPMN dataState element
 
The BPMN dataStore element
The BPMN dataStore element
The BPMN dataStoreReference element
 
 
Transform values of type Date and String into DateValue which contains date and time.
 
 
 
 
Utility for DateTime that uses the JVM timezone for date / time related operations.
A PrimitiveValue corresponding to the Java type Date.
 
Serializes Dates as long values
A bulk operation
Orders bulk operations according to the lexicographical ordering of their statement names
 
A simple first level cache for Entities.
Provides the keys used by DbEntityCache for organizing the different DbEntity types.
Interface which can be implemented by DbEntities which want to be aware of their lifecycle.
 
 
An operation on a single DbEntity
 
 
 
History event handler that writes history events to the process engine database using the DbEntityManager.
WritableIdentityProvider implementation backed by a database.
 
 
A database operation.
 
Manages a set of database operations.
 
Read only implementation of DB-backed identity service
 
 
 
 
 
 
 
 
 
 
Definition of a decision resource
 
Deployer responsible to parse DMN 1.1 XML files and create the proper DecisionDefinitionEntitys.
 
 
 
 
 
This exception is thrown when a specific decision definition is not found.
 
 
 
Properties to sort decision definition queries by
 
 
 
 
Fluent builder to evaluate a decision.
 
 
This exception is thrown when something happens related to a decision.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Container of DecisionDefinitions which belongs to the same decision requirements graph (i.e.
 
Deployer responsible to parse DMN 1.1 XML files and create the proper DecisionRequirementsDefinitionEntitys.
 
 
 
 
 
 
Properties to sort decision requirements definition queries by.
 
 
 
 
 
 
Mapping function for a decision result.
 
 
Service to evaluate decisions inside the DMN engine.
 
 
 
 
Fluent builder to evaluate a decision.
 
 
 
 
 
 
 
 
 
 
 
 
Default Application registering all resources.
Default implementation of AppPluginRegistry that loads Plugins via the ServiceLoader facilities provided by the Java SE platform.
Default ArtifactService implementation.
 
Provides the default authorizations for Camunda Platform.
 
 
 
Provides the default cache implementation for the deployment caches see DeploymentCache.
 
 
 
This is the default CockpitRuntimeDelegate implementation that provides the camunda cockpit plugin services (i.e.
 
Default implementation of the business process association manager.
 
 
 
 
The default implementation of the DelegateInterceptor.
 
 
 
Validate a type against a list of allowed packages and classes.
Context which evaluates a decision on a given input
 
 
 
 
 
 
 
 
 
 
Represents the default priority provider for external tasks.
 
Register parseListener to setup failed job retry specification.
 
 
 
 
 
 
 
 
 
An incident handler that logs incidents of a certain type as instances of Incident to the engine database.
Prepares JobExecutor and registers all known custom JobHandlers.
 
This is a simple implementation of the JobExecutor using self-managed threads for performing background work.
 
 
 
 
 
 
 
 
 
Default implementation of PermissionProvider
Wrapper for backwards-compatibility to PluginRegistry.
Represents a default priority provider, which contains some functionality to evaluate the priority.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
File value is not available unless it is loaded actively Initially FileValue.getValue() returns null.
 
The BPMN definitions element
 
 
The BPMN definitions element
 
 
 
 
 
 
Execution used in JavaDelegates and ExecutionListeners.
Represents a delegation execution context which should return the current delegation execution.
 
 
 
 
FormFieldValidator delegating to a custom, user-provided validator implementation.
 
Interceptor responsible for handling calls to 'user code'.
Provides context about the invocation of usercode and handles the actual invocation
 
 
 
 
 
 
Represents a delegated mapping of input and output variables.
Implementation of SqlSession delegating to a wrapped session
Implements the SqlSessionFactory delegating to a wrapped SqlSessionFactory
Defines the different states of delegation that a task can be in.
 
 
 
 
 
 
Used for anything that needs a delete reason.
 
 
 
 
 
 
 
Deletes historic decision instances with the given id of the decision definition.
Deletes historic decision instances with the given id of the instance.
 
Deletes historic decision instances with the given ids in bulk manner.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluent builder to delete process definitions by a process definition key or process definition ids.
Fluent builder implementation to delete process definitions.
Command to delete process definitions by ids.
Command to delete process definitions by a given key.
Fluent builder to delete process definitions by a process definition key or process definition ids.
Fluent builder to delete process definitions by a process definition key or process definition ids.
 
Configuration object that is passed to the Job that will actually perform execution of deletion.
Perform serialization of DeleteProcessInstanceBatchConfiguration into JSON format.
 
 
 
 
 
 
Can be used to qualify events fired when a task is deleted.
 
 
 
 
 
 
 
 
 
 
 
 
Creates demo credentials to be used in the invoice showcase.
 
 
 
 
 
Represents a deployment that is already present in the process repository.
Annotation for a test method or class to create and delete a deployment around a test method.
 
Builder for creating new deployments.
 
 
 
 
 
 
The DeploymentHandler interface should be implemented when there is a need to define a custom behavior for determining what Resources should be added to a new Deployment.
Builds the DeploymentHandler for determining of the deployment process for the Process Engine.
 
Aggregated information on deployment ids and the number of related resources
 
List of aggregated information on deployment ids and the number of related resources
Collection of constant string values used by the parsers.
Parse implementation for Deployment Metadata.
A DeploymentOperation allows bundling multiple deployment steps into a composite operation that succeeds or fails atomically.
 
An atomic step that is part of a composite DeploymentOperation.
Allows programmatic querying of Deployments.
 
 
Contains the possible properties that can be used in a DeploymentQuery.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An extension of the deployment interface to expose the deployed definitions.
 
 
Deployment step responsible for creating individual DeployProcessArchiveStep instances for each process archive configured in the META-INF/processes.xml file.
Deployment operation step responsible for deploying a process archive
 
 
 
 
 
Validate a type before deserialization
Read the already configured historyLevel from DB and map to given list of total levels.
The DI Diagram element
Stores waypoints of a diagram edge.
Stores the position of a waypoint of a diagram edge.
Represents a diagram node.
The DI DiagramElement element
The DI DiagramElement element
The DI Diagram element
Stores a two-dimensional graph layout.
Stores position and dimensions of a diagram node.
 
 
 
 
 
 
Implementation of a Bpmn BusinessRuleTask executing a DMN Decision.
Transform a value into a specific type.
Provide DmnDataTypeTransformers for specific type names.
A decision of the DMN Engine.
Event which represents the evaluation of a decision
 
A listener which will be notified after a decision was evaluated.
 
Event which represents the evaluation of a decision with a literal expression.
 
 
Represents the decision logic of a decision.
Event which represents the evaluation of a decision.
Evaluates decisions with a specific kind of decision logic and generates the result.
Container of DmnDecisions which belongs to the same decision requirements graph (i.e.
 
 
The result of one decision evaluation.
Represents the output entries (i.e., pairs of output name and value).
 
Exception throw for errors during the result creation of a decision.
 
The result of one decision rule.
 
 
Event which represents the evaluation of a decision table
 
A listener which will be notified after a decision table was evaluated.
 
 
 
 
 
 
The result of one decision table.
 
 
 
 
 
 
 
 
 
 
Context available during the DMN transformation
Handler to transform a DMN model element.
Registry of DMN model element transformers
A DMN engine which can parse DMN decision models and evaluate decisions.
The configuration of a DmnEngine.
Modify the given DMN engine configuration so that the DMN engine can be used from the process engine.
The base exception of the DMN Engine.
JUnit 5 Extension to create and inject a DmnEngine into the test class.
 
DMN engine metric collector which records the executed decision elements since since its creation.
 
JUnit rule for DmnEngine initialization.
A evaluated decision rule.
 
The input for a evaluated decision.
 
The output for a evaluated decision.
 
Exception throw for errors during the evaluation of a decision.
 
 
The producer for DMN history events.
Exception throw if a hit policy is not applicable for a decision result.
Handler for a DMN decision table hit policy.
Registry of hit policy handlers
 
 
 
 
 
 
 
 
 
 
This exception is thrown when a DmnModelInstance is not found.
 
Resolver for available script engines.
A transform of a DMN model instance
DMN Transformer which creates a DmnTransform to transform a DMN model instance
Exception throw for errors during the transformation of a decision.
Factory to create a DmnTransform from a DmnTransformer
Listener for a DMN transformation
 
The definition of a type used in the DMN engine to transform data
 
 
 
The BPMN documentation element
 
The BPMN documentation element
 
Encapsulates a Document.
 
Encapsulates Element.
 
Helper methods which abstract some gruesome DOM specifics.
 
Filters Elements by their nodeName + namespaceUri
 
Filter retaining only Nodes of type Node.ELEMENT_NODE
A DomUtil.NodeListFilter allows to filter a NodeList, retaining only elements in the list which match the filter.
 
 
 
 
 
Transform values of type Number and String into DoubleValue.
A PrimitiveValue corresponding to the Java type Double.
 
 
 
 
 
 
 
 
helper class for parsing ISO8601 duration format (also recurring) and computing next timer date
Represents a report result about duration of completed instances for a given period.
 
 
A script which is dynamically determined during the execution.
A script which resource path is dynamically determined during the execution.
A script which source code is dynamically determined during the execution.
The DI Edge element
 
Bootstrap for the Camunda Platform using a singleton EJB
 
Deployment Step that reads the bpm-platform.xml from the classpath
 
Common base class for writing EJB process applications.
A reference to an EJB process application.
Exposes the ProcessApplicationService as EJB inside the container.
Exposes the ProcessEngineService as EJB inside the container.
Adds an additional configuration before the engine is built
 
 
An Element.
Represents one XML element.
 
 
 
 
 
 
 
 
 
 
 
 
Provider for Java Expression Language (EL) support.
Implementations indicate that they are compatible with ElProvider and can provide one.
Makes it possible to use expression in IoParameter mappings.
 
An embedded process application is a ProcessApplication that uses an embedded process engine.
The process engine holds a strong reference to the embedded process application.
 
Represents a instance which will be created by a migration, i.e.
 
 
 
 
 
 
 
An empty variable context implementation which does not allow to resolve any variables.
Annotation to bootstrap the External Task Client
Annotation that disables the SpringProcessEngineConfiguration auto-deploy feature and instead uses the required META-INF/processes.xml as an indicator for resource scanning.
 
 
 
 
 
 
Can be used to qualify events fired when an activity is ended / left
 
The BPMN endEvent element
 
The BPMN endEvent element
The BPMN endPoint element
The BPMN endPoint element
The BPMN interfaceRef element of the BPMN tParticipant type
 
 
 
 
 
Thrown if something went wrong during the engine execution (e.g., a persistence exception occurred).
 
This is a RequestAuthorizer which authorizes all process engine api requests based on the current authentication
The engine rest api exposed by the application.
 
 
 
 
 
 
 
Compares operations by Entity type.
 
 
 
EnumAttribute<T extends Enum<T>>
An attribute exposing an Enum value
 
 
 
Represents a BPMN Error definition, whereas BpmnError represents an actual instance of an Error.
The BPMN error element
Provides a way to define a back off between fetch and lock requests.
 
 
 
The BPMN errorEventDefinition element
 
The BPMN errorEventDefinition element
 
 
 
The BPMN errorRef element of the BPMN tOperation type
Represents an 'escalation' element.
The BPMN escalation element
Represents an escalation event definition that reference an 'escalation' element.
The BPMN escalationEventDefinition element
 
The BPMN escalationEventDefinition element
Helper class handling the propagation of escalation.
The BPMN escalation element
Evaluates the decision with the given key or id.
 
Evaluates the decision table with the given key or id.
Evaluate a decision table using the DecisionService of the engine.
Evaluates the conditions to start processes by conditional start events
 
Deprecated.
The BPMN event element
 
The BPMN eventBasedGateway element
 
 
The BPMN eventBasedGateway element
 
The BPMN tEventBasedGatewayType simpleType
The BPMN eventDefinition element
The BPMN eventDefinition element
The BPMN eventDefinitionRef element of the BPMN tCatchEvent type
 
 
The BPMN event element
 
Properties controlling spring eventing.
 
 
 
 
 
Engine Plugin forwarding Camunda task, execution and history events as Spring Events.
 
 
 
Specialization of the Start Event for Event Sub-Processes.
A message event subscription exists, if an Execution waits for an event like a message.
 
 
 
 
 
Describes and creates jobs for handling an event asynchronously.
 
Allows querying of event subscriptions.
 
 
 
 
 
 
 
Defines the existing event types, on which the subscription can be done.
JobEntity for ever living job, which can be rescheduled and executed again.
A command interceptor to catch ProcessEngineException errors and assign error codes.
One of the provider methods are called when a ProcessEngineException occurs.
 
Translates any Throwable to a HTTP 500 error and a JSON response.
 
 
 
 
 
 
The BPMN exclusiveGateway element
implementation of the Exclusive Gateway/XOR gateway/exclusive data-based gateway as defined in the BPMN specification.
 
The BPMN exclusiveGateway element
 
Represents an executable script.
 
 
 
 
 
 
 
 
Represent a 'path of execution' in a process instance.
Deprecated.
since 7.2: use BpmnExecutionContext
 
 
 
 
Qualifier annotation for injecting the current executionId.
 
ExecutionListener recording the current execution id in the PerfTestRunContext using the key PerfTestConstants.EXECUTION_ID.
 
Callback interface to be notified of execution events like starting a process instance, ending an activity instance or taking a transition.
Class handling invocations of ExecutionListeners
 
Represents an observer for the exeuction.
Allows programmatic querying of Executions.
 
 
Contains the possible properties that can be used in a ExecutionQuery.
 
 
 
 
 
 
Provides access to the snapshot of latest variables of an execution.
 
 
 
Bean exposing the JCA implementation of the ExecutorService as Stateless Bean.
 
 
 
 
Provides an exponential backoff strategy.
Provides an exponential backoff strategy when an error occurs fetching external tasks.
 
 
The BPMN expression element
 
 
 
 
 
An ExecutionListener that evaluates a Expression when notified.
Expression factory implementation.
A profile provides a default set of language features that will define the builder's behavior.
Class used to get hold of a ExpressionFactory.
Class responsible for handling Expression.getValue invocations
The BPMN expression element
 
 
Central manager for all expressions.
Expression node interface.
Class responsible for handling Expression.setValue() invocations.
 
 
 
 
 
The DI extension element of the DI DiagramElement type
The BPMN extension element
The BPMN extensionElements element
 
The DMN extensionElements element
The BPMN extensionElements element
 
The DMN extensionElements element
The DI extension element of the DI DiagramElement type
The BPMN extension element
Represents an external task
Represents an instance of an external task that is created when a service-task like activity (i.e.
Implements behavior of external task activities, i.e.
Assertions for an ExternalTask.
 
Camunda external task client
A fluent builder to configure the Camunda client
 
External task client exception
 
 
Represents a base class for the external task commands.
 
 
 
 
Interface for a custom implementation of the handler, which is invoked for each fetched and locked task
 
 
Represents the logger for the external task.
 
 
 
 
 
 
 
 
 
 
 
 
Service that provides possibilities to interact with fetched and locked tasks.
Service that provides access to ExternalTask instances.
 
 
 
 
Annotation to subscribe the External Task Client to a topic.
 
 
 
 
 
 
 
Exception thrown if a invalid type conversion occurs in a FEEL expression.
Provides one or more functions which can be used in an FEEL expression.
 
 
Engine to evaluate FEEL expressions.
Factory to create a instance of a FeelEngine.
 
 
 
Exception which is thrown if a error occurs during the evaluation of a FEEL expression.
 
 
Exception thrown if an error occurs during a method invocation in a FEEL expression.
Exception thrown if a method used in a FEEL expression is not available.
Exception thrown if a variable used in a FEEL expression is not available.
Exception thrown if the syntax of a FEEL expression is invalid.
 
 
 
 
 
 
 
SPI supposed to replace the default implementation of the long-polling fetch and lock handler
 
 
 
 
 
 
 
 
 
Simple JPA entity, id is set on a field.
Represents a field declaration in object form: <field name='someField> <string ...
 
 
 
 
 
 
 
 
Valuetype to save files from byte arrays, inputstreams or just files as process variables and retrieve them via an InputStream.
 
 
 
 
 
 
 
 
 
 
 
 
 
Utility to load and match filter rules.
 
 
 
 
 
Fix value type validation for ObjectTypeAttributeDefinition containing a map as value type.
 
Expression that always returns the same value when getValue is called.
The BPMN flowElement element
The BPMN flowElement element
The BPMN flowNode element
Superclass for all 'connectable' BPMN 2.0 process elements: tasks, gateways and events.
The BPMN flowNode element
The BPMN flowNodeRef element of the BPMN tLane type
Walks the flow scope hierarchy upwards
 
The DC font element
The DC font element
The BPMN formalExpression element
The BPMN formalExpression element
 
 
Contains all metadata for displaying a form and serves as base interface for StartFormData and TaskFormData
 
 
 
 
 
Represents an individual field in a form.
 
 
 
 
Wrapper for a validation constraint
 
Runtime exception for use within a FormFieldValidator.
Interface for implenting form field validators.
Object passed in to a FormFieldValidator providing access to validation properties
Runtime exception for validation of form fields.
 
 
Deprecated.
 
 
 
 
Access to form data and rendered forms for starting new process instances and completing tasks.
 
Used to indicate the type on a FormProperty.
 
Registry for built-in FormFieldValidator implementations.
 
The BPMN from element of the BPMN tAssignment type
 
 
Function node interface.
The BPMN gateway element
super class for all gateway activity implementations.
The BPMN tGatewayDirection simpleType
The BPMN gateway element
For synchronizing gateways (inclusive; parallel), the situation in which more tokens end up at the target gateway than there are incoming sequence flows must be avoided.
Represents an task which generates metrics of an year.
 
 
 
Creates an activity instance tree according to the following strategy: Event scope executions are not considered at all For every leaf execution, generate an activity/transition instance; the activity instance id is set in the leaf execution and the parent instance id is set in the parent execution For every non-leaf scope execution, generate an activity instance; the activity instance id is always set in the parent execution and the parent activity instance id is always set in the parent's parent (because of tree compactation, we ensure that an activity instance id for a scope activity is always stored in the corresponding scope execution's parent, unless the execution is a leaf) Compensation is an exception to the above procedure: A compensation throw event is not a scope, however the compensating executions are added as child executions of the (probably non-scope) execution executing the throw event.
 
 
 
 
 
 
 
 
 
 
Gives access to a deploy BPMN model instance which can be accessed by the BPMN model API.
 
Gives access to a deployed case diagram, e.g., a PNG image, through a stream of bytes.
 
 
Gives access to a deployed decision definition instance.
Gives access to a deployed decision diagram, e.g., a PNG image, through a stream of bytes.
Gives access to a deployed decision model, e.g., a DMN 1.0 XML file, through a stream of bytes.
Gives access to a deployed decision requirements definition instance.
Gives access to a deployed decision requirements diagram, e.g., a PNG image, through a stream of bytes.
Gives access to a deployed decision requirements model, e.g., a DMN 1.1 XML file, through a stream of bytes.
Gives access to a deployed DMN model instance which can be accessed by the DMN model API.
Gives access to a deployed process diagram, e.g., a PNG image, through a stream of bytes.
Provides positions and dimensions of elements in a process diagram as provided by GetDeploymentProcessDiagramCmd.
Gives access to a deployed process model, e.g., a BPMN 2.0 XML file, through a stream of bytes.
 
 
 
 
 
 
 
 
 
Command for retrieving start or task form keys.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
The BPMN globalConversation element
The BPMN globalConversation element
Represents a group, used in IdentityService.
 
 
 
 
 
 
 
 
Allows to programmatically query for Groups.
 
 
Contains the possible properties that can be used by the GroupQuery.
 
 
 
 
Holds the set of built-in user identities for Camunda Platform.
 
 
 
 
 
 
 
 
 
 
 
 
Partial implementation of the HAL link object as defined in json-hal-06#section-5
A stateful linker which collects information about the links it creates.
A link resolver is capable of resolving a set of resources by Id.
 
 
 
 
 
 
Base class for implementing a HAL resource as defined in json-hal-06#section-4
 
 
 
 
 
 
 
 
 
Command to handle an external task BPMN error.
Represents an abstract class for the handle of external task commands.
Base DTO class for Worker-related External Task operations.
 
An implementation of this context should contain necessary information to be accessed by a ModelElementHandler.
Command to handle a task BPMN error.
Command to handle a task escalation.
 
Entities that are using revisions for optimistic locking, need to implement this interface.
Marks implementing class as having DI-information bounded by a rectangle at a certain location.
 
 
Represents one execution of an activity and it's stored permanent for statistics, audit and other business intelligence purposes.
 
 
HistoryEvent implementation for events that happen in an activity.
 
Programmatic querying for HistoricActivityInstances.
 
 
Contains the possible properties which can be used in a HistoricActivityInstanceQuery.
 
 
 
 
 
 
 
 
 
 
 
Historic representation of a Batch.
 
 
 
Query for HistoricBatch instances.
 
 
Contains the possible properties that can be used in a HistoricBatchQuery.
 
 
 
 
Represents one execution of a case activity which is stored permanent for statistics, audit and other business intelligence purposes.
 
 
HistoryEvent implementation for events that happen in a case activity.
 
Programmatic querying for HistoricCaseActivityInstances.
 
 
Contains the possible properties which can be used in a HistoricCaseActivityInstanceQuery.
 
 
 
 
 
 
 
 
 
 
 
A single execution of a case definition that is stored permanently.
 
 
 
 
Allows programmatic querying of HistoricCaseInstances.
 
 
Contains the possible properties which can be used in a HistoricCaseInstanceQueryProperty.
 
 
 
 
 
 
Container for history entities which belongs to a decision evaluation.
Represents one input variable of a decision evaluation.
 
 
Represents one evaluation of a decision.
 
History entry for an evaluated decision.
Data base operations for HistoricDecisionInstanceEntity.
Allows programmatic querying of HistoricDecisionInstances.
 
 
Properties which can be used in HistoricDecisionInstanceQuery to sort historic decision instances.
 
 
 
 
 
 
 
 
Represents one output variable of a decision evaluation.
 
 
 
 
Base class for all kinds of information that is related to either a HistoricProcessInstance or a HistoricActivityInstance.
 
 
 
Programmatic querying for HistoricDetails.
 
 
Contains the possible properties which can be used in a HistoricDetailQuery.
 
 
 
 
 
Marks an entity as an historic entity to ensure that OptimisticLockingExceptions are swallowed on UPDATE or DELETE operations.
The HistoricExternalTaskLog is used to have a log containing information about task execution.
 
 
 
 
 
 
 
 
 
 
 
Historic form fields
 
Deprecated.
 
 
An historic identity link stores the association of a task with a certain identity.
 
 
 
 
 
 
 
 
 
 
Represents a historic incident that is stored permanently.
 
 
 
 
 
 
 
 
 
 
 
The HistoricJobLog is used to have a log containing information about job execution.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A single execution of a whole process definition that is stored permanently.
 
 
HistoryEvent signifying a top-level event in a process instance.
 
The set of built-in Permissions for Historic Process Instance in Camunda Platform.
Allows programmatic querying of HistoricProcessInstances.
 
 
Contains the possible properties which can be used in a HistoricProcessInstanceQueryProperty.
Defines a report query for HistoricProcessInstances.
 
 
 
 
 
 
 
 
Represents a historic task instance (waiting, finished or deleted) that is stored permanent for statistics, audit and other business intelligence purposes.
 
 
 
 
Allows programmatic querying for HistoricTaskInstances.
 
 
 
 
 
 
 
 
 
 
 
The set of built-in Permissions for Historic Task in Camunda Platform.
A single process variable containing the last value when its process instance has finished.
 
 
 
Programmatic querying for HistoricVariableInstances.
 
 
Contains the possible properties which can be used in a HistoricVariableInstanceQuery.
 
 
 
 
Update of a process variable.
 
 
 
Batch of work for history cleanup.
 
 
 
 
 
Job declaration for history cleanup.
Job handler for history cleanup job.
 
 
 
 
 
 
 
The base class for all history events.
The interface for implementing an history event handler.
The HistoryEventProcessor should be used to process an history event.
The HistoryEventProcessor.HistoryEventCreator interface which is used to interchange the implementation of the creation of different HistoryEvents.
The producer for history events.
An history event type.
The set of built-in history event types.
An ExecutionListener implementation that delegates to a HistoryEventProducer.
The history level controls what kind of data is logged to the history database.
 
 
 
 
 
 
 
This class is responsible for wiring history as execution listeners into process execution.
The provider is either invoked on root process instance start or end based on the selected history removal time strategy.
 
 
Service exposing information about ongoing and past process instances.
 
A TaskListener implementation that delegates to a HistoryEventProducer.
 
Class that encapsulates the business logic of parsing HistoryTimeToLive of different deployable resources (process, definition, case).
 
Represents the hit policy and the aggregator of a decision table.
 
The HtmlDocumentBuilder is part of the HtmlFormEngine and maintains a stack of element which are written out to a StringWriter.
Simple writer for html elements.
A simple FormEngine implementaiton which renders forms as HTML such that they can be used as embedded forms inside camunda Tasklist.
Uses a TabularResultSet and renders it as a Html Table.
Authenticates a request against the provided process engine's identity service by applying http basic authentication.
 
 
Automatically creates a session mutex when a HttpSession is created.
The BPMN humanPerformer element
The BPMN humanPerformer element
 
 
 
 
 
 
 
Identifier node interface.
Transform the given value into untyped value.
 
 
An identity link is used to associate a task with a certain identity.
 
 
 
Contains constants for all types of identity links that can be used to involve a user or group with a certain task.
Holds the result of an IdentityService operation including the operation that was executed and optionally a resulting value.
Marks an exception triggered inside an identity provider implementation
 
 
Service to manage Users and Groups.
 
generates IdBlocks that are used to assign ids to new objects.
 
 
 
 
 
Thrown if the webapp is configured incorrectly
Immutable representation of a 2-tuple of elements.
 
 
 
 
The BPMN Import element
 
 
 
 
 
 
The BPMN import element
 
 
An Incident represents a failure in the execution of a process instance.
The context of an Incident.
 
 
 
The IncidentHandler interface may be implemented by components that handle and resolve incidents of a specific type that occur during the execution of a process instance.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Represents a statistic which the aggregate number of incidents to the corresponding incident type.
 
 
 
 
 
The BPMN inclusiveGateway element
Implementation of the Inclusive Gateway/OR gateway/inclusive data-based gateway as defined in the BPMN specification.
 
The BPMN inclusiveGateway element
The BPMN incoming element of the BPMN tFlowNode type
 
 
 
 
 
 
 
The BPMN inMessageRef element of the BPMN tOperation type
The BPMN innerParticipantRef element of the BPMN tParticipantAssociation type
 
 
 
 
 
 
 
The BPMN 2.0 inputDataItem from the tMultiInstanceLoopCharacteristics type
The BPMN 2.0 inputDataItem from the tMultiInstanceLoopCharacteristics type
 
 
 
 
 
 
 
 
 
 
 
+-----------------+ | | outer scope-----> inner scope | | | +-----------------+
 
 
 
 
The BPMN inputSet element
The BPMN inputSet element
The BPMN inputSetRefs element of the BPMN tOutputSet type
 
 
 
 
Expresses that the list of activities should be instantiated and optionally a transition afterwards.
 
 
 
Transform values of type Number and String into IntegerValue.
A PrimitiveValue corresponding to the Java type Integer.
 
 
The BPMN interactionNode interface
The BPMN interactionNode interface
The BPMN interface element
The BPMN interface element
The BPMN interfaceRef element of the BPMN tParticipant type
The BPMN intermediateCatchEvent element
 
 
The BPMN intermediateCatchEvent element
 
 
The BPMN intermediateThrowEvent element
 
The BPMN intermediateThrowEvent element
 
This class represents the structure of data describing Camunda internal metrics and the technical environment in which Camunda is set-up.
 
 
 
 
 
 
 
This exception is used for any kind of errors that occur due to malformed parameters in a Http query.
 
The context of an invocation.
 
 
Process Application exposing this application's resources the process engine.
The BPMN ioBinding element
The BPMN ioBinding element
Maps variables in and out of a variable scope.
An IoParameter creates a variable in a target variable scope.
The BPMN inputOutputSpecification element
The BPMN IoSpecification element
 
 
 
 
The BPMN itemAwareElement element
 
 
 
 
 
The BPMN itemDefinition element
 
 
 
 
 
 
The BPMN tItemKind simple type
 
 
 
 
 
 
 
Common base class for writing Jakarta Enterprise Bean process applications.
A reference to an EJB process application.
A AbstractProcessApplication Implementation to be used in a Servlet container environment.
This class is an implementation of ServletContainerInitializer and is notified whenever a subclass of ServletProcessApplication annotated with the ProcessApplication annotation is deployed.
Jakarta Transactions-based implementation of the AbstractTransactionContext
 
 
Jakarta Transactions-based implementation of the AbstractTransactionInterceptor
Jakarta Transactions-based implementation of the AbstractTransactionProcessEngineConfiguration
Convience class that should be used when a Java delegation in a BPMN 2.0 process is required (for example, to call custom business logic).
Class handling invocations of JavaDelegates
Uses default java serialization to serialize java objects as byte streams.
 
Provides method abstractions to make our subsystem compatible with different JBoss versions.
 
 
 
 
 
The ResourceAdapter responsible for bootstrapping the JcaExecutorService
MBean Service delegating to the Jca ExecutorService
 
 
 
 
AbstractPlatformJobExecutor implementation delegating to a JCA WorkManager.
An adapter for wrapping a Runnable as a JCA Work instance.
This class represents the data structure used for collecting information about the installed Java runtime environment.
 
 
 
 
 
MBean interface exposing management properties of the jobExecutor through JMX.
 
MBean interface for ProcessApplications.
Represents a process engine managed by the MBeanServiceContainer
Represents a managed process engine that is started / stopped inside the MBeanServiceContainer
An MBean interface for the ProcessEngine.
 
MBean responsible for controlling a Thread Pool.
Represents one job (timer, message, etc.).
Provides the description and the implementation of the job-acquisition#add operation.
 
 
Provides the description and the implementation of the process-engine#remove operation.
 
Java API to the JobAcquisition deployment metadata
Implementation of the JobAcquisitionXml SPI interface
Assertions for a Job.
A job declaration is associated with an activity in the process definition graph.
A Job Definition provides details about asynchronous background processing ("Jobs") performed by the process engine.
 
 
Manager implementation for JobDefinitionEntity
 
Allows programmatic querying of JobDefinitions.
 
 
Contains the possible properties that can be used in a JobDefinitionQuery.
 
 
 
 
 
 
 
Stub of the common parts of a Job.
Interface to be implemented by a MessageDriven bean handling the execution of a job.
Represents the activation of a JobExecutionHandler
 
MessageDrivenBean implementation of the JobExecutionHandler interface
 
Interface to the component responsible for performing background work (Jobs).
Installs the JobExecutor service into the container.
 
 
 
 
 
Provides the JobExecutor related features of AbstractProcessEngineTestCase.
 
 
 
Deployment Metadata for the JobExecutor Service.
Implementation of the JobExecutorXml
 
 
 
 
 
This actually simulates creation of a job in Camunda 7.0; we use 7.3
Allows programmatic querying of Jobs.
 
 
Contains the possible properties that can be used in a JobQuery.
 
 
 
 
 
 
 
 
 
 
 
 
 
Deserializes query ordering properties from the deprecated 7.2 format in which the SQL-like orderBy parameter was used.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
JTA-based implementation of the AbstractTransactionProcessEngineConfiguration
JTA-based implementation of the AbstractTransactionContext
 
 
JTA-based implementation of the AbstractTransactionInterceptor
 
A simple implementation of ElProvider using Juel.
 
Expression implementation backed by a JUEL ValueExpression.
JUEL-specific implementation of an ExpressionManager.
 
ScriptEngine that used JUEL for script evaluation and compilation (JSR-223).
Factory to create JuelScriptEngines.
 
 
 
 
The DI Label element
The DI LabeledEdge element
The DI LabeledEdge element
The DI LabeledShape element
The DI LabeledShape element
The DI Label element
A single lane in a BPMN 2.0 LaneSet, currently only used internally for rendering the diagram.
The BPMN lane element
The BPMN lane element
A BPMN 2.0 LaneSet, containg Lanes, currently only used for rendering the DI info.
The BPMN laneSet element
The BPMN laneSet element
 
 
 
This wrapper class should ensure that LDAP exceptions are wrapped as process engine exceptions to avoid that error details are disclosed in the REST API.
Java Bean holding LDAP configuration
 
 
 
ProcessEnginePlugin providing Ldap Identity Provider support
 
 
Since multi-tenancy is not supported for the LDAP plugin, the query always returns 0 or an empty list.
 
 
Collects executions that execute an activity instance that is a leaf in the activity instance tree.
This class encapsulates legacy runtime behavior for the process engine.
 
This class represents the data structure used for collecting information about the license key issued for enterprise versions of Camunda Platform.
 
 
 
The BPMN linkEventDefinition element
The BPMN linkEventDefinition element
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Represents an external task that was fetched and locked.
 
 
 
 
 
 
 
 
Deprecated.
since 7.4, use slf4j
 
 
 
Transform values of type Number and String into LongValue.
 
A PrimitiveValue corresponding to the Java type Long.
 
 
The loopCardinality element from the tMultiInstanceLoopCharacteristics complex type
The loopCardinality element from the tMultiInstanceLoopCharacteristics complex type
The BPMN loopCharacteristics element
The BPMN loopCharacteristics element
The BPMN 2.0 loopDataInputRef element of the BPMN 2.0 tMultiInstanceLoopCharacteristics type
The BPMN 2.0 loopDataOutputRef element of the BPMN 2.0 tMultiInstanceLoopCharacteristics type
 
 
JobExecutor implementation that utilises an application server's managed thread pool to acquire and execute jobs.
A JobExecutor implementation that utilises a separate thread pool to acquire and execute jobs.
 
Factory bean registering a spring-managed process engine with the BpmPlatform.
 
 
 
Service for admin and maintenance operations on the process engine.
 
 
 
 
The BPMN manualTask element
Implementation of the BPMN 2.0 'manual task': a task that is external to the BPMS and to which there is no reference to IT systems whatsoever.
 
The BPMN manualTask element
 
 
 
 
A simple Service Container that delegates to the JVM's MBeanServer.
 
The BPMN message element
 
A fluent builder for defining asynchronous message correlation
 
 
 
Job handler for message correlation jobs.
A fluent builder for defining message correlation
 
The result of a message correlation.
 
 
The message correlation result type indicates which type of message correlation result is returned after a message correlation.
 
* The result of a message correlation containing the process variables
Implementation of the BPMN 2.0 'message'
NOTE: instances of Message Entity should be created via MessageJobDeclaration.
The BPMN messageEventDefinition element
 
 
 
 
The BPMN messageFlow element
The BPMN messageFlowAssociation element
The BPMN messageFlowAssociation element
The BPMN messageFlow element
The BPMN messageFlowRef element of the BPMN tConversationNode type
The BPMN message event
Declaration of a Message Job (Asynchronous continuation job)
The BPMN messagePath element of the BPMN tCorrelationPropertyRetrievalExpression type
 
 
The BPMNDI MessageVisibleKind simpleType
this code is taken almost (99.99%) verbatim from the Spring Integration project's source code where it's a static private inner class.
this code is taken almost verbatim from the Spring Integration project's source code where it's a static private inner class.
A Meter implementation based on AtomicLong
 
 
 
This class represents the data structure used for collecting information about certain internal metrics for telemetry data.
 
 
 
 
Represents a metric which contains a name, reporter like the node, timestamp and corresponding value.
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated.
Please use HostnameProvider for providing the Metrics Reporter id.
 
 
 
 
 
 
 
 
How migration works: Validate migration instructions.
 
 
Collects all failures for a migrating activity instance.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Builds a MigratingProcessInstance, a data structure that contains meta-data for the activity instances that are migrated.
 
 
Walks the hierarchy of MigratingProcessElementInstances in a top-down-fashion.
 
 
 
Thrown if at least one migration instruction cannot be applied to the activity instance it matches.
 
Collects general failures and the migrating activity instance validation reports for a migrating process instance.
 
 
A process element instance that can have other process element instances as children
 
Keeps track of scope instances (activity instances; event scope instances) created in a branch of the activity/event scope tree from the process instance downwards
 
 
Collects all failures for a migrating transition instance.
 
 
 
 
 
Check if two activities are equal in the context of the migration of two process definitions.
Check if an activity can be migrated.
 
 
Job handler for batch migration jobs.
 
 
 
Represents an instruction to migrate instances of one activity to another activity.
 
 
Generates all migration instructions which represent a direct one to one mapping of mapped entities in two process definitions.
 
 
 
Collects the validation failures for a single migration instruction.
 
 
Checks that a migration instruction is valid for the migration plan.
 
 
Specifies how process instances from one process definition (the source process definition) should be migrated to another process definition (the target process definition).
 
 
 
Builder to execute a migration.
 
 
 
 
 
Thrown if a migration plan is not valid, e.g.
 
Collects the migration validation reports for all instructions and variables of the migration plan which contain failures.
 
 
 
Collects the validation failures for a single migration variable.
 
 
 
 
 
 
 
 
 
 
Wrapper containing the missing authorization information.
*
 
 
Registry for mock objects.
 
A model contains all defined types and the relationship between them.
 
This builder is used to define and create a new model.
This builder is used to define and create a new model.
A model build operation allows to participate in a model build phase and perform some resolution steps once all types are defined.
Constants used in the model
A ModelElementHandler handles an instance of a modelElement to create a new activity.
An instance of a ModelElementType
Base class for implementing Model Elements.
 
 
 
 
 
 
A validator for model element instances.
An Exception in the Core XML Model.
A model contains all defined types and the relationship between them.
An instance of a model
 
An instance of a model
 
An exception during IO operations.
Thrown when an error is encountered during XML parsing
Thrown when an error is encountered during reference resolving.
Thrown in case a value cannot be converted to or from the requested type
 
Some Helpers useful when handling model elements.
Thrown when an error is encountered during the model validation.
 
 
 
 
 
 
 
 
 
 
When a (scope) activity behavior implements this behavior, its scope execution is notified in case of an external modification about the following: the scope execution is newly created a new concurrent execution is created in that scope a concurrent execution is removed in that scope
 
 
 
 
 
This Processor creates implicit module dependencies for process applications
The BPMN monitoring element
The BPMN monitoring element
 
 
Represents a Process Application registered with the Msc
Service representing a managed process engine instance registered with the Msc.
Service responsible for starting / stopping a managed process engine inside the Msc
A RuntimeContainerDelegate implementation for JBoss AS 7
 
Abstract Multi Instance Behavior: used for both parallel and sequential multi instance implementation.
The BPMN 2.0 tMultiInstanceFlowCondition simple type
The BPMN 2.0 multiInstanceLoopCharacteristics element type
 
The BPMN 2.0 multiInstanceLoopCharacteristics element
 
Custom implementation of Multipart Form Data which can be used for handling requests.
Dto representing a part in a multipart form.
Provides a MessageBodyReader for MultipartFormData.
 
 
 
 
 
 
 
 
 
 
This bean provides producers for the process engine services such that the injection point can choose the process engine it wants to inject by its name:
An Element.
 
Allows querying of Executions via native (SQL) queries
 
Allows querying of HistoricActivityInstanceQuerys via native (SQL) queries
 
Allows querying of HistoricCaseActivityInstances via native (SQL) queries
 
Allows querying of HistoricCaseInstances via native (SQL) queries
 
Allows querying of HistoricDecisionInstances via native (SQL) queries.
Allows querying of HistoricTaskInstanceQuerys via native (SQL) queries
 
Allows querying of HistoricTaskInstanceQuerys via native (SQL) queries
 
Allows querying of HistoricVariableInstanceQuerys via native (SQL) queries
 
 
Allows querying of ProcessInstances via native (SQL) queries
 
NativeQuery<T extends NativeQuery<?,?>,U>
Describes basic methods for doing native queries
Allows querying of Tasks via native (SQL) queries
 
Allows querying of Users via native (SQL) queries
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Basic node interface.
The DI Node element
The DI Node element
Node pretty printer for debugging purposes.
 
implementation of the 'none start event': a start event that has no specific trigger but the programmatic one (processService.startProcessInstanceXXX()).
 
 
 
This exception is thrown, if an operation is not allowed to be executed.
Exception is thrown if the task has been canceled and therefore does not exist anymore
This exception is thrown, if an entity (case execution, case definition) is not found.
 
This is an empty service implementation illustrating how to use a plain Java Class as a BPMN 2.0 Service Task delegate.
 
Exception is thrown when subscription has not yet been initialized
Exception is thrown when subscription has not yet been opened
 
This exception is thrown, if a given value is not valid.
Subscriptions for compensation start events must be migrated, similar to compensation boundary events.
 
Start Service for process applications that do not expose an EE Component View (like ServletProcessApplication
 
Untyped Null
 
 
Used to serialize untyped null values.
Arithmetic Operations as specified in chapter 1.7.
 
 
 
 
A typed value representing a Java Object.
 
Object wrapper expression.
 
 
 
 
 
 
 
 
The BPMN operation element
The BPMN operation element
This is a functional interface to pass a callback that writes the Operation Log.
This is a functional interface to pass a callback that writes the Operation Log.
Contains sortable properties which can be used in a UserOperationLogQuery.
The BPMN operationRef element of the BPMN tMessageEventDefinition type
Exception that is thrown when an optimistic locking occurs in the datastore caused by concurrent access of the same data entry.
Allows registering a listener which is notified when an DbOperationType.UPDATE or DbOperationType.DELETE could not be performed.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated.
These permissions have no effect
 
 
 
 
 
The BPMN optionalInputRefs element of the BPMN tInputSet type
The BPMN optionalOutputRefs element of the BPMN tOutputSet type
 
 
 
 
 
 
The BPMN outerParticipantRef element of the BPMN tParticipantAssociation type
The BPMN outgoing element of the BPMN tFlowNode type
 
The BPMN outMessageRef of the BPMN tOperation type
 
 
 
 
 
The BPMN 2.0 outputDataItem from the tMultiInstanceLoopCharacteristics type
The BPMN 2.0 outputDataItem from the tMultiInstanceLoopCharacteristics type
 
 
 
 
 
 
 
+--------------+ | | | inner scope ------> outer scope | | +--------------+
 
 
 
 
The BPMN outputSet element
The BPMN outputSet element
The BPMN outputSetRefs element of the BPMN tInputSet type
 
 
Pass the output variables from the process instance of a subprocess to the calling process instance.
 
 
holds the parameters of a page (partial result) for a query.
The BPMN parallelGateway element
Implementation of the Parallel Gateway/AND gateway as definined in the BPMN 2.0 specification.
 
The BPMN parallelGateway element
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Dto for ParseException The exception contains a list of errors and warning that occurred during parsing.
 
Detects and parses all META-INF/processes.xml files within the process application and attaches the parsed Metadata to the operation context.
 
Handcrafted top-down parser.
Provide limited support for syntax extensions.
 
Parse exception type
 
The BPMN participant element
The BPMN participantAssociation element
The BPMN participantAssociation element
The BPMNDI ParticipantBandKind simpleType
The BPMN participant element
The BPMN participantMultiplicity element
The BPMN participantMultiplicity element
Object indicating that a ProcessDefinitionImpl is a participant in a collaboration (pool).
The BPMN participantRef element of the BPMN tConversationNode type
The BPMN partitionElement of the BPMN tLane type
Exception thrown during the encryption process.
The PasswordEncryptor provides the api to customize the encryption of passwords.
Different Camunda versions use different hashing algorithms.
Contains a list of rules that must be matched by passwords for engine-managed users.
 
 
 
 
 
The result of a password which was checked against a PasswordPolicy.
 
Describes a rule of a PasswordPolicy.
 
 
 
 
Patches execution variables: First, applies modifications to existing variables and then deletes specified variables.
Patches task variables: First, applies modifications to existing variables and then deletes specified variables.
 
A SecurityFilterRule that deleagates to a set of PathMatchers
 
 
 
The BPMN performer element
The BPMN performer element
A performance test.
 
Configuration of a performance test
JUnit rule allowing to load the performance test configuration from a file
 
 
A step in a performance test.
 
 
JUnit rule recording the performance test result
 
An individual run of a performance test.
Represents an individual run.
 
A step in a performance test.
 
 
Allows to follows the progress of a PerfTestRun.
Specifies a unit for a span of time (i.e.
 
A permission represents an authorization to interact with a given resource in a specific way.
 
 
Converts between the String-Array based and the Integer-based representation of permissions.
This is a functional interface to pass a callback that performs the permission check.
A simple provider used to determine custom Permissions and Resources
The set of built-in Permissions for Camunda Platform.
 
 
The DI Plane element
The DI Plane element
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A ServiceType is a collection of services that share a common name prefix.
Used by the MscRuntimeContainerDelegate to create the jndi bindings
 
Retrieves the List of ProcessEngines from an attached ProcessesXml.
Base class for the process engine test cases.
Deprecated.
Used to replace a plugin resource.
 
The DC point element
The DC point element
Annotation that can be placed on a method of a ProcessApplication class.
 
Operation step responsible for invoking the @PostDeploy method of a ProcessApplication class.
 
The BPMN potentialOwner element
The BPMN potentialOwner element
 
Annotation that can be placed on a method of a ProcessApplication class.
 
Operation step responsible for invoking the @PreUndeploy method of a ProcessApplication class.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Implementation of the primitive variable value types
 
 
 
 
 
 
 
 
 
 
 
 
Interface of a problem occurred during parsing
Dto for Problem The problem contains a list of element ids and other details for root causing the issue.
 
The BPMN process element
 
Used to annotate a user-provided AbstractProcessApplication class and specify the unique name of the process application.
 
Resolves a BeanELResolver from the current process application.
Wrapps the user-provided Callable and records the Thread Context Classloader after the context switch has been performed.
A utility to declare the process application in which subsequent engine API calls are executed.
 
 
 
 
Builder for a ProcessApplication deployment
 
 
Object holding information about a deployment made by a process application.
 
This processor installs the process application into the container.
Service responsible for performing a deployment to the process engine and managing the resulting ProcessApplicationRegistration with the process engine.
SPI interface that allows providing a custom ElResolver implementation.
Comparator used for sorting providers
This is an ELResolver implementation that delegates to a ProcessApplication-provided ELResolver.
 
ExecutionListener and TaskListener implementation delegating to the ExecutionListener and TaskListener provided by a ProcessApplication.
ProcessEnginePlugin enabling the process application event listener support.
 
 
 
 
Object holding information about a deployed Process Application
 
A Process Application is an ordinary Java Application that uses the camunda process engine for BPM and Worklow functionality.
 
 
Service installed for a process application module
This processor detects a user-provided component annotated with the ProcessApplication-annotation.
A reference to a process application.
Represents a registration of a process application with a process engine
 
 
 
The process application service provides access to all deployed process applications.
ObjectFactory that can be used for binding the ProcessApplicationService into JNDI
 
This service is responsible for starting the MscManagedProcessApplication service.
 
Checked exception thrown by a ProcessApplicationReference if the referenced process application is unavailable.
Sets the ProcessApplicationInfo.PROP_SERVLET_CONTEXT_PATH property if this is deployed as part of a WebApplication.
Java API representation of a ProcessArchive definition inside a processes.xml file
 
 
Holds the contextual process data.
New context properties are always part of a section that can be started by ProcessDataContext.pushSection(ExecutionEntity).
 
 
An object structure representing an executable process composed of activities and transitions.
Assertions for a ProcessDefinition.
 
 
 
 
 
 
 
 
The set of built-in Permissions for Process definition in Camunda Platform.
Allows programmatic querying of ProcessDefinitions.
 
 
 
Contains the possible properties that can be used in a ProcessDefinitionQuery.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Provides positions and dimensions of elements in a process diagram as provided by RepositoryService.getProcessDiagram(String).
A ProcessElementInstance is an instance of a process construct such as an Activity (see ActivityInstance) or a transition (see TransitionInstance).
 
Provides access to all the services that expose the BPM and workflow operations.
Provides the description and the implementation of the process-engine#add operation.
 
Servlet filter to plug in authentication.
 
 
 
Represents an exception in activiti cdi.
Indicates that the given bean is an process engine handler.
Configuration information from which a process engine can be build.
 
 
When a Process Engine API call is performed, the engine will create a Process Engine Context.
 
 
Holds process engine version and edition (enterprise or community) Used in retrieving the process engine details when sending telemetry data
 
ELContext used by the process engine.
Runtime exception that is the superclass of all exceptions in the process engine.
Translates any ProcessEngineException to a HTTP 500 error and a JSON response.
 
Junit 5 Extension to create and inject a ProcessEngine into the test class.
 
 
 
Represents information about the initialization of the process engine.
 
 
 
 
 
 
 
Base class for implementing a process engine performance test
Exception thrown by the persistence layer of the process engine in the occurrence of a problematic interaction with the datasource.
A process engine plugin allows customizing the process engine
Java API representation of a ProcessEnginePlugin configuration inside a deployment descriptor.
Implementation of the ProcessEnginePluginXml descriptor
A simple provider SPI used to locate a process engine object.
 
Provides the description and the implementation of the process-engine#remove operation.
Convenience for ProcessEngine and services initialization in the form of a JUnit rule.
Runner that ensures closing process engines after test run.
Helper for initializing and closing process engines in server environments.
The ProcessEngineService provides access to the list of Managed Process Engines.
ObjectFactory that can be used for binding the ProcessEngineService into JNDI
Base interface providing access to the process engine's public API services.
Interface providing access to the ProcessEngineServices from Java delegation code.
Makes the managed process engine and the provided services available for injection
 
Deployment Unit Processor that creates process engine services for each process engine configured in a processes.xml file
Convenience for ProcessEngine and services initialization in the form of a JUnit base class.
Convenience class to access all available Camunda Platform related Assertions PLUS helper methods.
 
Java API representation of a ProcessEngine definition inside an XML deployment descriptor.
Implementation of the ProcessEngineXml descriptor.
Java API representation of the ProcessesXml Metadata.
 
Parse object for the processes.xml file.
A SAX Parser for the processes.xml file
Detects and processes all META-INF/processes.xml files that are visible from the module classloader of the DeploymentUnit.
Retrieves the List of ProcessEngines from an attached ProcessesXml.
Deployment operation responsible for stopping all process engines started by the deployment.
 
 
 
when used on a method parameter, this triggers the injection of the current processId.
The BPMN process element
 
Represents one execution of a ProcessDefinition.
Assertions for a ProcessInstance.
 
 
 
 
 
Qualifier annotation for injecting the id of the current process instance.
 
A fluent builder to specify a modification of process instance state in terms of cancellation of activity instances and instantiations of activities and sequence flows.
 
 
 
 
 
 
 
The set of built-in Permissions for Process instances in Camunda Platform.
Allows programmatic querying of ProcessInstances.
 
 
 
Contains the possible properties that can be used in a ProcessInstanceQuery.
 
 
 
 
 
 
 
 
 
 
Represents a process instance with the corresponding latest variables.
Represents a process instance dto extension dto that contains latest variables.
 
 
Simply wraps a modification builder because their API is equivalent.
 
 
 
 
 
 
binds variables to a currently executing Activiti business process (a ProcessInstance).
 
 
Proxies beans with methods annotated with StartProcess.
MethodInterceptor that starts a business process as a result of a successful method invocation.
AOP advice for methods annotated with (by default) StartProcess.
 
 
 
 
 
The BPMN tProcessType simple type
Annotation for qualifying injection points such that process variables are injected.
Annotation used on method signatures to tell the runtime to inject the current process' process variables as a Map<String,Object>.
Annotation for qualifying injection points such that local process variables are injected.
Allows to expose the local process variables of the current business process as a java.util.Map<String,Object>
Annotation for qualifying injection points such that local process variables are injected.
Allows to expose the process variables of the current business process as a java.util.Map<String,Object>
Allows to access the process variables of a managed process instance.
Annotation used on method signatures to tell the runtime to inject the current process' process variables as a Map<String,Object>.
Annotation for qualifying injection points such that process variables are injected.
 
 
 
 
 
Starts the process with a parallel gateway, service task and user task on the old engine.
Starts the process with a parallel gateway and user task's on the old engine.
Starts the process with a user task on the old engine.
Starts the process with a user task on the old engine.
This class represents the data structure of information about the Camunda product.
 
 
Provides product information data loaded from a *.properties file.
Utility class for performing programmatic bean lookups.
Properties that maps property keys to values.
 
 
Adds camunda.bpm.version properties to environment.
 
The BPMN property element
 
Contains data about a property change.
 
 
The BPMN property element
 
Key of a typed property.
Key of a list property.
 
Key of a map property.
 
Parse listener adding provided execution and task listeners.
Event handler publishing history events as Spring Events.
Purges the database and the deployment cache.
The purge report contains information about the deleted rows for each table and also the deleted values which are removed from the deployment cache.
Represents an interface for the purge reporting.
Defines an activity insisde a process.
 
 
 
Instantiates the next activity on the stack of the current execution's start context.
 
 
 
Base Atomic operation for implementing atomic operations which mark the creation of a new activity instance.
 
 
 
Cancel scope operation performed when an execution starts at an ActivityImpl#isCancelActivity() activity.
 
 
 
Base atomic operation used for implementing atomic operations which create a new concurrent execution for executing an activity.
 
 
 
This atomic operation simply fires the activity end event
 
 
 
 
 
In BPMN this is used for terminate end events
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Query<T extends Query<?,?>,U>
Describes basic methods for querying.
 
 
 
Specifies a condition by which two entity types can be related.
 
 
 
 
Used to indicate the operator that should be used to comparing values in a query clause.
A QueryOrderingProperty specifies a condition by which the results of a query should be sorted.
Typed query parameters for usage in cockpit plugins
Describes a property that can be used in a Query.
 
 
 
 
 
 
 
 
Represents a variable value used in queries.
 
 
SPI interface for read-only identity Service Providers.
An ELResolver that exposed object values in the map, under the name of the entry's key.
 
 
 
The BPMN receiveTask element
A receive task is a wait state that waits for the receival of some message.
 
The BPMN receiveTask element
 
 
 
 
 
 
A walker for walking through an object reference structure (e.g.
 
 
 
 
 
 
 
Strategy for handling jobs that were acquired but cannot be executed at this point (queue-size exceeded).
 
 
The BPMN relationship element
 
The BPMN tRelationshipDirection type
 
The BPMN relationship element
 
 
 
Represents a instance which will be removed by a migration, i.e.
The BPMN rendering element
The BPMN rendering element
 
 
 
Describes basic methods for creating a report.
 
 
This interface defines basic methods for resulting reports.
 
 
 
 
Service providing access to the repository of process definitions and deployments.
 
The interface for request authorizers.
 
 
 
A request matcher that matches uris compatible to the JAX-RS syntax and extracts the arguments on match.
 
 
 
 
 
 
 
This only works if ProcessEngineRule or AbstractProcessEngineTestCase is used.
 
 
Annotation for a test method or class to specify the required history level.
 
 
 
 
 
 
 
 
A resolver for Objects bound to a key.
 
 
Resources are entities for which a user or a group is authorized.
 
The BPMN resource element
The BPMN resourceAssignmentExpression element
The BPMN resourceAssignmentExpression element
Manages (create/update/delete) default authorization when an entity is changed
Definition of a resource which was deployed
 
Entity of a deployed resource definition
 
A script which is provided by an external resource.
The BPMN resource element
 
 
The BPMN resourceParameter element
The BPMN resourceParameterBinding element
The BPMN resourceParameterBinding element
The BPMN resourceParameter element
 
The BPMN resourceRef element of the BPMN tResourceRole type
This a report created during a parsing.
 
Resource report created during resource parsing
The BPMN resourceRole element
The BPMN resourceRole element
The set of built-in Resource names.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Thrown when a request from the engine's REST API fails.
 
Translates RestExceptions to error responses according to the status that is set in the exception.
 
 
Maps the decision result to a list of pairs that contains output name and untyped entry.
Contains the constants for the possible values the property ProcessApplicationDeploymentBuilder.resumePreviousVersionsBy(String).
 
 
 
Contains the rolling update tags which are used for the scenarios and test cases.
The BPMN rootElement element
The BPMN rootElement element
Simple root property resolver implementation.
 
 
 
 
 
The RuntimeContainerDelegate in an SPI that allows the process engine to integrate with the runtime container in which it is deployed.
Holder of the current RuntimeContainerDelegate instance.
This is the default RuntimeContainerDelegate implementation that delegates to the local MBeanServer infrastructure.
JobExecutor implementation that delegates the execution of jobs to the RuntimeContainer
Service which provides access to Deployments, ProcessDefinitions and ProcessInstances.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Handcrafted scanner.
 
Scan exception type
Symbol type
 
 
 
 
 
Log entry for database schema version changes.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A Bpmn scope.
Represents the backlog error callback interface.
Keeps track of the execution state when a hierarchy of scopes is instantiated at once (e.g.
this class was copied wholesale from Spring 3.1's RefreshScope, which Dave Syer wrote.
The BPMN script element
A Bindings implementation which wraps an existing binding and enhances the key / value map with read-only access to: variables provided in a VariableScope, additional bindings provided through a set of Resolvers.
Factory for the Bindings used by the ScriptingEngines.
An CaseExecutionListener which invokes a ExecutableScript when notified.
 
Exception resulting from a error during a script compilation.
A Condition which invokes a ExecutableScript when evaluated.
Base exception resulting from a script engine interaction.
 
Resolver for environment scripts.
Exception resulting from a error during a script evaluation.
An ExecutionListener which invokes a ExecutableScript when notified.
A script factory is responsible for creating a ExecutableScript instance.
The BPMN script element
Manager for JSR-223 ScriptEngine handling.
The scripting environment contains scripts that provide an environment to a user provided script.
 
 
The BPMN scriptTask element
ActivityBehavior implementation of the BPMN 2.0 script task.
 
The BPMN scriptTask element
A TaskListener which invokes a ExecutableScript when notified.
 
Makes it possible to use scripts in IoParameter mappings.
 
 
 
 
Simple filter implementation which delegates to a list of FilterRules, evaluating their SecurityFilterRule#setAuthorized(org.camunda.bpm.webapp.impl.security.filter.AppRequest) condition for the given request.
POJO representing the configuration of the security filter
 
 
This interface is used by the SecurityFilter to authorize incoming requests.
 
 
Allows to take screenshots in case of an selenium test error.
The BPMN sendTask element
 
The BPMN sendTask element
 
 
 
 
 
 
The BPMN sequenceFlow element
 
The BPMN sequenceFlow element
AcquireJobsRunnable able to serve multiple process engines.
 
 
 
 
 
 
A TypedValue for which a serialized value can be obtained and specified
 
Represents a serialization data format.
 
 
 
 
A Future implementation backed by a LifecycleListener
All ServiceName references run through here.
The BPMN serviceTask element
 
 
ActivityBehavior used when 'delegateExpression' is used for a serviceTask.
ActivityBehavior that evaluates an expression when executed.
The BPMN serviceTask element
 
Service Listener that adds / removes services to / from a collection as they are added / removed to the service controller.
The service types managed by this container.
With Camunda Platform 7.13 we introduced the application path prefix /camunda to Spring Boot.
Common logic that is used in servlet filters.
A AbstractProcessApplication Implementation to be used in a Servlet container environment.
This class is an implementation of ServletContainerInitializer and is notified whenever a subclass of ServletProcessApplication annotated with the ProcessApplication annotation is deployed.
 
 
 
 
 
 
 
 
 
 
Represents the command to set the priority of an existing external task.
 
 
 
 
 
 
 
 
 
Fluent builder to update the number of retries for one or multiple jobs asynchronously.
 
 
 
Fluent builder to update the number of retries for one or multiple jobs synchronously.
 
Fluent builder to update the number of retries for one or multiple jobs asynchronously.
 
Fluent builder to update the number of retries for one or multiple jobs referenced by process asynchronously.
 
 
 
 
 
 
 
 
 
Command that changes the process definition version of an existing process instance.
Command which can be used for setting the value of a property
 
 
Fluent builder to select the mode to set the removal time for historic batches.
Fluent builder to select the mode to set the removal time for historic decision instances.
Fluent builder to select the mode to set the removal time for historic process instances.
Fluent builder to set the removal time to historic batches and all associated historic entities.
 
 
 
 
Fluent builder to set the removal time to historic decision instances and all associated historic entities.
 
 
 
 
Fluent builder to set the removal time to historic process instances and all associated historic entities.
 
 
 
 
 
 
 
 
Command that changes the description of a task.
Command to change task priority to a new value.
Command to change task followUpDate to a new value.
Command to change a Task's name to a new value.
 
Command to change task priority to a new value.
 
Jax RS resource allowing to perform the setup steps.
 
 
 
 
 
 
 
 
PasswordEncryptor implementation using base64 encoded SHA-512 password hashes
PasswordEncryptor implementation using base64 encoded SHA password hashes
The DI Shape element
The DI Shape element
 
A PrimitiveValue corresponding to the Java type Short.
 
 
The BPMN signal element
 
Represents a bpmn signal definition
 
The BPMN signalEventDefinition element
 
The BPMN signalEventDefinition element
 
Fluent builder to notify the process engine that a signal event has been received.
 
 
 
The BPMN signal element
 
 
 
 
Simple context implementation.
For mybatis ExecutorType.SIMPLE
The SimpleFormFieldType can be used when the form value and the model value are equal.
 
Simple resolver implementation.
 
 
 
 
MPSC Condition implementation.
Maps the decision result to a single typed entry.
 
 
Maps the decision result to pairs of output name and untyped entries.
An VariableContext allowing to resolve a single variable only.
 
The BPMN source element of the BPMN tRelationship and tLinkEventDefinition type
 
A script which is provided as source code.
 
The BPMN sourceRef element of the BPMN tDataAssociation type
 
 
 
 
 
Java Bean holding Spin configuration properties.
 
 
A FunctionMapper which resolves the Spin functions for Expression Language.
 
Implementation of a TypedValueSerializer for ObjectValues using a Spin-provided DataFormat to serialize and deserialize java objects.
 
 
Resolves Spin Environment Scripts.
 
 
 
 
 
 
 
 
 
 
 
 
 
ResolverFactory and Resolver classes to make the beans managed by the Spring container available in scripting
 
 
Convenience class that specializes AbstractProcessEnginePlugin to use SpringProcessEngineConfiguration (to save casting).
 
 
Runtime exception that is the superclass of all exceptions in the spring boot started.
 
 
ExpressionManager that exposes the full application-context or a limited set of beans in expressions.
Spring External Task Client Exception
This is a spring based implementation of the JobExecutor using spring abstraction TaskExecutor for performing background task execution.
Process Application implementation to be used in a Spring Application.
ProcessApplicationElResolver implementation providing support for the Spring Framework.
 
This is bean-name-aware extension of the AbstractProcessEnginePlugin allowing anonymous classes get logged correctly when processed.
Exposes all camunda process engine services as beans.
Process Application to be used in a Spring Web Application.
Represents a topic subscription of the External Task Client.
 
 
 
 
 
Aggregates the results from a Sql Statement Test run.
Aggregates the results from a Sql Statement Test run.
 
 
 
 
 
 
 
Default in memory configuration, pre-configured with mock, dbSchema and metrics.
 
 
 
 
Can be used to qualify events fired when an activity is started
 
 
 
The BPMN startEvent element
 
The BPMN startEvent element
Specific FormData for starting a new process instance.
 
 
Deployment operation responsible registering a service which represents a Proxy to the JCA-Backed ExecutorService
Deployment operation step responsible for starting a JobEexecutor
Deployment operation step responsible for starting the JobExecutor
Deployment operation step responsible for deploying a thread pool for the JobExecutor
Starts a new process instance after the annotated method returns.
this annotation instructs the component model to start an Activiti business process on sucessful invocation of a method that's annotated with it.
This deployment operation step starts an MBeanService for the process application.
Deployment operation step responsible for starting a managed process engine inside the runtime container.
 
 
 
 
 
 
 
 
implementation of the StartProcess annotation
Variable-scope only used to resolve variables when NO execution is active but expression-resolving is needed.
 
 
 
 
indicates that a method is to be enlisted as a handler for a given BPMN state
this class is responsible for registering the other BeanFactoryPostProcessors and BeanFactoryPostProcessors.
PerfTestWatcher performing statement logging.
ProcessEnginePlugin activating statement logging.
This SqlSession wraps an actual SqlSession and logs executed sql statements.
 
 
DelegatingSqlSessionFactory wrapping the created sessions using a {@link StatementLogSqlSession.
 
 
 
Deployment operation responsible for stopping a service which represents a Proxy to the JCA-Backed ExecutorService
Deployment operation step responsible for stopping all job acquisitions
 
Deployment operations step responsible for removing the JmxManagedProcessApplication service.
Deployment operation step that is responsible for stopping (undeploying) all process applications
Deployment operation step that stops ALL process engines registered inside the container.
 
 
 
 
 
Base class for String attributes
 
 
 
Transform values of type Object into StringValue.
 
 
 
 
Implementations are used to convert http parameters from string to java types.
 
 
 
Converts String to and from bytes using the encodings required by the Java specification.
A PrimitiveValue corresponding to the Java type String.
 
 
IdGenerator implementation based on the current time and the ethernet address of the machine it is running on.
Setters are only needed to create stub results.
The DI Style element
The DI Style element
The BPMN subConversation element
The BPMN subConversation element
 
 
 
The BPMN subProcess element
Implementation of the BPMN 2.0 subprocess (formally known as 'embedded' subprocess): a subprocess defined within another process definition.
behavior for activities that delegate to a complete separate execution of a process definition.
 
 
The BPMN subProcess element
 
 
 
Event to be published after the SpringTopicSubscription was initialized.
 
 
 
 
 
*Supported* refers to whether an activity instance of a certain activity type can be migrated.
The BPMN supportedInterfaceRef element of the BPMN tCallableElement type
 
 
Validator for events that passively wait for an event, i.e.
The BPMN supports element of the BPMN tProcess type
 
This exception is thrown, if an operation that requires a non-suspended entity (execution, task, process definition) is executed on a suspended one.
 
 
 
 
 
Contains a predefined set of states for process definitions and process instances
 
 
 
 
 
 
 
Structure containing meta data (column names, column types, etc.) about a certain database table.
Data structure used for retrieving database table content.
Allows programmatic querying of TablePages.
 
A result aggregator is used to aggregate the results of a performance testsuite run as a table.
Holds the aggregated results of a performance testsuite.
Can be used to qualify events fired when a transition is taken
 
The BPMN target element of the BPMN tRelationship type
 
 
The BPMN targetRef element of the BPMN tDataAssociation type
 
 
Represents one task for a human user.
The BPMN task element
 
Parent class for all BPMN 2.0 task types such as ServiceTask, ScriptTask, UserTask, etc.
 
This exception is thrown when you try to claim a task that is already claimed by someone else.
Assertions for a Task.
 
 
 
 
 
 
 
 
 
 
Container for task definition information gathered at parsing time.
 
 
 
 
 
 
 
 
 
 
Specific FormData for completing a task.
 
 
Qualifier annotation for injecting the current taskId.
specifies which parameter is a task id
TaskListener recording the current task id in the PerfTestRunContext using the key PerfTestConstants.TASK_ID.
The BPMN task element
 
 
The tasklist application.
 
 
 
Listener interface implemented by user code which wants to be notified when a property of a task changes.
Deprecated.
use org.camunda.bpm.engine.delegate.TaskListener instead
Class handling invocations of TaskListeners
SPI inteface for plugins to the tasklist webapplication.
 
 
The tasklist application service runtime delegate.
 
 
The set of built-in Permissions for Task in Camunda Platform.
Allows programmatic querying of Tasks;
 
 
Contains the possible properties that can be used in a TaskQuery.
Represents a variable value used in a task query.
 
 
 
 
 
 
 
 
 
 
 
Service which provides access to Task and form related operations.
 
 
Utility methods to manipulate the Current Thread Context Classloader
 
 
 
The engine collects information about multiple aspects of the installation.
 
 
 
 
 
 
 
 
 
 
Represents a tenant, used in IdentityService.
 
CommandChecker to ensure that commands are only executed for entities which belongs to one of the authenticated tenants.
 
 
 
 
SPI which can be implemented to assign tenant ids to process instances, case instances and historic decision instances.
Provides information about a starting case instance to a TenantIdProvider implementation.
Provides information about a historic decision instance to a TenantIdProvider implementation.
Provides information about a starting process instance to a TenantIdProvider implementation.
 
A relationship between a tenant and an user or a group.
Allows to programmatically query for Tenants.
 
 
Contains the possible properties that can be used by the TenantQuery.
 
 
 
 
 
 
 
The BPMN terminate End Event.
The BPMN terminateEventDefinition element
The BPMN terminateEventDefinition element
 
 
 
Sets up scenarios for rolling updates.
Sets up scenarios for migration from 7.3.0
 
 
Creates process instances with the new engine for the rolling updates.
Uses the BpmPlatform and exposes the default process engine
 
 
The BPMN 2.0 text element from the tTextAnnotation complex type
 
 
The BPMN 2.0 textAnnotation element
 
 
The BPMN 2.0 textAnnotation element
 
 
The BPMN 2.0 text element from the tTextAnnotation complex type
 
 
 
 
 
The activity behavior for an intermediate throwing escalation event and an escalation end event.
The BPMN throwEvent element
The BPMN throwEvent element
Defines activity behavior for signal end event and intermediate throw signal event.
The BPMN timeCycle element of the BPMN tTimerEventDefinition type
The BPMN timeDuration element of the BPMN tTimerEventDefinition type
The BPMN timeDate element of the BPMN tTimerEventDefinition type
The BPMN timeDate element of the BPMN tTimerEventDefinition type
The BPMN timeDuration element of the BPMN tTimerEventDefinition type
The BPMN timeDuration element of the BPMN tTimerEventDefinition type
 
 
 
 
 
 
 
 
 
 
 
 
 
The BPMN timerEventDefinition element
The BPMN timerEventDefinition element
 
 
 
 
 
 
 
 
 
JobHandler implementation for timer start events which are embedded into an event subprocess.
 
 
JobHandler implementation for timer task listeners which can be defined for user tasks.
 
The BPMN to element of the BPMN tAssignment type
Set of constant keys to be used in apache tomcat deployment operations
Apache Tomcat server listener responsible for deploying the Camunda Platform.
This deployment operation step is responsible for parsing and attaching the bpm-platform.xml file on tomcat.
 
 
Subscription to a topic
A fluent builder to configure the topic subscription
 
 
 
 
 
 
 
The transaction context is an abstraction for different transaction management strategies existing the Java Ecosystem.
 
 
 
Implementations may not assume that this is executed by the same thread as the command itself.
 
 
 
 
 
The BPMN transformation element of the BPMN tDataAssociation type
 
 
Transformer<T extends Transform<? extends CoreActivity>>
 
 
 
A transition instance represents an execution token that has just completed a transition (sequence flow in BPMN) or is about to take an outgoing transition.
 
 
 
 
 
 
Parsed expression, usually created by a TreeBuilder.
Tree builder interface.
Exception type thrown in build phase (scan/parse).
Tree cache interface.
A method expression is ready to be evaluated (by calling either TreeMethodExpression.invoke(ELContext, Object[]) or TreeMethodExpression.getMethodInfo(ELContext)).
Tree store class.
A visitor for SingleReferenceWalker.
 
Provokes misbehaving error propagation that none of the other cases triggers
This CommandContextFactory allows to explicitly pass in a TransactionContextFactory.
 
 
Type Conversions as described in EL 2.1 specification (section 1.17).
Detects the canonical type string of a supplied object
A TypedValue is a value with additional type information (the ValueType).
 
 
A field what provide a typed version of a value.
 
A TypedValueSerializer persists TypedValues of a given ValueType to provided ValueFields.
 
 
 
 
Condition that resolves an UEL expression at runtime.
 
 
Deployment operation responsible for undeploying all process archives.
Deployment operation step responsible for performing the undeployment of a process archive
 
Exception is thrown in case the HTTP status code is not known by the client.
 
Unlock job.
Allows to unlock users.
 
 
 
 
Exception thrown if a user attempts to perform an unsupported model operation.
Used when the type of an object has not been specified by the user and needs to be autodetected.
 
 
Ensure that the option updateEventTriggers can only be used activities defining an event trigger
 
 
 
Fluent builder to update the suspension state of job definitions.
 
Fluent builder to update the suspension state of job definitions.
Fluent builder to update the suspension state of job definitions.
Fluent builder to update the suspension state of jobs.
 
Fluent builder to update the suspension state of jobs.
Fluent builder to update the suspension state of jobs.
 
Fluent builder to update the suspension state of process definitions.
 
Fluent builder to update the suspension state of process definitions.
Fluent builder to update the suspension state of process definitions.
 
 
 
 
 
 
 
 
 
Fluent builder to update the suspension state of process instances.
 
Fluent builder to update the suspension state of process instances.
Fluent builder to update the suspension state of process instances.
 
 
 
 
 
 
 
Represents a user, used in IdentityService.
An authentication for a user
Jax-Rs resource allowing users to authenticate with username and password
 
 
 
 
 
 
 
 
 
specifies which parameter is a user id
 
 
The set of built-in Permissions for User operation log based on categories in Camunda Platform.
Provides information about user operations.
One op log context entry represents an operation on a set of entities of the same type (see entityType field).
 
Log entry about an operation performed by a user.
 
 
Manager for UserOperationLogEntryEventEntity that also provides a generic and some specific log methods.
Programmatic querying for UserOperationLogEntry instances.
 
 
Exposes the UserOperationLogQuery as REST service.
 
 
Allows programmatic querying of User
 
 
Contains the possible properties that can be used by the UserQuery.
 
 
 
 
The BPMN userTask element
activity implementation for the user task.
 
The BPMN userTask element
 
 
 
 
 
 
 
An individual validation result.
Object passed to the ModelElementValidator to collect validation results.
SPI which can be implemented to print out a summary of a validation result.
Object in which the results of a model validation are collected.
 
 
Validators must be equal (in terms of #equals(Object)) if they validate the exact same thing.
 
 
 
Exception is thrown when a value could not be mapped
 
 
 
Resolves ValueType by name.
 
 
Validates that when an activity instance has a variable with the same name twice (as a scope execution variable and a a concurrent variable parent execution variable), no situation occurs in which either one is overwritten.
A context for variables.
 
 
A Script Bindings implementation wrapping a provided VariableContext and Bindings instance.
Deprecated.
 
 
 
A VariableInstance represents a variable in the execution of a process instance.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Reads a list of VariableQueryParameterDtos from a single parameter.
 
 
A Map of variables.
 
 
 
 
 
 
 
This class is the entry point to the process engine's typed variables API.
A set of builtin serialization dataformat constants.
 
Implementation of the VariableContext interface backed by a VariableScope.
Implementation of an ELResolver that resolves expressions with the process variables of a given VariableScope as context.
Wraps a variable scope as if it has no parent such that it is reduced to its local variables.
Bindings implementation using an ExecutionImpl as 'back-end'.
 
 
Interface describing a container for all available TypedValueSerializers of variables.
 
 
 
 
 
 
 
 
 
 
 
A ProcessArchiveScanner which uses Jboss VFS for scanning the process archive for processes.
 
The DI waypoint element of the DI Edge type
The DI waypoint element of the DI Edge type
 
 
 
The welcome application.
The rest api exposed by the welcome application
 
 
SPI interface for plugins to the welcome webapplication.
 
 
The welcome application service runtime delegate.
The BPMN whileExecutingInputRefs of the BPMN tInputSet type
The BPMN whileExecutingOutputRefs element of the BPMN tOutputSet type
Validate a type before deserialization against a whitelist of allowed types
SPI Interface for identity service implementations which offer read / write access to the user database.
Exception that is thrown when the Activiti engine discovers a mismatch between the database schema version and the engine version.
Thrown when a Model Element is added to the wrong document
A XML importer