refactor(v2): init events (#7823)

creates events structures for initial projections and read models

internal/v2/avatar/added.go

@@ -0,0 +1,7 @@
+package avatar
+
+const AvatarAddedTypeSuffix = ".avatar.added"
+
+type AddedPayload struct {
+	StoreKey string `json:"storeKey"`
+}

internal/v2/avatar/removed.go

@@ -0,0 +1,7 @@
+package avatar
+
+const AvatarRemovedTypeSuffix = ".avatar.removed"
+
+type RemovedPayload struct {
+	StoreKey string `json:"storeKey"`
+}

internal/v2/database/mock/sql_mock.go

@@ -137,3 +137,11 @@ type AnyType[T interface{}] struct{}
 func (a AnyType[T]) Match(v driver.Value) bool {
 	return reflect.TypeOf(new(T)).Elem().Kind().String() == reflect.TypeOf(v).Kind().String()
 }
+
+var NilArg nilArgument
+
+type nilArgument struct{}
+
+func (a nilArgument) Match(v driver.Value) bool {
+	return reflect.ValueOf(v).IsNil()
+}

internal/v2/domain/added.go

@@ -0,0 +1,7 @@
+package domain
+
+const AddedTypeSuffix = "domain.added"
+
+type AddedPayload struct {
+	Name string `json:"domain"`
+}

internal/v2/domain/primary_set.go

@@ -0,0 +1,7 @@
+package domain
+
+const PrimarySetTypeSuffix = "domain.primary.set"
+
+type PrimarySetPayload struct {
+	Name string `json:"domain"`
+}

internal/v2/domain/removed.go

@@ -0,0 +1,7 @@
+package domain
+
+const RemovedTypeSuffix = "domain.removed"
+
+type RemovedPayload struct {
+	Name string `json:"domain"`
+}

internal/v2/domain/verfied.go

@@ -0,0 +1,7 @@
+package domain
+
+const VerifiedTypeSuffix = "domain.verified"
+
+type VerifiedPayload struct {
+	Name string `json:"domain"`
+}

internal/v2/eventstore/event.go

@@ -1,36 +1,66 @@
 package eventstore
 
-import "time"
+import (
+	"time"
+)
+
+type Unmarshal func(ptr any) error
+
+type Payload interface {
+	Unmarshal | any
+}
+
+type Action[P Payload] struct {
+	Creator  string
+	Type     string
+	Revision uint16
+	Payload  P
+}
+
+type Command struct {
+	Action[any]
+	UniqueConstraints []*UniqueConstraint
+}
+
+type StorageEvent struct {
+	Action[Unmarshal]
 
-type Event[P any] struct {
 	Aggregate Aggregate
 	CreatedAt time.Time
-	Creator   string
 	Position  GlobalPosition
-	Revision  uint16
 	Sequence  uint32
-	Type      string
-	Payload   P
 }
 
-type StoragePayload interface {
+type Event[P any] struct {
-	Unmarshal(ptr any) error
+	*StorageEvent
+	Payload P
 }
 
-func EventFromStorage[E Event[P], P any](event *Event[StoragePayload]) (*E, error) {
+func UnmarshalPayload[P any](unmarshal Unmarshal) (P, error) {
 	var payload P
-
+	err := unmarshal(&payload)
-	if err := event.Payload.Unmarshal(&payload); err != nil {
+	return payload, err
-		return nil, err
+}
-	}
+
-	return &E{
+type EmptyPayload struct{}
-		Aggregate: event.Aggregate,
+
-		CreatedAt: event.CreatedAt,
+type TypeChecker interface {
-		Creator:   event.Creator,
+	ActionType() string
-		Position:  event.Position,
+}
-		Revision:  event.Revision,
+
-		Sequence:  event.Sequence,
+func Type[T TypeChecker]() string {
-		Type:      event.Type,
+	var t T
-		Payload:   payload,
+	return t.ActionType()
-	}, nil
+}
+
+func IsType[T TypeChecker](types ...string) bool {
+	gotten := Type[T]()
+
+	for _, typ := range types {
+		if gotten == typ {
+			return true
+		}
+	}
+
+	return false
 }

internal/v2/eventstore/event_store.go

@@ -34,8 +34,12 @@ type GlobalPosition struct {
 	InPositionOrder uint32
 }
 
-type Reducer interface {
+func (gp GlobalPosition) IsLess(other GlobalPosition) bool {
-	Reduce(events ...*Event[StoragePayload]) error
+	return gp.Position < other.Position || (gp.Position == other.Position && gp.InPositionOrder < other.InPositionOrder)
 }
 
-type Reduce func(events ...*Event[StoragePayload]) error
+type Reducer interface {
+	Reduce(events ...*StorageEvent) error
+}
+
+type Reduce func(events ...*StorageEvent) error

internal/v2/eventstore/postgres/event.go

@@ -2,8 +2,8 @@ package postgres
 
 import (
 	"encoding/json"
-
+	"reflect"
-	"github.com/zitadel/logging"
+	"time"
 
 	"github.com/zitadel/zitadel/internal/v2/eventstore"
 	"github.com/zitadel/zitadel/internal/zerrors"
@@ -13,52 +13,52 @@ func intentToCommands(intent *intent) (commands []*command, err error) {
 	commands = make([]*command, len(intent.Commands()))
 
 	for i, cmd := range intent.Commands() {
-		var payload unmarshalPayload
+		payload, err := marshalPayload(cmd.Payload)
-		if cmd.Payload() != nil {
+		if err != nil {
-			payload, err = json.Marshal(cmd.Payload())
+			return nil, zerrors.ThrowInternal(err, "POSTG-MInPK", "Errors.Internal")
-			if err != nil {
-				logging.WithError(err).Warn("marshal payload failed")
-				return nil, zerrors.ThrowInternal(err, "POSTG-MInPK", "Errors.Internal")
-			}
 		}
-
 		commands[i] = &command{
-			Event: &eventstore.Event[eventstore.StoragePayload]{
+			Command:  cmd,
-				Aggregate: *intent.Aggregate(),
+			intent:   intent,
-				Creator:   cmd.Creator(),
+			sequence: intent.nextSequence(),
-				Revision:  cmd.Revision(),
+			payload:  payload,
-				Type:      cmd.Type(),
-				// always add at least 1 to the currently stored sequence
-				Sequence: intent.sequence + uint32(i) + 1,
-				Payload:  payload,
-			},
-			intent:            intent,
-			uniqueConstraints: cmd.UniqueConstraints(),
 		}
 	}
 
 	return commands, nil
 }
 
+func marshalPayload(payload any) ([]byte, error) {
+	if reflect.ValueOf(payload).IsZero() {
+		return nil, nil
+	}
+	return json.Marshal(payload)
+}
+
 type command struct {
-	*eventstore.Event[eventstore.StoragePayload]
+	eventstore.Command
 
-	intent            *intent
+	intent *intent
-	uniqueConstraints []*eventstore.UniqueConstraint
+
+	payload   []byte
+	position  eventstore.GlobalPosition
+	createdAt time.Time
+	sequence  uint32
 }
 
-var _ eventstore.StoragePayload = (unmarshalPayload)(nil)
+func (cmd *command) toEvent() *eventstore.StorageEvent {
-
+	return &eventstore.StorageEvent{
-type unmarshalPayload []byte
+		Action: eventstore.Action[eventstore.Unmarshal]{
-
+			Creator:  cmd.Creator,
-// Unmarshal implements eventstore.StoragePayload.
+			Type:     cmd.Type,
-func (p unmarshalPayload) Unmarshal(ptr any) error {
+			Revision: cmd.Revision,
-	if len(p) == 0 {
+			Payload: func(ptr any) error {
-		return nil
+				return json.Unmarshal(cmd.payload, ptr)
+			},
+		},
+		Aggregate: *cmd.intent.Aggregate(),
+		Sequence:  cmd.intent.sequence,
+		Position:  cmd.position,
+		CreatedAt: cmd.createdAt,
 	}
-	if err := json.Unmarshal(p, ptr); err != nil {
-		return zerrors.ThrowInternal(err, "POSTG-u8qVo", "Errors.Internal")
-	}
-
-	return nil
 }

internal/v2/eventstore/postgres/intent.go

@@ -12,6 +12,11 @@ type intent struct {
 	sequence uint32
 }
 
+func (i *intent) nextSequence() uint32 {
+	i.sequence++
+	return i.sequence
+}
+
 func makeIntents(pushIntent *eventstore.PushIntent) []*intent {
 	res := make([]*intent, len(pushIntent.Aggregates()))
 

internal/v2/eventstore/postgres/push.go

@@ -140,19 +140,19 @@ func push(ctx context.Context, tx *sql.Tx, reducer eventstore.Reducer, commands
 			stmt.WriteString(", ")
 		}
 
-		cmd.Position.InPositionOrder = uint32(i)
+		cmd.position.InPositionOrder = uint32(i)
 		stmt.WriteString(`(`)
 		stmt.WriteArgs(
-			cmd.Aggregate.Instance,
+			cmd.intent.Aggregate().Instance,
-			cmd.Aggregate.Owner,
+			cmd.intent.Aggregate().Owner,
-			cmd.Aggregate.Type,
+			cmd.intent.Aggregate().Type,
-			cmd.Aggregate.ID,
+			cmd.intent.Aggregate().ID,
 			cmd.Revision,
 			cmd.Creator,
 			cmd.Type,
-			cmd.Payload,
+			cmd.payload,
-			cmd.Sequence,
+			cmd.sequence,
-			i,
+			cmd.position.InPositionOrder,
 		)
 		stmt.WriteString(", statement_timestamp(), EXTRACT(EPOCH FROM clock_timestamp())")
 		stmt.WriteString(`)`)
@@ -171,13 +171,13 @@ func push(ctx context.Context, tx *sql.Tx, reducer eventstore.Reducer, commands
 		defer func() { i++ }()
 
 		err := scan(
-			&commands[i].CreatedAt,
+			&commands[i].createdAt,
-			&commands[i].Position.Position,
+			&commands[i].position.Position,
 		)
 		if err != nil {
 			return err
 		}
-		return reducer.Reduce(commands[i].Event)
+		return reducer.Reduce(commands[i].toEvent())
 	})
 }
 
@@ -188,12 +188,13 @@ func uniqueConstraints(ctx context.Context, tx *sql.Tx, commands []*command) (er
 	var stmt database.Statement
 
 	for _, cmd := range commands {
-		if len(cmd.uniqueConstraints) == 0 {
+		if len(cmd.UniqueConstraints) == 0 {
 			continue
 		}
-		for _, constraint := range cmd.uniqueConstraints {
+		for _, constraint := range cmd.UniqueConstraints {
 			stmt.Reset()
-			instance := cmd.Aggregate.Instance
+
+			instance := cmd.intent.PushAggregate.Aggregate().Instance
 			if constraint.IsGlobal {
 				instance = ""
 			}

internal/v2/eventstore/postgres/push_test.go

@@ -47,13 +47,16 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewAddEventUniqueConstraint("test", "id", "error"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewAddEventUniqueConstraint("test", "id", "error"),
+							},
 						},
 					},
 				},
@@ -72,13 +75,16 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewAddGlobalUniqueConstraint("test", "id", "error"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewAddGlobalUniqueConstraint("test", "id", "error"),
+							},
 						},
 					},
 				},
@@ -97,14 +103,17 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewAddEventUniqueConstraint("test", "id", "error"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
-							eventstore.NewAddEventUniqueConstraint("test", "id2", "error"),
+								eventstore.NewAddEventUniqueConstraint("test", "id", "error"),
+								eventstore.NewAddEventUniqueConstraint("test", "id2", "error"),
+							},
 						},
 					},
 				},
@@ -128,23 +137,29 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewAddEventUniqueConstraint("test", "id", "error"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewAddEventUniqueConstraint("test", "id", "error"),
+							},
 						},
 					},
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewAddEventUniqueConstraint("test", "id2", "error"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewAddEventUniqueConstraint("test", "id2", "error"),
+							},
 						},
 					},
 				},
@@ -168,13 +183,16 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewRemoveInstanceUniqueConstraints(),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewRemoveInstanceUniqueConstraints(),
+							},
 						},
 					},
 				},
@@ -193,23 +211,29 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewRemoveInstanceUniqueConstraints(),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewRemoveInstanceUniqueConstraints(),
+							},
 						},
 					},
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewRemoveInstanceUniqueConstraints(),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewRemoveInstanceUniqueConstraints(),
+							},
 						},
 					},
 				},
@@ -233,13 +257,16 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewRemoveUniqueConstraint("test", "id"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewRemoveUniqueConstraint("test", "id"),
+							},
 						},
 					},
 				},
@@ -258,13 +285,16 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewRemoveGlobalUniqueConstraint("test", "id"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewRemoveGlobalUniqueConstraint("test", "id"),
+							},
 						},
 					},
 				},
@@ -283,14 +313,17 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewRemoveUniqueConstraint("test", "id"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
-							eventstore.NewRemoveUniqueConstraint("test", "id2"),
+								eventstore.NewRemoveUniqueConstraint("test", "id"),
+								eventstore.NewRemoveUniqueConstraint("test", "id2"),
+							},
 						},
 					},
 				},
@@ -314,23 +347,29 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewRemoveUniqueConstraint("test", "id"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewRemoveUniqueConstraint("test", "id"),
+							},
 						},
 					},
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewRemoveUniqueConstraint("test", "id2"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewRemoveUniqueConstraint("test", "id2"),
+							},
 						},
 					},
 				},
@@ -354,13 +393,16 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewAddEventUniqueConstraint("test", "id", ""),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewAddEventUniqueConstraint("test", "id", ""),
+							},
 						},
 					},
 				},
@@ -385,13 +427,16 @@ func Test_uniqueConstraints(t *testing.T) {
 			args: args{
 				commands: []*command{
 					{
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						intent: &intent{
-							Aggregate: eventstore.Aggregate{
+							PushAggregate: eventstore.NewPushIntent(
-								Instance: "instance",
+								"instance",
-							},
+								eventstore.AppendAggregate("", "", ""),
+							).Aggregates()[0],
 						},
-						uniqueConstraints: []*eventstore.UniqueConstraint{
+						Command: eventstore.Command{
-							eventstore.NewAddEventUniqueConstraint("test", "id", "My.Error"),
+							UniqueConstraints: []*eventstore.UniqueConstraint{
+								eventstore.NewAddEventUniqueConstraint("test", "id", "My.Error"),
+							},
 						},
 					},
 				},
@@ -741,16 +786,14 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type",
-							Sequence: 1,
 						},
+						sequence: 1,
 					},
 				},
 				expectations: []mock.Expectation{
@@ -764,9 +807,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type",
-							nil,
+							mock.NilArg,
 							uint32(1),
-							0,
+							uint32(0),
 						),
 						mock.WithQueryResult(
 							[]string{"created_at", "position"},
@@ -798,16 +841,14 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type",
-							Sequence: 1,
 						},
+						sequence: 1,
 					},
 					{
 						intent: &intent{
@@ -816,16 +857,14 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type2",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type2",
-							Sequence: 2,
 						},
+						sequence: 2,
 					},
 				},
 				expectations: []mock.Expectation{
@@ -839,9 +878,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type",
-							nil,
+							mock.NilArg,
 							uint32(1),
-							0,
+							uint32(0),
 							"instance",
 							"owner",
 							"testType",
@@ -849,9 +888,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type2",
-							nil,
+							mock.NilArg,
 							uint32(2),
-							1,
+							uint32(1),
 						),
 						mock.WithQueryResult(
 							[]string{"created_at", "position"},
@@ -887,36 +926,30 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type",
-							Sequence: 1,
 						},
+						sequence: 1,
 					},
 					{
 						intent: &intent{
 							PushAggregate: eventstore.NewPushIntent(
 								"instance",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								eventstore.AppendAggregate("owner", "type2", "id2"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: eventstore.Aggregate{
+							Action: eventstore.Action[any]{
-								ID:       "id2",
+								Creator:  "gigi",
-								Type:     "type2",
+								Revision: 1,
-								Instance: "instance",
+								Type:     "test.type2",
-								Owner:    "owner",
 							},
-							Creator:  "gigi",
-							Revision: 1,
-							Type:     "test.type2",
-							Sequence: 10,
 						},
+						sequence: 10,
 					},
 				},
 				expectations: []mock.Expectation{
@@ -930,9 +963,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type",
-							nil,
+							mock.NilArg,
 							uint32(1),
-							0,
+							uint32(0),
 							"instance",
 							"owner",
 							"type2",
@@ -940,9 +973,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type2",
-							nil,
+							mock.NilArg,
 							uint32(10),
-							1,
+							uint32(1),
 						),
 						mock.WithQueryResult(
 							[]string{"created_at", "position"},
@@ -978,17 +1011,15 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type",
-							Sequence: 1,
-							Payload:  unmarshalPayload(`{"name": "gigi"}`),
 						},
+						sequence: 1,
+						payload:  []byte(`{"name": "gigi"}`),
 					},
 				},
 				expectations: []mock.Expectation{
@@ -1002,9 +1033,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type",
-							unmarshalPayload(`{"name": "gigi"}`),
+							[]byte(`{"name": "gigi"}`),
 							uint32(1),
-							0,
+							uint32(0),
 						),
 						mock.WithQueryResult(
 							[]string{"created_at", "position"},
@@ -1036,16 +1067,14 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type",
-							Sequence: 1,
 						},
+						sequence: 1,
 					},
 				},
 				expectations: []mock.Expectation{
@@ -1059,9 +1088,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type",
-							nil,
+							mock.NilArg,
 							uint32(1),
-							0,
+							uint32(0),
 						),
 						mock.WithQueryResult(
 							[]string{"created_at", "position"},
@@ -1094,16 +1123,14 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type",
-							Sequence: 1,
 						},
+						sequence: 1,
 					},
 					{
 						intent: &intent{
@@ -1112,16 +1139,14 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type2",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type2",
-							Sequence: 2,
 						},
+						sequence: 2,
 					},
 				},
 				expectations: []mock.Expectation{
@@ -1135,9 +1160,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type",
-							nil,
+							mock.NilArg,
 							uint32(1),
-							0,
+							uint32(0),
 							"instance",
 							"owner",
 							"testType",
@@ -1145,9 +1170,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type2",
-							nil,
+							mock.NilArg,
 							uint32(2),
-							1,
+							uint32(1),
 						),
 						mock.WithQueryResult(
 							[]string{"created_at", "position"},
@@ -1189,16 +1214,14 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type",
-							Sequence: 1,
 						},
+						sequence: 1,
 					},
 					{
 						intent: &intent{
@@ -1207,16 +1230,14 @@ func Test_push(t *testing.T) {
 								eventstore.AppendAggregate("owner", "testType", "testID"),
 							).Aggregates()[0],
 						},
-						Event: &eventstore.Event[eventstore.StoragePayload]{
+						Command: eventstore.Command{
-							Aggregate: *eventstore.NewPushIntent(
+							Action: eventstore.Action[any]{
-								"instance",
+								Creator:  "gigi",
-								eventstore.AppendAggregate("owner", "testType", "testID"),
+								Revision: 1,
-							).Aggregates()[0].Aggregate(),
+								Type:     "test.type2",
-							Creator:  "gigi",
+							},
-							Revision: 1,
-							Type:     "test.type2",
-							Sequence: 2,
 						},
+						sequence: 2,
 					},
 				},
 				expectations: []mock.Expectation{
@@ -1230,9 +1251,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type",
-							nil,
+							mock.NilArg,
 							uint32(1),
-							0,
+							uint32(0),
 							"instance",
 							"owner",
 							"testType",
@@ -1240,9 +1261,9 @@ func Test_push(t *testing.T) {
 							uint16(1),
 							"gigi",
 							"test.type2",
-							nil,
+							mock.NilArg,
 							uint32(2),
-							1,
+							uint32(1),
 						),
 						mock.WithQueryResult(
 							[]string{"created_at", "position"},

internal/v2/eventstore/postgres/query.go

@@ -3,6 +3,7 @@ package postgres
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
 	"slices"
 
 	"github.com/zitadel/logging"
@@ -38,7 +39,7 @@ func executeQuery(ctx context.Context, tx database.Querier, stmt *database.State
 	}
 
 	err = database.MapRowsToObject(rows, func(scan func(dest ...any) error) error {
-		e := new(eventstore.Event[eventstore.StoragePayload])
+		e := new(eventstore.StorageEvent)
 
 		var payload sql.Null[[]byte]
 
@@ -59,7 +60,12 @@ func executeQuery(ctx context.Context, tx database.Querier, stmt *database.State
 		if err != nil {
 			return err
 		}
-		e.Payload = unmarshalPayload(payload.V)
+		e.Payload = func(ptr any) error {
+			if len(payload.V) == 0 {
+				return nil
+			}
+			return json.Unmarshal(payload.V, ptr)
+		}
 		eventCount++
 
 		return reducer.Reduce(e)

internal/v2/eventstore/postgres/query_test.go

@@ -1143,7 +1143,7 @@ type testReducer struct {
 }
 
 // Reduce implements eventstore.Reducer.
-func (r *testReducer) Reduce(events ...*eventstore.Event[eventstore.StoragePayload]) error {
+func (r *testReducer) Reduce(events ...*eventstore.StorageEvent) error {
 	if r == nil {
 		return nil
 	}

internal/v2/eventstore/push.go

@@ -36,7 +36,7 @@ func (pi *PushIntent) Instance() string {
 	return pi.instance
 }
 
-func (pi *PushIntent) Reduce(events ...*Event[StoragePayload]) error {
+func (pi *PushIntent) Reduce(events ...*StorageEvent) error {
 	if pi.reducer == nil {
 		return nil
 	}
@@ -170,21 +170,3 @@ func AppendCommands(commands ...Command) PushAggregateOpt {
 		pa.commands = append(pa.commands, commands...)
 	}
 }
-
-type Command interface {
-	// Creator is the id of the user which created the action
-	Creator() string
-	// Type describes the action it's in the past (e.g. user.created)
-	Type() string
-	// Revision of the action
-	Revision() uint16
-	// Payload returns the payload of the event. It represent the changed fields by the event
-	// valid types are:
-	// * nil: no payload
-	// * struct: which can be marshalled to json
-	// * pointer to struct: which can be marshalled to json
-	// * []byte: json marshalled data
-	Payload() any
-	// UniqueConstraints should be added for unique attributes of an event, if nil constraints will not be checked
-	UniqueConstraints() []*UniqueConstraint
-}

internal/v2/eventstore/query.go

@@ -41,7 +41,7 @@ func (q *Query) Pagination() *Pagination {
 	return q.pagination
 }
 
-func (q *Query) Reduce(events ...*Event[StoragePayload]) error {
+func (q *Query) Reduce(events ...*StorageEvent) error {
 	return q.reducer.Reduce(events...)
 }
 

internal/v2/instance/aggregate.go

@@ -0,0 +1,8 @@
+package instance
+
+import "github.com/zitadel/zitadel/internal/repository/instance"
+
+const (
+	AggregateType   = string(instance.AggregateType)
+	eventTypePrefix = AggregateType + "."
+)

internal/v2/instance/domain_policy.go

@@ -0,0 +1,65 @@
+package instance
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/v2/policy"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const DomainPolicyAddedType = eventTypePrefix + policy.DomainPolicyAddedTypeSuffix
+
+type DomainPolicyAddedPayload policy.DomainPolicyAddedPayload
+
+type DomainPolicyAddedEvent eventstore.Event[DomainPolicyAddedPayload]
+
+var _ eventstore.TypeChecker = (*DomainPolicyAddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainPolicyAddedEvent) ActionType() string {
+	return DomainPolicyAddedType
+}
+
+func DomainPolicyAddedEventFromStorage(event *eventstore.StorageEvent) (e *DomainPolicyAddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "INSTA-z1a7D", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainPolicyAddedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainPolicyAddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}
+
+const DomainPolicyChangedType = eventTypePrefix + policy.DomainPolicyChangedTypeSuffix
+
+type DomainPolicyChangedPayload policy.DomainPolicyChangedPayload
+
+type DomainPolicyChangedEvent eventstore.Event[DomainPolicyChangedPayload]
+
+var _ eventstore.TypeChecker = (*DomainPolicyChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainPolicyChangedEvent) ActionType() string {
+	return DomainPolicyChangedType
+}
+
+func DomainPolicyChangedEventFromStorage(event *eventstore.StorageEvent) (e *DomainPolicyChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "INSTA-BTLhd", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainPolicyChangedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainPolicyChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/instance/removed.go

@@ -0,0 +1,27 @@
+package instance
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const RemovedType = eventTypePrefix + "removed"
+
+type RemovedEvent eventstore.Event[eventstore.EmptyPayload]
+
+var _ eventstore.TypeChecker = (*RemovedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *RemovedEvent) ActionType() string {
+	return RemovedType
+}
+
+func RemovedEventFromStorage(event *eventstore.StorageEvent) (e *RemovedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "INSTA-xppIg", "Errors.Invalid.Event.Type")
+	}
+
+	return &RemovedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/org/added.go

@@ -0,0 +1,62 @@
+package org
+
+import (
+	"context"
+	"strings"
+
+	"github.com/zitadel/zitadel/internal/api/authz"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const AddedType = eventTypePrefix + "added"
+
+type addedPayload struct {
+	Name string `json:"name"`
+}
+
+type AddedEvent eventstore.Event[addedPayload]
+
+var _ eventstore.TypeChecker = (*AddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *AddedEvent) ActionType() string {
+	return AddedType
+}
+
+func AddedEventFromStorage(event *eventstore.StorageEvent) (e *AddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-Nf3tr", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[addedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &AddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}
+
+const uniqueOrgName = "org_name"
+
+func NewAddedCommand(ctx context.Context, name string) (*eventstore.Command, error) {
+	if name = strings.TrimSpace(name); name == "" {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-mruNY", "Errors.Invalid.Argument")
+	}
+	return &eventstore.Command{
+		Action: eventstore.Action[any]{
+			Creator:  authz.GetCtxData(ctx).UserID,
+			Type:     AddedType,
+			Revision: 1,
+			Payload: addedPayload{
+				Name: name,
+			},
+		},
+		UniqueConstraints: []*eventstore.UniqueConstraint{
+			eventstore.NewAddEventUniqueConstraint(uniqueOrgName, name, "Errors.Org.AlreadyExists"),
+		},
+	}, nil
+}

internal/v2/org/aggregate.go

@@ -0,0 +1,22 @@
+package org
+
+import (
+	"context"
+
+	"github.com/zitadel/zitadel/internal/api/authz"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+)
+
+const (
+	AggregateType   = "org"
+	eventTypePrefix = AggregateType + "."
+)
+
+func NewAggregate(ctx context.Context, id string) *eventstore.Aggregate {
+	return &eventstore.Aggregate{
+		ID:       id,
+		Type:     AggregateType,
+		Instance: authz.GetInstance(ctx).InstanceID(),
+		Owner:    authz.GetCtxData(ctx).OrgID,
+	}
+}

internal/v2/org/changed.go

@@ -0,0 +1,37 @@
+package org
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const ChangedType = eventTypePrefix + "changed"
+
+type changedPayload struct {
+	Name string `json:"name"`
+}
+
+type ChangedEvent eventstore.Event[changedPayload]
+
+var _ eventstore.TypeChecker = (*ChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *ChangedEvent) ActionType() string {
+	return ChangedType
+}
+
+func ChangedEventFromStorage(event *eventstore.StorageEvent) (e *ChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-pzOfP", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[changedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/org/deactivated.go

@@ -0,0 +1,27 @@
+package org
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const DeactivatedType = eventTypePrefix + "deactivated"
+
+type DeactivatedEvent eventstore.Event[eventstore.EmptyPayload]
+
+var _ eventstore.TypeChecker = (*DeactivatedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DeactivatedEvent) ActionType() string {
+	return DeactivatedType
+}
+
+func DeactivatedEventFromStorage(event *eventstore.StorageEvent) (e *DeactivatedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-4zeWH", "Errors.Invalid.Event.Type")
+	}
+
+	return &DeactivatedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/org/domain.go

@@ -0,0 +1,123 @@
+package org
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const DomainAddedType = "org." + domain.AddedTypeSuffix
+
+type DomainAddedPayload domain.AddedPayload
+
+type DomainAddedEvent eventstore.Event[DomainAddedPayload]
+
+var _ eventstore.TypeChecker = (*DomainAddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainAddedEvent) ActionType() string {
+	return DomainAddedType
+}
+
+func DomainAddedEventFromStorage(event *eventstore.StorageEvent) (e *DomainAddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-CXVe3", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainAddedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainAddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}
+
+const DomainVerifiedType = "org." + domain.VerifiedTypeSuffix
+
+type DomainVerifiedPayload domain.VerifiedPayload
+
+type DomainVerifiedEvent eventstore.Event[DomainVerifiedPayload]
+
+var _ eventstore.TypeChecker = (*DomainVerifiedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainVerifiedEvent) ActionType() string {
+	return DomainVerifiedType
+}
+
+func DomainVerifiedEventFromStorage(event *eventstore.StorageEvent) (e *DomainVerifiedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-RAwdb", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainVerifiedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainVerifiedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}
+
+const DomainPrimarySetType = "org." + domain.PrimarySetTypeSuffix
+
+type DomainPrimarySetPayload domain.PrimarySetPayload
+
+type DomainPrimarySetEvent eventstore.Event[DomainPrimarySetPayload]
+
+var _ eventstore.TypeChecker = (*DomainPrimarySetEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainPrimarySetEvent) ActionType() string {
+	return DomainPrimarySetType
+}
+
+func DomainPrimarySetEventFromStorage(event *eventstore.StorageEvent) (e *DomainPrimarySetEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-7P3Iz", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainPrimarySetPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainPrimarySetEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}
+
+const DomainRemovedType = "org." + domain.RemovedTypeSuffix
+
+type DomainRemovedPayload domain.RemovedPayload
+
+type DomainRemovedEvent eventstore.Event[DomainRemovedPayload]
+
+var _ eventstore.TypeChecker = (*DomainRemovedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainRemovedEvent) ActionType() string {
+	return DomainRemovedType
+}
+
+func DomainRemovedEventFromStorage(event *eventstore.StorageEvent) (e *DomainRemovedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-ndpL2", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainRemovedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainRemovedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/org/domain_policy.go

@@ -0,0 +1,94 @@
+package org
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/v2/policy"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const DomainPolicyAddedType = eventTypePrefix + policy.DomainPolicyAddedTypeSuffix
+
+type DomainPolicyAddedPayload policy.DomainPolicyAddedPayload
+
+type DomainPolicyAddedEvent eventstore.Event[DomainPolicyAddedPayload]
+
+var _ eventstore.TypeChecker = (*DomainPolicyAddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainPolicyAddedEvent) ActionType() string {
+	return DomainPolicyAddedType
+}
+
+func DomainPolicyAddedEventFromStorage(event *eventstore.StorageEvent) (e *DomainPolicyAddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-asiSN", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainPolicyAddedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainPolicyAddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}
+
+const DomainPolicyChangedType = eventTypePrefix + policy.DomainPolicyChangedTypeSuffix
+
+type DomainPolicyChangedPayload policy.DomainPolicyChangedPayload
+
+type DomainPolicyChangedEvent eventstore.Event[DomainPolicyChangedPayload]
+
+var _ eventstore.TypeChecker = (*DomainPolicyChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainPolicyChangedEvent) ActionType() string {
+	return DomainPolicyChangedType
+}
+
+func DomainPolicyChangedEventFromStorage(event *eventstore.StorageEvent) (e *DomainPolicyChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-BmN6K", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainPolicyChangedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainPolicyChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}
+
+const DomainPolicyRemovedType = eventTypePrefix + policy.DomainPolicyRemovedTypeSuffix
+
+type DomainPolicyRemovedPayload policy.DomainPolicyRemovedPayload
+
+type DomainPolicyRemovedEvent eventstore.Event[DomainPolicyRemovedPayload]
+
+var _ eventstore.TypeChecker = (*DomainPolicyRemovedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainPolicyRemovedEvent) ActionType() string {
+	return DomainPolicyRemovedType
+}
+
+func DomainPolicyRemovedEventFromStorage(event *eventstore.StorageEvent) (e *DomainPolicyRemovedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-nHy4z", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[DomainPolicyRemovedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainPolicyRemovedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/org/reactivated.go

@@ -0,0 +1,27 @@
+package org
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const ReactivatedType = eventTypePrefix + "reactivated"
+
+type ReactivatedEvent eventstore.Event[eventstore.EmptyPayload]
+
+var _ eventstore.TypeChecker = (*ReactivatedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *ReactivatedEvent) ActionType() string {
+	return ReactivatedType
+}
+
+func ReactivatedEventFromStorage(event *eventstore.StorageEvent) (e *ReactivatedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-cPWZw", "Errors.Invalid.Event.Type")
+	}
+
+	return &ReactivatedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/org/removed.go

@@ -0,0 +1,27 @@
+package org
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const RemovedType = eventTypePrefix + "removed"
+
+type RemovedEvent eventstore.Event[eventstore.EmptyPayload]
+
+var _ eventstore.TypeChecker = (*RemovedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *RemovedEvent) ActionType() string {
+	return RemovedType
+}
+
+func RemovedEventFromStorage(event *eventstore.StorageEvent) (e *RemovedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "ORG-RSPYk", "Errors.Invalid.Event.Type")
+	}
+
+	return &RemovedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/org/state.go

@@ -0,0 +1,36 @@
+package org
+
+type State uint8
+
+const (
+	UndefinedState State = iota
+	ActiveState
+	InactiveState
+	RemovedState
+	maxState
+)
+
+func (s State) IsValid() bool {
+	return s != UndefinedState ||
+		s < maxState
+}
+
+func (s State) Is(state State) bool {
+	return s == state
+}
+
+func (s State) IsValidState(state State) bool {
+	return s.IsValid() && s.Is(state)
+}
+
+func (s State) IsValidStates(states ...State) bool {
+	if !s.IsValid() {
+		return false
+	}
+	for _, state := range states {
+		if s.Is(state) {
+			return true
+		}
+	}
+	return false
+}

internal/v2/policy/domain.go

@@ -0,0 +1,23 @@
+package policy
+
+import "github.com/zitadel/zitadel/internal/v2/eventstore"
+
+const DomainPolicyAddedTypeSuffix = "policy.domain.added"
+
+type DomainPolicyAddedPayload struct {
+	UserLoginMustBeDomain                  bool `json:"userLoginMustBeDomain,omitempty"`
+	ValidateOrgDomains                     bool `json:"validateOrgDomains,omitempty"`
+	SMTPSenderAddressMatchesInstanceDomain bool `json:"smtpSenderAddressMatchesInstanceDomain,omitempty"`
+}
+
+const DomainPolicyChangedTypeSuffix = "policy.domain.changed"
+
+type DomainPolicyChangedPayload struct {
+	UserLoginMustBeDomain                  *bool `json:"userLoginMustBeDomain,omitempty"`
+	ValidateOrgDomains                     *bool `json:"validateOrgDomains,omitempty"`
+	SMTPSenderAddressMatchesInstanceDomain *bool `json:"smtpSenderAddressMatchesInstanceDomain,omitempty"`
+}
+
+const DomainPolicyRemovedTypeSuffix = "policy.domain.removed"
+
+type DomainPolicyRemovedPayload eventstore.EmptyPayload

internal/v2/user/aggregate.go

@@ -0,0 +1,23 @@
+package user
+
+import (
+	"context"
+
+	"github.com/zitadel/zitadel/internal/api/authz"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+)
+
+const (
+	AggregateType = "user"
+	humanPrefix   = AggregateType + ".human"
+	machinePrefix = AggregateType + ".machine"
+)
+
+func NewAggregate(ctx context.Context, id string) *eventstore.Aggregate {
+	return &eventstore.Aggregate{
+		ID:       id,
+		Type:     AggregateType,
+		Instance: authz.GetInstance(ctx).InstanceID(),
+		Owner:    authz.GetCtxData(ctx).OrgID,
+	}
+}

internal/v2/user/domain_claimed.go

@@ -0,0 +1,38 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type domainClaimedPayload struct {
+	Username          string `json:"userName"`
+	TriggeredAtOrigin string `json:"triggerOrigin,omitempty"`
+}
+
+type DomainClaimedEvent eventstore.Event[domainClaimedPayload]
+
+const DomainClaimedType = AggregateType + ".domain.claimed.sent"
+
+var _ eventstore.TypeChecker = (*DomainClaimedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DomainClaimedEvent) ActionType() string {
+	return DomainClaimedType
+}
+
+func DomainClaimedEventFromStorage(event *eventstore.StorageEvent) (e *DomainClaimedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-x8O4o", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[domainClaimedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DomainClaimedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/human_added.go

@@ -0,0 +1,57 @@
+package user
+
+import (
+	"golang.org/x/text/language"
+
+	"github.com/zitadel/zitadel/internal/crypto"
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+const HumanAddedType = AggregateType + ".human.added"
+
+type humanAddedPayload struct {
+	Username string `json:"userName"`
+
+	FirstName         string        `json:"firstName,omitempty"`
+	LastName          string        `json:"lastName,omitempty"`
+	NickName          string        `json:"nickName,omitempty"`
+	DisplayName       string        `json:"displayName,omitempty"`
+	PreferredLanguage language.Tag  `json:"preferredLanguage,omitempty"`
+	Gender            domain.Gender `json:"gender,omitempty"`
+
+	EmailAddress domain.EmailAddress `json:"email,omitempty"`
+	PhoneNumber  domain.PhoneNumber  `json:"phone,omitempty"`
+
+	// New events only use EncodedHash. However, the secret field
+	// is preserved to handle events older than the switch to Passwap.
+	Secret                 *crypto.CryptoValue `json:"secret,omitempty"`
+	EncodedHash            string              `json:"encodedHash,omitempty"`
+	PasswordChangeRequired bool                `json:"changeRequired,omitempty"`
+}
+
+type HumanAddedEvent eventstore.Event[humanAddedPayload]
+
+var _ eventstore.TypeChecker = (*HumanAddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanAddedEvent) ActionType() string {
+	return HumanAddedType
+}
+
+func HumanAddedEventFromStorage(event *eventstore.StorageEvent) (e *HumanAddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-MRZ3p", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[humanAddedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanAddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/human_avatar.go

@@ -0,0 +1,61 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/avatar"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type HumanAvatarAddedEvent eventstore.Event[avatar.AddedPayload]
+
+const HumanAvatarAddedType = humanPrefix + avatar.AvatarAddedTypeSuffix
+
+var _ eventstore.TypeChecker = (*HumanAvatarAddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanAvatarAddedEvent) ActionType() string {
+	return HumanAvatarAddedType
+}
+
+func HumanAvatarAddedEventFromStorage(event *eventstore.StorageEvent) (e *HumanAvatarAddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-ddQaI", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[avatar.AddedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanAvatarAddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}
+
+type HumanAvatarRemovedEvent eventstore.Event[avatar.RemovedPayload]
+
+const HumanAvatarRemovedType = humanPrefix + avatar.AvatarRemovedTypeSuffix
+
+var _ eventstore.TypeChecker = (*HumanAvatarRemovedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanAvatarRemovedEvent) ActionType() string {
+	return HumanAvatarRemovedType
+}
+
+func HumanAvatarRemovedEventFromStorage(event *eventstore.StorageEvent) (e *HumanAvatarRemovedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-j2CkY", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[avatar.RemovedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanAvatarRemovedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/human_email_changed.go

@@ -0,0 +1,38 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type humanEmailChangedPayload struct {
+	Address domain.EmailAddress `json:"email,omitempty"`
+}
+
+type HumanEmailChangedEvent eventstore.Event[humanEmailChangedPayload]
+
+const HumanEmailChangedType = humanPrefix + ".email.changed"
+
+var _ eventstore.TypeChecker = (*HumanEmailChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanEmailChangedEvent) ActionType() string {
+	return HumanEmailChangedType
+}
+
+func HumanEmailChangedEventFromStorage(event *eventstore.StorageEvent) (e *HumanEmailChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-Wr2lR", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[humanEmailChangedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanEmailChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/human_email_verified.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type HumanEmailVerifiedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const HumanEmailVerifiedType = humanPrefix + ".email.verified"
+
+var _ eventstore.TypeChecker = (*HumanEmailVerifiedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanEmailVerifiedEvent) ActionType() string {
+	return HumanEmailVerifiedType
+}
+
+func HumanEmailVerifiedEventFromStorage(event *eventstore.StorageEvent) (e *HumanEmailVerifiedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-X3esB", "Errors.Invalid.Event.Type")
+	}
+
+	return &HumanEmailVerifiedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/human_init_code_added.go

@@ -0,0 +1,43 @@
+package user
+
+import (
+	"time"
+
+	"github.com/zitadel/zitadel/internal/crypto"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type humanInitCodeAddedPayload struct {
+	Code              *crypto.CryptoValue `json:"code,omitempty"`
+	Expiry            time.Duration       `json:"expiry,omitempty"`
+	TriggeredAtOrigin string              `json:"triggerOrigin,omitempty"`
+	AuthRequestID     string              `json:"authRequestID,omitempty"`
+}
+
+type HumanInitCodeAddedEvent eventstore.Event[humanInitCodeAddedPayload]
+
+const HumanInitCodeAddedType = humanPrefix + ".initialization.code.added"
+
+var _ eventstore.TypeChecker = (*HumanInitCodeAddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanInitCodeAddedEvent) ActionType() string {
+	return HumanInitCodeAddedType
+}
+
+func HumanInitCodeAddedEventFromStorage(event *eventstore.StorageEvent) (e *HumanInitCodeAddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-XaGf6", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[humanInitCodeAddedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanInitCodeAddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/human_init_code_succeeded.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type HumanInitCodeSucceededEvent eventstore.Event[eventstore.EmptyPayload]
+
+const HumanInitCodeSucceededType = humanPrefix + ".initialization.check.succeeded"
+
+var _ eventstore.TypeChecker = (*HumanInitCodeSucceededEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanInitCodeSucceededEvent) ActionType() string {
+	return HumanInitCodeSucceededType
+}
+
+func HumanInitCodeSucceededEventFromStorage(event *eventstore.StorageEvent) (e *HumanInitCodeSucceededEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-12A5m", "Errors.Invalid.Event.Type")
+	}
+
+	return &HumanInitCodeSucceededEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/human_password_changed.go

@@ -0,0 +1,44 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/crypto"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type humanPasswordChangedPayload struct {
+	// New events only use EncodedHash. However, the secret field
+	// is preserved to handle events older than the switch to Passwap.
+	Secret            *crypto.CryptoValue `json:"secret,omitempty"`
+	EncodedHash       string              `json:"encodedHash,omitempty"`
+	ChangeRequired    bool                `json:"changeRequired"`
+	UserAgentID       string              `json:"userAgentID,omitempty"`
+	TriggeredAtOrigin string              `json:"triggerOrigin,omitempty"`
+}
+
+type HumanPasswordChangedEvent eventstore.Event[humanPasswordChangedPayload]
+
+const HumanPasswordChangedType = humanPrefix + ".password.changed"
+
+var _ eventstore.TypeChecker = (*HumanPasswordChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanPasswordChangedEvent) ActionType() string {
+	return HumanPasswordChangedType
+}
+
+func HumanPasswordChangedEventFromStorage(event *eventstore.StorageEvent) (e *HumanPasswordChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-Fx5tr", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[humanPasswordChangedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanPasswordChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/human_phone_changed.go

@@ -0,0 +1,38 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type humanPhoneChangedPayload struct {
+	PhoneNumber domain.PhoneNumber `json:"phone,omitempty"`
+}
+
+type HumanPhoneChangedEvent eventstore.Event[humanPhoneChangedPayload]
+
+const HumanPhoneChangedType = humanPrefix + ".phone.changed"
+
+var _ eventstore.TypeChecker = (*HumanPhoneChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanPhoneChangedEvent) ActionType() string {
+	return HumanPhoneChangedType
+}
+
+func HumanPhoneChangedEventFromStorage(event *eventstore.StorageEvent) (e *HumanPhoneChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-d6hGS", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[humanPhoneChangedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanPhoneChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/human_phone_removed.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type HumanPhoneRemovedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const HumanPhoneRemovedType = humanPrefix + ".phone.removed"
+
+var _ eventstore.TypeChecker = (*HumanPhoneRemovedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanPhoneRemovedEvent) ActionType() string {
+	return HumanPhoneRemovedType
+}
+
+func HumanPhoneRemovedEventFromStorage(event *eventstore.StorageEvent) (e *HumanPhoneRemovedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-vaD75", "Errors.Invalid.Event.Type")
+	}
+
+	return &HumanPhoneRemovedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/human_phone_verified.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type HumanPhoneVerifiedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const HumanPhoneVerifiedType = humanPrefix + ".phone.removed"
+
+var _ eventstore.TypeChecker = (*HumanPhoneVerifiedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanPhoneVerifiedEvent) ActionType() string {
+	return HumanPhoneVerifiedType
+}
+
+func HumanPhoneVerifiedEventFromStorage(event *eventstore.StorageEvent) (e *HumanPhoneVerifiedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-ycRBi", "Errors.Invalid.Event.Type")
+	}
+
+	return &HumanPhoneVerifiedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/human_profile_changed.go

@@ -0,0 +1,45 @@
+package user
+
+import (
+	"golang.org/x/text/language"
+
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type humanProfileChangedPayload struct {
+	FirstName         string         `json:"firstName,omitempty"`
+	LastName          string         `json:"lastName,omitempty"`
+	NickName          *string        `json:"nickName,omitempty"`
+	DisplayName       *string        `json:"displayName,omitempty"`
+	PreferredLanguage *language.Tag  `json:"preferredLanguage,omitempty"`
+	Gender            *domain.Gender `json:"gender,omitempty"`
+}
+
+type HumanProfileChangedEvent eventstore.Event[humanProfileChangedPayload]
+
+const HumanProfileChangedType = humanPrefix + ".profile.changed"
+
+var _ eventstore.TypeChecker = (*HumanProfileChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanProfileChangedEvent) ActionType() string {
+	return HumanProfileChangedType
+}
+
+func HumanProfileChangedEventFromStorage(event *eventstore.StorageEvent) (e *HumanProfileChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-Z1aFH", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[humanProfileChangedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanProfileChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/human_registered.go

@@ -0,0 +1,55 @@
+package user
+
+import (
+	"golang.org/x/text/language"
+
+	"github.com/zitadel/zitadel/internal/crypto"
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type humanRegisteredPayload struct {
+	Username          string              `json:"userName"`
+	FirstName         string              `json:"firstName,omitempty"`
+	LastName          string              `json:"lastName,omitempty"`
+	NickName          string              `json:"nickName,omitempty"`
+	DisplayName       string              `json:"displayName,omitempty"`
+	PreferredLanguage language.Tag        `json:"preferredLanguage,omitempty"`
+	Gender            domain.Gender       `json:"gender,omitempty"`
+	EmailAddress      domain.EmailAddress `json:"email,omitempty"`
+	PhoneNumber       domain.PhoneNumber  `json:"phone,omitempty"`
+
+	// New events only use EncodedHash. However, the secret field
+	// is preserved to handle events older than the switch to Passwap.
+	Secret                 *crypto.CryptoValue `json:"secret,omitempty"` // legacy
+	EncodedHash            string              `json:"encodedHash,omitempty"`
+	PasswordChangeRequired bool                `json:"changeRequired,omitempty"`
+}
+
+type HumanRegisteredEvent eventstore.Event[humanRegisteredPayload]
+
+const HumanRegisteredType = humanPrefix + ".selfregistered"
+
+var _ eventstore.TypeChecker = (*HumanRegisteredEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *HumanRegisteredEvent) ActionType() string {
+	return HumanRegisteredType
+}
+
+func HumanRegisteredEventFromStorage(event *eventstore.StorageEvent) (e *HumanRegisteredEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-8HvGi", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[humanRegisteredPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HumanRegisteredEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/machine_added.go

@@ -0,0 +1,41 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type machineAddedPayload struct {
+	Username        string               `json:"userName"`
+	Name            string               `json:"name,omitempty"`
+	Description     string               `json:"description,omitempty"`
+	AccessTokenType domain.OIDCTokenType `json:"accessTokenType,omitempty"`
+}
+
+type MachineAddedEvent eventstore.Event[machineAddedPayload]
+
+const MachineAddedType = machinePrefix + ".added"
+
+var _ eventstore.TypeChecker = (*MachineAddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *MachineAddedEvent) ActionType() string {
+	return MachineAddedType
+}
+
+func MachineAddedEventFromStorage(event *eventstore.StorageEvent) (e *MachineAddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-WLLoW", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[machineAddedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MachineAddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/machine_changed.go

@@ -0,0 +1,40 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type machineChangedPayload struct {
+	Name            *string               `json:"name,omitempty"`
+	Description     *string               `json:"description,omitempty"`
+	AccessTokenType *domain.OIDCTokenType `json:"accessTokenType,omitempty"`
+}
+
+type MachineChangedEvent eventstore.Event[machineChangedPayload]
+
+const MachineChangedType = machinePrefix + ".changed"
+
+var _ eventstore.TypeChecker = (*MachineChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *MachineChangedEvent) ActionType() string {
+	return MachineChangedType
+}
+
+func MachineChangedEventFromStorage(event *eventstore.StorageEvent) (e *MachineChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-JHwNs", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[machineChangedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MachineChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/machine_secret_hash_updated.go

@@ -0,0 +1,37 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type machineSecretHashUpdatedPayload struct {
+	HashedSecret string `json:"hashedSecret,omitempty"`
+}
+
+type MachineSecretHashUpdatedEvent eventstore.Event[machineSecretHashUpdatedPayload]
+
+const MachineSecretHashUpdatedType = machinePrefix + ".secret.updated"
+
+var _ eventstore.TypeChecker = (*MachineSecretHashUpdatedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *MachineSecretHashUpdatedEvent) ActionType() string {
+	return MachineSecretHashUpdatedType
+}
+
+func MachineSecretHashUpdatedEventFromStorage(event *eventstore.StorageEvent) (e *MachineSecretHashUpdatedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-y41RK", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[machineSecretHashUpdatedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MachineSecretHashUpdatedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/machine_secret_removed.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type MachineSecretRemovedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const MachineSecretRemovedType = machinePrefix + ".secret.removed"
+
+var _ eventstore.TypeChecker = (*MachineSecretRemovedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *MachineSecretRemovedEvent) ActionType() string {
+	return MachineSecretRemovedType
+}
+
+func MachineSecretRemovedEventFromStorage(event *eventstore.StorageEvent) (e *MachineSecretRemovedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-SMtct", "Errors.Invalid.Event.Type")
+	}
+
+	return &MachineSecretRemovedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/machine_secret_set.go

@@ -0,0 +1,41 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/crypto"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type machineSecretSetPayload struct {
+	// New events only use EncodedHash. However, the ClientSecret field
+	// is preserved to handle events older than the switch to Passwap.
+	ClientSecret *crypto.CryptoValue `json:"clientSecret,omitempty"`
+	HashedSecret string              `json:"hashedSecret,omitempty"`
+}
+
+type MachineSecretHashSetEvent eventstore.Event[machineSecretSetPayload]
+
+const MachineSecretHashSetType = machinePrefix + ".secret.set"
+
+var _ eventstore.TypeChecker = (*MachineSecretHashSetEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *MachineSecretHashSetEvent) ActionType() string {
+	return MachineSecretHashSetType
+}
+
+func MachineSecretHashSetEventFromStorage(event *eventstore.StorageEvent) (e *MachineSecretHashSetEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-DzycT", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[machineSecretSetPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MachineSecretHashSetEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/token_added.go

@@ -0,0 +1,51 @@
+package user
+
+import (
+	"time"
+
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type tokenAddedPayload struct {
+	TokenID               string             `json:"tokenId,omitempty"`
+	ApplicationID         string             `json:"applicationId,omitempty"`
+	UserAgentID           string             `json:"userAgentId,omitempty"`
+	RefreshTokenID        string             `json:"refreshTokenID,omitempty"`
+	Audience              []string           `json:"audience,omitempty"`
+	Scopes                []string           `json:"scopes,omitempty"`
+	AuthMethodsReferences []string           `json:"authMethodsReferences,omitempty"`
+	AuthTime              time.Time          `json:"authTime,omitempty"`
+	Expiration            time.Time          `json:"expiration,omitempty"`
+	PreferredLanguage     string             `json:"preferredLanguage,omitempty"`
+	Reason                domain.TokenReason `json:"reason,omitempty"`
+	Actor                 *domain.TokenActor `json:"actor,omitempty"`
+}
+
+type TokenAddedEvent eventstore.Event[tokenAddedPayload]
+
+const TokenAddedType = AggregateType + ".token.added"
+
+var _ eventstore.TypeChecker = (*TokenAddedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *TokenAddedEvent) ActionType() string {
+	return TokenAddedType
+}
+
+func TokenAddedEventFromStorage(event *eventstore.StorageEvent) (e *TokenAddedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-0YSt4", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[tokenAddedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &TokenAddedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}

internal/v2/user/user_deactivated.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type DeactivatedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const DeactivatedType = AggregateType + ".deactivated"
+
+var _ eventstore.TypeChecker = (*DeactivatedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *DeactivatedEvent) ActionType() string {
+	return DeactivatedType
+}
+
+func DeactivatedEventFromStorage(event *eventstore.StorageEvent) (e *DeactivatedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-SBLu2", "Errors.Invalid.Event.Type")
+	}
+
+	return &DeactivatedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/user_locked.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type LockedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const LockedType = AggregateType + ".locked"
+
+var _ eventstore.TypeChecker = (*LockedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *LockedEvent) ActionType() string {
+	return LockedType
+}
+
+func LockedEventFromStorage(event *eventstore.StorageEvent) (e *LockedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-48jjE", "Errors.Invalid.Event.Type")
+	}
+
+	return &LockedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/user_reactivated.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type ReactivatedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const ReactivatedType = AggregateType + ".reactivated"
+
+var _ eventstore.TypeChecker = (*ReactivatedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *ReactivatedEvent) ActionType() string {
+	return ReactivatedType
+}
+
+func ReactivatedEventFromStorage(event *eventstore.StorageEvent) (e *ReactivatedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-B3fcY", "Errors.Invalid.Event.Type")
+	}
+
+	return &ReactivatedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/user_removed.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type RemovedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const RemovedType = AggregateType + ".removed"
+
+var _ eventstore.TypeChecker = (*RemovedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *RemovedEvent) ActionType() string {
+	return RemovedType
+}
+
+func RemovedEventFromStorage(event *eventstore.StorageEvent) (e *RemovedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-UN6Xa", "Errors.Invalid.Event.Type")
+	}
+
+	return &RemovedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/user_unlocked.go

@@ -0,0 +1,27 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type UnlockedEvent eventstore.Event[eventstore.EmptyPayload]
+
+const UnlockedType = AggregateType + ".unlocked"
+
+var _ eventstore.TypeChecker = (*UnlockedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *UnlockedEvent) ActionType() string {
+	return UnlockedType
+}
+
+func UnlockedEventFromStorage(event *eventstore.StorageEvent) (e *UnlockedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-HB0wi", "Errors.Invalid.Event.Type")
+	}
+
+	return &UnlockedEvent{
+		StorageEvent: event,
+	}, nil
+}

internal/v2/user/username_changed.go

@@ -0,0 +1,37 @@
+package user
+
+import (
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type usernameChangedPayload struct {
+	Username string `json:"userName"`
+}
+
+type UsernameChangedEvent eventstore.Event[usernameChangedPayload]
+
+const UsernameChangedType = AggregateType + ".username.changed"
+
+var _ eventstore.TypeChecker = (*UsernameChangedEvent)(nil)
+
+// ActionType implements eventstore.Typer.
+func (c *UsernameChangedEvent) ActionType() string {
+	return UsernameChangedType
+}
+
+func UsernameChangedEventFromStorage(event *eventstore.StorageEvent) (e *UsernameChangedEvent, _ error) {
+	if event.Type != e.ActionType() {
+		return nil, zerrors.ThrowInvalidArgument(nil, "USER-hCGsh", "Errors.Invalid.Event.Type")
+	}
+
+	payload, err := eventstore.UnmarshalPayload[usernameChangedPayload](event.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &UsernameChangedEvent{
+		StorageEvent: event,
+		Payload:      payload,
+	}, nil
+}