controllers

type A1Policy struct {
	PolicyTypeID string `json:"policy_type_id"`

	PolicyData json.RawMessage `json:"policy_data"`
}

type AuditTrailController struct {
	client.Client

	Log logr.Logger

	Scheme *runtime.Scheme

	Recorder record.EventRecorder
	// contains filtered or unexported fields
}

type AuthContextKey string

type AuthenticatedE2NodeSetReconciler struct {
	*AuthenticatedReconciler

	OriginalReconciler *E2NodeSetReconciler
}

type AuthenticatedReconciler struct {
	client.Client
	// contains filtered or unexported fields
}

type BackoffConfig struct {
	BaseDelay    time.Duration
	MaxDelay     time.Duration
	Multiplier   float64
	JitterFactor float64
}

type CNFControllerConfig struct {
	ReconcileTimeout time.Duration

	MaxConcurrentReconciles int

	EnableStatusUpdates bool

	StatusUpdateInterval time.Duration

	EnableMetrics bool

	EnableEvents bool
}

type CNFDeploymentContext struct {
	NetworkIntent *nephoranv1.NetworkIntent

	ProcessingResult *nephoranv1.CNFIntentProcessingResult

	CNFDeployments []*nephoranv1.CNFDeployment

	StartTime time.Time

	RequestID string

	ProcessingPhase string

	Errors []error

	Warnings []string
}

type CNFDeploymentReconciler struct {
	client.Client

	Scheme *runtime.Scheme

	Recorder record.EventRecorder

	CNFOrchestrator *cnf.CNFOrchestrator

	LLMProcessor *llm.Processor

	MetricsCollector *monitoring.MetricsCollector

	Config *CNFControllerConfig
}

type CNFDeploymentRequest struct {
	CNFDeployment *nephoranv1.CNFDeployment

	Context context.Context

	RequestID string

	Source string // "intent" or "direct"

	NetworkIntent *nephoranv1.NetworkIntent
}

type CNFIntegrationConfig struct {
	EnableCNFIntegration bool

	CNFProcessingTimeout time.Duration

	CNFDeploymentTimeout time.Duration

	MaxConcurrentCNFDeploys int

	EnableAutoDeployment bool

	RequireExplicitApproval bool

	DefaultTargetNamespace string

	CNFLabelSelector map[string]string

	RetryPolicy CNFRetryPolicy
}

type CNFIntegrationManager struct {
	Client client.Client

	Scheme *runtime.Scheme

	Recorder record.EventRecorder

	CNFIntentProcessor *cnf.CNFIntentProcessor

	CNFOrchestrator *cnf.CNFOrchestrator

	Config *CNFIntegrationConfig
}

type CNFRetryPolicy struct {
	MaxRetries int

	InitialDelay time.Duration

	MaxDelay time.Duration

	BackoffMultiplier float64
}

type CertificateAutomationCondition struct {
	Type CertificateAutomationConditionType `json:"type"`

	Status metav1.ConditionStatus `json:"status"`

	LastTransitionTime metav1.Time `json:"lastTransitionTime"`

	Reason string `json:"reason,omitempty"`

	Message string `json:"message,omitempty"`
}

type CertificateAutomationConditionType string

type CertificateAutomationReconciler struct {
	client.Client

	Scheme *runtime.Scheme

	Log logr.Logger

	AutomationEngine *ca.AutomationEngine

	CAManager *ca.CAManager
}

type CertificateAutomationSpec struct {
	ServiceName string `json:"serviceName"`

	Namespace string `json:"namespace"`

	DNSNames []string `json:"dnsNames,omitempty"`

	IPAddresses []string `json:"ipAddresses,omitempty"`

	Template string `json:"template,omitempty"`

	AutoRenewal bool `json:"autoRenewal,omitempty"`

	ValidityDuration *metav1.Duration `json:"validityDuration,omitempty"`

	SecretName string `json:"secretName,omitempty"`

	Priority string `json:"priority,omitempty"`
}

type CertificateAutomationStatus struct {
	Phase nephv1alpha1.CertificateAutomationPhase `json:"phase,omitempty"`

	Conditions []CertificateAutomationCondition `json:"conditions,omitempty"`

	CertificateSerialNumber string `json:"certificateSerialNumber,omitempty"`

	ExpiresAt *metav1.Time `json:"expiresAt,omitempty"`

	LastRenewalTime *metav1.Time `json:"lastRenewalTime,omitempty"`

	NextRenewalTime *metav1.Time `json:"nextRenewalTime,omitempty"`

	SecretRef *v1.LocalObjectReference `json:"secretRef,omitempty"`

	ValidationStatus *CertificateValidationStatus `json:"validationStatus,omitempty"`

	RevocationStatus string `json:"revocationStatus,omitempty"`

	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

type CertificateValidationStatus struct {
	Valid bool `json:"valid"`

	ChainValid bool `json:"chainValid,omitempty"`

	CTLogVerified bool `json:"ctLogVerified,omitempty"`

	LastValidationTime *metav1.Time `json:"lastValidationTime,omitempty"`

	ValidationErrors []string `json:"validationErrors,omitempty"`

	ValidationWarnings []string `json:"validationWarnings,omitempty"`
}

type CleanupManagerInterface interface {
	PerformCleanup(ctx context.Context, networkIntent *nephoranv1.NetworkIntent) error

	CleanupGeneratedResources(ctx context.Context, networkIntent *nephoranv1.NetworkIntent) error

	CleanupCachedData(ctx context.Context, networkIntent *nephoranv1.NetworkIntent) error
}

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

type Config struct {
	MaxRetries int

	RetryDelay time.Duration

	Timeout time.Duration

	GitRepoURL string

	GitBranch string

	GitDeployPath string

	LLMProcessorURL string

	UseNephioPorch bool

	Constants *configPkg.Constants
}

type ContextManagerInterface interface {
	InitializeProcessingContext(networkIntent *nephoranv1.NetworkIntent) *ProcessingContext

	UpdateProcessingContext(processingCtx *ProcessingContext, phase ProcessingPhase, data map[string]interface{})

	ValidateProcessingContext(processingCtx *ProcessingContext, expectedPhase ProcessingPhase) error

	SerializeProcessingContext(processingCtx *ProcessingContext) (string, error)

	DeserializeProcessingContext(data string) (*ProcessingContext, error)
}

type ControllerAuthContext struct {
	UserID string

	OperationType string

	ResourceType string

	ResourceName string

	ResourceNamespace string

	Timestamp time.Time

	RequestID string
}

type ControllerInterface interface {
	ReconcilerInterface

	SetupWithManager(mgr ctrl.Manager) error

	GetConfig() *Config

	GetDependencies() Dependencies
}

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

type Dependencies interface {
	GetGitClient() git.ClientInterface

	GetLLMClient() shared.ClientInterface

	GetPackageGenerator() *nephio.PackageGenerator

	GetHTTPClient() *http.Client

	GetEventRecorder() record.EventRecorder

	GetTelecomKnowledgeBase() *telecom.TelecomKnowledgeBase

	GetMetricsCollector() monitoring.MetricsCollector
}

type DependencyError struct {
	Dependency string

	Cause error
}

type DeploymentSpec struct {
	Replicas int `json:"replicas"`

	Image string `json:"image"`

	Resources json.RawMessage `json:"resources"`
}

type E2NodeConfigData struct {
	NodeID string `json:"nodeId"`

	E2InterfaceVersion string `json:"e2InterfaceVersion"`

	RICEndpoint string `json:"ricEndpoint"`

	RANFunctions []RANFunctionConfig `json:"ranFunctions"`

	SimulationConfig SimulationConfigData `json:"simulationConfig"`

	CreatedAt time.Time `json:"createdAt"`

	UpdatedAt time.Time `json:"updatedAt"`
}

type E2NodeSetReconciler struct {
	client.Client

	Scheme *runtime.Scheme

	Recorder record.EventRecorder

	// External dependencies
	GitClient git.ClientInterface
	E2Manager e2.E2ManagerInterface
	// contains filtered or unexported fields
}

type E2NodeStatusData struct {
	NodeID string `json:"nodeId"`

	State string `json:"state"`

	LastHeartbeat *time.Time `json:"lastHeartbeat,omitempty"`

	ConnectedSince *time.Time `json:"connectedSince,omitempty"`

	ActiveSubscriptions int32 `json:"activeSubscriptions"`

	ErrorMessage string `json:"errorMessage,omitempty"`

	HeartbeatCount int64 `json:"heartbeatCount"`

	StatusUpdatedAt time.Time `json:"statusUpdatedAt"`
}

type EndpointSpec struct {
	Name string `json:"name"`

	Port int `json:"port"`

	Protocol string `json:"protocol"`

	Path string `json:"path,omitempty"`
}

type EventManagerInterface interface {
	RecordEvent(networkIntent *nephoranv1.NetworkIntent, eventType, reason, message string)

	RecordFailureEvent(networkIntent *nephoranv1.NetworkIntent, reason, message string)

	RecordSuccessEvent(networkIntent *nephoranv1.NetworkIntent, reason, message string)
}

type GitClientInterface = git.ClientInterface

type GitOpsHandler struct {
	*NetworkIntentReconciler
}

type GitOpsHandlerInterface interface {
	PhaseProcessor

	CommitToGitOps(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, processingCtx *ProcessingContext) (ctrl.Result, error)

	VerifyDeployment(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, processingCtx *ProcessingContext) (ctrl.Result, error)

	CleanupGitOpsResources(ctx context.Context, networkIntent *nephoranv1.NetworkIntent) error
}

type HealthCheckInterface interface {
	CheckHealth(ctx context.Context) error

	CheckDependencies(ctx context.Context) error

	CheckLLMHealth(ctx context.Context) error

	CheckGitHealth(ctx context.Context) error
}

type HealthCheckSpec struct {
	Type string `json:"type"`

	Path string `json:"path"`

	Port int `json:"port"`

	Interval string `json:"interval"`

	Timeout string `json:"timeout"`

	Retries int `json:"retries"`
}

type InterfaceConfiguration struct {
	Name string `json:"name"`

	Type string `json:"type"`

	Protocol string `json:"protocol"`

	Endpoints []EndpointSpec `json:"endpoints"`

	Security SecuritySpec `json:"security"`

	QoS QoSSpec `json:"qos"`
}

type LLMProcessor struct {
	*NetworkIntentReconciler
}

type LLMProcessorInterface interface {
	PhaseProcessor

	ProcessLLMPhase(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, processingCtx *ProcessingContext) (ctrl.Result, error)

	BuildTelecomEnhancedPrompt(ctx context.Context, intent string, processingCtx *ProcessingContext) (string, error)

	ExtractTelecomContext(intent string) map[string]interface{}
}

type MetricsManagerInterface interface {
	RecordProcessingMetrics(phase ProcessingPhase, duration float64, success bool)

	RecordLLMMetrics(model string, tokenCount int, duration float64, success bool)

	RecordGitOpsMetrics(operation string, duration float64, success bool)

	UpdateNetworkIntentStatus(name, namespace, intentType, status string)
}

type MonitoringSpec struct {
	Enabled bool `json:"enabled"`

	Metrics []string `json:"metrics"`

	Alerts []string `json:"alerts"`

	Dashboards []string `json:"dashboards"`
}

type NetworkFunctionDeploymentIntent struct {
	Type string `json:"type"`

	Name string `json:"name"`

	Namespace string `json:"namespace"`

	Spec DeploymentSpec `json:"spec"`

	O1Config string `json:"o1_config"`

	A1Policy A1Policy `json:"a1_policy"`
}

type NetworkFunctionScaleIntent struct {
	Type string `json:"type"`

	Name string `json:"name"`

	Namespace string `json:"namespace"`

	Replicas int `json:"replicas"`
}

type NetworkIntentAuthDecorator struct {
	*AuthenticatedReconciler
	// contains filtered or unexported fields
}

type NetworkIntentError struct {
	Phase string

	Operation string

	Cause error

	Retries int

	Timestamp time.Time
}

type NetworkIntentReconciler struct {
	client.Client

	Scheme *runtime.Scheme
	// contains filtered or unexported fields
}

type OranAdaptorReconciler struct {
	client.Client

	Scheme *runtime.Scheme

	O1Adaptor *o1.O1Adaptor

	A1Adaptor *a1.A1Adaptor
}

type PhaseProcessor interface {
	ProcessPhase(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, processingCtx *ProcessingContext) (ctrl.Result, error)

	GetPhaseName() ProcessingPhase

	IsPhaseComplete(networkIntent *nephoranv1.NetworkIntent) bool
}

type PlannedNetworkFunction struct {
	Name string `json:"name"`

	Type string `json:"type"`

	Version string `json:"version"`

	Replicas int `json:"replicas"`

	Resources ResourceRequirements `json:"resources"`

	Configuration json.RawMessage `json:"configuration"`

	Dependencies []string `json:"dependencies"`

	Interfaces []string `json:"interfaces"`

	HealthChecks []HealthCheckSpec `json:"health_checks"`

	Monitoring MonitoringSpec `json:"monitoring"`
}

type ProcessingContext struct {
	StartTime time.Time

	CurrentPhase ProcessingPhase

	IntentType string

	ExtractedEntities map[string]interface{}

	TelecomContext map[string]interface{}

	ResourcePlan *ResourcePlan

	Manifests map[string]string

	GitCommitHash string

	DeploymentStatus map[string]interface{}

	Metrics map[string]float64
}

type ProcessingPhase string

type QoSSpec struct {
	Bandwidth string `json:"bandwidth"`

	Latency string `json:"latency"`

	Jitter string `json:"jitter"`

	PacketLoss float64 `json:"packet_loss"`
}

type RANFunctionConfig struct {
	FunctionID int32 `json:"functionId"`

	Revision int32 `json:"revision"`

	Description string `json:"description"`

	OID string `json:"oid"`
}

type Reconciler struct {
	*NetworkIntentReconciler
	// contains filtered or unexported fields
}

type ReconcilerInterface interface {
	Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

	ExecuteProcessingPipeline(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, processingCtx *ProcessingContext) (ctrl.Result, error)

	IsProcessingComplete(networkIntent *nephoranv1.NetworkIntent) bool
}

type ResourcePlan struct {
	NetworkFunctions []PlannedNetworkFunction `json:"network_functions"`

	ResourceRequirements ResourceRequirements `json:"resource_requirements"`

	DeploymentPattern string `json:"deployment_pattern"`

	QoSProfile string `json:"qos_profile"`

	SliceConfiguration *SliceConfiguration `json:"slice_configuration,omitempty"`

	Interfaces []InterfaceConfiguration `json:"interfaces"`

	SecurityPolicies []SecurityPolicy `json:"security_policies"`

	EstimatedCost float64 `json:"estimated_cost"`
}

type ResourcePlanner struct {
	*NetworkIntentReconciler
}

type ResourcePlannerInterface interface {
	PhaseProcessor

	PlanResources(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, processingCtx *ProcessingContext) (ctrl.Result, error)

	GenerateManifests(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, processingCtx *ProcessingContext) (ctrl.Result, error)

	PlanNetworkFunction(nfName string, llmParams, telecomContext map[string]interface{}) (*PlannedNetworkFunction, error)

	CalculateEstimatedCost(plan *ResourcePlan) (float64, error)
}

type ResourceRequirements struct {
	CPU string `json:"cpu"`

	Memory string `json:"memory"`

	Storage string `json:"storage"`

	NetworkBW string `json:"network_bandwidth"`

	GPU string `json:"gpu,omitempty"`

	Accelerator string `json:"accelerator,omitempty"`
}

type RetryManagerInterface interface {
	GetRetryCount(networkIntent *nephoranv1.NetworkIntent, operation string) int

	SetRetryCount(networkIntent *nephoranv1.NetworkIntent, operation string, count int)

	ClearRetryCount(networkIntent *nephoranv1.NetworkIntent, operation string)

	IsRetryLimitExceeded(networkIntent *nephoranv1.NetworkIntent, operation string, maxRetries int) bool

	CalculateBackoffDelay(retryCount int, operation string) ctrl.Result
}

type SecurityManagerInterface interface {
	SanitizeInput(ctx context.Context, input string) (string, error)

	ValidateOutput(ctx context.Context, output string) (string, error)

	BuildSecurePrompt(systemPrompt, userPrompt string) string
}

type SecurityPolicy struct {
	Name string `json:"name"`

	Type string `json:"type"`

	Config json.RawMessage `json:"config"`
}

type SecuritySpec struct {
	Authentication string `json:"authentication"`

	Encryption string `json:"encryption"`
}

type SimulationConfigData struct {
	UECount int32 `json:"ueCount"`

	TrafficGeneration bool `json:"trafficGeneration"`

	MetricsInterval string `json:"metricsInterval"`

	TrafficProfile string `json:"trafficProfile"`
}

type SliceConfiguration struct {
	SliceType string `json:"slice_type"`

	SST int `json:"sst"`

	SD string `json:"sd,omitempty"`

	QoSProfile string `json:"qos_profile"`

	Isolation string `json:"isolation"`

	Parameters json.RawMessage `json:"parameters"`
}

type StatusManagerInterface interface {
	UpdatePhase(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, phase string) error

	SetReadyCondition(ctx context.Context, networkIntent *nephoranv1.NetworkIntent, status, reason, message string) error

	UpdateCondition(networkIntent *nephoranv1.NetworkIntent, conditionType, status, reason, message string)

	IsConditionTrue(networkIntent *nephoranv1.NetworkIntent, conditionType string) bool
}

type StructuredIntent struct {
	Type string `json:"type"`

	Data json.RawMessage `json:"data"`
}

type ValidationError struct {
	Field string

	Value interface{}

	Message string
}

type ValidationInterface interface {
	ValidateNetworkIntent(networkIntent *nephoranv1.NetworkIntent) error

	ValidateProcessingContext(processingCtx *ProcessingContext) error

	ValidateResourcePlan(plan *ResourcePlan) error

	ValidateConfiguration(config *Config) error
}