token

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

type CacheEntry struct {
	Data       TokenData
	ValidUntil time.Time
}

type CacheOptions struct {
	// Time-to-live for cache entries (default: 5 minutes)
	TTL time.Duration

	// Maximum size of the cache (default: 1000)
	MaxSize int

	// Whether to enable automatic cache cleanup (default: true)
	EnableCleanup bool

	// Interval for cache cleanup (default: 1 minute)
	CleanupInterval time.Duration
}

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

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

type ManagerStore interface {
	TokenStore
	RevocationStore
	RateLimitStore
}

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

type RateLimitStore interface {
	// GetTokenByID retrieves a token by its ID
	GetTokenByID(ctx context.Context, tokenID string) (TokenData, error)

	// IncrementTokenUsage increments the usage count for a token
	IncrementTokenUsage(ctx context.Context, tokenID string) error

	// ResetTokenUsage resets the usage count for a token to zero
	ResetTokenUsage(ctx context.Context, tokenID string) error

	// UpdateTokenLimit updates the maximum allowed requests for a token
	UpdateTokenLimit(ctx context.Context, tokenID string, maxRequests *int) error
}

type RateLimiter interface {
	// AllowRequest checks if a token is within its rate limits and updates usage
	AllowRequest(ctx context.Context, tokenID string) error

	// GetRemainingRequests returns the number of remaining requests for a token
	GetRemainingRequests(ctx context.Context, tokenID string) (int, error)

	// ResetUsage resets the usage counter for a token
	ResetUsage(ctx context.Context, tokenID string) error

	// UpdateLimit updates the maximum allowed requests for a token
	UpdateLimit(ctx context.Context, tokenID string, maxRequests *int) error
}

type RedisGoRateLimitAdapter struct {
	Client *redis.Client
}

type RedisRateLimitClient interface {
	// Incr atomically increments a key and returns the new value
	Incr(ctx context.Context, key string) (int64, error)
	// Get retrieves the value of a key
	Get(ctx context.Context, key string) (string, error)
	// Set sets the value of a key
	Set(ctx context.Context, key, value string) error
	// Expire sets a TTL on a key
	Expire(ctx context.Context, key string, expiration time.Duration) error
	// SetNX sets a key only if it doesn't exist.
	// Included for interface compatibility with eventbus.RedisClient and potential future enhancements.
	SetNX(ctx context.Context, key string, value string, expiration time.Duration) (bool, error)
	// Del deletes a key
	Del(ctx context.Context, key string) error
}

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

type RedisRateLimiterConfig struct {
	// KeyPrefix is the prefix for all Redis keys used by the rate limiter
	KeyPrefix string
	// KeyHashSecret is the HMAC secret for hashing token IDs in Redis keys.
	// When set, token IDs are hashed using HMAC-SHA256 to prevent cleartext exposure.
	// This is recommended for production deployments to enhance security.
	KeyHashSecret []byte
	// DefaultWindowDuration is the default sliding window duration for rate limiting
	DefaultWindowDuration time.Duration
	// DefaultMaxRequests is the default maximum requests per window
	DefaultMaxRequests int
	// EnableFallback enables fallback to in-memory rate limiting when Redis is unavailable
	EnableFallback bool
	// FallbackRate is the rate for fallback in-memory token bucket (tokens per second)
	FallbackRate float64
	// FallbackCapacity is the capacity for fallback in-memory token bucket
	FallbackCapacity int
}

type RevocationStore interface {
	// RevokeToken disables a token by setting is_active to false
	RevokeToken(ctx context.Context, tokenID string) error

	// DeleteToken completely removes a token from storage
	DeleteToken(ctx context.Context, tokenID string) error

	// RevokeBatchTokens revokes multiple tokens at once
	RevokeBatchTokens(ctx context.Context, tokenIDs []string) (int, error)

	// RevokeProjectTokens revokes all tokens for a project
	RevokeProjectTokens(ctx context.Context, projectID string) (int, error)

	// RevokeExpiredTokens revokes all tokens that have expired
	RevokeExpiredTokens(ctx context.Context) (int, error)
}

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

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

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

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

type TokenData struct {
	ID            string     // The token ID (UUID) - used for management operations
	Token         string     // The token string (sk-...) - used for authentication
	ProjectID     string     // The associated project ID
	ExpiresAt     *time.Time // When the token expires (nil for no expiration)
	IsActive      bool       // Whether the token is active
	DeactivatedAt *time.Time // When the token was deactivated (nil if not deactivated)
	RequestCount  int        // Number of requests made with this token
	MaxRequests   *int       // Maximum number of requests allowed (nil for unlimited)
	CreatedAt     time.Time  // When the token was created
	LastUsedAt    *time.Time // When the token was last used (nil if never used)
	CacheHitCount int        // Number of cache hits for this token
}

type TokenGenerator struct {
	// Default expiration time for new tokens
	DefaultExpiration time.Duration

	// Default maximum requests for new tokens (nil means unlimited)
	DefaultMaxRequests *int
}

type TokenInfo struct {
	Token           string     `json:"token"`
	ObfuscatedToken string     `json:"obfuscated_token"`
	CreationTime    time.Time  `json:"creation_time"`
	ExpiresAt       *time.Time `json:"expires_at,omitempty"`
	IsActive        bool       `json:"is_active"`
	RequestCount    int        `json:"request_count"`
	MaxRequests     *int       `json:"max_requests,omitempty"`
	LastUsedAt      *time.Time `json:"last_used_at,omitempty"`
	TimeRemaining   string     `json:"time_remaining,omitempty"`
	IsValid         bool       `json:"is_valid"`
}

type TokenOptions struct {
	// Expiration duration (0 for no expiration)
	Expiration time.Duration

	// Maximum requests (nil for no limit)
	MaxRequests *int

	// Custom metadata (implementation-dependent)
	Metadata map[string]string
}

type TokenRateLimit struct {
	MaxRequests    int
	WindowDuration time.Duration
}

type TokenStats struct {
	Token           string
	ObfuscatedToken string
	RequestCount    int
	RemainingCount  int // -1 means unlimited
	LastUsed        *time.Time
	TimeRemaining   time.Duration // -1 means no expiration
	IsValid         bool
}

type TokenStore interface {
	// GetTokenByID retrieves a token by its UUID (for management operations)
	GetTokenByID(ctx context.Context, id string) (TokenData, error)

	// GetTokenByToken retrieves a token by its token string (for authentication)
	GetTokenByToken(ctx context.Context, tokenString string) (TokenData, error)

	// IncrementTokenUsage increments the usage count for a token by its token string
	IncrementTokenUsage(ctx context.Context, tokenString string) error

	// CreateToken creates a new token in the store
	CreateToken(ctx context.Context, token TokenData) error

	// UpdateToken updates an existing token
	UpdateToken(ctx context.Context, token TokenData) error

	// ListTokens retrieves all tokens from the store
	ListTokens(ctx context.Context) ([]TokenData, error)

	// GetTokensByProjectID retrieves all tokens for a project
	GetTokensByProjectID(ctx context.Context, projectID string) ([]TokenData, error)
}

type TokenValidator interface {
	// ValidateToken validates a token and returns the associated project ID
	ValidateToken(ctx context.Context, token string) (string, error)

	// ValidateTokenWithTracking validates a token, returns the project ID, and tracks usage
	ValidateTokenWithTracking(ctx context.Context, token string) (string, error)
}

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

type UsageStatsAggregatorConfig struct {
	BufferSize    int           // Size of buffered channel (default: 1000)
	FlushInterval time.Duration // How often to flush stats (default: 5s)
	BatchSize     int           // Max events before flush (default: 100)
}

type UsageStatsStore interface {
	// IncrementTokenUsageBatch increments request_count for multiple tokens and updates last_used_at.
	// The deltas map has token strings as keys and increment values as values.
	IncrementTokenUsageBatch(ctx context.Context, deltas map[string]int, lastUsedAt time.Time) error
}