Event schema reference

interface AssetEventEnvelope<TPayload = unknown> {
  id: string;                    // evt_<ULID>
  tenantId: string;
  spaceId: string;
  eventType: string;             // PascalCase past-tense
  eventSchemaVersion: number;    // integer per event type
  subjectType: string;           // PascalCase, must be registered
  subjectId: string;
  actorId: string;
  actorType: string;             // see ActorType enum
  actionInvocationId?: string;   // empty for platform-emitted events not tied to an action
  payload: TPayload;
  sequence: number;              // monotonic per (subjectType, subjectId)
  occurredAt: Date;
  recordedAt: Date;
  correlationId: string;
  causationId?: string;
}

public interface IAssetEventEnvelope<TPayload>
{
    string Id { get; }                    // evt_<ULID>
    string TenantId { get; }
    string SpaceId { get; }
    string EventType { get; }             // PascalCase past-tense
    int EventSchemaVersion { get; }       // integer per event type
    string SubjectType { get; }           // PascalCase, must be registered
    string SubjectId { get; }
    string ActorId { get; }
    string ActorType { get; }             // see ActorType enum
    string? ActionInvocationId { get; }   // empty for platform-emitted events not tied to an action
    TPayload Payload { get; }
    int Sequence { get; }                 // monotonic per (subjectType, subjectId)
    DateTime OccurredAt { get; }
    DateTime RecordedAt { get; }
    string CorrelationId { get; }
    string? CausationId { get; }
}

export function registerSubjectType(type: string): void;
export function isValidSubjectType(type: string): boolean;
export function getRegisteredSubjectTypes(): string[];

export function registerEventType(type: string): void;
export function isValidEventType(type: string): boolean;
export function getRegisteredEventTypes(): string[];

export interface EventTypeRegistry {
  register(eventType: string): void;
  has(eventType: string): boolean;
  list(): string[];
}

export function createEventTypeRegistry(initial?: string[]): EventTypeRegistry;

public static class SubjectTypeRegistry
{
    public static void Register(string type);
    public static bool IsValid(string type);
    public static IReadOnlyList<string> GetRegistered();
}

public static class EventTypeRegistry
{
    public static void Register(string type);
    public static bool IsValid(string type);
    public static IReadOnlyList<string> GetRegistered();
}

public interface IEventTypeRegistry
{
    void Register(string eventType);
    bool Has(string eventType);
    IReadOnlyList<string> List();
}

public static IEventTypeRegistry CreateEventTypeRegistry(IEnumerable<string>? initial = null);