streaming

type AIEventPayload struct {
	AnalysisID   string                 `json:"analysis_id"`
	ContentID    string                 `json:"content_id"`
	ContentType  string                 `json:"content_type"`  // status, media, profile
	AnalysisType string                 `json:"analysis_type"` // sentiment, toxicity, classification
	Results      map[string]interface{} `json:"results"`
	Confidence   float64                `json:"confidence"`
	ModelVersion string                 `json:"model_version,omitempty"`
	ProcessedAt  time.Time              `json:"processed_at"`
}

type AccountEventPayload struct {
	AccountID      string    `json:"account_id"`
	Username       string    `json:"username"`
	DisplayName    string    `json:"display_name,omitempty"`
	Avatar         string    `json:"avatar,omitempty"`
	Header         string    `json:"header,omitempty"`
	Bio            string    `json:"bio,omitempty"`
	URL            string    `json:"url,omitempty"`
	FollowersCount int64     `json:"followers_count"`
	FollowingCount int64     `json:"following_count"`
	StatusesCount  int64     `json:"statuses_count"`
	LastStatusAt   time.Time `json:"last_status_at,omitempty"`
	CreatedAt      time.Time `json:"created_at"`
	UpdatedAt      time.Time `json:"updated_at,omitempty"`
}

type BackpressureAction int

type BackpressureConfig struct {
	MaxConcurrentMessages int           `json:"max_concurrent_messages"` // Maximum concurrent message processing
	MessageQueueSize      int           `json:"message_queue_size"`      // Maximum queued messages per connection
	ProcessingTimeout     time.Duration `json:"processing_timeout"`      // Timeout for message processing
	DropStrategy          DropStrategy  `json:"drop_strategy"`           // Strategy when queue is full
	EnableAdaptive        bool          `json:"enable_adaptive"`         // Enable adaptive backpressure
}

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

type BulkAccountValidationConfig struct {
	RequiredFields []string
	MaxAccounts    int
	MinAccounts    int
}

type BulkProcessingConfig struct {
	BatchSize        int
	ProgressInterval int // Send progress every N operations
	BatchDelay       time.Duration
}

type BulkProcessingTracker struct {
	Total      int
	Processed  int
	Successful int
	Failed     int
	Errors     []string
}

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

type CircuitBreakerState int

type Command struct {
	ID      string                 `json:"id"`      // Client-provided ID for request/response matching
	Type    string                 `json:"type"`    // Command type (e.g., "create_status", "follow_user")
	Payload map[string]interface{} `json:"payload"` // Command payload data
}

type CommandError struct {
	Code    string `json:"code"`              // Error code
	Message string `json:"message"`           // Human-readable error message
	Details string `json:"details,omitempty"` // Additional error details
}

type CommandHandler interface {
	// HandleCommand processes a WebSocket command and returns a response
	HandleCommand(ctx context.Context, conn *ConnectionInfo, cmd *Command) (*CommandResponse, error)

	// GetSupportedCommands returns a list of command types this handler supports
	GetSupportedCommands() []string
}

type CommandHandlerConfig struct {
	RequiredFields  []string                                                                                    // Fields required in payload validation
	ParameterName   string                                                                                      // Name of the parameter to extract (e.g., "operation_id", "id")
	ErrorCodePrefix string                                                                                      // Prefix for error codes (e.g., "GET_OPERATION", "MARK_READ")
	OperationName   string                                                                                      // Name for error messages (e.g., "get bulk operation", "mark notification as read")
	ResultExtractor func(result interface{}) interface{}                                                        // Function to extract data from service result
	ServiceCall     func(ctx context.Context, conn *ConnectionInfo, extractedParam string) (interface{}, error) // Function to call the service
}

type CommandInfo struct {
	Type           string   `json:"type"`
	Category       string   `json:"category"`
	Description    string   `json:"description"`
	RequiresAuth   bool     `json:"requires_auth"`
	AdminOnly      bool     `json:"admin_only"`
	RequiredFields []string `json:"required_fields,omitempty"`
	OptionalFields []string `json:"optional_fields,omitempty"`
}

type CommandRateLimit struct {
	MaxPerMinute   int
	MaxPerHour     int
	BurstLimit     int
	RequiresAuth   bool
	CostMultiplier float64 // Some commands cost more (e.g., searches)
}

type CommandResponse struct {
	ID      string                 `json:"id"`              // Matching client ID
	Type    string                 `json:"type"`            // Response type (e.g., "command_result", "command_error")
	Success bool                   `json:"success"`         // Whether command succeeded
	Data    map[string]interface{} `json:"data"`            // Response data
	Error   *CommandError          `json:"error,omitempty"` // Error details if failed
}

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

type ConflictResolver interface {
	ResolveConflict(ctx context.Context, local, remote *models.WebSocketConnection) (*models.WebSocketConnection, error)
}

type ConnectionInfo struct {
	ConnectionID    string                 `json:"connection_id"`
	UserID          string                 `json:"user_id"`
	Username        string                 `json:"username"`
	Streams         []string               `json:"streams"`
	IsAuthenticated bool                   `json:"is_authenticated"`
	Metadata        map[string]interface{} `json:"metadata"` // For storing connection-specific data
}

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

type ConnectionManagerConfig struct {
	HealthCheckInterval time.Duration // How often to run health checks
	CleanupInterval     time.Duration // How often to run cleanup tasks
	PingTimeout         time.Duration // How long to wait for pong response
	IdleThreshold       time.Duration // When to mark connections as idle
	MaxIdleConnections  int           // Maximum number of idle connections to keep
}

type ConnectionMetrics struct {
	Timestamp             time.Time        `json:"timestamp"`
	TotalConnections      int64            `json:"total_connections"`
	ActiveConnections     int64            `json:"active_connections"`
	ConnectionsByState    map[string]int64 `json:"connections_by_state"`
	TotalMessages         int64            `json:"total_messages"`
	TotalBytes            int64            `json:"total_bytes"`
	AverageLatency        time.Duration    `json:"average_latency"`
	ErrorsByType          map[string]int64 `json:"errors_by_type"`
	AverageQualityScore   float64          `json:"average_quality_score"`
	MessageRate           float64          `json:"message_rate"`           // messages per second
	ByteRate              float64          `json:"byte_rate"`              // bytes per second
	ConnectionUtilization float64          `json:"connection_utilization"` // percentage of max connections used
}

type ConnectionRateLimit struct {
	ConnectionID string
	UserID       string
	IPAddress    string
	// contains filtered or unexported fields
}

type ConnectionRepository interface {
	// GetUserConnections returns all active connections for a user
	GetUserConnections(ctx context.Context, userID string) ([]*StreamConnection, error)

	// GetStreamConnections returns all connections subscribed to a stream
	GetStreamConnections(ctx context.Context, streamName string) ([]*StreamConnection, error)

	// GetConversationConnections returns all connections for participants in a conversation
	GetConversationConnections(ctx context.Context, conversationID string) ([]*StreamConnection, error)
}

type CostEventPayload struct {
	Operation string                 `json:"operation"`
	Service   string                 `json:"service"` // dynamodb, lambda, s3, etc.
	CostUSD   float64                `json:"cost_usd"`
	Units     map[string]interface{} `json:"units,omitempty"` // RCU, WCU, requests, etc.
	UserID    string                 `json:"user_id,omitempty"`
	TenantID  string                 `json:"tenant_id,omitempty"`
	Timestamp time.Time              `json:"timestamp"`
}

type DropStrategy int

type ErrorRecoveryConfig struct {
	MaxRetries     int           // Maximum number of retry attempts
	BaseRetryDelay time.Duration // Base delay between retries
	MaxRetryDelay  time.Duration // Maximum delay between retries
	JitterFactor   float64       // Jitter factor for randomizing delays (0.0-1.0)
	EnableBackoff  bool          // Enable exponential backoff
}

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

type Event struct {
	Type      string                 `json:"type"`      // Event type (e.g., "status.created")
	Stream    string                 `json:"stream"`    // Stream name (e.g., "user:alice")
	Payload   map[string]interface{} `json:"payload"`   // Event payload data
	Timestamp time.Time              `json:"timestamp"` // Event timestamp
}

type EventAction string

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

type EventFilter struct {
	Types       []EventType       `json:"types,omitempty"`        // Filter by event types
	Actions     []EventAction     `json:"actions,omitempty"`      // Filter by actions
	ActorID     string            `json:"actor_id,omitempty"`     // Filter by actor
	UserID      string            `json:"user_id,omitempty"`      // Filter by user
	TenantID    string            `json:"tenant_id,omitempty"`    // Filter by tenant
	Streams     []string          `json:"streams,omitempty"`      // Filter by streams
	Metadata    map[string]string `json:"metadata,omitempty"`     // Filter by metadata
	MinPriority EventPriority     `json:"min_priority,omitempty"` // Minimum priority
}

type EventPriority int

type EventType string

type GlobalRateLimit struct {
	Identifier string // user:id or ip:address
	// contains filtered or unexported fields
}

type HashtagEventPayload struct {
	Hashtag       string    `json:"hashtag"`
	Count         int64     `json:"count"`
	PreviousCount int64     `json:"previous_count,omitempty"`
	TrendScore    float64   `json:"trend_score,omitempty"`
	Period        string    `json:"period"` // hour, day, week
	UpdatedAt     time.Time `json:"updated_at"`
}

type HealthBasedResolver struct{}

type HealthCheckResult struct {
	ConnectionID      string    `json:"connection_id"`
	Timestamp         time.Time `json:"timestamp"`
	IsHealthy         bool      `json:"is_healthy"`
	QualityScore      float64   `json:"quality_score"`
	LatencyMs         int64     `json:"latency_ms"`
	PacketLoss        float64   `json:"packet_loss"`
	RecommendedAction string    `json:"recommended_action"`
}

type HighestPriorityResolver struct{}

type InternalEvent struct {
	// Event identification
	ID     string      `json:"id"`
	Type   EventType   `json:"type"`
	Action EventAction `json:"action"`

	// Event context
	ActorID  string `json:"actor_id,omitempty"`  // Who triggered the event
	TargetID string `json:"target_id,omitempty"` // What was affected
	UserID   string `json:"user_id,omitempty"`   // User context for the event
	TenantID string `json:"tenant_id,omitempty"` // Multi-tenant support

	// Timing
	Timestamp time.Time `json:"timestamp"`

	// Event payload - the actual data
	Data interface{} `json:"data"`

	// Metadata for filtering and routing
	Metadata map[string]string `json:"metadata,omitempty"`

	// Stream context
	Streams []string `json:"streams,omitempty"` // Which streams this event should go to

	// Priority for event processing
	Priority EventPriority `json:"priority"`
}

type JobQueue interface {
	QueueDelayedJob(ctx context.Context, queueName string, messageBody interface{}, delaySeconds int32) error
}

type LastWriteWinsResolver struct{}

type ListCommandValidationConfig struct {
	RequiredFields []string
	RequireID      bool
	RequireTitle   bool
}

type MediaEventPayload struct {
	MediaID     string                 `json:"media_id"`
	URL         string                 `json:"url"`
	MediaType   string                 `json:"media_type"` // image, video, audio
	Status      string                 `json:"status"`     // processing, ready, error
	Size        int64                  `json:"size,omitempty"`
	Duration    int64                  `json:"duration,omitempty"` // for video/audio
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
	ProcessedAt time.Time              `json:"processed_at,omitempty"`
}

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

type MetricsCollectorConfig struct {
	CollectionInterval time.Duration // How often to collect metrics
	RetentionPeriod    time.Duration // How long to retain metrics
}

type MetricsEventPayload struct {
	MetricID             string            `json:"metric_id"`
	ServiceName          string            `json:"service_name"`
	MetricType           string            `json:"metric_type"`
	SubscriptionCategory string            `json:"subscription_category"` // moderation, security, performance, etc.
	AggregationLevel     string            `json:"aggregation_level"`     // raw, 5min, hourly, daily
	Timestamp            time.Time         `json:"timestamp"`
	Count                int64             `json:"count,omitempty"`
	Sum                  float64           `json:"sum,omitempty"`
	Min                  float64           `json:"min,omitempty"`
	Max                  float64           `json:"max,omitempty"`
	Average              float64           `json:"average,omitempty"`
	P50                  float64           `json:"p50,omitempty"`
	P95                  float64           `json:"p95,omitempty"`
	P99                  float64           `json:"p99,omitempty"`
	Unit                 string            `json:"unit,omitempty"`
	UserCostMicrocents   int64             `json:"user_cost_microcents,omitempty"`
	TotalCostMicrocents  int64             `json:"total_cost_microcents,omitempty"`
	Dimensions           map[string]string `json:"dimensions,omitempty"`
	UserID               string            `json:"user_id,omitempty"`
	TenantID             string            `json:"tenant_id,omitempty"`
	InstanceDomain       string            `json:"instance_domain,omitempty"`
}

type MockPublishedEvent struct {
	Method      string    `json:"method"`    // "PublishToUser", "PublishToStream", "PublishToConversation"
	TargetID    string    `json:"target_id"` // userID, streamName, or conversationID
	Event       *Event    `json:"event"`
	PublishedAt time.Time `json:"published_at"`
}

type ModerationEventPayload struct {
	ItemID      string                 `json:"item_id"`
	ItemType    string                 `json:"item_type"` // status, account, media
	Action      string                 `json:"action"`    // flag, review, approve, reject
	ModeratorID string                 `json:"moderator_id,omitempty"`
	Reason      string                 `json:"reason,omitempty"`
	Details     map[string]interface{} `json:"details,omitempty"`
	CreatedAt   time.Time              `json:"created_at"`
}

type NotificationEventPayload struct {
	NotificationID string    `json:"notification_id"`
	Type           string    `json:"type"` // follow, mention, favourite, reblog, etc.
	RecipientID    string    `json:"recipient_id"`
	ActorID        string    `json:"actor_id"`
	StatusID       string    `json:"status_id,omitempty"`
	Read           bool      `json:"read"`
	CreatedAt      time.Time `json:"created_at"`
}

type PerformanceMetrics struct {
	AverageConnectionDuration time.Duration `json:"average_connection_duration"`
	MedianConnectionDuration  time.Duration `json:"median_connection_duration"`
	P95ConnectionDuration     time.Duration `json:"p95_connection_duration"`
	P99ConnectionDuration     time.Duration `json:"p99_connection_duration"`

	AverageMessageRate float64 `json:"average_message_rate"`
	PeakMessageRate    float64 `json:"peak_message_rate"`

	ConnectionSuccessRate float64 `json:"connection_success_rate"`
	MessageDeliveryRate   float64 `json:"message_delivery_rate"`

	HealthyConnections   int64   `json:"healthy_connections"`
	UnhealthyConnections int64   `json:"unhealthy_connections"`
	AverageQualityScore  float64 `json:"average_quality_score"`
}

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

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

type Publisher interface {
	// PublishToUser publishes an event to a specific user's streams
	PublishToUser(ctx context.Context, userID string, event *Event) error

	// PublishToStream publishes an event to all subscribers of a stream
	PublishToStream(ctx context.Context, streamName string, event *Event) error

	// PublishToConversation publishes an event to all participants in a conversation
	PublishToConversation(ctx context.Context, conversationID string, event *Event) error

	// Close closes the publisher and cleans up resources
	Close() error
}

type PublisherConnectionConfig struct {
	EventType      string
	StreamTemplate string // Template for stream name, e.g., "user:%s"
	Timeout        time.Duration
}

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

type RetryJobMessage struct {
	ConnectionID  string `json:"connection_id"`
	RetryCount    int    `json:"retry_count"`
	Timestamp     int64  `json:"timestamp"`
	OriginalError string `json:"original_error,omitempty"`
}

type ServiceRegistry interface {
}

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

type ShutdownManagerConfig struct {
	ShutdownTimeout time.Duration       // Total time to wait for graceful shutdown
	DrainTimeout    time.Duration       // Time to wait for connection draining
	Backpressure    *BackpressureConfig // Backpressure configuration
}

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

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

type StateSynchronizerConfig struct {
	InstanceID       string           // Unique instance identifier
	SyncInterval     time.Duration    // How often to sync state
	StaleThreshold   time.Duration    // When to consider connections stale
	ConflictResolver ConflictResolver // Strategy for resolving conflicts
}

type StatusEventPayload struct {
	StatusID       string                 `json:"status_id"`
	AuthorID       string                 `json:"author_id"`
	AuthorUsername string                 `json:"author_username"`
	Content        string                 `json:"content,omitempty"`
	Visibility     string                 `json:"visibility,omitempty"`
	InReplyToID    string                 `json:"in_reply_to_id,omitempty"`
	ReblogOfID     string                 `json:"reblog_of_id,omitempty"`
	Sensitive      bool                   `json:"sensitive"`
	Language       string                 `json:"language,omitempty"`
	Hashtags       []string               `json:"hashtags,omitempty"`
	Mentions       []string               `json:"mentions,omitempty"`
	URL            string                 `json:"url,omitempty"`
	CreatedAt      time.Time              `json:"created_at"`
	UpdatedAt      time.Time              `json:"updated_at,omitempty"`
	ExtraData      map[string]interface{} `json:"extra_data,omitempty"`
}

type StreamConnection struct {
	ConnectionID string    `json:"connection_id"`
	UserID       string    `json:"user_id,omitempty"`
	Username     string    `json:"username,omitempty"`
	Streams      []string  `json:"streams"`
	LastActivity time.Time `json:"last_activity"`
}

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

type StreamEventLogItem struct {
	ID        string
	Event     string
	Data      string
	CreatedAt time.Time
}

type StreamQueueService interface {
	// QueueEventForUser queues an event for a specific user's streams
	QueueEventForUser(ctx context.Context, userID string, eventType string, payload map[string]interface{}) error

	// QueueEventForStream queues an event for all subscribers of a stream
	QueueEventForStream(ctx context.Context, streamName string, eventType string, payload map[string]interface{}) error

	// QueueEventForConversation queues an event for all participants in a conversation
	QueueEventForConversation(ctx context.Context, conversationID string, eventType string, payload map[string]interface{}) error

	// QueueEventForFollowers queues an event for all followers of a user
	QueueEventForFollowers(ctx context.Context, userID string, eventType string, payload map[string]interface{}) error
}

type SyncStats struct {
	TotalSyncs            int64         `json:"total_syncs"`
	SuccessfulSyncs       int64         `json:"successful_syncs"`
	FailedSyncs           int64         `json:"failed_syncs"`
	ConflictsResolved     int64         `json:"conflicts_resolved"`
	StaleConnectionsFound int64         `json:"stale_connections_found"`
	LastSyncTime          time.Time     `json:"last_sync_time"`
	LastSyncDuration      time.Duration `json:"last_sync_duration"`
	AverageSyncDuration   time.Duration `json:"average_sync_duration"`
}

type TrustEventPayload struct {
	SubjectID     string                 `json:"subject_id"`
	SubjectType   string                 `json:"subject_type"` // user, content, domain
	Score         float64                `json:"score"`
	PreviousScore float64                `json:"previous_score,omitempty"`
	Reason        string                 `json:"reason,omitempty"`
	Evidence      map[string]interface{} `json:"evidence,omitempty"`
	UpdatedBy     string                 `json:"updated_by,omitempty"`
	UpdatedAt     time.Time              `json:"updated_at"`
}

type WebSocketRateLimitConfig struct {
	// Connection limits
	MaxConnectionsPerUser int
	MaxConnectionsPerIP   int
	ConnectionWindowSize  time.Duration

	// Command rate limits (per connection)
	MaxCommandsPerMinute int
	MaxCommandsPerSecond int
	CommandWindowSize    time.Duration

	// Command-specific limits
	CommandLimits map[string]CommandRateLimit

	// Progressive delays
	EnableProgressiveDelays bool
	BaseDelayMillis         int
	MaxDelayMillis          int

	// Burst protection
	BurstWindowSize  time.Duration
	MaxBurstCommands int

	// Penalty configuration
	ViolationThreshold int
	PenaltyDuration    time.Duration
	PenaltyMultiplier  float64
}

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