performance

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

type AdaptiveParameter struct {
	Name               string
	CurrentValue       float64
	MinValue           float64
	MaxValue           float64
	MaxChangeRate      float64
	MinChangeThreshold float64
	LastUpdate         time.Time
	History            []ParameterChange
	// contains filtered or unexported fields
}

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

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

type AdaptiveTuner interface {
	// Tuning operations
	TuneParameter(name string, value interface{}) error
	GetParameter(name string) (interface{}, error)
	ResetParameter(name string) error

	// Learning operations
	RecordOutcome(parameters map[string]interface{}, performance float64) error
	GetRecommendations() ([]TuningRecommendation, error)

	// Model management
	SaveModel(path string) error
	LoadModel(path string) error
	ResetModel() error

	// Lifecycle
	Start(ctx context.Context) error
	Stop() error
	Health() error
}

type AdaptiveTunerConfig struct {
	TuningInterval         time.Duration
	LearningInterval       time.Duration
	ImpactMeasurementDelay time.Duration
	MachineLearning        MLConfig
	Profiler               ProfilerConfig
	Controller             ControllerConfig
	Predictor              PredictorConfig
	Feedback               FeedbackConfig
	Optimizer              OptimizerConfig
	Knowledge              KnowledgeConfig
}

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

type AdaptiveTuningConfig struct{}

type AdjustmentDirection int

type Alert struct {
	ID        string            `json:"id"`
	Rule      string            `json:"rule"`
	Metric    string            `json:"metric"`
	Value     float64           `json:"value"`
	Threshold float64           `json:"threshold"`
	Severity  string            `json:"severity"`
	Message   string            `json:"message"`
	CreatedAt time.Time         `json:"created_at"`
	UpdatedAt time.Time         `json:"updated_at"`
	Tags      map[string]string `json:"tags"`
	Status    string            `json:"status"`
}

type AlertRule struct {
	Name      string        `json:"name"`
	Metric    string        `json:"metric"`
	Threshold float64       `json:"threshold"`
	Operator  string        `json:"operator"`
	Duration  time.Duration `json:"duration"`
	Severity  string        `json:"severity"`
	Actions   []string      `json:"actions"`
}

type AlertingConfig struct {
	Enabled  bool                  `json:"enabled"`
	Rules    []AlertRule           `json:"rules"`
	Channels []NotificationChannel `json:"channels"`
}

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

type Buffer struct {
	Data []byte
	Size int
	// contains filtered or unexported fields
}

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

type CPUConfig struct {
	MaxCores         int    `json:"max_cores"`
	AffinityMask     string `json:"affinity_mask"`
	SchedulingPolicy string `json:"scheduling_policy"`
	Priority         int    `json:"priority"`
}

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

type CacheConfig struct {
	Enabled     bool           `json:"enabled"`
	MaxSize     int64          `json:"max_size"`
	TTL         time.Duration  `json:"ttl"`
	Strategy    CacheStrategy  `json:"strategy"`
	Levels      []CacheLevel   `json:"levels"`
	Compression bool           `json:"compression"`
	Persistence bool           `json:"persistence"`
	Sharding    ShardingConfig `json:"sharding"`
}

type CacheEntry struct {
	Value      interface{}
	ExpiresAt  time.Time
	AccessedAt time.Time
	CreatedAt  time.Time
	Size       int64
}

type CacheLevel struct {
	Name        string        `json:"name"`
	MaxSize     int64         `json:"max_size"`
	TTL         time.Duration `json:"ttl"`
	Strategy    CacheStrategy `json:"strategy"`
	Compression bool          `json:"compression"`
	Persistence bool          `json:"persistence"`
}

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

type CacheManager interface {
	// Cache operations
	Get(ctx context.Context, key string) (interface{}, bool)
	Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error
	Delete(ctx context.Context, key string) error
	Clear(ctx context.Context) error

	// Multi-operations
	GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error)
	SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error
	DeleteMulti(ctx context.Context, keys []string) error

	// Management
	GetMetrics() CacheMetrics
	GetStats() CacheStats
	ApplyOptimization(action OptimizationAction) error

	// Configuration
	UpdateConfig(config CacheConfig) error
	GetConfig() CacheConfig

	// Lifecycle
	Start(ctx context.Context) error
	Stop() error
	Health() error
}

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

type CacheMetrics struct {
	HitRate   float64 `json:"hit_rate"`
	Size      int64   `json:"size"`
	Evictions int64   `json:"evictions"`
}

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

type CacheStats struct {
	Hits        int64   `json:"hits"`
	Misses      int64   `json:"misses"`
	Evictions   int64   `json:"evictions"`
	Size        int64   `json:"size"`
	MaxSize     int64   `json:"max_size"`
	HitRate     float64 `json:"hit_rate"`
	MemoryUsage int64   `json:"memory_usage"`
}

type CacheStrategy string

type CollectorConfig struct {
	Name    string                 `json:"name"`
	Type    string                 `json:"type"`
	Enabled bool                   `json:"enabled"`
	Config  map[string]interface{} `json:"config"`
}

type ConcurrencyConfig struct {
	MaxWorkers  int                         `json:"max_workers"`
	QueueSize   int                         `json:"queue_size"`
	WorkerPools map[string]WorkerPoolConfig `json:"worker_pools"`
	Strategies  []ConcurrencyStrategy       `json:"strategies"`
	Throttling  ThrottlingConfig            `json:"throttling"`
}

type ConcurrencyEngine interface {
	// Task execution
	Submit(ctx context.Context, task Task) error
	SubmitWithPriority(ctx context.Context, task Task, priority int) error
	SubmitBatch(ctx context.Context, tasks []Task) error

	// Worker pool management
	ScaleWorkers(poolName string, count int) error
	GetWorkerPools() map[string]WorkerPoolInfo

	// Pipeline operations
	CreatePipeline(name string, stages []PipelineStage) error
	ExecutePipeline(ctx context.Context, pipelineName string, input interface{}) error

	// Metrics and monitoring
	GetMetrics() ConcurrencyMetrics
	GetQueueStats() QueueStats
	ApplyOptimization(action OptimizationAction) error

	// Configuration
	UpdateConfig(config ConcurrencyConfig) error
	GetConfig() ConcurrencyConfig

	// Lifecycle
	Start(ctx context.Context) error
	Stop() error
	Health() error
}

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

type ConcurrencyMetrics struct {
	ActiveWorkers  int   `json:"active_workers"`
	QueuedTasks    int   `json:"queued_tasks"`
	CompletedTasks int64 `json:"completed_tasks"`
	FailedTasks    int64 `json:"failed_tasks"`
}

type ConcurrencyStrategy struct {
	Name       string                 `json:"name"`
	Type       ConcurrencyType        `json:"type"`
	Parameters map[string]interface{} `json:"parameters"`
	Conditions []string               `json:"conditions"`
}

type ConcurrencyType string

type Config struct {
	// General settings
	Enabled     bool   `json:"enabled"`
	AutoTuning  bool   `json:"auto_tuning"`
	ProfileName string `json:"profile_name"`

	// Cache configuration
	Cache CacheConfig `json:"cache"`

	// Concurrency settings
	Concurrency ConcurrencyConfig `json:"concurrency"`

	// Resource management
	Resources ResourceConfig `json:"resources"`

	// Monitoring configuration
	Monitoring MonitoringConfig `json:"monitoring"`

	// Load balancing
	LoadBalancing LoadBalancingConfig `json:"load_balancing"`

	// Optimization settings
	Optimization OptimizationConfig `json:"optimization"`

	// Adaptive tuning
	AdaptiveTuning AdaptiveTuningConfig `json:"adaptive_tuning"`
}

type Connection interface {
	Resource
	IsValid() bool
	LastUsed() time.Time
}

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

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

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

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

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

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

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

type HealthCheckConfig struct {
	Type               string        `json:"type"`
	Endpoint           string        `json:"endpoint"`
	Interval           time.Duration `json:"interval"`
	Timeout            time.Duration `json:"timeout"`
	Retries            int           `json:"retries"`
	HealthyThreshold   int           `json:"healthy_threshold"`
	UnhealthyThreshold int           `json:"unhealthy_threshold"`
}

type IOConfig struct{}

type Individual struct {
	Genes   map[string]float64
	Fitness float64
}

type LargeMemoryBlock struct {
	Data []byte
	Size int
}

type LeastConnectionsAlgorithm struct{}

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

type LoadBalanceAlgorithm string

type LoadBalanceTarget struct {
	ID       string                 `json:"id"`
	Address  string                 `json:"address"`
	Weight   int                    `json:"weight"`
	Enabled  bool                   `json:"enabled"`
	Metadata map[string]interface{} `json:"metadata"`
}

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

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

type LoadBalancingAlgorithm interface {
	SelectNode(nodes []*LoadBalancerNode, request *Request) (*LoadBalancerNode, error)
	GetName() string
	Configure(config map[string]interface{}) error
}

type LoadBalancingConfig struct{}

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

type Logger interface {
	Info(msg string, keysAndValues ...interface{})
	Warn(msg string, keysAndValues ...interface{})
	Error(msg string, keysAndValues ...interface{})
	Debug(msg string, keysAndValues ...interface{})
}

type MLConfig struct {
	TrainingInterval   time.Duration
	MinTrainingSamples int
	Training           TrainingConfig
	Evaluation         EvaluationConfig
	Features           FeatureConfig
	Pipeline           PipelineConfig
}

type MLModelType int

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

type MemoryBlock struct {
	Data []byte
	Size int
	// contains filtered or unexported fields
}

type MemoryConfig struct {
	MaxHeapSize     int64          `json:"max_heap_size"`
	GCTarget        int            `json:"gc_target"`
	GCThreshold     float64        `json:"gc_threshold"`
	PoolSizes       map[string]int `json:"pool_sizes"`
	EnableProfiling bool           `json:"enable_profiling"`
}

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

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

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

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

type MemorySnapshot struct {
	Timestamp   time.Time `json:"timestamp"`
	HeapSize    int64     `json:"heap_size"`
	HeapUsed    int64     `json:"heap_used"`
	GCRuns      int64     `json:"gc_runs"`
	Allocations int64     `json:"allocations"`
	Objects     int64     `json:"objects"`
}

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

type MetricQuery struct {
	Metric      string            `json:"metric"`
	StartTime   time.Time         `json:"start_time"`
	EndTime     time.Time         `json:"end_time"`
	Tags        map[string]string `json:"tags"`
	Aggregation string            `json:"aggregation"`
}

type MetricResult struct {
	Metrics []Metric      `json:"metrics"`
	Summary MetricSummary `json:"summary"`
}

type MetricSummary struct {
	Count   int64   `json:"count"`
	Average float64 `json:"average"`
	Min     float64 `json:"min"`
	Max     float64 `json:"max"`
	Sum     float64 `json:"sum"`
}

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

type MonitorMetrics struct{}

type MonitoringConfig struct{}

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

type NetworkBuffers struct {
	Read  int `json:"read"`
	Write int `json:"write"`
}

type NetworkConfig struct{}

type NotificationChannel struct {
	Name    string                 `json:"name"`
	Type    string                 `json:"type"`
	Config  map[string]interface{} `json:"config"`
	Enabled bool                   `json:"enabled"`
}

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

type OptimizationAction struct{}

type OptimizationAlgorithm interface {
	Optimize(context OptimizationContext) (*OptimizationResult, error)
	GetName() string
	Configure(config map[string]interface{}) error
	IsApplicable(context OptimizationContext) bool
}

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

type OptimizationCondition struct{}

type OptimizationConfig struct{}

type OptimizationConstraint struct {
	Metric   string  `json:"metric"`
	Operator string  `json:"operator"`
	Value    float64 `json:"value"`
	Hard     bool    `json:"hard"`
}

type OptimizationEngine interface {
	// Optimization operations
	Optimize(ctx context.Context, objectives []OptimizationObjective) (*OptimizationResult, error)
	EvaluateSolution(solution OptimizationSolution) (float64, error)

	// Algorithm management
	RegisterAlgorithm(algorithm OptimizationAlgorithm) error
	GetAlgorithms() []OptimizationAlgorithm

	// Solution management
	GetBestSolution() (*OptimizationSolution, error)
	GetSolutionHistory() ([]OptimizationSolution, error)

	// Lifecycle
	Start(ctx context.Context) error
	Stop() error
	Health() error
}

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

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

type OptimizationObjective struct {
	Metric    string  `json:"metric"`
	Target    float64 `json:"target"`
	Weight    float64 `json:"weight"`
	Direction string  `json:"direction"` // minimize, maximize
}

type OptimizationRecommendation struct {
	Type        OptimizationType `json:"type"`
	Priority    Priority         `json:"priority"`
	Description string           `json:"description"`
	Action      string           `json:"action"`
}

type OptimizationResult struct {
	Solution   OptimizationSolution   `json:"solution"`
	Score      float64                `json:"score"`
	Iterations int                    `json:"iterations"`
	Duration   time.Duration          `json:"duration"`
	Convergent bool                   `json:"convergent"`
	Metadata   map[string]interface{} `json:"metadata"`
}

type OptimizationRule struct {
	ID        string                `json:"id"`
	Name      string                `json:"name"`
	Type      OptimizationType      `json:"type"`
	Condition OptimizationCondition `json:"condition"`
	Action    OptimizationAction    `json:"action"`
	Priority  int                   `json:"priority"`
	Enabled   bool                  `json:"enabled"`
}

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

type OptimizationSolution struct {
	ID         string                 `json:"id"`
	Parameters map[string]interface{} `json:"parameters"`
	Score      float64                `json:"score"`
	CreatedAt  time.Time              `json:"created_at"`
	AppliedAt  *time.Time             `json:"applied_at,omitempty"`
}

type OptimizationType string

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

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

type PerformanceConstraints struct {
	MaxWorkers     int   `json:"max_workers"`
	MaxMemory      int64 `json:"max_memory"`
	MaxCacheSize   int64 `json:"max_cache_size"`
	MaxConnections int   `json:"max_connections"`
}

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

type PerformanceMetrics struct {
	StartTime  time.Time `json:"start_time"`
	LastUpdate time.Time `json:"last_update"`

	// System metrics
	CPUUsage       float64         `json:"cpu_usage"`
	MemoryUsage    int64           `json:"memory_usage"`
	GoroutineCount int             `json:"goroutine_count"`
	GCStats        runtime.GCStats `json:"gc_stats"`

	// Performance metrics
	ThroughputRPS float64       `json:"throughput_rps"`
	LatencyP50    time.Duration `json:"latency_p50"`
	LatencyP95    time.Duration `json:"latency_p95"`
	LatencyP99    time.Duration `json:"latency_p99"`
	ErrorRate     float64       `json:"error_rate"`

	// Cache metrics
	CacheHitRate   float64 `json:"cache_hit_rate"`
	CacheSize      int64   `json:"cache_size"`
	CacheEvictions int64   `json:"cache_evictions"`

	// Concurrency metrics
	ActiveWorkers  int   `json:"active_workers"`
	QueuedTasks    int   `json:"queued_tasks"`
	CompletedTasks int64 `json:"completed_tasks"`
	FailedTasks    int64 `json:"failed_tasks"`

	// Resource metrics
	PoolUtilization map[string]float64       `json:"pool_utilization"`
	ResourceWaits   map[string]time.Duration `json:"resource_waits"`
}

type PerformanceMonitor interface {
	// Metrics collection
	RecordMetric(name string, value float64, tags map[string]string) error
	RecordLatency(name string, duration time.Duration, tags map[string]string) error
	RecordCounter(name string, value int64, tags map[string]string) error

	// Query operations
	GetMetric(name string) (*Metric, error)
	GetMetrics(pattern string) ([]*Metric, error)
	QueryMetrics(query MetricQuery) (*MetricResult, error)

	// Alerting
	AddAlertRule(rule AlertRule) error
	RemoveAlertRule(name string) error
	GetActiveAlerts() ([]Alert, error)

	// Lifecycle
	Start(ctx context.Context) error
	Stop() error
	Health() error
	GetMetrics() MonitorMetrics
}

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

type PerformanceProfile struct {
	Name          string                 `json:"name"`
	Description   string                 `json:"description"`
	Target        PerformanceTarget      `json:"target"`
	Constraints   PerformanceConstraints `json:"constraints"`
	Optimizations []OptimizationRule     `json:"optimizations"`
	CreatedAt     time.Time              `json:"created_at"`
	UpdatedAt     time.Time              `json:"updated_at"`
}

type PerformanceTarget struct {
	MaxLatency     time.Duration `json:"max_latency"`
	MinThroughput  float64       `json:"min_throughput"`
	MaxErrorRate   float64       `json:"max_error_rate"`
	MaxMemoryUsage int64         `json:"max_memory_usage"`
	MaxCPUUsage    float64       `json:"max_cpu_usage"`
}

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

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

type PipelineStageConfig struct {
	Name     string `json:"name"`
	Function func(ctx context.Context, input interface{}) (interface{}, error)
	Parallel bool          `json:"parallel"`
	Timeout  time.Duration `json:"timeout"`
}

type PoolInfo struct {
	Name         string       `json:"name"`
	Type         ResourceType `json:"type"`
	Size         int          `json:"size"`
	Available    int          `json:"available"`
	InUse        int          `json:"in_use"`
	Created      int64        `json:"created"`
	Destroyed    int64        `json:"destroyed"`
	LastActivity time.Time    `json:"last_activity"`
}

type PoolStats struct {
	AcquisitionTime time.Duration `json:"acquisition_time"`
	UtilizationRate float64       `json:"utilization_rate"`
	WaitingCount    int           `json:"waiting_count"`
	ErrorRate       float64       `json:"error_rate"`
}

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

type Priority string

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

type QueueStats struct {
	TotalQueued     int64          `json:"total_queued"`
	TotalProcessed  int64          `json:"total_processed"`
	AverageWaitTime time.Duration  `json:"average_wait_time"`
	QueueSizes      map[string]int `json:"queue_sizes"`
}

type RandomAlgorithm struct{}

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

type Resource interface {
	ID() string
	Close() error
}

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

type ResourceConfig struct {
	Memory  MemoryConfig         `json:"memory"`
	CPU     CPUConfig            `json:"cpu"`
	IO      IOConfig             `json:"io"`
	Network NetworkConfig        `json:"network"`
	Pools   []ResourcePoolConfig `json:"pools"`
}

type ResourceMetrics struct {
	Utilization map[string]float64       `json:"utilization"`
	WaitTimes   map[string]time.Duration `json:"wait_times"`
}

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

type ResourcePool interface {
	Acquire(ctx context.Context) (Resource, error)
	Release(resource Resource) error
	Resize(newSize int) error
	GetStats() PoolStats
	Close() error
}

type ResourcePoolConfig struct{}

type ResourcePoolManager interface {
	// Pool operations
	CreatePool(name string, config ResourcePoolConfig) error
	GetPool(name string) (ResourcePool, error)
	DeletePool(name string) error

	// Resource operations
	Acquire(ctx context.Context, poolName string) (Resource, error)
	Release(poolName string, resource Resource) error

	// Management
	GetMetrics() ResourceMetrics
	GetPoolInfo(poolName string) (PoolInfo, error)
	ListPools() []PoolInfo

	// Lifecycle
	Start(ctx context.Context) error
	Stop() error
	Health() error
}

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

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

type ResourceType string

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

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

type ShardingConfig struct {
	Enabled      bool   `json:"enabled"`
	ShardCount   int    `json:"shard_count"`
	Algorithm    string `json:"algorithm"`
	KeyExtractor string `json:"key_extractor"`
}

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

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

type Solution struct {
	Parameters map[string]float64
}

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

type Task interface {
	Execute(ctx context.Context) error
	GetID() string
	GetPriority() int
}

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

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

type ThrottlingConfig struct {
	Enabled   bool          `json:"enabled"`
	RateLimit float64       `json:"rate_limit"`
	BurstSize int           `json:"burst_size"`
	Window    time.Duration `json:"window"`
	Algorithm string        `json:"algorithm"`
}

type TrendDirection int

type TuningParameter struct {
	Name       string      `json:"name"`
	Type       string      `json:"type"`
	MinValue   interface{} `json:"min_value"`
	MaxValue   interface{} `json:"max_value"`
	StepSize   interface{} `json:"step_size"`
	Current    interface{} `json:"current"`
	Importance float64     `json:"importance"`
}

type TuningRecommendation struct {
	Parameter        string      `json:"parameter"`
	CurrentValue     interface{} `json:"current_value"`
	RecommendedValue interface{} `json:"recommended_value"`
	Confidence       float64     `json:"confidence"`
	Reason           string      `json:"reason"`
	Impact           float64     `json:"impact"`
}

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

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

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

type WorkerPoolConfig struct {
	Name        string        `json:"name"`
	MinWorkers  int           `json:"min_workers"`
	MaxWorkers  int           `json:"max_workers"`
	QueueSize   int           `json:"queue_size"`
	IdleTimeout time.Duration `json:"idle_timeout"`
	TaskTimeout time.Duration `json:"task_timeout"`
}

type WorkerPoolInfo struct {
	Name           string    `json:"name"`
	ActiveWorkers  int       `json:"active_workers"`
	QueuedTasks    int       `json:"queued_tasks"`
	CompletedTasks int64     `json:"completed_tasks"`
	FailedTasks    int64     `json:"failed_tasks"`
	LastActivity   time.Time `json:"last_activity"`
}

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