mq

type ActiveAlert struct {
	Rule        AlertRule         `json:"rule"`
	Value       float64           `json:"value"`
	StartsAt    time.Time         `json:"starts_at"`
	EndsAt      *time.Time        `json:"ends_at,omitempty"`
	Labels      map[string]string `json:"labels"`
	Annotations map[string]string `json:"annotations"`
	Status      AlertStatus       `json:"status"`
}

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

type AlertNotifier interface {
	Notify(ctx context.Context, alert ActiveAlert) error
	Name() string
}

type AlertRule struct {
	Name        string            `json:"name"`
	Metric      string            `json:"metric"`
	Condition   string            `json:"condition"` // "gt", "lt", "eq", "gte", "lte"
	Threshold   float64           `json:"threshold"`
	Duration    time.Duration     `json:"duration"`
	Labels      map[string]string `json:"labels"`
	Annotations map[string]string `json:"annotations"`
	Enabled     bool              `json:"enabled"`
}

type AlertStatus string

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

type BrokerConfig struct {
	Address              string            `json:"address"`
	Port                 int               `json:"port"`
	MaxConnections       int               `json:"max_connections"`
	ConnectionTimeout    time.Duration     `json:"connection_timeout"`
	ReadTimeout          time.Duration     `json:"read_timeout"`
	WriteTimeout         time.Duration     `json:"write_timeout"`
	IdleTimeout          time.Duration     `json:"idle_timeout"`
	KeepAlive            bool              `json:"keep_alive"`
	KeepAlivePeriod      time.Duration     `json:"keep_alive_period"`
	MaxQueueDepth        int               `json:"max_queue_depth"`
	EnableDeadLetter     bool              `json:"enable_dead_letter"`
	DeadLetterMaxRetries int               `json:"dead_letter_max_retries"`
	EnableMetrics        bool              `json:"enable_metrics"`
	MetricsInterval      time.Duration     `json:"metrics_interval"`
	GracefulShutdown     time.Duration     `json:"graceful_shutdown"`
	MessageTTL           time.Duration     `json:"message_ttl"`
	Headers              map[string]string `json:"headers"`
}

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

type Callback func(ctx context.Context, result Result) error

type CircuitBreaker struct {
	Enabled          bool
	FailureThreshold int
	ResetTimeout     time.Duration
}

type CircuitBreakerConfig struct {
	Enabled          bool
	FailureThreshold int
	ResetTimeout     time.Duration
}

type CircuitState int

type ClusteringConfig struct {
	EnableClustering      bool          `json:"enable_clustering"`
	NodeID                string        `json:"node_id"`
	ClusterNodes          []string      `json:"cluster_nodes"`
	DiscoveryMethod       string        `json:"discovery_method"` // "static", "consul", "etcd", "k8s"
	DiscoveryEndpoint     string        `json:"discovery_endpoint"`
	HeartbeatInterval     time.Duration `json:"heartbeat_interval"`
	ElectionTimeout       time.Duration `json:"election_timeout"`
	EnableLoadBalancing   bool          `json:"enable_load_balancing"`
	LoadBalancingStrategy string        `json:"load_balancing_strategy"` // "round_robin", "least_connections", "hash"
	EnableFailover        bool          `json:"enable_failover"`
	FailoverTimeout       time.Duration `json:"failover_timeout"`
	EnableReplication     bool          `json:"enable_replication"`
	ReplicationFactor     int           `json:"replication_factor"`
	ConsistencyLevel      string        `json:"consistency_level"` // "weak", "strong", "eventual"
}

type CompletionCallback func()

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

type ConfigWatcher interface {
	OnConfigChange(oldConfig, newConfig *ProductionConfig) error
}

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

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

type ConsumerConfig struct {
	MaxRetries              int           `json:"max_retries"`
	InitialDelay            time.Duration `json:"initial_delay"`
	MaxBackoff              time.Duration `json:"max_backoff"`
	JitterPercent           float64       `json:"jitter_percent"`
	EnableReconnect         bool          `json:"enable_reconnect"`
	ReconnectInterval       time.Duration `json:"reconnect_interval"`
	HealthCheckInterval     time.Duration `json:"health_check_interval"`
	MaxConcurrentTasks      int           `json:"max_concurrent_tasks"`
	TaskTimeout             time.Duration `json:"task_timeout"`
	EnableDeduplication     bool          `json:"enable_deduplication"`
	DeduplicationWindow     time.Duration `json:"deduplication_window"`
	EnablePriorityQueue     bool          `json:"enable_priority_queue"`
	EnableHTTPAPI           bool          `json:"enable_http_api"`
	HTTPAPIPort             int           `json:"http_api_port"`
	EnableCircuitBreaker    bool          `json:"enable_circuit_breaker"`
	CircuitBreakerThreshold int           `json:"circuit_breaker_threshold"`
	CircuitBreakerTimeout   time.Duration `json:"circuit_breaker_timeout"`
}

type CronSchedule struct {
	Seconds    string
	Minute     string
	Hour       string
	DayOfMonth string
	Month      string
	DayOfWeek  string
}

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

type DefaultPlugin struct{}

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

type DiskSpaceHealthCheck struct{}

type DistributedLocker interface {
	Acquire(key string, ttl time.Duration) bool
	Release(key string)
}

type DynamicConfig struct {
	Timeout          time.Duration
	BatchSize        int
	MaxMemoryLoad    int64
	IdleTimeout      time.Duration
	BackoffDuration  time.Duration
	MaxRetries       int
	ReloadInterval   time.Duration
	WarningThreshold WarningThresholds
	NumberOfWorkers  int // new field for worker count
}

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

type ExecutionHistory struct {
	Timestamp time.Time
	Result    Result
}

type FormattedMetrics struct {
	TotalTasks           int64  `json:"total_tasks"`
	CompletedTasks       int64  `json:"completed_tasks"`
	ErrorCount           int64  `json:"error_count"`
	CurrentMemoryUsed    string `json:"current_memory_used"`
	CumulativeMemoryUsed string `json:"cumulative_memory_used"`
	TotalScheduled       int64  `json:"total_scheduled"`
	CumulativeExecution  string `json:"cumulative_execution"`
	AverageExecution     string `json:"average_execution"`
}

type GoRoutineHealthCheck struct{}

type Handler func(context.Context, *Task) Result

type HealthCheck interface {
	Name() string
	Check(ctx context.Context) *HealthCheckResult
	Timeout() time.Duration
}

type HealthCheckResult struct {
	Name      string                 `json:"name"`
	Status    HealthStatus           `json:"status"`
	Message   string                 `json:"message"`
	Duration  time.Duration          `json:"duration"`
	Timestamp time.Time              `json:"timestamp"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

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

type HealthStatus string

type HealthThresholds struct {
	MaxMemoryUsage  int64
	MaxCPUUsage     float64
	MaxConnections  int
	MaxQueueDepth   int
	MaxResponseTime time.Duration
	MinFreeMemory   int64
}

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

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

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

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

type MemoryHealthCheck struct{}

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

type MessageStore interface {
	Store(msg *StoredMessage) error
	Retrieve(id string) (*StoredMessage, error)
	Delete(id string) error
	List(queue string, limit int, offset int) ([]*StoredMessage, error)
	Count(queue string) (int64, error)
	Cleanup(olderThan time.Time) error
}

type Metric struct {
	Name      string            `json:"name"`
	Value     float64           `json:"value"`
	Timestamp time.Time         `json:"timestamp"`
	Tags      map[string]string `json:"tags,omitempty"`
}

type MetricType string

type Metrics struct {
	TotalTasks           int64 // total number of tasks processed
	CompletedTasks       int64 // number of successfully processed tasks
	ErrorCount           int64 // number of tasks that resulted in error
	TotalMemoryUsed      int64 // current memory used (in bytes) by tasks in flight
	TotalScheduled       int64 // number of tasks scheduled
	ExecutionTime        int64 // cumulative execution time in milliseconds
	CumulativeMemoryUsed int64 // cumulative memory used (sum of all task sizes) in bytes
}

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

type MetricsRegistry interface {
	Register(metricName string, value interface{})
	Increment(metricName string)
	Get(metricName string) interface{}
}

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

type MonitoringConfig struct {
	EnableMetrics       bool          `json:"enable_metrics"`
	MetricsPort         int           `json:"metrics_port"`
	MetricsPath         string        `json:"metrics_path"`
	EnableHealthCheck   bool          `json:"enable_health_check"`
	HealthCheckPort     int           `json:"health_check_port"`
	HealthCheckPath     string        `json:"health_check_path"`
	HealthCheckInterval time.Duration `json:"health_check_interval"`
	EnableTracing       bool          `json:"enable_tracing"`
	TracingEndpoint     string        `json:"tracing_endpoint"`
	TracingSampleRate   float64       `json:"tracing_sample_rate"`
	EnableLogging       bool          `json:"enable_logging"`
	LogLevel            string        `json:"log_level"`
	LogFormat           string        `json:"log_format"` // "json", "text"
	LogOutput           string        `json:"log_output"` // "stdout", "file", "syslog"
	LogFilePath         string        `json:"log_file_path"`
	LogMaxSize          int           `json:"log_max_size"` // MB
	LogMaxBackups       int           `json:"log_max_backups"`
	LogMaxAge           int           `json:"log_max_age"` // days
	EnableProfiling     bool          `json:"enable_profiling"`
	ProfilingPort       int           `json:"profiling_port"`
}

type Option func(*Options)

type Options struct {
	BrokerRateLimiter   *RateLimiter // new field for broker rate limiting
	ConsumerRateLimiter *RateLimiter // new field for consumer rate limiting
	// contains filtered or unexported fields
}

type PersistenceConfig struct {
	EnablePersistence  bool          `json:"enable_persistence"`
	StorageType        string        `json:"storage_type"` // "memory", "file", "redis", "postgres", "mysql"
	ConnectionString   string        `json:"connection_string"`
	MaxConnections     int           `json:"max_connections"`
	ConnectionTimeout  time.Duration `json:"connection_timeout"`
	RetentionPeriod    time.Duration `json:"retention_period"`
	CleanupInterval    time.Duration `json:"cleanup_interval"`
	BackupEnabled      bool          `json:"backup_enabled"`
	BackupInterval     time.Duration `json:"backup_interval"`
	BackupPath         string        `json:"backup_path"`
	CompressionEnabled bool          `json:"compression_enabled"`
	EncryptionEnabled  bool          `json:"encryption_enabled"`
	ReplicationEnabled bool          `json:"replication_enabled"`
	ReplicationNodes   []string      `json:"replication_nodes"`
}

type Plugin interface {
	Initialize(config interface{}) error
	BeforeTask(task *QueueTask)
	AfterTask(task *QueueTask, result Result)
}

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

type PoolConfig struct {
	MinWorkers               int           `json:"min_workers"`
	MaxWorkers               int           `json:"max_workers"`
	QueueSize                int           `json:"queue_size"`
	MaxMemoryLoad            int64         `json:"max_memory_load"`
	TaskTimeout              time.Duration `json:"task_timeout"`
	IdleWorkerTimeout        time.Duration `json:"idle_worker_timeout"`
	EnableDynamicScaling     bool          `json:"enable_dynamic_scaling"`
	ScalingFactor            float64       `json:"scaling_factor"`
	ScalingInterval          time.Duration `json:"scaling_interval"`
	MaxQueueWaitTime         time.Duration `json:"max_queue_wait_time"`
	EnableWorkStealing       bool          `json:"enable_work_stealing"`
	EnablePriorityScheduling bool          `json:"enable_priority_scheduling"`
	GracefulShutdownTimeout  time.Duration `json:"graceful_shutdown_timeout"`
}

type PoolOption func(*Pool)

type PriorityQueue []*QueueTask

type Processor interface {
	ProcessTask(ctx context.Context, msg *Task) Result
	Consume(ctx context.Context) error
	Pause(ctx context.Context) error
	Resume(ctx context.Context) error
	Stop(ctx context.Context) error
	Close() error
	GetKey() string
	SetKey(key string)
	GetType() string
}

type ProductionConfig struct {
	Broker      BrokerConfig      `json:"broker"`
	Consumer    ConsumerConfig    `json:"consumer"`
	Publisher   PublisherConfig   `json:"publisher"`
	Pool        PoolConfig        `json:"pool"`
	Security    SecurityConfig    `json:"security"`
	Monitoring  MonitoringConfig  `json:"monitoring"`
	Persistence PersistenceConfig `json:"persistence"`
	Clustering  ClusteringConfig  `json:"clustering"`
	RateLimit   RateLimitConfig   `json:"rate_limit"`
	LastUpdated time.Time         `json:"last_updated"`
}

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

type PublisherConfig struct {
	MaxRetries            int           `json:"max_retries"`
	InitialDelay          time.Duration `json:"initial_delay"`
	MaxBackoff            time.Duration `json:"max_backoff"`
	JitterPercent         float64       `json:"jitter_percent"`
	ConnectionPoolSize    int           `json:"connection_pool_size"`
	PublishTimeout        time.Duration `json:"publish_timeout"`
	EnableBatching        bool          `json:"enable_batching"`
	BatchSize             int           `json:"batch_size"`
	BatchTimeout          time.Duration `json:"batch_timeout"`
	EnableCompression     bool          `json:"enable_compression"`
	CompressionLevel      int           `json:"compression_level"`
	EnableAsync           bool          `json:"enable_async"`
	AsyncBufferSize       int           `json:"async_buffer_size"`
	EnableOrderedDelivery bool          `json:"enable_ordered_delivery"`
}

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

type QueueConfig struct {
	MaxDepth       int           `json:"max_depth"`
	MaxRetries     int           `json:"max_retries"`
	MessageTTL     time.Duration `json:"message_ttl"`
	DeadLetter     bool          `json:"dead_letter"`
	Persistent     bool          `json:"persistent"`
	BatchSize      int           `json:"batch_size"`
	Priority       int           `json:"priority"`
	OrderedMode    bool          `json:"ordered_mode"`
	Throttling     bool          `json:"throttling"`
	ThrottleRate   int           `json:"throttle_rate"`
	ThrottleBurst  int           `json:"throttle_burst"`
	CompactionMode bool          `json:"compaction_mode"`
}

type QueueMetrics struct {
	MessagesReceived  int64         `json:"messages_received"`
	MessagesProcessed int64         `json:"messages_processed"`
	MessagesFailed    int64         `json:"messages_failed"`
	CurrentDepth      int64         `json:"current_depth"`
	AverageLatency    time.Duration `json:"average_latency"`
	LastActivity      time.Time     `json:"last_activity"`
}

type QueueOption func(*QueueConfig)

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

type QueuedTask struct {
	Message    *codec.Message
	RetryCount int
}

type RateLimitConfig struct {
	EnableBrokerRateLimit    bool `json:"enable_broker_rate_limit"`
	BrokerRate               int  `json:"broker_rate"` // requests per second
	BrokerBurst              int  `json:"broker_burst"`
	EnableConsumerRateLimit  bool `json:"enable_consumer_rate_limit"`
	ConsumerRate             int  `json:"consumer_rate"`
	ConsumerBurst            int  `json:"consumer_burst"`
	EnablePublisherRateLimit bool `json:"enable_publisher_rate_limit"`
	PublisherRate            int  `json:"publisher_rate"`
	PublisherBurst           int  `json:"publisher_burst"`
	EnablePerQueueRateLimit  bool `json:"enable_per_queue_rate_limit"`
	PerQueueRate             int  `json:"per_queue_rate"`
	PerQueueBurst            int  `json:"per_queue_burst"`
}

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

type Result struct {
	CreatedAt       time.Time       `json:"created_at"`
	ProcessedAt     time.Time       `json:"processed_at,omitempty"`
	Latency         string          `json:"latency"`
	Error           error           `json:"-"` // Keep error as an error type
	Topic           string          `json:"topic"`
	TaskID          string          `json:"task_id"`
	Status          Status          `json:"status"`
	ConditionStatus string          `json:"condition_status"`
	Ctx             context.Context `json:"-"`
	Payload         json.RawMessage `json:"payload"`
	Last            bool
}

type Schedule struct {
	TimeOfDay  time.Time
	CronSpec   string
	DayOfWeek  []time.Weekday
	DayOfMonth []int
	Interval   time.Duration
	Recurring  bool
}

type ScheduleOptions struct {
	Handler      Handler
	Callback     Callback
	Interval     time.Duration
	Overlap      bool
	Recurring    bool
	ScheduleSpec string
}

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

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

type SchedulerConfig struct {
	Callback   Callback
	Overlap    bool
	MaxRetries int
}

type SchedulerOpt func(*Scheduler)

type SchedulerOption func(*ScheduleOptions)

type SecurityConfig struct {
	EnableTLS             bool          `json:"enable_tls"`
	TLSCertPath           string        `json:"tls_cert_path"`
	TLSKeyPath            string        `json:"tls_key_path"`
	TLSCAPath             string        `json:"tls_ca_path"`
	TLSInsecureSkipVerify bool          `json:"tls_insecure_skip_verify"`
	EnableAuthentication  bool          `json:"enable_authentication"`
	AuthenticationMethod  string        `json:"authentication_method"` // "basic", "jwt", "oauth"
	EnableAuthorization   bool          `json:"enable_authorization"`
	EnableEncryption      bool          `json:"enable_encryption"`
	EncryptionKey         string        `json:"encryption_key"`
	EnableAuditLog        bool          `json:"enable_audit_log"`
	AuditLogPath          string        `json:"audit_log_path"`
	SessionTimeout        time.Duration `json:"session_timeout"`
	MaxLoginAttempts      int           `json:"max_login_attempts"`
	LockoutDuration       time.Duration `json:"lockout_duration"`
}

type Status string

type StoredMessage struct {
	ID        string                 `json:"id"`
	Queue     string                 `json:"queue"`
	Payload   []byte                 `json:"payload"`
	Headers   map[string]string      `json:"headers,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
	Priority  int                    `json:"priority"`
	CreatedAt time.Time              `json:"created_at"`
	ExpiresAt *time.Time             `json:"expires_at,omitempty"`
	Attempts  int                    `json:"attempts"`
}

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

type TLSConfig struct {
	CertPath string
	KeyPath  string
	CAPath   string
	UseTLS   bool
}

type Task struct {
	CreatedAt   time.Time       `json:"created_at"`
	ProcessedAt time.Time       `json:"processed_at"`
	Expiry      time.Time       `json:"expiry"`
	Error       error           `json:"-"`               // Don't serialize errors directly
	ErrorMsg    string          `json:"error,omitempty"` // Serialize error message if present
	ID          string          `json:"id"`
	Topic       string          `json:"topic"`
	Status      Status          `json:"status"` // Use Status type instead of string
	Payload     json.RawMessage `json:"payload"`
	Priority    int             `json:"priority,omitempty"`
	Retries     int             `json:"retries,omitempty"`
	MaxRetries  int             `json:"max_retries,omitempty"`

	// Enhanced deduplication and tracing
	DedupKey string            `json:"dedup_key,omitempty"`
	TraceID  string            `json:"trace_id,omitempty"`
	SpanID   string            `json:"span_id,omitempty"`
	Tags     map[string]string `json:"tags,omitempty"`
	Headers  map[string]string `json:"headers,omitempty"`
	// contains filtered or unexported fields
}

type TaskInfo struct {
	TaskID      string    `json:"task_id"`
	NextRunTime time.Time `json:"next_run_time"`
}

type TaskOption func(*Task)

type TaskStorage interface {
	SaveTask(task *QueueTask) error
	GetTask(taskID string) (*QueueTask, error)
	DeleteTask(taskID string) error
	GetAllTasks() ([]*QueueTask, error)
	FetchNextTask() (*QueueTask, error)
	CleanupExpiredTasks() error
}

type ThresholdConfig struct {
	HighMemory    int64
	LongExecution time.Duration
}

type TimeSeries struct {
	Name        string            `json:"name"`
	Type        MetricType        `json:"type"`
	Description string            `json:"description"`
	Labels      map[string]string `json:"labels"`
	Values      []TimeSeriesPoint `json:"values"`
	MaxPoints   int               `json:"max_points"`
	// contains filtered or unexported fields
}

type TimeSeriesPoint struct {
	Timestamp time.Time `json:"timestamp"`
	Value     float64   `json:"value"`
}

type WarningThresholds struct {
	HighMemory    int64         // in bytes
	LongExecution time.Duration // threshold duration
}