# All Classes

- All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
  Class | Description
  --- | ---
  AbstractOutput<T> |
  AccumulateFunction<C extends Serializable> | An interface for accumulate external function implementations
  AccumulateNullPropagationOption | An option to define if 'accumulate' propagates its result even when its accumulate function result is 'null'.
  ActionNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  ActivationGroup |
  ActivationListener |
  AdvancedQueryContext | Extension class to the basic ordering and pagination queries which use `QueryContext`.
  AfterFunctionRemovedEvent |
  AfterKieBaseLockedEvent |
  AfterKieBaseUnlockedEvent |
  AfterKiePackageAddedEvent |
  AfterKiePackageRemovedEvent |
  AfterMatchFiredEvent |
  AfterProcessAddedEvent |
  AfterProcessRemovedEvent |
  AfterRuleAddedEvent |
  AfterRuleRemovedEvent |
  Agenda |
  AgendaEventListener |
  AgendaFilter |
  AgendaGroup |
  AgendaGroupEvent |
  AgendaGroupPoppedEvent |
  AgendaGroupPushedEvent |
  All |
  Annotation |
  AttachedViewChangedEventListener |
  Attachment |
  AuditService | AuditService provides access to active and already completed process (and its components) data.
  BatchExecutionCommand |
  BatchRequestMessage |
  BeforeFunctionRemovedEvent |
  BeforeKieBaseLockedEvent |
  BeforeKieBaseUnlockedEvent |
  BeforeKiePackageAddedEvent |
  BeforeKiePackageRemovedEvent |
  BeforeMatchFiredEvent |
  BeforeProcessAddedEvent |
  BeforeProcessRemovedEvent |
  BeforeRuleAddedEvent |
  BeforeRuleRemovedEvent |
  BeliefSystemTypeOption | A class for the belief system configuration.
  BetaRangeIndexOption | An enum to enable beta node range index option.
  BoundaryEventNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  Calendar |
  Calendars |
  CaseAssignment | Represents case assignment which usually means named role to individuals or groups.
  CaseData | Top level of Case(File)Data that holds all shared information within a case.
  Channel | A channel provides a mechanism to send objects from the working memory to some external process or function.
  ChannelModel | ChannelModel is a model allowing to programmatically define a Channel and wire it to a KieSession
  ClassObjectFilter | Filters objects by class, only accepting objects of the class specified in the constructor
  ClassReactive | Annotation used to declare that a given class is not property specific
  ClockTypeOption | A class for the session clock configuration.
  ClusterAwareService | Interface that allows to rise some awareness about the cluster environment
  ClusterListener |
  ClusterNode |
  Command<T> |
  CommandExecutor | Batch Executor allows for the scripting of a KieSession using Commands, both the KieSession and KieSession implement this interface.
  Comment |
  CompositeNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  CompositeNodeOperations<T extends NodeContainerBuilder<T,​P>,​P extends NodeContainerBuilder<P,​?>> |
  Connection | A connection is a link from one Node to another.
  ConsequenceException |
  ConsequenceExceptionHandler |
  Content |
  Context | The context of an execution
  Context<T> | Context represents to highest level hierarchy of contextual data that might be used when working with `RuntimeManager` that is then relying on the context to look up correct instances of `RuntimeEngine`.
  DataTransformer | Data transformation capabilities used by data input and data output transformation as part of BPMN2 process definition.
  DebugAgendaEventListener |
  DebugRuleRuntimeEventListener |
  DeclarativeAgendaOption | An enum to enable Declarative Agenda option.
  DefaultAgendaEventListener |
  DefaultKieBaseEventListener |
  DefaultKieScannerEventListener |
  DefaultProcessEventListener |
  DefaultRuleRuntimeEventListener |
  Description | Annotation used to decorate a field or class with a description.
  Dialect | Supported programming languages for action scripts
  Direct |
  DirectFiringOption | An option to define if the KieSession should directly firing consequences bypassing the agenda.
  DoubleFieldOutput |
  Duration |
  DynamicNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  Email |
  EndNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  EntryPoint | An entry-point is an abstract channel through where facts are inserted into the engine.
  Environment |
  EnvironmentName |
  EqualityBehaviorOption | An Enum for EqualityBehavior option.
  Evaluator | A public interface to be implemented by all evaluators
  EvaluatorDefinition | A markup interface for Evaluator definitions
  EventListener | An interface that represents an element that is listening for specific types of events.
  EventNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  EventProcessingOption | An Enum for Event Processing option.
  Executable |
  ExecutableCommand<T> |
  ExecutableRunner<C extends Context> |
  ExecutionResults | Contains the results for the BatchExecution Command.
  Expires |
  Expires.Policy |
  FactField | A field from a declared fact type
  FactHandle | An handle to a fact inserted into the working memory
  FactHandle.State | The way how the fact to which this FactHandle was assigned has been inserted into the working memory
  FactType | FactType declarations are fact definitions (like classes) that are managed alongside the rules.
  FaultNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  FileLoggerModel | FileLoggerModel is a model allowing to programmatically define a FileLogger and wire it to a KieSession
  ForEachNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  GAV | A simple immutable pojo representing Maven GAV coordinates, with a JMX-compliant method in order to be exposed and used via JMX/Monitoring.
  GenericKieSessionMonitoringMXBean | An MBean interface for `KieSession` monitoring
  GenericKieSessionMonitoringMXBean.IAgendaStatsData |
  GenericKieSessionMonitoringMXBean.IGlobalProcessStatsData |
  GenericKieSessionMonitoringMXBean.IProcessStatsData |
  Global |
  Globals |
  Group |
  HumanTaskNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  I18NText |
  Include |
  IntegerFieldOutput |
  JoinNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  KBase |
  KContainer |
  KeepReferenceOption | Option to configure if the KieBase should retain a reference to the KieSession or not.
  Key | Annotation used to declare that a field is a key for the class it belongs to and then it will be used to calculate the equals/hashCode methods of the class itself.
  KieAssemblers |
  KieAssemblerService |
  KieBase | The KieBase is a repository of all the application's knowledge definitions.
  KieBaseConfiguration | A class to store KieBase related configuration.
  KieBaseConfigurationMonitorMBean |
  KieBaseEvent |
  KieBaseEventListener |
  KieBaseEventManager |
  KieBaseModel | KieBaseModel is a model allowing to programmatically define a KieBase
  KieBaseMutabilityOption | An option to define if a KieBase should be mutable or not.
  KieBaseOption | A markup interface for `KieBaseConfiguration` options.
  KieBaseOptionsConfiguration | A base interface for type safe configurations
  KieBuilder | KieBuilder is a builder for the resources contained in a KieModule
  KieBuilder.ProjectType | A marker interace implemented by the different type of projects supported by this KieBuilder
  KieCommands | KieCommands is a factory for Commands that can be used by classes that implement CommandExecutor.
  KieContainer | A container for all the KieBases of a given KieModule
  KieContainerMonitorMXBean |
  KieContainerSessionsPool | A pool of session created from a KieContainer
  KieContext |
  KieDefinition | Marker interface for all KnowlegeDefinition's
  KieDefinition.KnowledgeType |
  KieDescr | A top level interface for Knowledge Descriptors.
  KieExecutors |
  KieExecutors.Pool |
  KieFileSystem | KieFileSystem is an in memory file system used to programmatically define the resources composing a KieModule
  KieLoggers | KieLoggers is a factory for KieRuntimeLogger
  KieManagementAgentMBean | A tree root level class for all the drools management MBeans published to an MBean agent
  KieMarshallers | This api is experimental and thus the classes and the interfaces returned are subject to change.
  KieModule | A KieModule is a container of all the resources necessary to define a set of KieBases like a pom.xml defining its ReleaseId, a kmodule.xml file declaring the KieBases names and configurations together with all the KieSession that can be created from them and all the other files necessary to build the KieBases themselves
  KieModuleModel | KieModuleModel is a model allowing to programmatically define a KieModule
  KiePackage | This provides a collection of knowledge definitions that can be given to a `KieBase`.
  KieRepository | KieRepository is a singleton acting as a repository for all the available KieModules regardless if they are stored in the maven repository or programmatically built by the user
  KieResources | KieResources is a factory that provides Resource implementations for the desired IO resource
  KieRuntime |
  KieRuntimeEvent | An event that is generated by the KIE runtime.
  KieRuntimeEventManager | A manager for runtime events.
  KieRuntimeFactory | Maintains a collection of Knowledge Runtimes that is bound to the given KieBase.
  KieRuntimeLogger | A logger for audit events.
  KieRuntimes |
  KieRuntimeService<T> |
  KieScanner | A KieScanner is a scanner of the maven repositories (both local and remote) used to automatically discover if there are new releases for a given KieModule and its dependencies and eventually deploy them in the KieRepository
  KieScanner.Status |
  KieScannerEvent |
  KieScannerEventListener |
  KieScannerFactoryService |
  KieScannerStatusChangeEvent |
  KieScannerUpdateResultsEvent |
  KieService |
  KieServices | The KieServices is a thread-safe singleton acting as a hub giving access to the other Services provided by Kie.
  KieServices.Factory | A Factory for this KieServices
  KieSession | KieSession is the most common way to interact with the engine.
  KieSession.AtomicAction | An action that will be executed atomically on this session.
  KieSessionConfiguration | A class to store Session related configuration.
  KieSessionModel | KieSessionModel is a model allowing to programmatically define a KieSession
  KieSessionModel.KieSessionType |
  KieSessionMonitoringMXBean | An MBean interface for `KieSession` monitoring
  KieSessionOption | A markup interface for KieSessionConfiguration options
  KieSessionOptionsConfiguration | A base interface for type safe configurations
  KieSessionsPool | A pool of session created from a KieContainer
  KieStoreServices |
  KieWeavers |
  KieWeaverService<P extends ResourceTypePackage> |
  KReleaseId |
  KSession |
  Label | Annotation used to decorate a field or class with a label.
  ListenerModel | ListenerModel is a model allowing to programmatically define a Listener and wire it to a KieSession
  ListenerModel.Kind |
  LiveQuery |
  Marshaller |
  MarshallingConfiguration |
  Match |
  MatchCancelledCause |
  MatchCancelledEvent |
  MatchCreatedEvent |
  MatchEvent |
  MBeansOption | An Enum for MBeans Enabled option.
  Message | A Message generated by the building process of a KieModule
  Message.Level |
  MessageEvent | An event when a message is sent
  MilestoneNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  Modifies | Annotation used to declare that a given method (potenially) modifies the values of the named properties
  MultiValueKieBaseOption | A markup interface for MultiValueKieBaseConfiguration options
  MultiValueKieSessionOption | A markup interface for MultiValueKieSessionConfiguration options
  Node | A Node represents an activity in the process flow chart.
  NodeBuilder<T extends NodeBuilder<T,​P>,​P extends NodeContainerBuilder<P,​?>> | Contains common operations for all nodes, basically naming, metadata and definition completion.
  NodeContainer | A NodeContainer contains a set of Nodes There are different types of NodeContainers and NodeContainers may be nested.
  NodeContainerBuilder<T extends NodeContainerBuilder<T,​P>,​P extends NodeContainerBuilder<P,​?>> | Include operations to define a container node. As it name indicates, a container node contains nodes (a process is also a container node), so this class defines all methods to create children nodes. A container node also holds variables, exception handlers and establish connections between nodes.
  NodeInstance | A node instance represents the execution of one specific node in a process instance.
  NodeInstanceContainer | A node instance container is a container that can contain (zero or more) node instances.
  NodeInstanceLog | Audit view of node instance where each node instance (in most of the cases) will have two entries: when node instance was triggered when node instance was left - completed
  NodeType |
  ObjectDeletedEvent |
  ObjectFilter | ObjectFilter is used with WorkingMemories to filter out instances during Iteration
  ObjectInsertedEvent |
  ObjectMarshallingStrategy |
  ObjectMarshallingStrategy.Context |
  ObjectMarshallingStrategyAcceptor |
  ObjectMarshallingStrategyStore |
  ObjectStoringStrategy |
  ObjectTypeNodeMonitorMBean | An interface for OTN MBean
  ObjectUpdatedEvent |
  Operator | An interface for Operator definitions.
  Option | A base interface for type safe options in configuration objects
  OrganizationalEntity |
  OutputFieldFactory |
  ParameterInfo<T> |
  PeopleAssignments |
  PMML4AbstractField |
  PMML4Data<T> |
  PMML4DataField |
  PMML4DataType |
  PMML4Field |
  PMML4Output<T> |
  PMML4OutputField |
  PMML4Result |
  PMMLRequestData | This class provides a vanilla mechanism for sending data to the rule engine, for use in having a PMML model applied against it
  Position | Annotation used to declare the Position of a field, when using Positional field constraints.
  Process | A Process represents one modular piece of business logic that can be executed by a process engine.
  ProcessBuilder | Builder that contains methods to create a process definition.
  ProcessBuilderFactories | Holds an utility method to retrieve `ProcessBuilderFactory` default instance. Default instance returned by `get` method can be modified by setting property "org.jbpm.processBuilder.factoryClass" Value should be full class name of a `ProcessBuilderFactory` implementation that contains a default public constructor
  ProcessBuilderFactory | Factory to create process builder instance. It is also a convenient place holder for additional utility methods
  ProcessCompletedEvent | A runtime event that is generated when a ProcessInstance is completed.
  ProcessContext | Represents the context when executing a process.
  ProcessedResource |
  ProcessEvent | A runtime event related to the execution of process instances.
  ProcessEventListener | A listener for events related to process instance execution.
  ProcessEventManager | A manager for process related events.
  ProcessInstance | A process instance represents one specific instance of a process that is currently executing.
  ProcessInstanceLog | Audit view of process instance
  ProcessNodeEvent | An event related to the execution of a node instance within a process instance.
  ProcessNodeLeftEvent | An event when a node inside a process instance has been left.
  ProcessNodeTriggeredEvent | An event when a node inside a process instance has been triggered.
  ProcessRuntime | The `ProcessRuntime` is a super-interface for all `KieSession`s.
  ProcessStartedEvent | An event when a process instance has been started.
  ProcessVariableChangedEvent | An event when a variable inside a process instance has been changed.
  ProcessWorkItemHandlerException |
  ProcessWorkItemHandlerException.HandlingStrategy |
  Propagation |
  Propagation.Type |
  PropagationContext |
  PropertiesConfiguration | Base class for other Configuration classes.
  PropertyChangeSupport |
  PropertyReactive | Annotation used to declare that a given class is property specific
  QualifierModel |
  Query | Public Query interface for runtime query inspection.
  QueryContext |
  QueryListenerOption | An enum to configure the session query listener configuration.
  QueryResults | Contains the results of a query.
  QueryResultsRow | A row of data from the QueryResults container.
  QuickTaskSummary |
  RegisterableItemsFactory | Factory that is used by `RuntimeManager` to configure `RuntimeEngine` (especially KieSession) with various registerable items: Work item handlers Process event listeners Agenda event listeners Working memory event listeners Implementations of this interface shall decide what shall be registered for given `RuntimeEngine`.
  ReleaseId | ReleaseId is a full identifier far a given version of an artifact.
  ReleaseIdComparator |
  ReleaseIdComparator.ComparableVersion |
  ReleaseIdComparator.SortDirection |
  Remotable | This annotation should be used by users to specify (user-defined) classes that should be available to remote services (REST, JMS, WS) when using a workbench.
  RemoveIdentitiesOption | An Enum for Remove Identities option.
  RequestContext |
  Resource | Generic interface to provide a Reader or InputStream for the underlying IO resource.
  ResourceConfiguration | This interface is a marker interface and should be implemented by any class that will provide configurations to the `KieBuilder` - currently this is only used by decision tables.
  ResourceType |
  ResourceTypePackage<T> | A container for resources that have been processed by a `KieAssemblerService`.
  ResourceWithConfiguration | Represent a tuple of a `Resource` with associated `ResourceConfiguration`, along with necessary kbuilder callbacks, to be used in in `KieAssemblerService`.
  Results | The Results of the building process of a KieModule
  Role | Annotation used to declare if a given class is a plain fact or an event
  Role.Type |
  Row |
  Rule | Public Rule interface for runtime rule inspection.
  RuleContext |
  RuleFlowGroup |
  RuleFlowGroupActivatedEvent |
  RuleFlowGroupDeactivatedEvent |
  RuleFlowGroupEvent |
  RuleRuntime | The `RuleRuntime` is a super-interface for all `KieSession`s.
  RuleRuntimeEvent |
  RuleRuntimeEventListener |
  RuleRuntimeEventManager |
  RuleSetNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  RuleTemplateModel | RuleTemplateModel is a model allowing to programmatically apply a Drools Rule Template to a Decision Table
  RuntimeEngine | RuntimeEngine is the main entry point to interact with the process engine and task service.
  RuntimeEnvironment | Definition of the runtime environment that will be used by instance of `RuntimeManager`.
  RuntimeEnvironmentBuilder |
  RuntimeEnvironmentBuilder.Factory |
  RuntimeEnvironmentBuilderFactory |
  RuntimeManager | RuntimeManager manages `RuntimeEngine`s that are essentially build with `KieSession` and `TaskService` to deliver executable environments for processes and user tasks. Moreover `RuntimeManager` ensures that all components are configured and bootstrapped as soon as manager is instantiated to ensure its fully featured functionality right from the start.
  RuntimeManagerFactory | Factory that produces instances of `RuntimeManager`.
  RuntimeManagerFactory.Factory | A Factory for this RuntimeManagerFactory
  SequentialOption | An Enum for Sequential option.
  SessionClock | A clock interface that all engine clocks must implement
  SessionPseudoClock | A clock interface for the implementation of pseudo clocks, that are clocks where the user have control over the actual clock working.
  SessionsPoolOption |
  Setter |
  SignalEvent | An event when a signal is thrown
  SingleValueKieBaseOption | A markup interface for KieBaseConfiguration options
  SingleValueKieSessionOption | A markup interface for SingleValueKieSessionConfiguration options
  SLAViolatedEvent | An event when a SLA has been violated.
  SplitNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  StartNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  StatefulProcessSession | There are currently no process related methods that are used with the external KieSession class.
  StatefulRuleSession | This interface adds methods available to the `KieSession` beyond what the WorkingMemory provides.
  StatelessKieSession | StatelessKieSession provides a convenience API, wrapping KieSession.
  StatelessKieSessionMonitoringMXBean | An MBean interface for `StatelessKieSession` monitoring
  StatelessProcessSession | There are currently no process related methods that are used with the external StatelessKieSession class.
  StatelessRuleSession | This interface is used as part of the `StatelessKieSession`, which is the interface returned from the `KieBase`.
  Status |
  StringFieldOutput |
  SubProcessNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  Task |
  TaskContext |
  TaskData |
  TaskEvent |
  TaskLifeCycleEventListener |
  TaskLifeCycleEventListener.AssignmentType |
  TaskService | The Task Service Entry Point serves as facade of all the other services, providing a single entry point to access to all the services
  TaskSummary |
  ThreadSafeOption | An option to define if the KieSession should should be thread safe or not.
  TimedRuleExecutionFilter |
  TimedRuleExecutionOption |
  TimedRuleExecutionOption.FILTERED |
  TimerJobFactoryOption | A class for the timer job factory manager configuration.
  TimerNodeBuilder<T extends NodeContainerBuilder<T,​?>> |
  Timestamp |
  TypeSafe |
  Unit |
  User |
  UserGroupCallback |
  UserInfo |
  Variable<T> | Builder pattern like class used to build a variable. A variable requires a name and a data type. Value and metadata are optional. Usage:
  Variable |
  VariableInstanceLog | Audit view of variables that keeps track of all changes of variable identified by given name/id.
  ViewChangedEventListener |
  Watch |
  WorkflowProcess | A WorkflowProcess is a type of Process that uses a flow chart (as a collection of Nodes and Connections) to model the business logic.
  WorkflowProcessInstance | A workflow process instance represents one specific instance of a workflow process that is currently executing.
  WorkItem | Represents one unit of work that needs to be executed.
  WorkItemHandler | A work item handler is responsible for executing work items of a specific type.
  WorkItemHandlerModel | WorkItemHandlerModel is a model allowing to programmatically define a WorkItemHandler and wire it to a KieSession
  WorkItemHandlerOption | WorkItemHandlers configuration option
  WorkItemManager | A work item manager is responsible for finding the right work item handler when a work item should be executed and should be notified when this work item has been completed (or aborted).
  WorkItemNodeBuilder<T extends NodeContainerBuilder<T,​?>> |