cache

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

type CacheConfig struct {
	// Redis connection
	RedisAddr     []string
	RedisPassword string
	RedisDB       int

	// Cluster mode
	ClusterMode bool

	// Cache settings
	DefaultTTL  time.Duration
	KeyPrefix   string
	Compression bool
	MaxRetries  int

	// Pool settings
	PoolSize     int
	MinIdleConns int
	MaxConnAge   time.Duration

	// Timeouts
	DialTimeout  time.Duration
	ReadTimeout  time.Duration
	WriteTimeout time.Duration
}

type CacheItem struct {
	Key       string
	Value     interface{}
	TTL       time.Duration
	Tags      []string
	Version   int
	CreatedAt time.Time
	UpdatedAt time.Time
}

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

type CacheStats struct {
	LocalHits   int64     `json:"local_hits"`
	LocalMisses int64     `json:"local_misses"`
	LocalSize   int64     `json:"local_size"`
	RedisHits   int64     `json:"redis_hits"`
	RedisMisses int64     `json:"redis_misses"`
	HitRate     float64   `json:"hit_rate"`
	Timestamp   time.Time `json:"timestamp"`
}

type CacheStrategy interface {
	Get(ctx context.Context, key string) (interface{}, error)
	Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error
	Delete(ctx context.Context, key string) error
	Clear(ctx context.Context, pattern string) error
	GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error)
	SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error
}

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

type CachedSearchResults struct {
	Query      string        `json:"query"`
	TotalCount int           `json:"total_count"`
	Results    []interface{} `json:"results"`
	CachedAt   time.Time     `json:"cached_at"`
}

type CachedSession struct {
	ID        string                 `json:"id"`
	UserID    int                    `json:"user_id"`
	Data      map[string]interface{} `json:"data"`
	ExpiresAt time.Time              `json:"expires_at"`
	CachedAt  time.Time              `json:"cached_at"`
}

type CachedTicket struct {
	ID           int64     `json:"id"`
	TicketNumber string    `json:"ticket_number"`
	Title        string    `json:"title"`
	QueueID      int       `json:"queue_id"`
	StateID      int       `json:"state_id"`
	PriorityID   int       `json:"priority_id"`
	CustomerID   string    `json:"customer_id"`
	OwnerID      int       `json:"owner_id"`
	CachedAt     time.Time `json:"cached_at"`
}

type CachedUser struct {
	ID       int       `json:"id"`
	Login    string    `json:"login"`
	Email    string    `json:"email"`
	Name     string    `json:"name"`
	RoleIDs  []int     `json:"role_ids"`
	GroupIDs []int     `json:"group_ids"`
	CachedAt time.Time `json:"cached_at"`
}

type DataLoader interface {
	Load(ctx context.Context, key string) (interface{}, error)
	LoadMulti(ctx context.Context, keys []string) (map[string]interface{}, error)
}

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

type LocalCacheConfig struct {
	MaxSize         int
	DefaultTTL      time.Duration
	CleanupInterval time.Duration
}

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

type LocalCacheStats struct {
	Hits      int64
	Misses    int64
	Sets      int64
	Deletes   int64
	Evictions int64
	Size      int64
}

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

type ManagerConfig struct {
	RedisConfig *CacheConfig
	LocalConfig *LocalCacheConfig

	// Strategy settings
	DefaultStrategy string
	EnableLocal     bool
	EnableRedis     bool

	// Cache warming
	WarmOnStartup   bool
	WarmupFunctions map[string]WarmupFunc
}

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

type QueryCacheConfig struct {
	RedisCache *RedisCache
	DefaultTTL time.Duration
}

type QueryResult struct {
	Query     string        `json:"query"`
	Args      []interface{} `json:"args"`
	Result    interface{}   `json:"result"`
	Count     int           `json:"count"`
	CachedAt  time.Time     `json:"cached_at"`
	ExpiresAt time.Time     `json:"expires_at"`
}

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

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

type WarmUpQuery struct {
	Query    string
	Args     []interface{}
	Executor func() (interface{}, error)
}

type WarmupFunc func(ctx context.Context, cache *Manager) error

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

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