auth

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

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

type AuthConfig = Config

type AuthManager = Manager

type AuthProvider = Provider

type Authenticator interface {
	// Core authentication methods
	Authenticate(ctx context.Context, config Config) (*Token, error)
	RefreshToken(ctx context.Context, token *Token) (*Token, error)
	ValidateToken(ctx context.Context, token *Token) error
	RevokeToken(ctx context.Context, token *Token) error

	// Plugin metadata
	GetInfo() AuthenticatorInfo
	GetConfigSchema() ConfigSchema

	// Lifecycle management
	Initialize(ctx context.Context, config Config) error
	Cleanup() error
}

type AuthenticatorInfo struct {
	Name        string
	Version     string
	Description string
	Author      string
	Supported   []string // List of supported authentication methods
}

type ClusterAuthInfo struct {
	ClusterID     string
	AuthType      string
	IsConfigured  bool
	HasValidToken bool
	TokenExpiry   *time.Time
	LastAuth      *time.Time
	Endpoints     []Endpoint
}

type Config map[string]interface{}

type ConfigSchema struct {
	Properties map[string]PropertySchema `json:"properties"`
	Required   []string                  `json:"required"`
}

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

type DNSLoadBalancer struct {
	*WeightedRoundRobinLoadBalancer
	// contains filtered or unexported fields
}

type DiscoveredToken struct {
	Token     string            // The JWT token value
	Username  string            // Username the token was generated for
	ExpiresAt time.Time         // Token expiration time
	Source    string            // How the token was obtained (scontrol, env, etc.)
	Metadata  map[string]string // Additional metadata
}

type DiscovererInfo struct {
	Name        string
	Version     string
	Description string
	Author      string
	Supported   []string // List of supported discovery methods
}

type DiscoveryConfig map[string]interface{}

type Endpoint struct {
	URL       string            `json:"url"`
	ClusterID string            `json:"cluster_id"`
	Weight    int               `json:"weight"`
	Metadata  map[string]string `json:"metadata"`
	Status    EndpointStatus    `json:"status"`
	LastCheck time.Time         `json:"last_check"`
}

type EndpointDiscoverer interface {
	DiscoverEndpoints(ctx context.Context, clusterID string) ([]Endpoint, error)
	HealthCheck(ctx context.Context, endpoint *Endpoint) error
	GetLoadBalancer() LoadBalancer

	// Plugin metadata
	GetInfo() DiscovererInfo
	Initialize(ctx context.Context, config DiscoveryConfig) error
	Cleanup() error
}

type EndpointManager interface {
	// ConfigureCluster sets up endpoint discovery for a cluster
	ConfigureCluster(clusterID string, discoveryType string, config DiscoveryConfig) error

	// DiscoverEndpoints discovers available endpoints for a cluster
	DiscoverEndpoints(ctx context.Context, clusterID string) ([]Endpoint, error)

	// GetEndpoint selects the best endpoint for a cluster
	GetEndpoint(ctx context.Context, clusterID string) (*Endpoint, error)

	// UpdateEndpointHealth updates the health status of an endpoint
	UpdateEndpointHealth(ctx context.Context, endpoint *Endpoint, healthy bool) error

	// GetAllEndpoints returns all known endpoints for a cluster
	GetAllEndpoints(clusterID string) []Endpoint

	// StartHealthChecking starts background health checking
	StartHealthChecking(ctx context.Context, interval time.Duration)

	// StopHealthChecking stops background health checking
	StopHealthChecking()
}

type EndpointStats struct {
	URL                 string
	Status              string
	Weight              int
	ActiveConnections   int32
	ConsecutiveFailures int
	ResponseTime        time.Duration
	LastSuccess         time.Time
	LastFailure         time.Time
	CircuitBreakerOpen  bool
	CircuitBreakerUntil time.Time
}

type EndpointStatus int

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

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

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

type KeyringBackend interface {
	Set(service, user, password string) error
	Get(service, user string) (string, error)
	Delete(service, user string) error
	List(service string) ([]string, error)
}

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

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

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

type LoadBalancer interface {
	// SelectEndpoint selects the best endpoint from the available ones
	SelectEndpoint(endpoints []Endpoint) (*Endpoint, error)

	// UpdateEndpointHealth updates the health status of an endpoint
	UpdateEndpointHealth(endpoint *Endpoint, healthy bool)

	// GetStrategy returns the load balancing strategy
	GetStrategy() string
}

type LoadBalancerConfig struct {
	Strategy               string
	MaxConsecutiveFailures int
	CircuitBreakerTimeout  time.Duration
	HealthCheckInterval    time.Duration
	HealthCheckTimeout     time.Duration
	HealthCheckPath        string
	ResponseTimeWeight     float64
	WeightUpdateInterval   time.Duration
}

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

type ManagedEndpoint struct {
	Endpoint
	// contains filtered or unexported fields
}

type Manager interface {
	// ConfigureCluster sets up authentication for a cluster
	ConfigureCluster(clusterID string, authType string, config Config) error

	// Authenticate authenticates against a specific cluster
	Authenticate(ctx context.Context, clusterID string) (*Token, error)

	// GetToken retrieves a valid token for a cluster
	GetToken(ctx context.Context, clusterID string) (*Token, error)

	// RefreshToken refreshes an expired token
	RefreshToken(ctx context.Context, clusterID string) (*Token, error)

	// RevokeToken revokes a token
	RevokeToken(ctx context.Context, clusterID string) error

	// ListClusters returns all configured clusters
	ListClusters() []string

	// GetClusterInfo returns information about a cluster's auth configuration
	GetClusterInfo(clusterID string) (*ClusterAuthInfo, error)

	// ValidateConfiguration validates auth configuration
	ValidateConfiguration(authType string, config Config) error
}

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

type PropertySchema struct {
	Type        string      `json:"type"`
	Description string      `json:"description"`
	Required    bool        `json:"required"`
	Sensitive   bool        `json:"sensitive"`
	Default     interface{} `json:"default,omitempty"`
	Enum        []string    `json:"enum,omitempty"`
}

type Provider interface {
	// Authenticate performs authentication and returns a token
	Authenticate(ctx context.Context, username, password string) (*Token, error)

	// RefreshToken refreshes an existing token
	RefreshToken(ctx context.Context, token *Token) (*Token, error)

	// ValidateToken validates if a token is still valid
	ValidateToken(ctx context.Context, token *Token) error

	// Logout invalidates a token
	Logout(ctx context.Context, token *Token) error
}

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

type SecureStore interface {
	Store(key string, data []byte) error
	Retrieve(key string) ([]byte, error)
	Delete(key string) error
	List() ([]string, error)
	Initialize() error
	Cleanup() error
}

type SimpleToken struct {
	Value      string    `json:"value"`
	ExpiresAt  time.Time `json:"expires_at"`
	ClusterURL string    `json:"cluster_url"`
	Username   string    `json:"username"`
}

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

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

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

type Token struct {
	AccessToken  string            `json:"access_token"`
	RefreshToken string            `json:"refresh_token,omitempty"`
	TokenType    string            `json:"token_type"`
	ExpiresAt    time.Time         `json:"expires_at"`
	Scopes       []string          `json:"scopes,omitempty"`
	Metadata     map[string]string `json:"metadata,omitempty"`
	ClusterID    string            `json:"cluster_id"`
}

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

type TokenDiscoveryConfig struct {
	Enabled       bool          `mapstructure:"enabled"`
	ScontrolPath  string        `mapstructure:"scontrolPath"`
	Timeout       time.Duration `mapstructure:"timeout"`
	TokenLifespan int           `mapstructure:"tokenLifespan"` // in seconds
}

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

type TokenStore interface {
	// Store saves a token securely
	Store(ctx context.Context, clusterID string, token *Token) error

	// Retrieve gets a token from storage
	Retrieve(ctx context.Context, clusterID string) (*Token, error)

	// Delete removes a token from storage
	Delete(ctx context.Context, clusterID string) error

	// List returns all stored cluster IDs
	List(ctx context.Context) ([]string, error)

	// Clear removes all tokens from storage
	Clear(ctx context.Context) error
}

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