types

type ActivityFilter struct {
	Actor      ActorRef
	Scope      ScopeFilter
	UserID     uuid.UUID
	ActorID    uuid.UUID
	Verbs      []string
	ObjectType string
	ObjectID   string
	Channel    string
	Channels   []string
	// ChannelDenylist excludes channels after allow filtering is applied.
	ChannelDenylist []string
	// MachineActivityEnabled toggles filtering of machine/system activity.
	MachineActivityEnabled *bool
	// MachineActorTypes enumerates actor types treated as machine/system.
	MachineActorTypes []string
	// MachineDataKeys enumerates data keys used to flag machine/system activity.
	MachineDataKeys []string
	Since           *time.Time
	Until           *time.Time
	Pagination      Pagination
	Keyword         string
}

type ActivityPage struct {
	Records    []ActivityRecord
	Total      int
	NextOffset int
	HasMore    bool
}

type ActivityRecord struct {
	ID         uuid.UUID
	UserID     uuid.UUID
	ActorID    uuid.UUID
	Verb       string
	ObjectType string
	ObjectID   string
	Channel    string
	IP         string
	TenantID   uuid.UUID
	OrgID      uuid.UUID
	Data       map[string]any
	OccurredAt time.Time
}

type ActivityRepository interface {
	ListActivity(ctx context.Context, filter ActivityFilter) (ActivityPage, error)
	ActivityStats(ctx context.Context, filter ActivityStatsFilter) (ActivityStats, error)
}

type ActivitySink interface {
	Log(context.Context, ActivityRecord) error
}

type ActivityStats struct {
	Total  int
	ByVerb map[string]int
}

type ActivityStatsFilter struct {
	Actor   ActorRef
	Scope   ScopeFilter
	UserID  uuid.UUID
	ActorID uuid.UUID
	Since   *time.Time
	Until   *time.Time
	Verbs   []string
	// MachineActivityEnabled toggles filtering of machine/system activity.
	MachineActivityEnabled *bool
	// MachineActorTypes enumerates actor types treated as machine/system.
	MachineActorTypes []string
	// MachineDataKeys enumerates data keys used to flag machine/system activity.
	MachineDataKeys []string
}

type ActorRef struct {
	ID   uuid.UUID
	Type string
}

type AllowAllAuthorizationPolicy struct{}

type AuthRepository interface {
	GetByID(ctx context.Context, id uuid.UUID) (*AuthUser, error)
	GetByIdentifier(ctx context.Context, identifier string) (*AuthUser, error)
	Create(ctx context.Context, input *AuthUser) (*AuthUser, error)
	Update(ctx context.Context, input *AuthUser) (*AuthUser, error)
	UpdateStatus(ctx context.Context, actor ActorRef, id uuid.UUID, next LifecycleState, opts ...TransitionOption) (*AuthUser, error)
	AllowedTransitions(ctx context.Context, id uuid.UUID) ([]LifecycleTransition, error)
	ResetPassword(ctx context.Context, id uuid.UUID, passwordHash string) error
}

type AuthUser struct {
	ID        uuid.UUID
	Role      string
	Status    LifecycleState
	Email     string
	Username  string
	FirstName string
	LastName  string
	Metadata  map[string]any
	CreatedAt *time.Time
	UpdatedAt *time.Time
	Raw       any
}

type AuthorizationPolicy interface {
	Authorize(ctx context.Context, check PolicyCheck) error
}

type AuthorizationPolicyFunc func(ctx context.Context, check PolicyCheck) error

type Clock interface {
	Now() time.Time
}

type Hooks struct {
	AfterLifecycle        func(context.Context, LifecycleEvent)
	AfterRoleChange       func(context.Context, RoleEvent)
	AfterPreferenceChange func(context.Context, PreferenceEvent)
	AfterProfileChange    func(context.Context, ProfileEvent)
	AfterActivity         func(context.Context, ActivityRecord)
}

type IDGenerator interface {
	UUID() uuid.UUID
}

type LifecycleEvent struct {
	UserID     uuid.UUID
	ActorID    uuid.UUID
	FromState  LifecycleState
	ToState    LifecycleState
	Reason     string
	OccurredAt time.Time
	Scope      ScopeFilter
	Metadata   map[string]any
}

type LifecycleState string

type LifecycleTransition struct {
	From LifecycleState
	To   LifecycleState
}

type Logger interface {
	Debug(msg string, fields ...any)
	Info(msg string, fields ...any)
	Error(msg string, err error, fields ...any)
}

type NopLogger struct{}

type Pagination struct {
	Limit  int
	Offset int
}

type PassthroughScopeResolver struct{}

type PasswordResetRecord struct {
	ID        uuid.UUID
	UserID    uuid.UUID
	Email     string
	Status    PasswordResetStatus
	JTI       string
	IssuedAt  time.Time
	ExpiresAt time.Time
	UsedAt    time.Time
	ResetAt   time.Time
	Scope     ScopeFilter
	CreatedAt time.Time
	UpdatedAt time.Time
}

type PasswordResetRepository interface {
	CreateReset(ctx context.Context, record PasswordResetRecord) (*PasswordResetRecord, error)
	GetResetByJTI(ctx context.Context, jti string) (*PasswordResetRecord, error)
	ConsumeReset(ctx context.Context, jti string, usedAt time.Time) error
	UpdateResetStatus(ctx context.Context, jti string, status PasswordResetStatus, usedAt time.Time) error
}

type PasswordResetStatus string

type PolicyAction string

type PolicyCheck struct {
	Actor    ActorRef
	Scope    ScopeFilter
	Action   PolicyAction
	TargetID uuid.UUID
}

type PreferenceEvent struct {
	UserID     uuid.UUID
	Scope      ScopeFilter
	Key        string
	Action     string
	ActorID    uuid.UUID
	OccurredAt time.Time
}

type PreferenceFilter struct {
	UserID uuid.UUID
	Scope  ScopeFilter
	Level  PreferenceLevel
	Keys   []string
}

type PreferenceLevel string

type PreferenceRecord struct {
	ID        uuid.UUID
	UserID    uuid.UUID
	Scope     ScopeFilter
	Level     PreferenceLevel
	Key       string
	Value     map[string]any
	Version   int
	CreatedAt time.Time
	UpdatedAt time.Time
	CreatedBy uuid.UUID
	UpdatedBy uuid.UUID
}

type PreferenceRepository interface {
	ListPreferences(ctx context.Context, filter PreferenceFilter) ([]PreferenceRecord, error)
	UpsertPreference(ctx context.Context, record PreferenceRecord) (*PreferenceRecord, error)
	DeletePreference(ctx context.Context, userID uuid.UUID, scope ScopeFilter, level PreferenceLevel, key string) error
}

type PreferenceSnapshot struct {
	Effective map[string]any
	Traces    []PreferenceTrace
}

type PreferenceTrace struct {
	Key    string
	Layers []PreferenceTraceLayer
}

type PreferenceTraceLayer struct {
	Level      PreferenceLevel
	UserID     uuid.UUID
	Scope      ScopeFilter
	SnapshotID string
	Value      any
	Found      bool
}

type ProfileEvent struct {
	UserID     uuid.UUID
	Scope      ScopeFilter
	ActorID    uuid.UUID
	OccurredAt time.Time
	Profile    UserProfile
}

type ProfilePatch struct {
	DisplayName *string
	AvatarURL   *string
	Locale      *string
	Timezone    *string
	Bio         *string
	Contact     map[string]any
	Metadata    map[string]any
}

type ProfileRepository interface {
	GetProfile(ctx context.Context, userID uuid.UUID, scope ScopeFilter) (*UserProfile, error)
	UpsertProfile(ctx context.Context, profile UserProfile) (*UserProfile, error)
}

type RoleAssignment struct {
	UserID     uuid.UUID
	RoleID     uuid.UUID
	RoleName   string
	Scope      ScopeFilter
	AssignedAt time.Time
	AssignedBy uuid.UUID
}

type RoleAssignmentFilter struct {
	Actor   ActorRef
	Scope   ScopeFilter
	UserID  uuid.UUID
	RoleID  uuid.UUID
	UserIDs []uuid.UUID
	RoleIDs []uuid.UUID
}

type RoleDefinition struct {
	ID          uuid.UUID
	Name        string
	Order       int
	Description string
	RoleKey     string
	Permissions []string
	Metadata    map[string]any
	IsSystem    bool
	Scope       ScopeFilter
	CreatedAt   time.Time
	UpdatedAt   time.Time
	CreatedBy   uuid.UUID
	UpdatedBy   uuid.UUID
}

type RoleEvent struct {
	RoleID     uuid.UUID
	UserID     uuid.UUID
	Action     string
	ActorID    uuid.UUID
	Scope      ScopeFilter
	OccurredAt time.Time
	Role       RoleDefinition
}

type RoleFilter struct {
	Actor         ActorRef
	Scope         ScopeFilter
	Keyword       string
	RoleKey       string
	IncludeSystem bool
	RoleIDs       []uuid.UUID
	Pagination    Pagination
}

type RoleMutation struct {
	Name        string
	Order       int
	Description string
	RoleKey     string
	Permissions []string
	Metadata    map[string]any
	IsSystem    bool
	Scope       ScopeFilter
	ActorID     uuid.UUID
}

type RolePage struct {
	Roles      []RoleDefinition
	Total      int
	NextOffset int
	HasMore    bool
}

type RoleRegistry interface {
	CreateRole(ctx context.Context, input RoleMutation) (*RoleDefinition, error)
	UpdateRole(ctx context.Context, id uuid.UUID, input RoleMutation) (*RoleDefinition, error)
	DeleteRole(ctx context.Context, id uuid.UUID, scope ScopeFilter, actor uuid.UUID) error
	AssignRole(ctx context.Context, userID, roleID uuid.UUID, scope ScopeFilter, actor uuid.UUID) error
	UnassignRole(ctx context.Context, userID, roleID uuid.UUID, scope ScopeFilter, actor uuid.UUID) error
	ListRoles(ctx context.Context, filter RoleFilter) (RolePage, error)
	GetRole(ctx context.Context, id uuid.UUID, scope ScopeFilter) (*RoleDefinition, error)
	ListAssignments(ctx context.Context, filter RoleAssignmentFilter) ([]RoleAssignment, error)
}

type ScopeEnforcer func(ctx context.Context, payload SecureLinkPayload, scope ScopeFilter) error

type ScopeFilter struct {
	TenantID uuid.UUID
	OrgID    uuid.UUID
	Labels   map[string]uuid.UUID
}

type ScopeResolver interface {
	ResolveScope(ctx context.Context, actor ActorRef, requested ScopeFilter) (ScopeFilter, error)
}

type ScopeResolverFunc func(ctx context.Context, actor ActorRef, requested ScopeFilter) (ScopeFilter, error)

type SecureLinkConfigurator interface {
	GetSigningKey() string
	GetExpiration() time.Duration
	GetBaseURL() string
	GetQueryKey() string
	GetRoutes() map[string]string
	GetAsQuery() bool
}

type SecureLinkManager interface {
	Generate(route string, payloads ...SecureLinkPayload) (string, error)
	Validate(token string) (map[string]any, error)
	GetAndValidate(fn func(string) string) (SecureLinkPayload, error)
	GetExpiration() time.Duration
}

type SecureLinkPayload map[string]any

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

type SystemClock struct{}

type TransitionConfig struct {
	Reason   string
	Metadata map[string]any
	Force    bool
}

type TransitionOption func(*TransitionConfig)

type TransitionPolicy interface {
	Validate(current, target LifecycleState) error
	AllowedTargets(current LifecycleState) []LifecycleState
}

type UUIDGenerator struct{}

type UserInventoryFilter struct {
	Actor      ActorRef
	Scope      ScopeFilter
	Statuses   []LifecycleState
	Role       string
	Keyword    string
	Pagination Pagination
	UserIDs    []uuid.UUID
}

type UserInventoryPage struct {
	Users      []AuthUser
	Total      int
	NextOffset int
	HasMore    bool
}

type UserInventoryRepository interface {
	ListUsers(ctx context.Context, filter UserInventoryFilter) (UserInventoryPage, error)
}

type UserProfile struct {
	UserID      uuid.UUID
	DisplayName string
	AvatarURL   string
	Locale      string
	Timezone    string
	Bio         string
	Contact     map[string]any
	Metadata    map[string]any
	Scope       ScopeFilter
	CreatedAt   time.Time
	UpdatedAt   time.Time
	CreatedBy   uuid.UUID
	UpdatedBy   uuid.UUID
}

type UserToken struct {
	ID        uuid.UUID
	UserID    uuid.UUID
	Type      UserTokenType
	JTI       string
	Status    UserTokenStatus
	IssuedAt  time.Time
	ExpiresAt time.Time
	UsedAt    time.Time
	CreatedAt time.Time
	UpdatedAt time.Time
}

type UserTokenRepository interface {
	CreateToken(ctx context.Context, token UserToken) (*UserToken, error)
	GetTokenByJTI(ctx context.Context, tokenType UserTokenType, jti string) (*UserToken, error)
	UpdateTokenStatus(ctx context.Context, tokenType UserTokenType, jti string, status UserTokenStatus, usedAt time.Time) error
}

type UserTokenStatus string

type UserTokenType string