All Classes and Interfaces

Class	Description
AbstractAnnotationBuilder<O>	A base AnnotationBuilder that ensures the object being built is only built one time.
AbstractAnnotationConfiguration<B extends AnnotationBuilder<O>,O>	Base implementation of @Configuration class.
AbstractCompositeItems<T>	Base implementation for all composite items.
AbstractCompositeListener<T>	Base implementation for all composite listeners.
AbstractConfiguredAnnotationBuilder<O,I,B extends AnnotationBuilder<O>>	A base AnnotationBuilder that allows AnnotationConfigurers to be applied to it.
AbstractExpressionEvaluator	Base class providing common functionality for using Spring expression language.
AbstractExternalTransition<S,E>
AbstractImportingAnnotationConfiguration<B extends AnnotationBuilder<O>,O>	Base class for Configuration which works on a bean definition level relying on ImportBeanDefinitionRegistrar phase to register beans.
AbstractImportingAnnotationConfiguration.BeanDelegatingFactoryBean<T,B extends AnnotationBuilder<O>,O>
AbstractInternalTransition<S,E>
AbstractIterator<T>
AbstractKryoStateMachineSerialisationService<S,E>	Abstract base implementation for StateMachineSerialisationService using kryo.
AbstractLocalTransition<S,E>
AbstractPersistingStateMachineInterceptor<S,E,T>	Base class for StateMachineInterceptor persisting StateMachineContexts.
AbstractPersistStateMachineHandler<S,E>	AbstractPersistStateMachineHandler is a base recipe which can be used to handle a state change of an arbitrary entity in a persistent storage.
AbstractPersistStateMachineHandler.GenericPersistStateChangeListener<S,E>	The listener interface for receiving persistStateChange events.
AbstractPseudoState<S,E>	Base implementation of a PseudoState.
AbstractSimpleState<S,E>	Base implementation of a State having a single state identifier.
AbstractState<S,E>	Base implementation of a State.
AbstractStateMachine<S,E>	Base implementation of a StateMachine loosely modelled from UML state machine.
AbstractStateMachineConfigurerAdapter<S,E>	Adapter base implementation for StateMachineConfigurer.
AbstractStateMachineFactory<S,E>	Base StateMachineFactory implementation building StateMachines.
AbstractStateMachineJUnit4Tests	Base helper class for state machine tests.
AbstractStateMachineJUnit5Tests	Base helper class for state machine tests.
AbstractStateMachineModelFactory<S,E>	Base implementation of a StateMachineModelFactory providing some common grounds for various implementations.
AbstractStateMachineMonitor<S,E>	Base implementation of a StateMachineMonitor.
AbstractStateMachinePersister<S,E,T>	Base implementation of a StateMachinePersister easing persist and restore operations with a StateMachinePersist.
AbstractTransition<S,E>	Base implementation of a Transition.
AbstractTransitionConfigurer<S,E>	Base class for transition configurers.
Action<S,E>	Generic strategy interface used by a state machine to respond events by executing an Action with a StateContext.
ActionListener<S,E>	ActionListener for various action events.
ActionRepository<T extends RepositoryAction>	Generic Repository interface for actions.
Actions	Action Utilities.
AnnotatedMethodFilter	A MethodFilter implementation that enables the following: matching on method name, if available exclusion of void-returning methods if 'requiresReply' is true limiting to annotated methods if at least one is present
AnnotationBuilder<O>	Interface for building an Object.
AnnotationConfigurer<O,B extends AnnotationBuilder<O>>	Allows for configuring an AnnotationBuilder.
AnnotationConfigurerAdapter<O,I,B extends AnnotationBuilder<O>>	A base class for AnnotationConfigurer that allows subclasses to only implement the methods they are interested in.
AnnotationConfigurerBuilder<I>	Interface for wrapping a return type from AnnotationConfigurer into AnnotationBuilder.
BaseRepositoryEntity	Generic base class for all entity classes.
BaseStructureVerifier<S,E>	StateMachineModelVerifier which verifies a base model structure like existence of initial states, etc.
BeanFactoryTypeConverter
BootStateMachineMonitor<S,E>	Implementation of a StateMachineMonitor which converts monitoring events and bridges those into supported format handled by Spring Boot's tracing and metrics frameworks.
ChoiceData<S,E>	A simple data object keeping choice related configs in a same place.
ChoicePseudoState<S,E>	Choice implementation of a PseudoState.
ChoicePseudoState.ChoiceStateData<S,E>	Data class wrapping choice State and Guard together.
ChoiceTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring Transition from a choice pseudo state.
CompositeActionListener<S,E>	Implementation of a ActionListener backed by a multiple listeners.
CompositeEnsembleListener<S,E>	Default EnsembleListener dispatcher.
CompositePseudoStateListener<S,E>
CompositeStateListener<S,E>	Composite state listener.
CompositeStateMachineListener<S,E>	Default StateMachineListener dispatcher.
CompositeStateMachineModelVerifier<S,E>	Implementation of a StateMachineModelVerifier backed by a multiple verifiers.
CompositeStateMachineMonitor<S,E>	Implementation of a StateMachineMonitor backed by a multiple monitors.
CompositeTriggerListener	Default TriggerListener dispatcher.
ConfigurationConfigurer<S,E>	Base ConfigConfigurer interface for configuring generic config.
ConfigurationData<S,E>	Configuration object used to keep things together in StateMachineConfigurationBuilder.
DefaultChoiceTransitionConfigurer<S,E>	Default implementation of a ChoiceTransitionConfigurer.
DefaultConfigurationConfigurer<S,E>	Default implementation of a ConfigurationConfigurer.
DefaultDistributedStateMachineConfigurer<S,E>	Default implementation of a DistributedStateMachineConfigurer.
DefaultEntryTransitionConfigurer<S,E>	Default implementation of a EntryTransitionConfigurer.
DefaultEventSecurityExpressionHandler<T>	The default implementation of SecurityExpressionHandler which uses a EventSecurityExpressionRoot.
DefaultExitTransitionConfigurer<S,E>	Default implementation of a ExitTransitionConfigurer.
DefaultExtendedState	Default implementation of a ExtendedState.
DefaultExternalTransition<S,E>
DefaultExternalTransitionConfigurer<S,E>	Default implementation of a ExternalTransitionConfigurer.
DefaultForkTransitionConfigurer<S,E>	Default implementation of a ForkTransitionConfigurer.
DefaultHistoryTransitionConfigurer<S,E>	Default implementation of a HistoryTransitionConfigurer.
DefaultInternalTransition<S,E>
DefaultInternalTransitionConfigurer<S,E>	Default implementation of a InternalTransitionConfigurer.
DefaultJoinTransitionConfigurer<S,E>	Default implementation of a JoinTransitionConfigurer.
DefaultJunctionTransitionConfigurer<S,E>	Default implementation of a JunctionTransitionConfigurer.
DefaultLocalTransition<S,E>
DefaultLocalTransitionConfigurer<S,E>	Default implementation of a LocalTransitionConfigurer.
DefaultModelConfigurer<S,E>	Default implementation of a ModelConfigurer.
DefaultMonitoringConfigurer<S,E>	Default implementation of a MonitoringConfigurer.
DefaultPersistenceConfigurer<S,E>	Default implementation of a PersistenceConfigurer.
DefaultPropertiesConfigurer<O,I,B extends AnnotationBuilder<O>>	AnnotationConfigurer which knows how to handle configuring a Properties.
DefaultPseudoState<S,E>	Default implementation of a PseudoState which is a simple passthrough via AbstractPseudoState.
DefaultPseudoStateContext<S,E>	Default implementation of a PseudoStateContext.
DefaultResourceConfigurer<O,I,B extends AnnotationBuilder<O>>	AnnotationConfigurer which knows how to handle configuring a Resources.
DefaultSecurityConfigurer<S,E>	Default implementation of a SecurityConfigurer.
DefaultStateConfigurer<S,E>	Default implementation of a StateConfigurer.
DefaultStateContext<S,E>	Default implementation of a StateContext.
DefaultStateMachineComponentResolver<S,E>	Default implementation of a StateMachineComponentResolver which resolves from a BeanFactory if given or from a manually registered actions and guards.
DefaultStateMachineContext<S,E>	Default implementation of a StateMachineContext.
DefaultStateMachineEventPublisher	Default implementation of StateMachineEventPublisher.
DefaultStateMachineModel<S,E>	Default implementation of a StateMachineModel.
DefaultStateMachineModelVerifier<S,E>	Default implementation of a StateMachineModelVerifier.
DefaultStateMachinePersister<S,E,T>	Default implementation of a StateMachinePersister.
DefaultStateMachineService<S,E>	Default implementation of a StateMachineService.
DefaultTransitionSecurityExpressionHandler
DefaultTriggerContext<S,E>
DefaultVerifierConfigurer<S,E>	Default implementation of a VerifierConfigurer.
DistributedLeaderAction<S,E>	Action which is used to wrap execution of an Action so that only a StateMachine considered to be a leader in an StateMachineEnsemble will do the execution.
DistributedStateMachine<S,E>	DistributedStateMachine is wrapping a real StateMachine and works together with a StateMachineEnsemble order to provide a distributed state machine.
DistributedStateMachineConfigurer<S,E>	Base DistributedStateMachineConfigurer interface for configuring distributed state machine.
EnableAnnotationConfiguration	Base annotation used in JavaConfig order to enable some base functionality.
EnableStateMachine	Annotation which imports @Configurations related to building state machines.
EnableStateMachineFactory	Annotation which imports @Configurations related to building state machine factories.
EnableWithStateMachine	Annotation which enables features needed for WithStateMachine.
EnsembleListener<S,E>	EnsembleListener for various ensemble events.
EnsembleListenerAdapter<S,E>	Adapter implementation of EnsembleListener implementing all methods which extended implementation can override.
EntryData<S,E>	A simple data object keeping entrypoint related configs in a same place.
EntryPseudoState<S,E>	Entrypoint implementation of a PseudoState.
EntryTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring Transition with an entrypoint pseudo state.
EnumState<S extends Enum<S>,E extends Enum<E>>	A State implementation where state and event is enum based.
EnumStateMachineConfigurerAdapter<S extends Enum<S>,E extends Enum<E>>	Base implementation of a StateMachineConfigurer using enums.
EventExpressionVoter<T>	Voter which handles Message authorisation decisions.
EventHeader	Annotation which indicates that a method parameter should be bound to a event header.
EventHeaders	Annotation which indicates that a method parameter should be bound to the event headers of a message.
EventSecurityExpressionRoot	The SecurityExpressionRoot used for Message expressions.
EventTrigger<S,E>
EventVoter<T>	Votes if any ConfigAttribute.getAttribute() starts with a prefix indicating that it is an event.
ExitData<S,E>	A simple data object keeping exitpoint related configs in a same place.
ExitPseudoState<S,E>	Exitpoint implementation of a PseudoState.
ExitTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring Transition with an exitpoint pseudo state.
ExpressionUtils	Utility class with static methods for helping with establishing environments for SpEL expressions.
ExtendedState	Extended states are used to supplement state machine with a variables.
ExtendedState.ExtendedStateChangeListener	The listener interface for receiving extended state change events.
ExtendedStateVariable
ExternalTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring external Transitions.
FactoryPersistStateMachineHandler<S,E>	FactoryPersistStateMachineHandler is a recipe can be used to handle a state change of an arbitrary entity in a persistent storage.
FixedMethodFilter	A MethodFilter implementation that will always return the same Method instance within a single-element list if it is present in the candidate list.
ForkPseudoState<S,E>	Fork implementation of a PseudoState.
ForkTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring Transition from a fork pseudo state.
GenericPersistStateMachineHandler<S,E>	GenericPersistStateMachineHandler is a recipe which can be used to handle a state change of an arbitrary entity in a persistent storage.
Guard<S,E>	Guards are typically considered as guard conditions which affect the behaviour of a state machine by enabling actions or transitions only when they evaluate to TRUE and disabling them when they evaluate to FALSE.
GuardRepository<T extends RepositoryGuard>	Generic Repository interface for guards.
Guards	Guard Utilities.
HistoryData<S,E>	A simple data object keeping history related configs in a same place.
HistoryPseudoState<S,E>	History implementation of a PseudoState.
HistoryTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring Transition with default history state.
InitialTransition<S,E>	Transition used during a state machine start.
InMemoryStateMachineTraceRepository	In-memory implementation of StateMachineTraceRepository.
InternalTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring internal Transitions.
JoinPseudoState<S,E>	Join implementation of a PseudoState.
JoinPseudoState.JoinStateData<S,E>	Data class wrapping join State and Guard together.
JoinTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring Transition from a join pseudo state.
JpaActionRepository	A ActionRepository interface for JPA used for actions.
JpaGuardRepository	A GuardRepository interface for JPA used for guards.
JpaPersistingStateMachineInterceptor<S,E,T>	JPA implementation of a AbstractPersistingStateMachineInterceptor.
JpaRepositoryAction	JPA entity for actions.
JpaRepositoryGuard	JPA entity for actions.
JpaRepositoryState	JPA entity for states.
JpaRepositoryStateMachine	A RepositoryStateMachine interface for JPA used for states machines.
JpaRepositoryStateMachinePersist<S,E>	JPA based implementation of a RepositoryStateMachinePersist.
JpaRepositoryTransition	JPA entity for transitions.
JpaStateMachineRepository	JPA entity for state machine.
JpaStateRepository	A StateRepository interface for JPA used for states.
JpaTransitionRepository	A StateRepository interface for JPA used for transitions.
JunctionData<S,E>	A simple data object keeping junction related configs in a same place.
JunctionPseudoState<S,E>	Junction implementation of a PseudoState.
JunctionPseudoState.JunctionStateData<S,E>	Data class wrapping choice State and Guard together.
JunctionTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring Transition from a junction pseudo state.
KryoStateMachineSerialisationService<S,E>	Implementation for StateMachineSerialisationService using kryo.
LatchStateMachineListener<S,E>	A StateMachineListener which is used during the tests to assert correct count of listener callbacks.
LatchStateMachineListener.ExtendedStateChangedWrapper
LatchStateMachineListener.StateChangedWrapper<S,E>
LeaderZookeeperStateMachineEnsemble<S,E>	StateMachineEnsemble backed by a zookeeper and leader functionality from a Spring Cloud Cluster.
LifecycleObjectSupport	Convenient base class for object which needs spring task scheduler, task executor and life cycle handling.
LocalTransitionConfigurer<S,E>	TransitionConfigurer interface for configuring local Transitions.
LoggingListener	Simple ApplicationListener which logs all events based on StateMachineEvent using a log level set during the construction.
MalformedConfigurationException	Generic exception indicating ill-formed state machine configuration.
MessageHeadersSerializer	Kryo Serializer for spring messaging message headers.
MethodAnnotationPostProcessor<T extends Annotation>	Strategy interface for post-processing annotated methods.
MethodInvokingStateMachineRuntimeProcessor<T,S,E>	A simple StateMachineRuntimeProcessor implementation using methods from a state machine protected bean.
ModelConfigurer<S,E>	Base ModelConfigurer interface for configuring state machine model.
ModelData<S,E>	Data object used return and build data from a ModelConfigurer.
MongoDbActionRepository	A ActionRepository interface for MongoDb used for actions.
MongoDbGuardRepository	A GuardRepository interface for MongoDb used for guards.
MongoDbPersistingStateMachineInterceptor<S,E,T>	MongoDb implementation of a AbstractPersistingStateMachineInterceptor.
MongoDbRepositoryAction	MongoDb entity for actions.
MongoDbRepositoryGuard	MongoDb entity for actions.
MongoDbRepositoryState	MongoDb entity for states.
MongoDbRepositoryStateMachine	A RepositoryStateMachine interface for Redis used for states machines.
MongoDbRepositoryStateMachinePersist<S,E>	MongoDb based implementation of a RepositoryStateMachinePersist.
MongoDbRepositoryTransition	MongoDb entity for transitions.
MongoDbStateMachineRepository	A StateMachineRepository interface for MongoDb used for states machines.
MongoDbStateRepository	A StateRepository interface for MongoDb used for states.
MongoDbTransitionRepository	A StateRepository interface for MongoDb used for transitions.
MonitoringConfigurer<S,E>	Base MonitoringConfigurer interface for configuring state machine monitoring.
ObjectPostProcessor<T>	Allows initialization of Objects.
ObjectPostProcessorConfiguration	Spring Configuration that exports the default ObjectPostProcessor.
ObjectState<S,E>	A State implementation where state and event is object based.
ObjectStateMachine<S,E>	Specialisation of a StateMachine using objects as its State and event types.
ObjectStateMachineFactory<S,E>	Implementation of a StateMachineFactory which know the actual types of State and StateMachine.
ObservableMap<K,V>	Utility class which wraps Map and notifies ObservableMap.MapChangeListener of changes for individual change operations.
ObservableMap.MapChangeListener<K,V>	The listener interface for receiving map change events.
OnEventNotAccepted	Indicates that a method is candidate to be called when event is not accepted by a state machine.
OnEventNotAcceptedEvent	Generic event representing that a state machine did not accept an event.
OnExtendedStateChanged	Indicates that a method is candidate to be called when ExtendedState is changed.
OnExtendedStateChanged	Generic event representing that extended state variable has been changed.
OnStateChanged	Indicates that a method is candidate to be called when State is changed.
OnStateChangedEvent	Generic event representing that state has been changed.
OnStateEntry	Indicates that a method is candidate to be called when State is entered.
OnStateEntryEvent	Generic event representing that state has been entered.
OnStateExit	Indicates that a method is candidate to be called when State is exited.
OnStateExitEvent	Generic event representing that state has been exited.
OnStateMachineError	Indicates that a method is candidate to be called when state machine has been entered in error it cannot recover.
OnStateMachineError	Generic event representing that state machine has been entered in error it cannot recover.
OnStateMachineStart	Indicates that a method is a candidate to be called when state machine is started.
OnStateMachineStart	Generic event representing that state machine has been started.
OnStateMachineStop	Indicates that a method is a candidate to be called when state machine is stopped.
OnStateMachineStop	Generic event representing that state machine has been stopped or terminated.
OnTransition	Indicates that a method is a candidate to be called with a Transition.
OnTransitionEnd	Indicates that a method is candidate to be called with a Transition.
OnTransitionEndEvent	Event representing that a Transition has ended.
OnTransitionEvent	Event representing that a Transition has happened.
OnTransitionStart	Indicates that a method is candidate to be called with a Transition.
OnTransitionStartEvent	Event representing that a Transition has started.
OrderedComposite<S>	Composite item which can be used in other components which may want to allow automatic and annotation based ordering.
OrderedCompositeItem<S>	Composite item which can be used in other components which may want to allow automatic and annotation based ordering.
PersistenceConfigurer<S,E>	Base PersistenceConfigurer interface for configuring state machine persistence.
PersistStateMachineHandler	PersistStateMachineHandler is a recipe which can be used to handle a state change of an arbitrary entity in a persistent storage.
PersistStateMachineHandler.PersistStateChangeListener
PropertiesConfigurer<I>	Interface for DefaultPropertiesConfigurer which act as intermediate gatekeeper between a user and an AnnotationConfigurer.
PropertiesConfigurerAware	Interface for AnnotationBuilder which wants to be aware of Properties configured by DefaultPropertiesConfigurer.
PseudoState<S,E>	A PseudoState is an abstraction that encompasses different types of transient states or vertices in the state machine.
PseudoStateContext<S,E>	Context object using in PseudoStateListener.
PseudoStateContext.PseudoAction	The PseudoAction enumeration.
PseudoStateKind	Defines enumeration of a PseudoState kind.
PseudoStateListener<S,E>	PseudoStateListener for various pseudo state events.
ReactiveAction<S,E>	Reactive counterpart of a Action being simply a Function of a return type of a Mono.
ReactiveGuard<S,E>	Reactive counterpart of a Guard being simply a Function of a return type of a Mono wrapping Boolean.
ReactiveLifecycleManager
ReactiveLifecycleManager.LifecycleState
ReactiveStateMachineAccess<S,E>	Functional interface exposing reactive StateMachine internals.
ReactiveStateMachineExecutor<S,E>	Default reactive implementation of a StateMachineExecutor.
RedisActionRepository	A ActionRepository interface for Redis used for actions.
RedisGuardRepository	A GuardRepository interface for Redis used for guards.
RedisPersistingStateMachineInterceptor<S,E,T>	JPA implementation of a AbstractPersistingStateMachineInterceptor.
RedisRepositoryAction	Redis entity for actions.
RedisRepositoryGuard	Redis entity for actions.
RedisRepositoryState	Redis entity for states.
RedisRepositoryStateMachine	A RepositoryStateMachine interface for Redis used for states machines.
RedisRepositoryStateMachinePersist<S,E>	Redis based implementation of a RepositoryStateMachinePersist.
RedisRepositoryTransition	Redis entity for transitions.
RedisStateMachineContextRepository<S,E>	A StateMachineContextRepository backed by a redis and kryo serialization.
RedisStateMachinePersister<S,E>	Implementation of a StateMachinePersister to be used with a redis.
RedisStateMachineRepository	A StateMachineRepository interface for Redis used for states machines.
RedisStateRepository	A StateRepository interface for Redis used for states.
RedisTransitionRepository	A StateRepository interface for Redis used for transitions.
Region<S,E>	A region is an orthogonal part of either a composite state or a state machine.
RegionExecutionPolicy	Enumerations for possible region execution policies.
RegionState<S,E>	A State implementation where states are wrapped in a regions..
RepositoryAction	Generic base class representing action entity.
RepositoryGuard	Generic base class representing guard entity.
RepositoryState	Generic base class representing state entity.
RepositoryStateMachine	Generic base class representing state machine entity.
RepositoryStateMachineModelFactory	A generic StateMachineModelFactory which is backed by a Spring Data Repository abstraction.
RepositoryStateMachinePersist<M extends RepositoryStateMachine,S,E>	Base implementation of a StateMachinePersist using Spring Data Repositories.
RepositoryStateMachinePersist<S,E>	A StateMachinePersist using a generic StateMachineContextRepository for persisting StateMachineContext.
RepositoryTransition	Generic base class representing transition entity.
ResourceConfigurer<I>	Interface for DefaultResourceConfigurer which act as intermediate gatekeeper between a user and an AnnotationConfigurer.
ResourceConfigurerAware	Interface for AnnotationBuilder which wants to be aware of Resources configured by DefaultResourceConfigurer.
RunnableAction	A Action which executes a Runnable.
SecurityConfigurer<S,E>	Base ConfigConfigurer interface for configuring generic config.
SecurityRule	Encapsulates the rules for comparing security attributes and expression.
SecurityRule.ComparisonType	Security comparison types.
SpelExpressionAction<S,E>	Action which uses Spring SpEL expression for action execution.
SpelExpressionGuard<S,E>	Guard which uses Spring SpEL expression for condition evaluation.
State<S,E>	State is an interface representing possible state in a state machine.
StateConfigurer<S,E>	Base StateConfigurer interface for configuring States.
StateConfigurer.History	Enumeration of a possible history pseudostate type.
StateContext<S,E>	StateContext is representing of a current context used in various stages in a state machine execution.
StateContext.Stage	Enumeration of possible stages context is attached.
StateContextAssert	Assertions applicable to a StateContext.
StateContextExpressionMethods	Helper class to work with a spel expressions and StateContext.
StateData<S,E>	StateData is a data representation of a State used as an abstraction between a StateMachineFactory and a state machine configuration.
StateDoActionPolicy	Enumerations for possible state do action policies.
StateHolder<S,E>	Utility class using holder pattern to keep a State reference.
StateListener<S,E>	StateListener for various state events.
StateListenerAdapter<S,E>	Adapter implementation of StateListener implementing all methods which extended implementation can override.
StateMachine<S,E>	StateMachine provides an APIs for generic finite state machine needed for basic operations like working with states, events and a lifecycle.
StateMachineAccess<S,E>	Functional interface exposing StateMachine internals.
StateMachineAccessor<S,E>	Functional interface for StateMachine to allow more programmatic access to underlying functionality.
StateMachineActivatorAnnotationPostProcessor<T extends Annotation>
StateMachineAnnotationPostProcessor	A BeanPostProcessor implementation that processes method-level annotations such as OnTransition.
StateMachineAnnotationPostProcessorConfiguration	Configuration for annotation post processor which is needed i.e.
StateMachineAssert	Assertions applicable to a StateMachine.
StateMachineAsserts	Entry point for all assertj definitions for a StateMachine.
StateMachineAutoConfiguration	Auto-configuration for Spring Statemachine.
StateMachineAutoConfiguration.StateMachineMonitoringConfiguration
StateMachineAutoConfiguration.StateMachineTraceEndpointConfiguration
StateMachineAutoConfiguration.StateMachineTraceRepositoryConfiguration
StateMachineBuilder	StateMachineBuilder provides a builder pattern for StateMachine using a similar concepts found from a normal annotation based configuration.
StateMachineBuilder.Builder<S,E>	Builder implementation handling logic of building a StateMachine manually.
StateMachineCommonConfiguration	Common configuration for statemachine.
StateMachineComponentResolver<S,E>	Strategy interface for resolving state machine components by their id's.
StateMachineConfig<S,E>	Generic pojo keeping relates configs together.
StateMachineConfigBuilder<S,E>	AnnotationBuilder handling all shared builders which effectively contructs full configuration for StateMachineConfig.
StateMachineConfiguration<S,E>	Configuration which gets imported from EnableStateMachine and registers a StateMachine build from a StateMachineConfigurerAdapter via a BeanDefinition.
StateMachineConfigurationBuilder<S,E>	AnnotationBuilder for StatesData.
StateMachineConfigurationConfigurer<S,E>	Configurer interface exposing generic config.
StateMachineConfigurationImportSelector	Spring ImportSelector choosing appropriate Configuration based on EnableStateMachine or EnableStateMachineFactory annotations.
StateMachineConfigurer<S,E>	AnnotationConfigurer exposing configurers for states and transitions.
StateMachineConfigurerAdapter<S,E>	Base implementation of a StateMachineConfigurer using objects.
StateMachineContext<S,E>	StateMachineContext represents a current state of a state machine.
StateMachineContextRepository<S,E,T extends StateMachineContext<S,E>>	Repository interface for saving and retrieving StateMachineContext objects.
StateMachineContextSerializer<S,E>	Kryo Serializer for StateMachineContext.
StateMachineContextUtils	Utility methods for accessing common components from the BeanFactory.
StateMachineEnsemble<S,E>	StateMachineEnsemble is a contract between a StateMachine and arbitrary ensemble of other StateMachines.
StateMachineEnsembleException	General exception indicating a problem in ensemble.
StateMachineEnsembleObjectSupport<S,E>	Support class for implementing StateMachineEnsembles.
StateMachineEvent	Base ApplicationEvent class for leader based events.
StateMachineEventPublisher	Interface for publishing state machine based application events.
StateMachineEventPublisherConfiguration	Configuration for common StateMachineEventPublisher.
StateMachineEventResult<S,E>	Interface defining a result for sending an event to a statemachine.
StateMachineEventResult.DefaultStateMachineEventResult<S,E>
StateMachineEventResult.ResultType	Enumeration of a result type indicating whether a region accepted, denied or deferred an event.
StateMachineEventResultAssert	Assertions applicable to a StateMachineEventResult.
StateMachineException	General exception indicating a problem in interacting with statemachine.
StateMachineExecutor<S,E>	Interface for a StateMachine event executor.
StateMachineExecutor.ExecutorExceptionHolder
StateMachineExecutor.MonoSinkStateMachineExecutorCallback
StateMachineExecutor.StateMachineExecutorCallback	Completion callback to notify back complete or error.
StateMachineExecutor.StateMachineExecutorTransit<S,E>	Callback interface when executor wants to handle transit.
StateMachineFactory<S,E>	StateMachineFactory is a strategy interface building StateMachines.
StateMachineFactoryConfiguration<S,E>	Configuration which gets imported from EnableStateMachineFactory and registers a StateMachineFactory build from a StateMachineConfigurerAdapter via a BeanDefinition.
StateMachineHandler<T extends Annotation,S,E>	Handler for a common object representing something to be run.
StateMachineHandlerApplicationListener	Spring ApplicationListener which hooks to ContextRefreshedEvent and tracks when was a last time context was refreshed.
StateMachineHandlerCallHelper<S,E>	Helper class which is used from a StateMachineObjectSupport to ease handling of StateMachineHandlers and provides needed caching so that a runtime calls are fast.
StateMachineInterceptor<S,E>	Interface which can be registered with a state machine and can be used to intercept and break a state change chain.
StateMachineInterceptorAdapter<S,E>	Adapter helper implementation for StateMachineInterceptor.
StateMachineInterceptorList<S,E>	Support class working with a StateMachineInterceptors.
StateMachineJackson2RepositoryPopulatorFactoryBean	FactoryBean to set up a ResourceReaderRepositoryPopulator with a StateMachineJackson2ResourceReader.
StateMachineJackson2ResourceReader	A ResourceReader using Jackson to read JSON into objects.
StateMachineJpaRepositoriesAutoConfiguration	Auto-configuration for JPA repositories and Entity classes.
StateMachineListener<S,E>	StateMachineListener for various state machine events.
StateMachineListenerAdapter<S,E>	Adapter implementation of StateMachineListener implementing all methods which extended implementation can override.
StateMachineMessageHeaders	Reserved Message headers used in StateMachine events.
StateMachineMethodInvokerHelper<T,S,E>	A helper class using spel to execute target methods.
StateMachineMethodInvokerHelper.ParametersWrapper<SS,EE>	Wrapping everything we need to work with spel.
StateMachineModel<S,E>	Base abstract SPI class for state machine configuration.
StateMachineModelBuilder<S,E>	AnnotationBuilder for ModelData.
StateMachineModelConfigurer<S,E>	Configurer interface exposing model.
StateMachineModelFactory<S,E>	A generic builder interface for building StateMachineModels.
StateMachineModelVerifier<S,E>	Strategy interface for implementations verifying StateMachineModel structures.
StateMachineMongoDbRepositoriesAutoConfiguration	Auto-configuration for MongoDb repositories and Entity classes.
StateMachineMonitor<S,E>	StateMachineMonitor for various state machine monitoring events.
StateMachineObjectSupport<S,E>	Support and helper class for base state machine implementation.
StateMachinePersist<S,E,T>	StateMachinePersist is an interface handling serialization logic of a StateMachineContext.
StateMachinePersister<S,E,T>	Interface persisting and restoring a StateMachine from a persistent storage.
StateMachineProperties	Spring Boot ConfigurationProperties for spring.statemachine.
StateMachineProperties.StateMachineMonitoringProperties	Config props for "spring.statemachine.monitor".
StateMachineReactiveLifecycle	Reactive equivalent of a Lifecycle.
StateMachineRedisRepositoriesAutoConfiguration	Auto-configuration for Redis repositories and Entity classes.
StateMachineRepository<M extends RepositoryStateMachine>	Generic Repository interface for states machines.
StateMachineRuntime<S,E>	A generic runtime representation of a state machine.
StateMachineRuntimePersister<S,E,T>	Interface defining a runtime persistence of a StateMachine.
StateMachineRuntimeProcessor<T,S,E>	Defines a strategy of processing a state machine and returning some Object (or null).
StateMachineSecurityConfigurer<S,E>	Configurer interface exposing generic config.
StateMachineSecurityInterceptor<S,E>	StateMachineInterceptor which can be registered into a StateMachine order to intercept a various security related checks.
StateMachineSerialisationService<S,E>	Generic interface to handle serialisation in a state machine.
StateMachineService<S,E>	Service class helping to persist and restore StateMachines in a runtime environment.
StateMachineState<S,E>	A State implementation where state is wrapped in a substatemachine.
StateMachineStateBuilder<S,E>	AnnotationBuilder for StatesData.
StateMachineStateConfigurer<S,E>	Configurer interface exposing states.
StateMachineSystemConstants	Various constants used in state machine lib.
StateMachineTestPlan<S,E>	StateMachineTestPlan is fully constructed plan how a StateMachine should be tested.
StateMachineTestPlanBuilder<S,E>	A builder for StateMachineTestPlan.
StateMachineTrace	A value object representing a statemachine trace event: at a particular time with a simple (map) information.
StateMachineTraceEndpoint	Endpoint to expose StateMachineTrace information.
StateMachineTraceRepository	A repository for StateMachineTraces.
StateMachineTransitionBuilder<S,E>	AnnotationBuilder for TransitionsData.
StateMachineTransitionConfigurer<S,E>	Configurer interface exposing different type of transitions.
StateMachineUtils	Various utility methods for state machine.
StateRepository<S extends RepositoryState>	Generic Repository interface for states.
StatesData<S,E>	Data object used return and build data from a StateConfigurer.
TasksHandler	TasksHandler is a recipe for executing arbitrary Runnable tasks using a state machine logic.
TasksHandler.Builder	Builder pattern implementation building a TasksHandler.
TasksHandler.TasksListener	TasksListener is a generic interface listening tasks execution events.
TasksHandler.TasksListenerAdapter	Adapter class for TasksHandler.TasksListener.
TestUtils	Utils for tests.
TimerTrigger<S,E>	Implementation of a Trigger capable of firing on a static periods.
Transition<S,E>	Transition is something what a state machine associates with a state changes.
TransitionConfigurer<T,S,E>	Base TransitionConfigurer interface for configuring Transitions.
TransitionConflictPolicy	Enumerations for possible transition conflict policies.
TransitionData<S,E>	A simple data object keeping transition related configs in a same place.
TransitionEvent	Generic base event representing something with a Transition.
TransitionExpressionConfigAttribute	Specific ConfigAttribute for spel expression.
TransitionExpressionVoter	AccessDecisionVoter evaluating access via security spel expression.
TransitionKind	Defines enumeration of a Transition kind.
TransitionRepository<T extends RepositoryTransition>	Generic Repository interface for transitions.
TransitionsData<S,E>	Data object for transitions.
TransitionSecurityExpressionRoot	Root object for security spel evaluation.
TransitionVoter<S,E>	Votes if any ConfigAttribute.getAttribute() starts with a prefix indicating that it is a transition source or target.
Tree<T>	Utility class which can be used to represent a tree based data structure.
Tree.Node<T>
TreeTraverser<T>
Trigger<S,E>	Trigger is the cause of the Transition.
TriggerContext<S,E>
TriggerListener	TriggerListener for listening a Trigger events.
UmlModelParser	Model parser which constructs states and transitions data out from an uml model.
UmlStateMachineModelFactory	StateMachineModelFactory which builds StateMachineModel from uml representation.
UmlUtils	Utilities for uml model processing.
UniqueMethodFilter	A ReflectionUtils.MethodFilter implementation that will match unique methods.
UUIDSerializer	Kryo Serializer for UUID.
VerifierConfigurer<S,E>	Base ConfigConfigurer interface for configuring state machine model verifier.
WithStateMachine	Annotation which is marking a bean to be a candidate for participating with a state machine events.
ZookeeperStateMachineEnsemble<S,E>	StateMachineEnsemble backed by a zookeeper.
ZookeeperStateMachinePersist<S,E>	StateMachinePersist using zookeeper as a storage and kroy libraries as a backing serialization technique.