Transform the event to another type before giving to the journal. Can be used to wrap events in types Journals understand but is of a different type than Event.

Back off strategy for persist failures.

Specifically BackOff to prevent resume being used. Resume is not allowed as it will be unknown if the event has been persisted.

This supervision is only around the event sourced behavior not any outer setup/withTimers block. If using restart, any actions e.g. scheduling timers, can be done on the PreRestart

If not specified the actor will be stopped on failure.

Allows the event sourced behavior to react on signals.

The regular lifecycle signals can be handled as well as Pekko Persistence specific signals (snapshot and recovery related). Those are all subtypes of pekko.persistence.typed.EventSourcedSignal

Transform the state to another type before giving to the journal. Can be used to transform older state types into the current state type e.g. when migrating from Persistent FSM to Typed EventSourcedBehavior.

Initiates a snapshot if the given predicate evaluates to true.

Decide to store a snapshot based on the State, Event and sequenceNr when the event has been successfully persisted.

When persisting multiple events at once the snapshot is triggered after all the events have been persisted.

Snapshots triggered by snapshotWhen will not trigger deletes of old snapshots and events if EventSourcedBehavior.withRetention with RetentionCriteria.snapshotEvery is used together with snapshotWhen. Such deletes are only triggered by snapshots matching the numberOfEvents in the RetentionCriteria.

Publish events to the system event stream as pekko.persistence.typed.PublishedEvent after they have been persisted

Change the recovery strategy. By default, snapshots and events are recovered.

Criteria for retention/deletion of snapshots and events. By default, retention is disabled and snapshots are not saved and deleted automatically.

Changes the snapshot selection criteria used by this behavior. By default the most recent snapshot is used, and the remaining state updates are recovered by replaying events from the sequence number up until which the snapshot reached.

You may configure the behavior to skip replaying snapshots completely, in which case the recovery will be performed by replaying all events -- which may take a long time.

Narrow the type of this Behavior, which is always a safe operation. This method is necessary to implement the contravariant nature of Behavior (which cannot be expressed directly due to type inference problems).

Transform the incoming messages by placing a funnel in front of the wrapped Behavior: the supplied PartialFunction decides which message to pull in (those that it is defined at) and may transform the incoming message to place them into the wrapped Behavior’s type hierarchy. Signals are not transformed.

Example:

val b: Behavior[Number] =
  Behaviors
    .receive[String] { (ctx, msg) =>
      println(msg)
      Behaviors.same
    }
    .transformMessages[Number] {
      case b: BigDecimal => s"BigDecimal($b)"
      case i: BigInt     => s"BigInteger($i)"
      // all other kinds of Number will be `unhandled`
    }

The ClassTag for Outer ensures that only messages of this class or a subclass thereof will be intercepted. Other message types (e.g. a private protocol) will bypass the interceptor and be continue to the inner behavior untouched.