dogma

type AggregateCommandScope interface {
	HandlerScope

	// InstanceID returns the ID of the aggregate instance that the [Command]
	// targets, as returned by [AggregateMessageHandler].RouteCommandToInstance.
	InstanceID() string

	// RecordEvent records an [Event] that results from handling the [Command].
	//
	// It applies the event to the aggregate root by calling
	// [AggregateRoot].ApplyEvent, making the state changes visible to the
	// handler immediately.
	//
	// The engine persists all events recorded within this scope in a single
	// atomic operation after the [AggregateMessageHandler] finishes handling
	// the inbound command.
	RecordEvent(Event)
}

type AggregateConfigurer interface {
	HandlerConfigurer

	// Routes declares the message types that the handler consumes and produces.
	//
	// It accepts routes created by [HandlesCommand] and [RecordsEvent].
	Routes(...AggregateRoute)
}

type AggregateHandlerRoute struct {
	// contains filtered or unexported fields
}

type AggregateMessageHandler interface {
	// Configure declares the handler's configuration by calling methods on c.
	//
	// The configuration includes the handler's identity and message routes.
	//
	// The engine calls this method at least once during startup. It must
	// produce the same configuration each time it's called.
	Configure(c AggregateConfigurer)

	// New returns a new [AggregateRoot] representing the initial state of an
	// aggregate instance.
	//
	// The engine calls this method to get a "blank slate" when handling the
	// first [Command] for a new instance or when reconstructing an existing
	// instance from its historical [Event] messages.
	New() AggregateRoot

	// RouteCommandToInstance returns the ID of the aggregate instance that c
	// targets.
	//
	// The return value must be a non-empty string that uniquely identifies the
	// target instance. For example, in a shopping cart aggregate, the instance
	// ID might be the customer's ID. RFC 9562 UUIDs are the recommended format.
	//
	// Commands routed to the same instance operate on the same state. There's
	// no need to create an instance in advance - it "exists" once the handler
	// records an [Event] against it.
	//
	// The engine calls this method before handling the [Command]. The
	// implementation must derive the ID from information within c.
	RouteCommandToInstance(c Command) string

	// HandleCommand updates an aggregate instance's state by recording [Event]
	// messages that represent the effects of a [Command].
	//
	// r is the [AggregateRoot] for the instance that the command targets, as
	// determined by [AggregateMessageHandler].RouteCommandToInstance. It
	// reflects the state of the targeted instance after applying its historical
	// events.
	//
	// The implementation must not cause external side-effects or modify r
	// directly. Logic must depend only on information within r, s, and c.
	//
	// The engine atomically persists the events recorded by exactly one
	// successful invocation of this method for each command message. It doesn't
	// guarantee the order, number, or concurrency of those attempts. The
	// implementation doesn't need to perform any synchronization or idempotency
	// checks.
	HandleCommand(
		r AggregateRoot,
		s AggregateCommandScope,
		c Command,
	)
}

type AggregateRoot interface {
	// ApplyEvent updates the aggregate instance to reflect the occurrence of an
	// event.
	//
	// The engine calls this method when loading the instance from historical
	// events or recording a new event. It must handle all historical event
	// types, including those no longer routed to this aggregate.
	ApplyEvent(Event)

	// MarshalBinary returns a binary representation of the aggregate instance's
	// current state suitable for use as a snapshot.
	//
	// Snapshots are an optimization that reduces the number of events applied
	// when loading an aggregate instance from its event history. Aggregates
	// that produce few events over their instances' lifetime may omit snapshot
	// support by embedding [NoSnapshotBehavior] or returning [ErrNotSupported].
	MarshalBinary() ([]byte, error)

	// UnmarshalBinary populates the aggregate instance's state from its binary
	// representation.
	//
	// The implementation must clone the data if it is used after returning.
	UnmarshalBinary(data []byte) error
}

type AggregateRoute interface {
	MessageRoute
	// contains filtered or unexported methods
}

type Application interface {
	// Configure declares the application's configuration by calling methods on
	// c.
	//
	// The configuration includes the application's identity and handler routes.
	//
	// The engine calls this method at least once during startup. It must
	// produce the same configuration each time it's called.
	Configure(c ApplicationConfigurer)
}

type ApplicationConfigurer interface {
	// Identity sets the application's unique identity.
	//
	// n is a short human-readable name displayed wherever the application's
	// identity appears, such as in logs and telemetry signals. The value must
	// be between 1 and 255 bytes in length, and contain only printable,
	// non-space UTF-8 characters. Changing the handler's name doesn't affect
	// its behavior.
	//
	// k is a key that uniquely identifies the application. The engine uses the
	// key to associate application state with the correct application instance
	// - it must not change. The value must be a canonical RFC 9562 UUID string,
	// such as "5195fe85-eb3f-4121-84b0-be72cbc5722f", and is case-insensitive.
	Identity(n, k string)

	// Routes adds handler routes that associate message types with handlers.
	//
	// It accepts routes created by [ViaAggregate], [ViaProcess],
	// [ViaIntegration], and [ViaProjection].
	//
	// The application doesn't declare routes for message types directly; it
	// inherits routes from the handlers it contains.
	Routes(...HandlerRoute)
}

type Command interface {
	Message

	// Validate returns a non-nil error if the message isn't well-formed.
	//
	// A command is well-formed if all required information is present and
	// correctly encoded such that it represents a valid action that the
	// application can perform, if current state permits.
	//
	// The [CommandValidationScope] argument exists for forward-compatibility;
	// the interface is currently empty.
	Validate(CommandValidationScope) error
}

type CommandExecutor interface {
	// ExecuteCommand submits a [Command] for execution.
	//
	// It returns once the engine has taken ownership of the command. It doesn't
	// wait for handling to finish.
	//
	// The engine may invoke the command's handler more than once, but the
	// command's side-effects, such as the events it produces, occur exactly
	// once.
	//
	// If it returns a non-nil error, the engine may not have taken ownership of
	// message delivery, and the application should retry execution.
	//
	// See [WithIdempotencyKey].
	ExecuteCommand(context.Context, Command, ...ExecuteCommandOption) error
}

type CommandValidationScope interface {
	MessageValidationScope

	// ExecutedAt returns the time at which the application submitted the
	// command for execution by calling ExecuteCommand() on a [CommandExecutor]
	// or [ProcessScope].
	ExecutedAt() time.Time
}

type ConcurrencyPreference int

type DisableOption interface {
	// contains filtered or unexported methods
}

type Event interface {
	Message

	// Validate returns a non-nil error if the message isn't well-formed.
	//
	// An event is well-formed if all required information is present and
	// correctly encoded such that it accurately represents an action that can
	// occur within the application.
	//
	// Validation requirements may change over time. Use the
	// [EventValidationScope] to access context that may affect the strictness
	// or criteria of the validation logic.
	Validate(EventValidationScope) error
}

type EventValidationScope interface {
	MessageValidationScope

	// RecordedAt returns the time at which the event occurred.
	RecordedAt() time.Time
}

type ExecuteCommandOption interface {
	// contains filtered or unexported methods
}

type ExecutesCommandOption interface {
	// contains filtered or unexported methods
}

type ExecutesCommandRoute struct {
	// contains filtered or unexported fields
}

type HandlerConfigurer interface {
	// Identity sets the handler's unique identity.
	//
	// n is a short human-readable name displayed wherever the handler's
	// identity appears, such as in logs and telemetry signals. The value must
	// be between 1 and 255 bytes in length, and contain only printable,
	// non-space UTF-8 characters. Changing the handler's name doesn't affect
	// its behavior. Each handler within an application must have a unique name.
	//
	// k is a key that uniquely identifies the handler. The engine uses the key
	// to associate handler state with the correct handler instance - it must
	// not change. The value must be a canonical RFC 9562 UUID string, such as
	// "3a6da031-aa6c-406a-8453-73762f71f917", and is case-insensitive.
	Identity(n string, k string)

	// Disable excludes the handler from the application's runtime without
	// removing it from the application's configuration.
	//
	// Disabling a handler is appropriate when it cannot function in the current
	// execution environment but should still be present for documentation,
	// static analysis, and route discovery purposes.
	//
	// Prefer conditionally disabling a handler over conditionally adding it to
	// the application.
	Disable(...DisableOption)
}

type HandlerRoute interface {
	// contains filtered or unexported methods
}

type HandlerScope interface {
	// Now returns the current local time according to the engine.
	//
	// Use this method in preference to [time.Now]; its return value may differ
	// in certain situations, such as when executing tests or when compensating
	// for clock skew in a distributed system.
	Now() time.Time

	// Log records an informational message using [fmt.Printf]-style formatting.
	//
	// The message should be clear and relevant to developers and non-technical
	// stakeholders familiar with the application's domain. It's not intended
	// for display to end users.
	//
	// Use lowercase sentences with no trailing punctuation and omit sensitive
	// information.
	//
	// Use this method to explain conditions or decisions that aren't captured
	// in a [Message]. For example, if a handler receives a command to cancel a
	// shopping cart order after shipping, it might log “cannot cancel order
	// #49412, it has already shipped”.
	Log(format string, args ...any)
}

type HandlesCommandOption interface {
	// contains filtered or unexported methods
}

type HandlesCommandRoute struct {
	// contains filtered or unexported fields
}

type HandlesEventOption interface {
	// contains filtered or unexported methods
}

type HandlesEventRoute struct {
	// contains filtered or unexported fields
}

type IdempotencyKeyOption struct {
	// contains filtered or unexported fields
}

type IntegrationCommandScope interface {
	HandlerScope

	// RecordEvent records an [Event] that results from handling the [Command].
	//
	// The engine persists all events recorded within this scope in a single
	// atomic operation after the [IntegrationMessageHandler] finishes handling
	// the inbound command. If the handler returns a non-nil error, the engine
	// discards the events.
	RecordEvent(Event)
}

type IntegrationConfigurer interface {
	HandlerConfigurer

	// Routes declares the message types that the handler consumes and produces.
	//
	// It accepts routes created by [HandlesCommand] and [RecordsEvent].
	Routes(...IntegrationRoute)

	// ConcurrencyPreference provides a hint to the engine as to the best way to
	// handle concurrent messages for this handler.
	//
	// The default is [MaximizeConcurrency].
	ConcurrencyPreference(ConcurrencyPreference)
}

type IntegrationHandlerRoute struct {
	// contains filtered or unexported fields
}

type IntegrationMessageHandler interface {
	// Configure declares the handler's configuration by calling methods on c.
	//
	// The configuration includes the handler's identity and message routes.
	//
	// The engine calls this method at least once during startup. It must
	// produce the same configuration each time it's called.
	Configure(c IntegrationConfigurer)

	// HandleCommand handles a [Command] message by performing an action outside
	// the Dogma application.
	//
	// It may cause side-effects in external systems, such as invoking a
	// third-party API. It may use s to record one or more [Event] messages that
	// describe the outcome.
	//
	// The engine atomically persists the events recorded by exactly one
	// successful invocation of this method for each command message. It doesn't
	// guarantee the order, number, or concurrency of those attempts. The
	// implementation must ensure that the command's external side-effects are
	// idempotent and safe for concurrent execution.
	HandleCommand(
		ctx context.Context,
		s IntegrationCommandScope,
		c Command,
	) error
}

type IntegrationRoute interface {
	MessageRoute
	// contains filtered or unexported methods
}

type Message interface {
	// MessageDescription returns a concise human-readable explanation of the
	// message's meaning for use in contexts such as logging and telemetry.
	//
	// The description should be clear and relevant to developers and
	// non-technical stakeholders familiar with the application's domain. It's
	// not intended for display to end users.
	//
	// Use lowercase sentences with no trailing punctuation. Omit sensitive
	// information and overly specific details that don't alter the message's
	// intent.
	//
	// Descriptions of [Command] messages should use present-continuous tense.
	// For example: "adding 10 widgets to Alex's shopping cart".
	//
	// Descriptions of [Event] messages should use past tense. For example:
	// "added 10 widgets to Alex's shopping cart".
	//
	// Descriptions of [Timeout] messages should read as though the timeout has
	// just elapsed. For example: "Alex's cart is now inactive" or "24 hours
	// elapsed since first item added to Alex's cart".
	//
	// Be wary of assuming a specific actor if the message doesn't explicitly
	// encode that information. For example, prefer "Alex's purchase completed"
	// over "Alex completed their purchase". This guidance is especially
	// relevant to [Event] messages, where each type should represent a specific
	// state change regardless of who initiated it.
	MessageDescription() string

	// MarshalBinary returns the message's binary representation, suitable for
	// persistence or transmission over the network.
	MarshalBinary() ([]byte, error)

	// UnmarshalBinary populates the message from its binary representation.
	//
	// The implementation must clone the data if it is used after returning.
	UnmarshalBinary([]byte) error
}

type MessageRoute interface {
	Type() RegisteredMessageType
	// contains filtered or unexported methods
}

type MessageValidationScope interface {
	// IsNew returns true when a handler or [CommandExecutor] is creating a new
	// message, or false when the engine is re-validating a message that it has
	// already accepted.
	//
	// Use the distinction to apply different validation rules for new messages
	// versus existing messages while keeping all validation logic in one
	// location.
	IsNew() bool
}

type NoCompactBehavior struct{}

type NoResetBehavior struct{}

type NoSnapshotBehavior struct{}

type NoTimeoutMessagesBehavior struct{}

type ProcessConfigurer interface {
	HandlerConfigurer

	// Routes declares the message types that the handler consumes and produces.
	//
	// It accepts routes created by [HandlesEvent], [ExecutesCommand], and
	// [SchedulesTimeout].
	Routes(...ProcessRoute)
}

type ProcessEventScope interface {
	ProcessScope

	// RecordedAt returns the time at which the inbound [Event] occurred.
	RecordedAt() time.Time
}

type ProcessHandlerRoute struct {
	// contains filtered or unexported fields
}

type ProcessMessageHandler interface {
	// Configure declares the handler's configuration by calling methods on c.
	//
	// The configuration includes the handler's identity and message routes.
	//
	// The engine calls this method at least once during startup. It must
	// produce the same configuration each time it's called.
	Configure(c ProcessConfigurer)

	// New returns a new [ProcessRoot] representing the initial state of a
	// process instance.
	//
	// The engine calls this method to get a "blank slate" when handling the
	// first [Event] for a new instance. Unlike aggregates, the engine doesn't
	// reconstruct process state from historical events.
	//
	// Not all processes maintain state. Embed [StatelessProcessBehavior] in the
	// handler implementation to indicate that the process is stateless.
	New() ProcessRoot

	// RouteEventToInstance returns the ID of the process instance that e
	// targets.
	//
	// If ok is false, the handler ignores the event. Otherwise, the returned ID
	// must be a non-empty string that uniquely identifies the target instance.
	// For example, in a shopping cart checkout process, the instance ID might
	// be the customer's ID. RFC 9562 UUIDs are the recommended format.
	//
	// Events routed to the same instance operate on the same state. There's no
	// need to create an instance in advance - it "exists" once the handler
	// modifies its [ProcessRoot], executes a [Command], or schedules a
	// [Timeout] against it.
	//
	// The engine calls this method before handling the [Event]. The
	// implementation may query external data - such as the application's
	// projections - but this isn't recommended. Wherever possible, it should
	// derive the ID from information within e.
	//
	// If the process instance identified by the returned ID has ended, the
	// engine ignores the event.
	RouteEventToInstance(
		ctx context.Context,
		e Event,
	) (id string, ok bool, err error)

	// HandleEvent begins or advances a process in response to an [Event]
	// message.
	//
	// r is the [ProcessRoot] for the instance that the event targets, as
	// determined by [ProcessMessageHandler].RouteEventToInstance. It reflects
	// the state of the targeted instance after handling any prior [Event] or
	// [Timeout] messages.
	//
	// The implementation may update r directly, execute [Command] messages,
	// schedule [Timeout] messages, or end the process. It may query external
	// data - such as the application's projections - but this isn't
	// recommended. Wherever possible, logic should depend solely on information
	// within r, s, and e.
	//
	// The engine atomically persists the state changes, events, and timeouts
	// produced by exactly one successful invocation of this method for each
	// event message. It doesn't guarantee the order, number, or concurrency of
	// those attempts. Generally, the implementation doesn't need to perform any
	// synchronization or idempotency checks.
	//
	// The engine delivers all [Event] messages recorded within a single scope
	// in the order they occurred. It also preserves the order of events from a
	// single aggregate instance, even across scopes. It doesn't guarantee the
	// relative delivery order of events from different handlers or aggregate
	// instances.
	HandleEvent(
		ctx context.Context,
		r ProcessRoot,
		s ProcessEventScope,
		e Event,
	) error

	// HandleTimeout advances a process in response to a [Timeout] message.
	//
	// r is the [ProcessRoot] for the instance that scheduled the timeout. It
	// reflects the state of the targeted instance after handling any prior
	// [Event] or [Timeout] messages.
	//
	// The implementation may update r directly, execute [Command] messages,
	// schedule [Timeout] messages, or end the process. It may query external
	// data - such as the application's projections - but this isn't
	// recommended. Wherever possible, logic should depend solely on information
	// within r, s, and t.
	//
	// The engine atomically persists the state changes, events, and timeouts
	// produced by exactly one successful invocation of this method for each
	// timeout message. It doesn't guarantee the order, number, or concurrency
	// of those attempts. Generally, the implementation doesn't need to perform
	// any synchronization or idempotency checks.
	//
	// The engine attempts to deliver timeout messages at their scheduled time.
	// It may deliver them later when recovering from downtime or retrying after
	// a failure. It doesn't guarantee the relative delivery order of timeout
	// messages with the same scheduled time.
	//
	// Not all processes use timeouts. Embed [NoTimeoutMessagesBehavior] in the
	// handler implementation to indicate that timeout messages aren't used.
	HandleTimeout(
		ctx context.Context,
		r ProcessRoot,
		s ProcessTimeoutScope,
		t Timeout,
	) error
}

type ProcessRoot interface {
	// MarshalBinary returns a binary representation of the process instsance's
	// current state.
	MarshalBinary() ([]byte, error)

	// UnmarshalBinary populates the process instance's state from its binary
	// representation.
	//
	// The implementation must clone the data if it is used after returning.
	UnmarshalBinary(data []byte) error
}

type ProcessRoute interface {
	MessageRoute
	// contains filtered or unexported methods
}

type ProcessScope interface {
	HandlerScope

	// InstanceID returns the ID of the process instance that the message
	// targets.
	//
	// When handling an [Event] message, it returns the ID produced by
	// [ProcessMessageHandler].RouteEventToInstance during routing.
	//
	// When handling a [Timeout] message, it returns the ID of the instance that
	// scheduled the timeout.
	InstanceID() string

	// End signals the end of a process.
	//
	// The engine discards the instance's state, cancels any pending [Timeout]
	// messages. It ignores any future messages that target the ended instance.
	End()

	// ExecuteCommand submits a [Command] for execution.
	//
	// The engine persists all commands and timeouts produced within this scope
	// in a single atomic operation after the [ProcessMessageHandler] finishes
	// handling the inbound message. If the handler returns a non-nil error, the
	// engine discards the messages.
	//
	// This method panics if the process instance has ended.
	ExecuteCommand(Command)

	// ScheduleTimeout schedules a [Timeout] message to occur at the specified
	// time.
	//
	// The engine persists all commands and timeouts produced within this scope
	// in a single atomic operation after the [ProcessMessageHandler] finishes
	// handling the inbound message. If the handler returns a non-nil error, the
	// engine discards the messages.
	//
	// This method panics if the process instance has ended.
	ScheduleTimeout(Timeout, time.Time)
}

type ProcessTimeoutScope interface {
	ProcessScope

	// ScheduledFor returns the time at which the timeout occurred.
	//
	// Even though the engine attempts to deliver timeouts at their scheduled
	// time, it may deliver them later when recovering from downtime or retrying
	// after a failure.
	ScheduledFor() time.Time
}

type ProjectionCompactScope interface {
	HandlerScope
}

type ProjectionConfigurer interface {
	HandlerConfigurer

	// Routes declares the message types that the handler consumes.
	//
	// It accepts routes created by [HandlesEvent].
	Routes(...ProjectionRoute)

	// ConcurrencyPreference provides a hint to the engine as to the best way to
	// handle concurrent messages for this handler.
	//
	// The default is [MaximizeConcurrency].
	ConcurrencyPreference(ConcurrencyPreference)
}

type ProjectionEventScope interface {
	HandlerScope

	// RecordedAt returns the time at which the [Event] occurred.
	RecordedAt() time.Time

	// StreamID returns the RFC 9562 UUID that identifies the event stream to
	// which the [Event] belongs.
	StreamID() string

	// Offset returns the event's zero-based offset within the stream.
	Offset() uint64

	// CheckpointOffset returns the offset from which the handler should resume
	// handling events from this stream, according to the engine.
	//
	// It may be lower than the incoming event's offset when the stream contains
	// event types that the handler doesn't consume.
	CheckpointOffset() uint64
}

type ProjectionHandlerRoute struct {
	// contains filtered or unexported fields
}

type ProjectionMessageHandler interface {
	// Configure declares the handler's configuration by calling methods on c.
	//
	// The configuration includes the handler's identity and message routes.
	//
	// The engine calls this method at least once during startup. It must
	// produce the same configuration each time it's called.
	Configure(c ProjectionConfigurer)

	// HandleEvent updates the projection to reflect the occurrence of an
	// [Event].
	//
	// The [ProjectionEventScope] s exposes the ID of the event stream to which
	// the incoming event belongs, the event's offset within that stream, and
	// the checkpoint offset at which the engine expects the handler to resume
	// consuming from the stream.
	//
	// If the engine and handler agree on the checkpoint offset, the handler
	// must atomically apply the event and update its checkpoint offset to one
	// greater than the incoming event's offset. Otherwise, the handler must not
	// modify any data.
	//
	// In either case, the method returns cp, the new checkpoint offset for this
	// stream. If cp is one greater than the offset of the incoming event, the
	// engine considers the event handled successfully. Otherwise, an OCC
	// conflict has occurred, and the engine resumes delivering events starting
	// at cp.
	//
	// A non-nil error indicates that the handler encountered a runtime problem
	// other than an OCC conflict.
	//
	// The engine arranges events on streams such that it delivers all events
	// within a single scope in the order they occurred. It also preserves the
	// order of events from a single aggregate instance, even across scopes. It
	// doesn't guarantee the relative delivery order of events from different
	// handlers or aggregate instances.
	//
	// See:
	//  - [ProjectionEventScope].StreamID
	//  - [ProjectionEventScope].Offset
	//  - [ProjectionEventScope].CheckpointOffset
	HandleEvent(
		ctx context.Context,
		s ProjectionEventScope,
		e Event,
	) (cp uint64, err error)

	// CheckpointOffset returns the offset at which the handler expects to
	// resume handling events from a specific stream.
	//
	// id is an RFC 9562 UUID that identifies the event stream, such as
	// "c50b5804-8312-4c61-b32c-9fbf49688db3". UUIDs are case-insensitive, but
	// the engine must use a lowercase representation.
	CheckpointOffset(ctx context.Context, id string) (uint64, error)

	// Compact reduces the projection's size by removing or consolidating data.
	//
	// The handler might delete obsolete entries, merge fine-grained data into
	// summaries, or move old data to archival storage. The specific strategy
	// depends on the projection's purpose and access patterns.
	//
	// The implementation should perform compaction incrementally to make some
	// progress even if ctx reaches its deadline.
	//
	// The engine may call this method at any time, including in parallel with
	// handling an event.
	//
	// Not all projections need compaction. Embed [NoCompactBehavior] in the
	// handler to indicate compaction not required.
	Compact(ctx context.Context, s ProjectionCompactScope) error

	// Reset clears all projection data and checkpoint offsets such that the
	// projection data is rebuilt by handling all historical events.
	//
	// Not all projections can be reset. Embed [NoResetBehavior] in the handler
	// to indicate that reset is not supported.
	Reset(ctx context.Context, s ProjectionResetScope) error
}

type ProjectionResetScope interface {
	HandlerScope
}

type ProjectionRoute interface {
	MessageRoute
	// contains filtered or unexported methods
}

type RecordsEventOption interface {
	// contains filtered or unexported methods
}

type RecordsEventRoute struct {
	// contains filtered or unexported fields
}

type RegisterCommandOption interface {
	// contains filtered or unexported methods
}

type RegisterEventOption interface {
	// contains filtered or unexported methods
}

type RegisterTimeoutOption interface {
	// contains filtered or unexported methods
}

type RegisteredMessageType struct {
	// contains filtered or unexported fields
}

type SchedulesTimeoutOption interface {
	// contains filtered or unexported methods
}

type SchedulesTimeoutRoute struct {
	// contains filtered or unexported fields
}

type StatelessProcessBehavior struct{}

type Timeout interface {
	Message

	// Validate returns a non-nil error if the message isn't well-formed.
	//
	// A timeout is well-formed if all required information is present and
	// correctly encoded such that it accurately represents an action that can
	// occur within the process, if current state permits.
	//
	// Validation requirements may change over time. Use the
	// [TimeoutValidationScope] to access context that may affect the strictness
	// or criteria of the validation logic.
	Validate(TimeoutValidationScope) error
}

type TimeoutValidationScope interface {
	MessageValidationScope

	// ScheduledAt returns the time at which the handler scheduled the timeout.
	ScheduledAt() time.Time

	// ScheduledFor returns the time at which the timeout occurs.
	ScheduledFor() time.Time
}

type ViaAggregateOption interface {
	// contains filtered or unexported methods
}

type ViaIntegrationOption interface {
	// contains filtered or unexported methods
}

type ViaProcessOption interface {
	// contains filtered or unexported methods
}

type ViaProjectionOption interface {
	// contains filtered or unexported methods
}