services

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

type AgentNotInWorkspaceError struct {
	AgentID     string
	WorkspaceID uuid.UUID
}

type AgentService interface {
	GetAgent(ctx context.Context, agentID string) (*models.Agent, error)
	GetAvailableAgents(ctx context.Context) ([]*models.Agent, error)
	GetAgentCapabilities(ctx context.Context, agentID string) ([]string, error)
	UpdateAgentStatus(ctx context.Context, agentID string, status string) error
	GetAgentWorkload(ctx context.Context, agentID string) (*models.AgentWorkload, error)
}

type AggregateRoot interface {
	GetID() uuid.UUID
	GetType() string
	GetVersion() int
}

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

type AssignmentStrategy interface {
	Assign(ctx context.Context, task *models.Task, agents []*models.Agent) (*models.Agent, error)
	GetName() string
}

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

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

type CollaboratorAddedEvent struct {
	WorkspaceID uuid.UUID
	AgentID     string
	Role        string
	Timestamp   time.Time
}

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

type ConcurrentModificationError struct {
	Resource string
	ID       uuid.UUID
	Version  int
}

type ConflictResolutionService interface {
	// Document conflict resolution
	ResolveDocumentConflict(ctx context.Context, documentID uuid.UUID, operations []collaboration.DocumentOperation) (*models.Document, error)
	GetDocumentCRDT(ctx context.Context, documentID uuid.UUID) (*collaboration.DocumentCRDT, error)
	ApplyDocumentOperation(ctx context.Context, documentID uuid.UUID, operation *collaboration.CRDTOperation) error
	SyncDocument(ctx context.Context, documentID uuid.UUID, remoteCRDT *collaboration.DocumentCRDT) error

	// Workspace state conflict resolution
	ResolveWorkspaceStateConflict(ctx context.Context, workspaceID uuid.UUID, operations []models.StateOperation) (*models.WorkspaceState, error)
	GetWorkspaceStateCRDT(ctx context.Context, workspaceID uuid.UUID) (*collaboration.StateCRDT, error)
	ApplyStateOperation(ctx context.Context, workspaceID uuid.UUID, operation *collaboration.StateOperation) error
	SyncWorkspaceState(ctx context.Context, workspaceID uuid.UUID, remoteState *collaboration.StateCRDT) error

	// Task conflict resolution
	ResolveTaskConflict(ctx context.Context, taskID uuid.UUID, conflicts []models.TaskConflict) (*models.Task, error)

	// General conflict detection
	DetectConflicts(ctx context.Context, entityType string, entityID uuid.UUID) ([]*models.ConflictInfo, error)
	GetConflictHistory(ctx context.Context, entityType string, entityID uuid.UUID) ([]*models.ConflictResolution, error)

	// Vector clock management
	GetVectorClock(ctx context.Context, nodeID string) (crdt.VectorClock, error)
	UpdateVectorClock(ctx context.Context, nodeID string, clock crdt.VectorClock) error
}

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

type DeadlockInfo struct {
	ID            string    `json:"id"`
	DetectedAt    time.Time `json:"detected_at"`
	InvolvedLocks []string  `json:"involved_locks"`
	Agents        []string  `json:"agents"`
	CycleInfo     string    `json:"cycle_info"`
}

type DefaultSanitizer struct{}

type DelegationError struct {
	Reason string
}

type DocumentLock struct {
	ID           string                 `json:"id"`
	DocumentID   uuid.UUID              `json:"document_id"`
	AgentID      string                 `json:"agent_id"`
	Type         LockType               `json:"type"`
	AcquiredAt   time.Time              `json:"acquired_at"`
	ExpiresAt    time.Time              `json:"expires_at"`
	RefreshCount int                    `json:"refresh_count"`
	Metadata     map[string]interface{} `json:"metadata,omitempty"`
}

type DocumentLockService interface {
	// Document-level locking
	LockDocument(ctx context.Context, documentID uuid.UUID, agentID string, duration time.Duration) (*DocumentLock, error)
	UnlockDocument(ctx context.Context, documentID uuid.UUID, agentID string) error
	ExtendLock(ctx context.Context, documentID uuid.UUID, agentID string, extension time.Duration) error
	IsDocumentLocked(ctx context.Context, documentID uuid.UUID) (bool, *DocumentLock, error)

	// Section-level locking
	LockSection(ctx context.Context, documentID uuid.UUID, sectionID string, agentID string, duration time.Duration) (*SectionLock, error)
	UnlockSection(ctx context.Context, documentID uuid.UUID, sectionID string, agentID string) error
	GetSectionLocks(ctx context.Context, documentID uuid.UUID) ([]*SectionLock, error)

	// Lock management
	GetActiveLocks(ctx context.Context, agentID string) ([]*DocumentLock, error)
	ReleaseAllLocks(ctx context.Context, agentID string) error

	// Deadlock detection
	DetectDeadlocks(ctx context.Context) ([]*DeadlockInfo, error)
	ResolveDeadlock(ctx context.Context, deadlockID string) error
}

type DocumentLockedError struct {
	DocumentID uuid.UUID
	LockedBy   string
}

type DocumentService interface {
	// Document lifecycle
	Create(ctx context.Context, doc *models.SharedDocument) error
	Get(ctx context.Context, id uuid.UUID) (*models.SharedDocument, error)
	Update(ctx context.Context, doc *models.SharedDocument) error
	Delete(ctx context.Context, id uuid.UUID) error

	// Collaborative editing
	ApplyOperation(ctx context.Context, docID uuid.UUID, operation *collaboration.DocumentOperation) error
	GetOperations(ctx context.Context, docID uuid.UUID, since time.Time) ([]*collaboration.DocumentOperation, error)
	GetOperationsBySequence(ctx context.Context, docID uuid.UUID, fromSeq, toSeq int64) ([]*collaboration.DocumentOperation, error)

	// Locking
	AcquireLock(ctx context.Context, docID uuid.UUID, agentID string, duration time.Duration) error
	ReleaseLock(ctx context.Context, docID uuid.UUID, agentID string) error
	ExtendLock(ctx context.Context, docID uuid.UUID, agentID string, duration time.Duration) error
	GetLockInfo(ctx context.Context, docID uuid.UUID) (*models.DocumentLock, error)

	// Conflict resolution
	DetectConflicts(ctx context.Context, docID uuid.UUID) ([]*models.ConflictInfo, error)
	ResolveConflict(ctx context.Context, conflictID uuid.UUID, resolution interface{}) error
	GetConflictHistory(ctx context.Context, docID uuid.UUID) ([]*models.ConflictResolution, error)

	// Version management
	CreateSnapshot(ctx context.Context, docID uuid.UUID) (*models.DocumentSnapshot, error)
	GetSnapshot(ctx context.Context, docID uuid.UUID, version int64) (*models.DocumentSnapshot, error)
	ListSnapshots(ctx context.Context, docID uuid.UUID) ([]*models.DocumentSnapshot, error)
	RestoreSnapshot(ctx context.Context, docID uuid.UUID, version int64) error

	// Search and query
	SearchDocuments(ctx context.Context, query string, filters interfaces.DocumentFilters) ([]*models.SharedDocument, error)
	GetDocumentsByWorkspace(ctx context.Context, workspaceID uuid.UUID) ([]*models.SharedDocument, error)
	GetDocumentsByCreator(ctx context.Context, createdBy string) ([]*models.SharedDocument, error)

	// Analytics
	GetDocumentStats(ctx context.Context, docID uuid.UUID) (*interfaces.DocumentStats, error)
	GetCollaborationMetrics(ctx context.Context, docID uuid.UUID, period time.Duration) (*models.CollaborationMetrics, error)

	// Real-time updates
	SubscribeToChanges(ctx context.Context, docID uuid.UUID, handler func(operation *collaboration.DocumentOperation)) (unsubscribe func())
	BroadcastChange(ctx context.Context, docID uuid.UUID, operation *collaboration.DocumentOperation) error
}

type EncryptionService interface {
	Encrypt(ctx context.Context, data []byte) ([]byte, error)
	Decrypt(ctx context.Context, data []byte) ([]byte, error)
	EncryptString(ctx context.Context, data string) (string, error)
	DecryptString(ctx context.Context, data string) (string, error)
}

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

type EventBus interface {
	Subscribe(topic string, handler func(event interface{})) (unsubscribe func())
	Publish(topic string, event interface{})
	Close()
}

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

type HealthChecker interface {
	Check(ctx context.Context) error
	RegisterCheck(name string, check func(context.Context) error)
}

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

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

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

type LockConflictError struct {
	DocumentID    uuid.UUID
	CurrentHolder string
	ExpiresAt     time.Time
}

type LockNotFoundError struct {
	DocumentID uuid.UUID
}

type LockRefreshLimitError struct {
	DocumentID   uuid.UUID
	RefreshCount int
	MaxRefresh   int
}

type LockType string

type MergeConflictError struct {
	DocumentID uuid.UUID
	Conflicts  []string
}

type NoEligibleAgentsError struct {
	TaskType     string
	Requirements []string
}

type NoOpEncryptionService struct{}

type NoOpSpan struct{}

type NotificationService interface {
	NotifyTaskAssigned(ctx context.Context, agentID string, task interface{}) error
	NotifyTaskCompleted(ctx context.Context, agentID string, task interface{}) error
	NotifyTaskFailed(ctx context.Context, taskID uuid.UUID, agentID string, reason string) error
	NotifyWorkflowStarted(ctx context.Context, workflow interface{}) error
	NotifyWorkflowCompleted(ctx context.Context, workflow interface{}) error
	NotifyWorkflowFailed(ctx context.Context, workflowID uuid.UUID, reason string) error
	NotifyWorkflowUpdated(ctx context.Context, workflow interface{}) error
	NotifyStepStarted(ctx context.Context, executionID uuid.UUID, stepID string) error
	NotifyStepCompleted(ctx context.Context, executionID uuid.UUID, stepID string, output interface{}) error
	NotifyResourceDeleted(ctx context.Context, resourceType string, resourceID uuid.UUID) error
	BroadcastToAgents(ctx context.Context, agentIDs []string, message interface{}) error
	BroadcastToWorkspace(ctx context.Context, workspaceID uuid.UUID, message interface{}) error
}

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

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

type QuotaError struct {
	TenantID uuid.UUID
	Resource string
	Limit    int64
	Current  int64
}

type QuotaExceededError struct {
	Resource string
	Used     int64
	Limit    int64
}

type QuotaInfo struct {
	Resource  string
	Limit     int64
	Used      int64
	Available int64
	Period    string
}

type QuotaManager interface {
	GetQuota(ctx context.Context, tenantID uuid.UUID, resource string) (int64, error)
	GetUsage(ctx context.Context, tenantID uuid.UUID, resource string) (int64, error)
	IncrementUsage(ctx context.Context, tenantID uuid.UUID, resource string, amount int64) error
	SetQuota(ctx context.Context, tenantID uuid.UUID, resource string, limit int64) error
	GetQuotaStatus(ctx context.Context, tenantID uuid.UUID) (*QuotaStatus, error)
}

type QuotaStatus struct {
	TenantID uuid.UUID
	Quotas   map[string]QuotaInfo
}

type RateLimitError struct {
	Key        string
	Limit      int
	Window     time.Duration
	RetryAfter time.Duration
}

type RateLimiter interface {
	Check(ctx context.Context, key string) error
	CheckWithLimit(ctx context.Context, key string, limit int, window time.Duration) error
	GetRemaining(ctx context.Context, key string) (int, error)
	Reset(ctx context.Context, key string) error
}

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

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

type Sanitizer interface {
	SanitizeString(input string) string
	SanitizeJSON(input interface{}) (interface{}, error)
	SanitizeHTML(input string) string
}

type SectionLock struct {
	DocumentLock
	SectionID   string `json:"section_id"`
	StartOffset int    `json:"start_offset"`
	EndOffset   int    `json:"end_offset"`
}

type SectionLockConflictError struct {
	DocumentID    uuid.UUID
	SectionID     string
	CurrentHolder string
}

type ServiceConfig struct {
	// Resilience
	CircuitBreaker *gobreaker.Settings
	RetryPolicy    resilience.RetryPolicy
	TimeoutPolicy  resilience.TimeoutPolicy
	BulkheadPolicy resilience.BulkheadPolicy

	// Rate Limiting
	RateLimiter  RateLimiter
	QuotaManager QuotaManager

	// Security
	Authorizer        auth.Authorizer
	Sanitizer         Sanitizer
	EncryptionService EncryptionService

	// Observability
	Logger  observability.Logger
	Metrics observability.MetricsClient
	Tracer  observability.StartSpanFunc

	// Business Rules
	RuleEngine    rules.Engine
	PolicyManager rules.PolicyManager
}

type StateStore interface {
	GetState(ctx context.Context, key string) (interface{}, error)
	SetState(ctx context.Context, key string, value interface{}) error
	GetStateForUpdate(ctx context.Context, key string) (interface{}, error)
	SaveState(ctx context.Context, key string, state interface{}) error
}

type StepDependencyError struct {
	StepID       string
	DependencyID string
	Status       string
}

type StepNotFoundError struct {
	WorkflowID uuid.UUID
	StepID     string
}

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

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

type TaskService interface {
	// Task lifecycle with idempotency
	Create(ctx context.Context, task *models.Task, idempotencyKey string) error
	CreateBatch(ctx context.Context, tasks []*models.Task) error
	Get(ctx context.Context, id uuid.UUID) (*models.Task, error)
	GetBatch(ctx context.Context, ids []uuid.UUID) ([]*models.Task, error)
	Update(ctx context.Context, task *models.Task) error
	Delete(ctx context.Context, id uuid.UUID) error

	// Task assignment with load balancing
	AssignTask(ctx context.Context, taskID uuid.UUID, agentID string) error
	AutoAssignTask(ctx context.Context, taskID uuid.UUID, strategy AssignmentStrategy) error
	DelegateTask(ctx context.Context, delegation *models.TaskDelegation) error
	AcceptTask(ctx context.Context, taskID uuid.UUID, agentID string) error
	RejectTask(ctx context.Context, taskID uuid.UUID, agentID string, reason string) error

	// Task execution with monitoring
	StartTask(ctx context.Context, taskID uuid.UUID, agentID string) error
	UpdateProgress(ctx context.Context, taskID uuid.UUID, progress int, message string) error
	CompleteTask(ctx context.Context, taskID uuid.UUID, agentID string, result interface{}) error
	FailTask(ctx context.Context, taskID uuid.UUID, agentID string, errorMsg string) error
	RetryTask(ctx context.Context, taskID uuid.UUID) error

	// Advanced querying with caching
	GetAgentTasks(ctx context.Context, agentID string, filters interfaces.TaskFilters) ([]*models.Task, error)
	GetAvailableTasks(ctx context.Context, agentID string, capabilities []string) ([]*models.Task, error)
	SearchTasks(ctx context.Context, query string, filters interfaces.TaskFilters) ([]*models.Task, error)
	GetTaskTimeline(ctx context.Context, taskID uuid.UUID) ([]*models.TaskEvent, error)

	// Distributed task management
	CreateDistributedTask(ctx context.Context, task *models.DistributedTask) error
	SubmitSubtaskResult(ctx context.Context, parentTaskID, subtaskID uuid.UUID, result interface{}) error
	GetTaskTree(ctx context.Context, rootTaskID uuid.UUID) (*models.TaskTree, error)
	CancelTaskTree(ctx context.Context, rootTaskID uuid.UUID, reason string) error

	// Workflow integration
	CreateWorkflowTask(ctx context.Context, workflowID, stepID uuid.UUID, params map[string]interface{}) (*models.Task, error)
	CompleteWorkflowTask(ctx context.Context, taskID uuid.UUID, output interface{}) error

	// Analytics and reporting
	GetTaskStats(ctx context.Context, filters interfaces.TaskFilters) (*models.TaskStats, error)
	GetAgentPerformance(ctx context.Context, agentID string, period time.Duration) (*models.AgentPerformance, error)
	GenerateTaskReport(ctx context.Context, filters interfaces.TaskFilters, format string) ([]byte, error)

	// Maintenance
	ArchiveCompletedTasks(ctx context.Context, before time.Time) (int64, error)
	RebalanceTasks(ctx context.Context) error
}

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

type TenantAwareAuthService struct {
	*auth.Service
	// contains filtered or unexported fields
}

type TenantConfigService interface {
	GetConfig(ctx context.Context, tenantID string) (*models.TenantConfig, error)
	CreateConfig(ctx context.Context, config *models.TenantConfig) error
	UpdateConfig(ctx context.Context, config *models.TenantConfig) error
	DeleteConfig(ctx context.Context, tenantID string) error

	// Service token management
	SetServiceToken(ctx context.Context, tenantID, provider, token string) error
	RemoveServiceToken(ctx context.Context, tenantID, provider string) error

	// Feature flag management
	SetFeature(ctx context.Context, tenantID, feature string, value interface{}) error
	IsFeatureEnabled(ctx context.Context, tenantID, feature string) (bool, error)

	// Rate limit management
	SetRateLimitForKeyType(ctx context.Context, tenantID, keyType string, limit models.KeyTypeRateLimit) error
	SetRateLimitForEndpoint(ctx context.Context, tenantID, endpoint string, limit models.EndpointRateLimit) error
}

type Transaction interface {
	Commit() error
	Rollback() error
	GetID() uuid.UUID
}

type TransactionParticipant interface {
	Prepare(ctx context.Context) error
	Commit(ctx context.Context) error
	Rollback(ctx context.Context) error
	GetID() string
}

type TransactionState int

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

type TxConfig struct {
	Timeout        time.Duration
	IsolationLevel string
	RetryPolicy    resilience.RetryPolicy
}

type TxOption func(*TxConfig)

type UnauthorizedError struct {
	Action string
	Reason string
}

type UnauthorizedLockError struct {
	DocumentID uuid.UUID
	AgentID    string
	OwnerID    string
}

type ValidationError struct {
	Field   string
	Message string
}

type VersionMismatchError struct {
	DocumentID      uuid.UUID
	ExpectedVersion int
	ActualVersion   int
}

type WorkflowNotActiveError struct {
	WorkflowID uuid.UUID
}

type WorkflowService interface {
	// Workflow management
	CreateWorkflow(ctx context.Context, workflow *models.Workflow) error
	GetWorkflow(ctx context.Context, id uuid.UUID) (*models.Workflow, error)
	UpdateWorkflow(ctx context.Context, workflow *models.Workflow) error
	DeleteWorkflow(ctx context.Context, id uuid.UUID) error
	ListWorkflows(ctx context.Context, filters interfaces.WorkflowFilters) ([]*models.Workflow, error)
	SearchWorkflows(ctx context.Context, query string) ([]*models.Workflow, error)

	// Execution management
	CreateExecution(ctx context.Context, execution *models.WorkflowExecution) error
	ExecuteWorkflow(ctx context.Context, workflowID uuid.UUID, input map[string]interface{}, idempotencyKey string) (*models.WorkflowExecution, error)
	ExecuteWorkflowStep(ctx context.Context, executionID uuid.UUID, stepID string) error
	StartWorkflow(ctx context.Context, workflowID uuid.UUID, initiatorID string, input map[string]interface{}) (*models.WorkflowExecution, error)
	GetExecution(ctx context.Context, executionID uuid.UUID) (*models.WorkflowExecution, error)
	ListExecutions(ctx context.Context, workflowID uuid.UUID, filters interfaces.ExecutionFilters) ([]*models.WorkflowExecution, error)
	GetExecutionStatus(ctx context.Context, executionID uuid.UUID) (*models.ExecutionStatus, error)
	GetExecutionTimeline(ctx context.Context, executionID uuid.UUID) ([]*models.ExecutionEvent, error)
	GetExecutionHistory(ctx context.Context, workflowID uuid.UUID) ([]*models.WorkflowExecution, error)

	// Execution control
	UpdateExecution(ctx context.Context, execution *models.WorkflowExecution) error
	PauseExecution(ctx context.Context, executionID uuid.UUID, reason string) error
	ResumeExecution(ctx context.Context, executionID uuid.UUID) error
	CancelExecution(ctx context.Context, executionID uuid.UUID, reason string) error
	RetryExecution(ctx context.Context, executionID uuid.UUID, fromStep string) error

	// Step management
	CompleteStep(ctx context.Context, executionID uuid.UUID, stepID string, output map[string]interface{}) error
	FailStep(ctx context.Context, executionID uuid.UUID, stepID string, reason string, details map[string]interface{}) error
	RetryStep(ctx context.Context, executionID uuid.UUID, stepID string) error
	GetCurrentStep(ctx context.Context, executionID uuid.UUID) (*models.StepExecution, error)
	GetPendingSteps(ctx context.Context, executionID uuid.UUID) ([]*models.StepExecution, error)
	GetStepExecution(ctx context.Context, executionID uuid.UUID, stepID string) (*models.StepExecution, error)

	// Approval management
	SubmitApproval(ctx context.Context, executionID uuid.UUID, stepID string, approval *models.ApprovalDecision) error
	GetPendingApprovals(ctx context.Context, approverID string) ([]*models.PendingApproval, error)

	// Template management
	CreateWorkflowTemplate(ctx context.Context, template *models.WorkflowTemplate) error
	GetWorkflowTemplate(ctx context.Context, templateID uuid.UUID) (*models.WorkflowTemplate, error)
	ListWorkflowTemplates(ctx context.Context) ([]*models.WorkflowTemplate, error)
	CreateFromTemplate(ctx context.Context, templateID uuid.UUID, params map[string]interface{}) (*models.Workflow, error)

	// Validation and simulation
	ValidateWorkflow(ctx context.Context, workflow *models.Workflow) error
	SimulateWorkflow(ctx context.Context, workflow *models.Workflow, input map[string]interface{}) (*models.SimulationResult, error)

	// Analytics and reporting
	GetWorkflowStats(ctx context.Context, workflowID uuid.UUID, period time.Duration) (*interfaces.WorkflowStats, error)
	GetWorkflowHistory(ctx context.Context, workflowID uuid.UUID, limit int, offset int) ([]*models.WorkflowExecution, error)
	GetWorkflowMetrics(ctx context.Context, workflowID uuid.UUID) (*models.WorkflowMetrics, error)
	GenerateWorkflowReport(ctx context.Context, filters interfaces.WorkflowFilters, format string) ([]byte, error)

	// Maintenance
	ArchiveCompletedExecutions(ctx context.Context, before time.Time) (int64, error)

	// Advanced features
	CreateBranchingPath(ctx context.Context, executionID uuid.UUID, branchPoint string, conditions map[string]interface{}) error
	MergeBranchingPaths(ctx context.Context, executionID uuid.UUID, branchIDs []string) error
	CreateCompensation(ctx context.Context, executionID uuid.UUID, failedStep string, compensation *models.CompensationAction) error
	ExecuteCompensation(ctx context.Context, executionID uuid.UUID) error
}

type WorkspaceActivity struct {
	ID           uuid.UUID              `json:"id" db:"id"`
	WorkspaceID  uuid.UUID              `json:"workspace_id" db:"workspace_id"`
	AgentID      string                 `json:"agent_id" db:"agent_id"`
	ActivityType string                 `json:"activity_type" db:"activity_type"`
	ResourceType string                 `json:"resource_type,omitempty" db:"resource_type"`
	ResourceID   string                 `json:"resource_id,omitempty" db:"resource_id"`
	Action       string                 `json:"action" db:"action"`
	Metadata     map[string]interface{} `json:"metadata" db:"metadata"`
	IPAddress    string                 `json:"ip_address,omitempty" db:"ip_address"`
	UserAgent    string                 `json:"user_agent,omitempty" db:"user_agent"`
	CreatedAt    time.Time              `json:"created_at" db:"created_at"`
}

type WorkspaceCreatedEvent struct {
	WorkspaceID uuid.UUID
	TenantID    uuid.UUID
	CreatedBy   string
	Timestamp   time.Time
}

type WorkspaceDeletedEvent struct {
	WorkspaceID uuid.UUID
	TenantID    uuid.UUID
	DeletedBy   string
	Timestamp   time.Time
}

type WorkspaceFullError struct {
	WorkspaceID uuid.UUID
	MaxAgents   int
}

type WorkspaceMember struct {
	WorkspaceID uuid.UUID              `json:"workspace_id" db:"workspace_id"`
	AgentID     string                 `json:"agent_id" db:"agent_id"`
	Role        WorkspaceMemberRole    `json:"role" db:"role"`
	Permissions map[string]interface{} `json:"permissions" db:"permissions"`
	JoinedAt    time.Time              `json:"joined_at" db:"joined_at"`
	JoinedBy    string                 `json:"joined_by" db:"joined_by"`
	LastActive  time.Time              `json:"last_active" db:"last_active"`
	Metadata    map[string]interface{} `json:"metadata" db:"metadata"`
}

type WorkspaceMemberRole string

type WorkspaceMemberService interface {
	// Member management
	AddMember(ctx context.Context, workspaceID uuid.UUID, agentID string, role WorkspaceMemberRole) error
	UpdateMemberRole(ctx context.Context, workspaceID uuid.UUID, agentID string, newRole WorkspaceMemberRole) error
	RemoveMember(ctx context.Context, workspaceID uuid.UUID, agentID string) error
	GetMember(ctx context.Context, workspaceID uuid.UUID, agentID string) (*WorkspaceMember, error)
	ListMembers(ctx context.Context, workspaceID uuid.UUID) ([]*WorkspaceMember, error)

	// Role-based access control
	CheckPermission(ctx context.Context, workspaceID uuid.UUID, agentID string, permission string) (bool, error)
	GetMemberRole(ctx context.Context, workspaceID uuid.UUID, agentID string) (WorkspaceMemberRole, error)

	// Activity tracking
	LogActivity(ctx context.Context, activity *WorkspaceActivity) error
	GetActivities(ctx context.Context, workspaceID uuid.UUID, limit int) ([]*WorkspaceActivity, error)

	// Workspace quotas
	CheckMemberQuota(ctx context.Context, workspaceID uuid.UUID) error
	UpdateLastActive(ctx context.Context, workspaceID uuid.UUID, agentID string) error
}

type WorkspaceService interface {
	// Workspace lifecycle
	Create(ctx context.Context, workspace *models.Workspace) error
	Get(ctx context.Context, id uuid.UUID) (*models.Workspace, error)
	Update(ctx context.Context, workspace *models.Workspace) error
	Delete(ctx context.Context, id uuid.UUID) error
	Archive(ctx context.Context, id uuid.UUID) error

	// Member management with permissions
	AddMember(ctx context.Context, member *models.WorkspaceMember) error
	RemoveMember(ctx context.Context, workspaceID uuid.UUID, agentID string) error
	UpdateMemberRole(ctx context.Context, workspaceID uuid.UUID, agentID string, role string) error
	UpdateMemberPermissions(ctx context.Context, workspaceID uuid.UUID, agentID string, permissions []string) error
	ListMembers(ctx context.Context, workspaceID uuid.UUID) ([]*models.WorkspaceMember, error)
	GetMemberActivity(ctx context.Context, workspaceID uuid.UUID) ([]*models.MemberActivity, error)

	// State management with CRDT
	GetState(ctx context.Context, workspaceID uuid.UUID) (*models.WorkspaceState, error)
	UpdateState(ctx context.Context, workspaceID uuid.UUID, operation *models.StateOperation) error
	MergeState(ctx context.Context, workspaceID uuid.UUID, remoteState *models.WorkspaceState) error
	GetStateHistory(ctx context.Context, workspaceID uuid.UUID, limit int) ([]*models.StateSnapshot, error)
	RestoreState(ctx context.Context, workspaceID uuid.UUID, snapshotID uuid.UUID) error

	// Document management
	CreateDocument(ctx context.Context, doc *models.SharedDocument) error
	GetDocument(ctx context.Context, docID uuid.UUID) (*models.SharedDocument, error)
	UpdateDocument(ctx context.Context, docID uuid.UUID, operation *collaboration.DocumentOperation) error
	ListDocuments(ctx context.Context, workspaceID uuid.UUID) ([]*models.SharedDocument, error)

	// Real-time collaboration
	BroadcastToMembers(ctx context.Context, workspaceID uuid.UUID, message interface{}) error
	SendToMember(ctx context.Context, workspaceID uuid.UUID, agentID string, message interface{}) error
	GetPresence(ctx context.Context, workspaceID uuid.UUID) ([]*models.MemberPresence, error)
	UpdatePresence(ctx context.Context, workspaceID uuid.UUID, agentID string, status string) error

	// Search and discovery
	ListByAgent(ctx context.Context, agentID string) ([]*models.Workspace, error)
	SearchWorkspaces(ctx context.Context, query string, filters interfaces.WorkspaceFilters) ([]*models.Workspace, error)
	GetRecommendedWorkspaces(ctx context.Context, agentID string) ([]*models.Workspace, error)

	// Analytics
	GetWorkspaceStats(ctx context.Context, workspaceID uuid.UUID) (*models.WorkspaceStats, error)
	GetCollaborationMetrics(ctx context.Context, workspaceID uuid.UUID, period time.Duration) (*models.CollaborationMetrics, error)
}

type WorkspaceUpdatedEvent struct {
	WorkspaceID uuid.UUID
	TenantID    uuid.UUID
	UpdatedBy   string
	Version     int
	Timestamp   time.Time
}