Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python

feat: generated client for kubernetes crd (#1673)

ming76b0cd8a29bc
diff --git a/.github/workflows/operator-ci.yml b/.github/workflows/operator-ci.yml
index 5db9aa791..b025a583f 100644
--- a/.github/workflows/operator-ci.yml
+++ b/.github/workflows/operator-ci.yml
@@ -56,6 +56,16 @@ jobs:
./bin/controller-gen object:headerFile="hack/boilerplate.go.txt" paths="./..."
git diff --exit-code api/
+ - name: Check generated typed client is up to date
+ run: |
+ # Ensure code-generator is available in module cache
+ go mod download k8s.io/code-generator
+ make generate-client
+ git diff --exit-code pkg/generated/
+ env:
+ # Suppress verbose output during CI
+ KUBE_VERBOSE: "0"
+
- name: go test
run: go test ./... -race -coverprofile=cover.out
diff --git a/kubernetes/operator/CLIENT_GENERATION.md b/kubernetes/operator/CLIENT_GENERATION.md
new file mode 100644
index 000000000..181612b52
--- /dev/null
+++ b/kubernetes/operator/CLIENT_GENERATION.md
@@ -0,0 +1,367 @@
+# Typed Kubernetes Client Generation for OpenRAG
+
+This document explains how to generate and use typed Kubernetes clients for the OpenRAG CRDs.
+
+## Overview
+
+Instead of using `unstructured.Unstructured`, you can now use strongly-typed Go clients that provide:
+- **Compile-time type safety** - Catch errors during development, not runtime
+- **IDE auto-completion** - Better developer experience
+- **Cleaner code** - No manual field path navigation or type assertions
+
+## Generating the Clientset
+
+### Prerequisites
+
+```bash
+# Install code-generator dependency
+go get k8s.io/[email protected]
+```
+
+### Generate Clients
+
+```bash
+# Generate clientset, listers, and informers
+make generate-client
+```
+
+This will create the following packages:
+- `pkg/generated/clientset/versioned` - Typed clientset
+- `pkg/generated/listers/api/v1alpha1` - Listers for efficient reads
+- `pkg/generated/informers/externalversions` - Informers for watching resources
+
+## Usage Examples
+
+### Before (Using Unstructured)
+
+```go
+import (
+ "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+ "k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// Create unstructured client
+dynamicClient, err := dynamic.NewForConfig(config)
+gvr := schema.GroupVersionResource{
+ Group: "openr.ag",
+ Version: "v1alpha1",
+ Resource: "openrags",
+}
+
+// Get OpenRAG (weakly typed - runtime errors)
+obj, err := dynamicClient.Resource(gvr).Namespace("default").Get(ctx, "my-openrag", metav1.GetOptions{})
+if err != nil {
+ return err
+}
+
+// Manual field navigation (error-prone)
+spec, found, err := unstructured.NestedMap(obj.Object, "spec")
+backend, found, err := unstructured.NestedMap(spec, "backend")
+image, found, err := unstructured.NestedString(backend, "image")
+// No compile-time type checking!
+```
+
+### After (Using Typed Client)
+
+```go
+import (
+ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ clientset "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"
+)
+
+// Create typed client
+client, err := clientset.NewForConfig(config)
+
+// Get OpenRAG (strongly typed - compile-time safety!)
+openrag, err := client.OpenrV1alpha1().OpenRAGs("default").Get(ctx, "my-openrag", metav1.GetOptions{})
+if err != nil {
+ return err
+}
+
+// Direct field access with type safety
+image := openrag.Spec.Backend.Image // ✅ Type-safe!
+replicas := openrag.Spec.Backend.Replicas // ✅ Auto-complete!
+```
+
+## Full Example: Creating an OpenRAG Instance
+
+```go
+package main
+
+import (
+ "context"
+ "fmt"
+
+ corev1 "k8s.io/api/core/v1"
+ "k8s.io/apimachinery/pkg/api/resource"
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ "k8s.io/client-go/tools/clientcmd"
+ "k8s.io/utils/ptr"
+
+ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ clientset "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"
+)
+
+func main() {
+ // Load kubeconfig
+ config, err := clientcmd.BuildConfigFromFlags("", "/path/to/kubeconfig")
+ if err != nil {
+ panic(err)
+ }
+
+ // Create OpenRAG typed client
+ client, err := clientset.NewForConfig(config)
+ if err != nil {
+ panic(err)
+ }
+
+ // Define OpenRAG instance
+ openrag := &openragv1alpha1.OpenRAG{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: "my-openrag",
+ Namespace: "default",
+ },
+ Spec: openragv1alpha1.OpenRAGSpec{
+ TenantID: "tenant-123",
+ Frontend: openragv1alpha1.FrontendSpec{
+ ComponentSpec: openragv1alpha1.ComponentSpec{
+ Image: "myregistry/openrag-frontend:v1.0.0",
+ Replicas: ptr.To(int32(2)),
+ Resources: corev1.ResourceRequirements{
+ Requests: corev1.ResourceList{
+ corev1.ResourceCPU: resource.MustParse("100m"),
+ corev1.ResourceMemory: resource.MustParse("256Mi"),
+ },
+ },
+ },
+ },
+ Backend: openragv1alpha1.BackendSpec{
+ ComponentSpec: openragv1alpha1.ComponentSpec{
+ Image: "myregistry/openrag-backend:v1.0.0",
+ Replicas: ptr.To(int32(3)),
+ Env: []corev1.EnvVar{
+ {Name: "CUSTOM_VAR", Value: "custom_value"},
+ },
+ },
+ Storage: &openragv1alpha1.PersistenceSpec{
+ Enabled: true,
+ Size: resource.MustParse("10Gi"),
+ },
+ },
+ Langflow: openragv1alpha1.LangflowSpec{
+ ComponentSpec: openragv1alpha1.ComponentSpec{
+ Image: "myregistry/langflow:v1.0.0",
+ Replicas: ptr.To(int32(2)),
+ },
+ PVCReclaimPolicy: openragv1alpha1.PVCReclaimRetain,
+ },
+ },
+ }
+
+ // Create the resource
+ result, err := client.OpenrV1alpha1().OpenRAGs("default").Create(
+ context.Background(),
+ openrag,
+ metav1.CreateOptions{},
+ )
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Printf("Created OpenRAG: %s\n", result.Name)
+
+ // Update the resource
+ result.Spec.Backend.Replicas = ptr.To(int32(5))
+ updated, err := client.OpenrV1alpha1().OpenRAGs("default").Update(
+ context.Background(),
+ result,
+ metav1.UpdateOptions{},
+ )
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Printf("Updated OpenRAG backend replicas to: %d\n", *updated.Spec.Backend.Replicas)
+
+ // List all OpenRAG instances
+ list, err := client.OpenrV1alpha1().OpenRAGs("").List(
+ context.Background(),
+ metav1.ListOptions{},
+ )
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Printf("Found %d OpenRAG instances\n", len(list.Items))
+ for _, item := range list.Items {
+ fmt.Printf(" - %s/%s (Phase: %s)\n", item.Namespace, item.Name, item.Status.Phase)
+ }
+}
+```
+
+## Using Informers (Efficient Watching)
+
+Informers provide efficient caching and watching of resources:
+
+```go
+import (
+ "time"
+
+ "k8s.io/client-go/tools/cache"
+
+ informers "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions"
+)
+
+// Create informer factory
+informerFactory := informers.NewSharedInformerFactory(client, time.Minute*10)
+
+// Get OpenRAG informer
+openragInformer := informerFactory.Openr().V1alpha1().OpenRAGs()
+
+// Add event handlers
+openragInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
+ AddFunc: func(obj interface{}) {
+ openrag := obj.(*openragv1alpha1.OpenRAG)
+ fmt.Printf("OpenRAG added: %s/%s\n", openrag.Namespace, openrag.Name)
+ },
+ UpdateFunc: func(old, new interface{}) {
+ newOpenRAG := new.(*openragv1alpha1.OpenRAG)
+ fmt.Printf("OpenRAG updated: %s/%s\n", newOpenRAG.Namespace, newOpenRAG.Name)
+ },
+ DeleteFunc: func(obj interface{}) {
+ openrag := obj.(*openragv1alpha1.OpenRAG)
+ fmt.Printf("OpenRAG deleted: %s/%s\n", openrag.Namespace, openrag.Name)
+ },
+})
+
+// Start informers
+stopCh := make(chan struct{})
+defer close(stopCh)
+informerFactory.Start(stopCh)
+
+// Wait for cache sync
+if !cache.WaitForCacheSync(stopCh, openragInformer.Informer().HasSynced) {
+ panic("Failed to sync cache")
+}
+
+// Now use the lister for efficient reads
+lister := openragInformer.Lister()
+openrags, err := lister.OpenRAGs("default").List(labels.Everything())
+```
+
+## Benefits
+
+### Type Safety
+```go
+// ❌ Unstructured - Runtime error
+image := obj.Object["spec"].(map[string]interface{})["backend"].(map[string]interface{})["image"].(string)
+
+// ✅ Typed - Compile-time error if field doesn't exist
+image := openrag.Spec.Backend.Image
+```
+
+### IDE Support
+- Auto-completion for all fields
+- Jump to definition
+- Inline documentation
+- Refactoring support
+
+### Cleaner Code
+- No type assertions
+- No manual field path navigation
+- Easier to read and maintain
+
+## Regenerating Clients
+
+Run this command whenever you modify the CRD types:
+
+```bash
+make generate # Regenerate DeepCopy methods
+make generate-client # Regenerate clientsets, listers, informers
+```
+
+## Distribution
+
+### Option 1: Publish as Go Module (Recommended)
+
+Users can import directly:
+
+```go
+import clientset "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"
+```
+
+### Option 2: Copy Generated Code
+
+If users don't want to depend on your entire module, they can copy the generated code to their project:
+
+```bash
+cp -r pkg/generated /path/to/their/project/
+```
+
+## Troubleshooting
+
+### `code-generator` not found
+
+If you see this error:
+```
+Error: k8s.io/code-generator not found in module cache
+```
+
+Run:
+```bash
+go mod download k8s.io/code-generator
+# OR
+go get k8s.io/[email protected]
+go mod tidy
+```
+
+The dependency is already in `go.mod`, so `go mod download` should be sufficient.
+
+### Permission denied on script
+
+```bash
+chmod +x hack/update-codegen.sh
+```
+
+### Generated code not in version control
+
+It's recommended to commit generated code to version control so users can use it without running code generation.
+
+### CI Check Failures
+
+If your pull request fails with:
+
+```text
+Error: git diff --exit-code pkg/generated/
+```
+
+This means you modified the API types but didn't regenerate the typed client. Fix it:
+
+```bash
+make generate-client
+git add pkg/generated/
+git commit --amend --no-edit
+git push --force-with-lease
+```
+
+Our CI automatically verifies that generated code is up to date to prevent inconsistencies.
+
+## Contributing
+
+When modifying API types in `api/v1alpha1/`, always run:
+
+```bash
+make generate # Regenerate deepcopy code
+make manifests # Regenerate CRDs and RBAC
+make generate-client # Regenerate typed client
+git add api/ config/ pkg/generated/
+git commit -m "feat: add new field to OpenRAG spec"
+```
+
+See [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md) for more details.
+
+## References
+
+- [Kubernetes Code Generator](https://github.com/kubernetes/code-generator)
+- [Sample Controller](https://github.com/kubernetes/sample-controller)
+- [Client-go Documentation](https://github.com/kubernetes/client-go)
diff --git a/kubernetes/operator/Makefile b/kubernetes/operator/Makefile
index d5438be40..bfa237b23 100644
--- a/kubernetes/operator/Makefile
+++ b/kubernetes/operator/Makefile
@@ -4,10 +4,11 @@
# under ~/.gvm/gos/go1.26.0, otherwise falls back to whatever 'go' is in PATH.
#
# Quick start:
-# make deps # install controller-gen, kustomize, envtest into ./bin
-# make manifests # generate CRD + RBAC YAML under config/
-# make generate # regenerate zz_generated.deepcopy.go
-# make build # compile the operator binary
+# make deps # install controller-gen, kustomize, envtest into ./bin
+# make manifests # generate CRD + RBAC YAML under config/
+# make generate # regenerate zz_generated.deepcopy.go
+# make generate-client # generate typed clientsets, listers, and informers
+# make build # compile the operator binary
# Image to push/pull for the operator container.
IMG ?= ghcr.io/langflow-ai/openrag-operator:latest
@@ -55,6 +56,14 @@ manifests: controller-gen ## Generate CRD and RBAC manifests from Go type marker
generate: controller-gen ## Regenerate zz_generated.deepcopy.go from type definitions.
$(CONTROLLER_GEN) object:headerFile="hack/boilerplate.go.txt" paths="./..."
+.PHONY: generate-client
+generate-client: ## Generate typed clientsets, listers, and informers.
+ @echo "Generating typed clientsets..."
+ bash hack/update-codegen.sh
+ @echo ""
+ @echo "⚠️ Remember to commit the generated files in pkg/generated/"
+ @echo " CI will verify these are up to date on pull requests"
+
.PHONY: fmt
fmt: ## Run go fmt.
go fmt ./...
diff --git a/kubernetes/operator/api/v1alpha1/doc.go b/kubernetes/operator/api/v1alpha1/doc.go
new file mode 100644
index 000000000..421c68587
--- /dev/null
+++ b/kubernetes/operator/api/v1alpha1/doc.go
@@ -0,0 +1,16 @@
+// Package v1alpha1 contains API Schema definitions for the openr.ag v1alpha1 API group.
+// +k8s:deepcopy-gen=package
+// +groupName=openr.ag
+package v1alpha1
+
+import (
+ "k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = schema.GroupVersion{Group: "openr.ag", Version: "v1alpha1"}
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+func Resource(resource string) schema.GroupResource {
+ return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
diff --git a/kubernetes/operator/api/v1alpha1/openrag_types.go b/kubernetes/operator/api/v1alpha1/openrag_types.go
index d64e6adb9..f2bfa0ef6 100644
--- a/kubernetes/operator/api/v1alpha1/openrag_types.go
+++ b/kubernetes/operator/api/v1alpha1/openrag_types.go
@@ -710,6 +710,7 @@ type OpenRAGStatus struct {
// +kubebuilder:printcolumn:name="Frontend",type="string",JSONPath=".spec.frontend.image"
// +kubebuilder:printcolumn:name="Backend",type="string",JSONPath=".spec.backend.image"
// +kubebuilder:printcolumn:name="Langflow",type="string",JSONPath=".spec.langflow.image"
+// +genclient
// OpenRAG is the Schema for the openrags API.
type OpenRAG struct {
diff --git a/kubernetes/operator/go.mod b/kubernetes/operator/go.mod
index 2bd836ec7..e0a8bb356 100644
--- a/kubernetes/operator/go.mod
+++ b/kubernetes/operator/go.mod
@@ -7,13 +7,15 @@ require (
k8s.io/api v0.33.2
k8s.io/apimachinery v0.33.2
k8s.io/client-go v0.33.2
- sigs.k8s.io/controller-runtime v0.21.0
+ k8s.io/code-generator v0.33.0
+ k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738
+ sigs.k8s.io/controller-runtime v0.19.7
)
require (
github.com/beorn7/perks v1.0.1 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
- github.com/davecgh/go-spew v1.1.1 // indirect
+ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
github.com/emicklei/go-restful/v3 v3.11.0 // indirect
github.com/evanphx/json-patch/v5 v5.9.11 // indirect
github.com/fsnotify/fsnotify v1.7.0 // indirect
@@ -24,7 +26,6 @@ require (
github.com/go-openapi/jsonreference v0.20.2 // indirect
github.com/go-openapi/swag v0.23.0 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
- github.com/google/btree v1.1.3 // indirect
github.com/google/gnostic-models v0.6.9 // indirect
github.com/google/go-cmp v0.7.0 // indirect
github.com/google/uuid v1.6.0 // indirect
@@ -35,7 +36,7 @@ require (
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
github.com/pkg/errors v0.9.1 // indirect
- github.com/pmezard/go-difflib v1.0.0 // indirect
+ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
github.com/prometheus/client_golang v1.22.0 // indirect
github.com/prometheus/client_model v0.6.1 // indirect
github.com/prometheus/common v0.62.0 // indirect
@@ -44,6 +45,8 @@ require (
github.com/x448/float16 v0.8.4 // indirect
go.uber.org/multierr v1.11.0 // indirect
go.uber.org/zap v1.27.1 // indirect
+ golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc // indirect
+ golang.org/x/mod v0.21.0 // indirect
golang.org/x/net v0.38.0 // indirect
golang.org/x/oauth2 v0.27.0 // indirect
golang.org/x/sync v0.12.0 // indirect
@@ -51,15 +54,16 @@ require (
golang.org/x/term v0.30.0 // indirect
golang.org/x/text v0.23.0 // indirect
golang.org/x/time v0.9.0 // indirect
+ golang.org/x/tools v0.26.0 // indirect
gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect
google.golang.org/protobuf v1.36.5 // indirect
gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect
gopkg.in/inf.v0 v0.9.1 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
- k8s.io/apiextensions-apiserver v0.33.0 // indirect
+ k8s.io/apiextensions-apiserver v0.31.4 // indirect
+ k8s.io/gengo/v2 v2.0.0-20250207200755-1244d31929d7 // indirect
k8s.io/klog/v2 v2.130.1 // indirect
k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff // indirect
- k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 // indirect
sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirect
sigs.k8s.io/randfill v1.0.0 // indirect
sigs.k8s.io/structured-merge-diff/v4 v4.6.0 // indirect
diff --git a/kubernetes/operator/go.sum b/kubernetes/operator/go.sum
index bd5293434..62ea18dbc 100644
--- a/kubernetes/operator/go.sum
+++ b/kubernetes/operator/go.sum
@@ -1,13 +1,12 @@
github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=
-github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g=
github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=
github.com/evanphx/json-patch v0.5.2 h1:xVCHIVMUu1wtM/VkR9jVZ45N3FhZfYMMYGorLCR8P3k=
@@ -34,8 +33,6 @@ github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1v
github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg=
-github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
github.com/google/gnostic-models v0.6.9 h1:MU/8wDLif2qCXZmzncUQ/BOfxWfthHi63KqpoNbWqVw=
github.com/google/gnostic-models v0.6.9/go.mod h1:CiWsm0s6BSQd1hRn8/QmxqB6BesYcbSZxsz9b0KuDBw=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
@@ -74,14 +71,15 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/onsi/ginkgo/v2 v2.22.0 h1:Yed107/8DjTr0lKCNt7Dn8yQ6ybuDRQoMGrNFKzMfHg=
-github.com/onsi/ginkgo/v2 v2.22.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo=
-github.com/onsi/gomega v1.36.1 h1:bJDPBO7ibjxcbHMgSCoo4Yj18UWbKDlLwX1x9sybDcw=
-github.com/onsi/gomega v1.36.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog=
+github.com/onsi/ginkgo/v2 v2.21.0 h1:7rg/4f3rB88pb5obDgNZrNHrQ4e6WpjonchcpuBRnZM=
+github.com/onsi/ginkgo/v2 v2.21.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo=
+github.com/onsi/gomega v1.35.1 h1:Cwbd75ZBPxFSuZ6T+rN/WCb/gOc6YgFBXLlZLhC7Ds4=
+github.com/onsi/gomega v1.35.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=
github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=
github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
@@ -118,8 +116,12 @@ go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU=
+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.21.0 h1:vvrHzRwRfVKSiLrG+d4FMl/Qi4ukBCE6kZlTUkDYRT0=
+golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -172,20 +174,24 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
k8s.io/api v0.33.2 h1:YgwIS5jKfA+BZg//OQhkJNIfie/kmRsO0BmNaVSimvY=
k8s.io/api v0.33.2/go.mod h1:fhrbphQJSM2cXzCWgqU29xLDuks4mu7ti9vveEnpSXs=
-k8s.io/apiextensions-apiserver v0.33.0 h1:d2qpYL7Mngbsc1taA4IjJPRJ9ilnsXIrndH+r9IimOs=
-k8s.io/apiextensions-apiserver v0.33.0/go.mod h1:VeJ8u9dEEN+tbETo+lFkwaaZPg6uFKLGj5vyNEwwSzc=
+k8s.io/apiextensions-apiserver v0.31.4 h1:FxbqzSvy92Ca9DIs5jqot883G0Ln/PGXfm/07t39LS0=
+k8s.io/apiextensions-apiserver v0.31.4/go.mod h1:hIW9YU8UsqZqIWGG99/gsdIU0Ar45Qd3A12QOe/rvpg=
k8s.io/apimachinery v0.33.2 h1:IHFVhqg59mb8PJWTLi8m1mAoepkUNYmptHsV+Z1m5jY=
k8s.io/apimachinery v0.33.2/go.mod h1:BHW0YOu7n22fFv/JkYOEfkUYNRN0fj0BlvMFWA7b+SM=
k8s.io/client-go v0.33.2 h1:z8CIcc0P581x/J1ZYf4CNzRKxRvQAwoAolYPbtQes+E=
k8s.io/client-go v0.33.2/go.mod h1:9mCgT4wROvL948w6f6ArJNb7yQd7QsvqavDeZHvNmHo=
+k8s.io/code-generator v0.33.0 h1:B212FVl6EFqNmlgdOZYWNi77yBv+ed3QgQsMR8YQCw4=
+k8s.io/code-generator v0.33.0/go.mod h1:KnJRokGxjvbBQkSJkbVuBbu6z4B0rC7ynkpY5Aw6m9o=
+k8s.io/gengo/v2 v2.0.0-20250207200755-1244d31929d7 h1:2OX19X59HxDprNCVrWi6jb7LW1PoqTlYqEq5H2oetog=
+k8s.io/gengo/v2 v2.0.0-20250207200755-1244d31929d7/go.mod h1:EJykeLsmFC60UQbYJezXkEsG2FLrt0GPNkU5iK5GWxU=
k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk=
k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE=
k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff h1:/usPimJzUKKu+m+TE36gUyGcf03XZEP0ZIKgKj35LS4=
k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff/go.mod h1:5jIi+8yX4RIb8wk3XwBo5Pq2ccx4FP10ohkbSKCZoK8=
k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 h1:M3sRQVHv7vB20Xc2ybTt7ODCeFj6JSWYFzOFnYeS6Ro=
k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=
-sigs.k8s.io/controller-runtime v0.21.0 h1:CYfjpEuicjUecRk+KAeyYh+ouUBn4llGyDYytIGcJS8=
-sigs.k8s.io/controller-runtime v0.21.0/go.mod h1:OSg14+F65eWqIu4DceX7k/+QRAbTTvxeQSNSOQpukWM=
+sigs.k8s.io/controller-runtime v0.19.7 h1:DLABZfMr20A+AwCZOHhcbcu+TqBXnJZaVBri9K3EO48=
+sigs.k8s.io/controller-runtime v0.19.7/go.mod h1:iRmWllt8IlaLjvTTDLhRBXIEtkCK6hwVBJJsYS9Ajf4=
sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 h1:/Rv+M11QRah1itp8VhT6HoVx1Ray9eB4DBr+K+/sCJ8=
sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3/go.mod h1:18nIHnGi6636UCz6m8i4DhaJ65T6EruyzmoQqI2BVDo=
sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=
diff --git a/kubernetes/operator/hack/tools.go b/kubernetes/operator/hack/tools.go
new file mode 100644
index 000000000..a251dcf42
--- /dev/null
+++ b/kubernetes/operator/hack/tools.go
@@ -0,0 +1,9 @@
+//go:build tools
+// +build tools
+
+// This package imports things required by build scripts, to force `go mod` to see them as dependencies
+package tools
+
+import (
+ _ "k8s.io/code-generator"
+)
diff --git a/kubernetes/operator/hack/update-codegen.sh b/kubernetes/operator/hack/update-codegen.sh
new file mode 100755
index 000000000..ec4eec5f3
--- /dev/null
+++ b/kubernetes/operator/hack/update-codegen.sh
@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+
+# Copyright The OpenRAG Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+SCRIPT_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
+
+# Find code-generator in go module cache
+CODEGEN_PKG=$(go list -f '{{.Dir}}' -m k8s.io/code-generator)
+
+if [ -z "${CODEGEN_PKG}" ] || [ ! -d "${CODEGEN_PKG}" ]; then
+ echo "Error: k8s.io/code-generator not found in module cache"
+ echo "Please run: go get k8s.io/[email protected]"
+ exit 1
+fi
+
+echo "Using code-generator from: ${CODEGEN_PKG}"
+
+# Ensure the output directory structure exists
+mkdir -p "${SCRIPT_ROOT}/pkg/generated"
+
+# Source the kube_codegen library
+source "${CODEGEN_PKG}/kube_codegen.sh"
+
+# Generate clientset for API types
+# Run from the module root directory
+# --with-watch enables generation of listers and informers
+kube::codegen::gen_client \
+ --with-watch \
+ --one-input-api "api/v1alpha1" \
+ --output-dir "${SCRIPT_ROOT}/pkg/generated" \
+ --output-pkg "github.com/langflow-ai/openrag-operator/pkg/generated" \
+ --boilerplate "${SCRIPT_ROOT}/hack/boilerplate.go.txt" \
+ "${SCRIPT_ROOT}"
+
+echo ""
+echo "✅ Code generation complete!"
+echo ""
+echo "Generated files:"
+echo " - pkg/generated/clientset/versioned/ (Typed clientset)"
+echo " - pkg/generated/listers/api/v1alpha1/ (Listers)"
+echo " - pkg/generated/informers/externalversions/ (Informers)"
+echo ""
+echo "Users can now import:"
+echo " import clientset \"github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned\""
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/clientset.go b/kubernetes/operator/pkg/generated/clientset/versioned/clientset.go
new file mode 100644
index 000000000..e8f79b3ce
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/clientset.go
@@ -0,0 +1,120 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package versioned
+
+import (
+ fmt "fmt"
+ http "net/http"
+
+ openrv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1"
+ discovery "k8s.io/client-go/discovery"
+ rest "k8s.io/client-go/rest"
+ flowcontrol "k8s.io/client-go/util/flowcontrol"
+)
+
+type Interface interface {
+ Discovery() discovery.DiscoveryInterface
+ OpenrV1alpha1() openrv1alpha1.OpenrV1alpha1Interface
+}
+
+// Clientset contains the clients for groups.
+type Clientset struct {
+ *discovery.DiscoveryClient
+ openrV1alpha1 *openrv1alpha1.OpenrV1alpha1Client
+}
+
+// OpenrV1alpha1 retrieves the OpenrV1alpha1Client
+func (c *Clientset) OpenrV1alpha1() openrv1alpha1.OpenrV1alpha1Interface {
+ return c.openrV1alpha1
+}
+
+// Discovery retrieves the DiscoveryClient
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+ if c == nil {
+ return nil
+ }
+ return c.DiscoveryClient
+}
+
+// NewForConfig creates a new Clientset for the given config.
+// If config's RateLimiter is not set and QPS and Burst are acceptable,
+// NewForConfig will generate a rate-limiter in configShallowCopy.
+// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient),
+// where httpClient was generated with rest.HTTPClientFor(c).
+func NewForConfig(c *rest.Config) (*Clientset, error) {
+ configShallowCopy := *c
+
+ if configShallowCopy.UserAgent == "" {
+ configShallowCopy.UserAgent = rest.DefaultKubernetesUserAgent()
+ }
+
+ // share the transport between all clients
+ httpClient, err := rest.HTTPClientFor(&configShallowCopy)
+ if err != nil {
+ return nil, err
+ }
+
+ return NewForConfigAndClient(&configShallowCopy, httpClient)
+}
+
+// NewForConfigAndClient creates a new Clientset for the given config and http client.
+// Note the http client provided takes precedence over the configured transport values.
+// If config's RateLimiter is not set and QPS and Burst are acceptable,
+// NewForConfigAndClient will generate a rate-limiter in configShallowCopy.
+func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset, error) {
+ configShallowCopy := *c
+ if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
+ if configShallowCopy.Burst <= 0 {
+ return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0")
+ }
+ configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
+ }
+
+ var cs Clientset
+ var err error
+ cs.openrV1alpha1, err = openrv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient)
+ if err != nil {
+ return nil, err
+ }
+
+ cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfigAndClient(&configShallowCopy, httpClient)
+ if err != nil {
+ return nil, err
+ }
+ return &cs, nil
+}
+
+// NewForConfigOrDie creates a new Clientset for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *Clientset {
+ cs, err := NewForConfig(c)
+ if err != nil {
+ panic(err)
+ }
+ return cs
+}
+
+// New creates a new Clientset for the given RESTClient.
+func New(c rest.Interface) *Clientset {
+ var cs Clientset
+ cs.openrV1alpha1 = openrv1alpha1.New(c)
+
+ cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
+ return &cs
+}
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/fake/clientset_generated.go b/kubernetes/operator/pkg/generated/clientset/versioned/fake/clientset_generated.go
new file mode 100644
index 000000000..1cbf72844
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/fake/clientset_generated.go
@@ -0,0 +1,94 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+ clientset "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"
+ openrv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1"
+ fakeopenrv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake"
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ "k8s.io/apimachinery/pkg/runtime"
+ "k8s.io/apimachinery/pkg/watch"
+ "k8s.io/client-go/discovery"
+ fakediscovery "k8s.io/client-go/discovery/fake"
+ "k8s.io/client-go/testing"
+)
+
+// NewSimpleClientset returns a clientset that will respond with the provided objects.
+// It's backed by a very simple object tracker that processes creates, updates and deletions as-is,
+// without applying any field management, validations and/or defaults. It shouldn't be considered a replacement
+// for a real clientset and is mostly useful in simple unit tests.
+//
+// DEPRECATED: NewClientset replaces this with support for field management, which significantly improves
+// server side apply testing. NewClientset is only available when apply configurations are generated (e.g.
+// via --with-applyconfig).
+func NewSimpleClientset(objects ...runtime.Object) *Clientset {
+ o := testing.NewObjectTracker(scheme, codecs.UniversalDecoder())
+ for _, obj := range objects {
+ if err := o.Add(obj); err != nil {
+ panic(err)
+ }
+ }
+
+ cs := &Clientset{tracker: o}
+ cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake}
+ cs.AddReactor("*", "*", testing.ObjectReaction(o))
+ cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
+ var opts metav1.ListOptions
+ if watchActcion, ok := action.(testing.WatchActionImpl); ok {
+ opts = watchActcion.ListOptions
+ }
+ gvr := action.GetResource()
+ ns := action.GetNamespace()
+ watch, err := o.Watch(gvr, ns, opts)
+ if err != nil {
+ return false, nil, err
+ }
+ return true, watch, nil
+ })
+
+ return cs
+}
+
+// Clientset implements clientset.Interface. Meant to be embedded into a
+// struct to get a default implementation. This makes faking out just the method
+// you want to test easier.
+type Clientset struct {
+ testing.Fake
+ discovery *fakediscovery.FakeDiscovery
+ tracker testing.ObjectTracker
+}
+
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+ return c.discovery
+}
+
+func (c *Clientset) Tracker() testing.ObjectTracker {
+ return c.tracker
+}
+
+var (
+ _ clientset.Interface = &Clientset{}
+ _ testing.FakeClient = &Clientset{}
+)
+
+// OpenrV1alpha1 retrieves the OpenrV1alpha1Client
+func (c *Clientset) OpenrV1alpha1() openrv1alpha1.OpenrV1alpha1Interface {
+ return &fakeopenrv1alpha1.FakeOpenrV1alpha1{Fake: &c.Fake}
+}
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/fake/doc.go b/kubernetes/operator/pkg/generated/clientset/versioned/fake/doc.go
new file mode 100644
index 000000000..8aed70b3d
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/fake/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated fake clientset.
+package fake
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/fake/register.go b/kubernetes/operator/pkg/generated/clientset/versioned/fake/register.go
new file mode 100644
index 000000000..6b1d1c75e
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/fake/register.go
@@ -0,0 +1,56 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+ openrv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ runtime "k8s.io/apimachinery/pkg/runtime"
+ schema "k8s.io/apimachinery/pkg/runtime/schema"
+ serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+ utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+)
+
+var scheme = runtime.NewScheme()
+var codecs = serializer.NewCodecFactory(scheme)
+
+var localSchemeBuilder = runtime.SchemeBuilder{
+ openrv1alpha1.AddToScheme,
+}
+
+// AddToScheme adds all types of this clientset into the given scheme. This allows composition
+// of clientsets, like in:
+//
+// import (
+// "k8s.io/client-go/kubernetes"
+// clientsetscheme "k8s.io/client-go/kubernetes/scheme"
+// aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"
+// )
+//
+// kclientset, _ := kubernetes.NewForConfig(c)
+// _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)
+//
+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
+// correctly.
+var AddToScheme = localSchemeBuilder.AddToScheme
+
+func init() {
+ v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: "v1"})
+ utilruntime.Must(AddToScheme(scheme))
+}
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/scheme/doc.go b/kubernetes/operator/pkg/generated/clientset/versioned/scheme/doc.go
new file mode 100644
index 000000000..31698488f
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/scheme/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package contains the scheme of the automatically generated clientset.
+package scheme
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/scheme/register.go b/kubernetes/operator/pkg/generated/clientset/versioned/scheme/register.go
new file mode 100644
index 000000000..b7c76391f
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/scheme/register.go
@@ -0,0 +1,56 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package scheme
+
+import (
+ openrv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ runtime "k8s.io/apimachinery/pkg/runtime"
+ schema "k8s.io/apimachinery/pkg/runtime/schema"
+ serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+ utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+)
+
+var Scheme = runtime.NewScheme()
+var Codecs = serializer.NewCodecFactory(Scheme)
+var ParameterCodec = runtime.NewParameterCodec(Scheme)
+var localSchemeBuilder = runtime.SchemeBuilder{
+ openrv1alpha1.AddToScheme,
+}
+
+// AddToScheme adds all types of this clientset into the given scheme. This allows composition
+// of clientsets, like in:
+//
+// import (
+// "k8s.io/client-go/kubernetes"
+// clientsetscheme "k8s.io/client-go/kubernetes/scheme"
+// aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"
+// )
+//
+// kclientset, _ := kubernetes.NewForConfig(c)
+// _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)
+//
+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
+// correctly.
+var AddToScheme = localSchemeBuilder.AddToScheme
+
+func init() {
+ v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"})
+ utilruntime.Must(AddToScheme(Scheme))
+}
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/api_client.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/api_client.go
new file mode 100644
index 000000000..dfe94a579
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/api_client.go
@@ -0,0 +1,101 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+ http "net/http"
+
+ apiv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ scheme "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/scheme"
+ rest "k8s.io/client-go/rest"
+)
+
+type OpenrV1alpha1Interface interface {
+ RESTClient() rest.Interface
+ OpenRAGsGetter
+}
+
+// OpenrV1alpha1Client is used to interact with features provided by the openr.ag group.
+type OpenrV1alpha1Client struct {
+ restClient rest.Interface
+}
+
+func (c *OpenrV1alpha1Client) OpenRAGs(namespace string) OpenRAGInterface {
+ return newOpenRAGs(c, namespace)
+}
+
+// NewForConfig creates a new OpenrV1alpha1Client for the given config.
+// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient),
+// where httpClient was generated with rest.HTTPClientFor(c).
+func NewForConfig(c *rest.Config) (*OpenrV1alpha1Client, error) {
+ config := *c
+ setConfigDefaults(&config)
+ httpClient, err := rest.HTTPClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return NewForConfigAndClient(&config, httpClient)
+}
+
+// NewForConfigAndClient creates a new OpenrV1alpha1Client for the given config and http client.
+// Note the http client provided takes precedence over the configured transport values.
+func NewForConfigAndClient(c *rest.Config, h *http.Client) (*OpenrV1alpha1Client, error) {
+ config := *c
+ setConfigDefaults(&config)
+ client, err := rest.RESTClientForConfigAndClient(&config, h)
+ if err != nil {
+ return nil, err
+ }
+ return &OpenrV1alpha1Client{client}, nil
+}
+
+// NewForConfigOrDie creates a new OpenrV1alpha1Client for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *OpenrV1alpha1Client {
+ client, err := NewForConfig(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+// New creates a new OpenrV1alpha1Client for the given RESTClient.
+func New(c rest.Interface) *OpenrV1alpha1Client {
+ return &OpenrV1alpha1Client{c}
+}
+
+func setConfigDefaults(config *rest.Config) {
+ gv := apiv1alpha1.SchemeGroupVersion
+ config.GroupVersion = &gv
+ config.APIPath = "/apis"
+ config.NegotiatedSerializer = rest.CodecFactoryForGeneratedClient(scheme.Scheme, scheme.Codecs).WithoutConversion()
+
+ if config.UserAgent == "" {
+ config.UserAgent = rest.DefaultKubernetesUserAgent()
+ }
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *OpenrV1alpha1Client) RESTClient() rest.Interface {
+ if c == nil {
+ return nil
+ }
+ return c.restClient
+}
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/doc.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/doc.go
new file mode 100644
index 000000000..bd9b51cf5
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated typed clients.
+package v1alpha1
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/doc.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/doc.go
new file mode 100644
index 000000000..e9452deb6
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// Package fake has the automatically generated clients.
+package fake
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_api_client.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_api_client.go
new file mode 100644
index 000000000..6ed62da4d
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_api_client.go
@@ -0,0 +1,40 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+ v1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1"
+ rest "k8s.io/client-go/rest"
+ testing "k8s.io/client-go/testing"
+)
+
+type FakeOpenrV1alpha1 struct {
+ *testing.Fake
+}
+
+func (c *FakeOpenrV1alpha1) OpenRAGs(namespace string) v1alpha1.OpenRAGInterface {
+ return newFakeOpenRAGs(c, namespace)
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeOpenrV1alpha1) RESTClient() rest.Interface {
+ var ret *rest.RESTClient
+ return ret
+}
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_openrag.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_openrag.go
new file mode 100644
index 000000000..b9c84167f
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_openrag.go
@@ -0,0 +1,50 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+ v1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ apiv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1"
+ gentype "k8s.io/client-go/gentype"
+)
+
+// fakeOpenRAGs implements OpenRAGInterface
+type fakeOpenRAGs struct {
+ *gentype.FakeClientWithList[*v1alpha1.OpenRAG, *v1alpha1.OpenRAGList]
+ Fake *FakeOpenrV1alpha1
+}
+
+func newFakeOpenRAGs(fake *FakeOpenrV1alpha1, namespace string) apiv1alpha1.OpenRAGInterface {
+ return &fakeOpenRAGs{
+ gentype.NewFakeClientWithList[*v1alpha1.OpenRAG, *v1alpha1.OpenRAGList](
+ fake.Fake,
+ namespace,
+ v1alpha1.SchemeGroupVersion.WithResource("openrags"),
+ v1alpha1.SchemeGroupVersion.WithKind("OpenRAG"),
+ func() *v1alpha1.OpenRAG { return &v1alpha1.OpenRAG{} },
+ func() *v1alpha1.OpenRAGList { return &v1alpha1.OpenRAGList{} },
+ func(dst, src *v1alpha1.OpenRAGList) { dst.ListMeta = src.ListMeta },
+ func(list *v1alpha1.OpenRAGList) []*v1alpha1.OpenRAG { return gentype.ToPointerSlice(list.Items) },
+ func(list *v1alpha1.OpenRAGList, items []*v1alpha1.OpenRAG) {
+ list.Items = gentype.FromPointerSlice(items)
+ },
+ ),
+ fake,
+ }
+}
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/generated_expansion.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/generated_expansion.go
new file mode 100644
index 000000000..198f5ffd1
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/generated_expansion.go
@@ -0,0 +1,21 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1alpha1
+
+type OpenRAGExpansion interface{}
diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/openrag.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/openrag.go
new file mode 100644
index 000000000..f1fa8dfc9
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/openrag.go
@@ -0,0 +1,70 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+ context "context"
+
+ apiv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ scheme "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/scheme"
+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ types "k8s.io/apimachinery/pkg/types"
+ watch "k8s.io/apimachinery/pkg/watch"
+ gentype "k8s.io/client-go/gentype"
+)
+
+// OpenRAGsGetter has a method to return a OpenRAGInterface.
+// A group's client should implement this interface.
+type OpenRAGsGetter interface {
+ OpenRAGs(namespace string) OpenRAGInterface
+}
+
+// OpenRAGInterface has methods to work with OpenRAG resources.
+type OpenRAGInterface interface {
+ Create(ctx context.Context, openRAG *apiv1alpha1.OpenRAG, opts v1.CreateOptions) (*apiv1alpha1.OpenRAG, error)
+ Update(ctx context.Context, openRAG *apiv1alpha1.OpenRAG, opts v1.UpdateOptions) (*apiv1alpha1.OpenRAG, error)
+ // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+ UpdateStatus(ctx context.Context, openRAG *apiv1alpha1.OpenRAG, opts v1.UpdateOptions) (*apiv1alpha1.OpenRAG, error)
+ Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
+ DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
+ Get(ctx context.Context, name string, opts v1.GetOptions) (*apiv1alpha1.OpenRAG, error)
+ List(ctx context.Context, opts v1.ListOptions) (*apiv1alpha1.OpenRAGList, error)
+ Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
+ Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *apiv1alpha1.OpenRAG, err error)
+ OpenRAGExpansion
+}
+
+// openRAGs implements OpenRAGInterface
+type openRAGs struct {
+ *gentype.ClientWithList[*apiv1alpha1.OpenRAG, *apiv1alpha1.OpenRAGList]
+}
+
+// newOpenRAGs returns a OpenRAGs
+func newOpenRAGs(c *OpenrV1alpha1Client, namespace string) *openRAGs {
+ return &openRAGs{
+ gentype.NewClientWithList[*apiv1alpha1.OpenRAG, *apiv1alpha1.OpenRAGList](
+ "openrags",
+ c.RESTClient(),
+ scheme.ParameterCodec,
+ namespace,
+ func() *apiv1alpha1.OpenRAG { return &apiv1alpha1.OpenRAG{} },
+ func() *apiv1alpha1.OpenRAGList { return &apiv1alpha1.OpenRAGList{} },
+ ),
+ }
+}
diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/api/interface.go b/kubernetes/operator/pkg/generated/informers/externalversions/api/interface.go
new file mode 100644
index 000000000..4d7ec382c
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/informers/externalversions/api/interface.go
@@ -0,0 +1,46 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package api
+
+import (
+ v1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/api/v1alpha1"
+ internalinterfaces "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+ // V1alpha1 provides access to shared informers for resources in V1alpha1.
+ V1alpha1() v1alpha1.Interface
+}
+
+type group struct {
+ factory internalinterfaces.SharedInformerFactory
+ namespace string
+ tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+ return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// V1alpha1 returns a new v1alpha1.Interface.
+func (g *group) V1alpha1() v1alpha1.Interface {
+ return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
+}
diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/interface.go b/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/interface.go
new file mode 100644
index 000000000..d5b5228bd
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/interface.go
@@ -0,0 +1,45 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+ internalinterfaces "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+ // OpenRAGs returns a OpenRAGInformer.
+ OpenRAGs() OpenRAGInformer
+}
+
+type version struct {
+ factory internalinterfaces.SharedInformerFactory
+ namespace string
+ tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+ return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// OpenRAGs returns a OpenRAGInformer.
+func (v *version) OpenRAGs() OpenRAGInformer {
+ return &openRAGInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/openrag.go b/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/openrag.go
new file mode 100644
index 000000000..c952d7aa3
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/openrag.go
@@ -0,0 +1,102 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+ context "context"
+ time "time"
+
+ openragoperatorapiv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ versioned "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"
+ internalinterfaces "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/internalinterfaces"
+ apiv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/listers/api/v1alpha1"
+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ runtime "k8s.io/apimachinery/pkg/runtime"
+ watch "k8s.io/apimachinery/pkg/watch"
+ cache "k8s.io/client-go/tools/cache"
+)
+
+// OpenRAGInformer provides access to a shared informer and lister for
+// OpenRAGs.
+type OpenRAGInformer interface {
+ Informer() cache.SharedIndexInformer
+ Lister() apiv1alpha1.OpenRAGLister
+}
+
+type openRAGInformer struct {
+ factory internalinterfaces.SharedInformerFactory
+ tweakListOptions internalinterfaces.TweakListOptionsFunc
+ namespace string
+}
+
+// NewOpenRAGInformer constructs a new informer for OpenRAG type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewOpenRAGInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+ return NewFilteredOpenRAGInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredOpenRAGInformer constructs a new informer for OpenRAG type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredOpenRAGInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+ return cache.NewSharedIndexInformer(
+ &cache.ListWatch{
+ ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+ if tweakListOptions != nil {
+ tweakListOptions(&options)
+ }
+ return client.OpenrV1alpha1().OpenRAGs(namespace).List(context.Background(), options)
+ },
+ WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+ if tweakListOptions != nil {
+ tweakListOptions(&options)
+ }
+ return client.OpenrV1alpha1().OpenRAGs(namespace).Watch(context.Background(), options)
+ },
+ ListWithContextFunc: func(ctx context.Context, options v1.ListOptions) (runtime.Object, error) {
+ if tweakListOptions != nil {
+ tweakListOptions(&options)
+ }
+ return client.OpenrV1alpha1().OpenRAGs(namespace).List(ctx, options)
+ },
+ WatchFuncWithContext: func(ctx context.Context, options v1.ListOptions) (watch.Interface, error) {
+ if tweakListOptions != nil {
+ tweakListOptions(&options)
+ }
+ return client.OpenrV1alpha1().OpenRAGs(namespace).Watch(ctx, options)
+ },
+ },
+ &openragoperatorapiv1alpha1.OpenRAG{},
+ resyncPeriod,
+ indexers,
+ )
+}
+
+func (f *openRAGInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+ return NewFilteredOpenRAGInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *openRAGInformer) Informer() cache.SharedIndexInformer {
+ return f.factory.InformerFor(&openragoperatorapiv1alpha1.OpenRAG{}, f.defaultInformer)
+}
+
+func (f *openRAGInformer) Lister() apiv1alpha1.OpenRAGLister {
+ return apiv1alpha1.NewOpenRAGLister(f.Informer().GetIndexer())
+}
diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/factory.go b/kubernetes/operator/pkg/generated/informers/externalversions/factory.go
new file mode 100644
index 000000000..6896c0e60
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/informers/externalversions/factory.go
@@ -0,0 +1,262 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package externalversions
+
+import (
+ reflect "reflect"
+ sync "sync"
+ time "time"
+
+ versioned "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"
+ api "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/api"
+ internalinterfaces "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/internalinterfaces"
+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ runtime "k8s.io/apimachinery/pkg/runtime"
+ schema "k8s.io/apimachinery/pkg/runtime/schema"
+ cache "k8s.io/client-go/tools/cache"
+)
+
+// SharedInformerOption defines the functional option type for SharedInformerFactory.
+type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory
+
+type sharedInformerFactory struct {
+ client versioned.Interface
+ namespace string
+ tweakListOptions internalinterfaces.TweakListOptionsFunc
+ lock sync.Mutex
+ defaultResync time.Duration
+ customResync map[reflect.Type]time.Duration
+ transform cache.TransformFunc
+
+ informers map[reflect.Type]cache.SharedIndexInformer
+ // startedInformers is used for tracking which informers have been started.
+ // This allows Start() to be called multiple times safely.
+ startedInformers map[reflect.Type]bool
+ // wg tracks how many goroutines were started.
+ wg sync.WaitGroup
+ // shuttingDown is true when Shutdown has been called. It may still be running
+ // because it needs to wait for goroutines.
+ shuttingDown bool
+}
+
+// WithCustomResyncConfig sets a custom resync period for the specified informer types.
+func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption {
+ return func(factory *sharedInformerFactory) *sharedInformerFactory {
+ for k, v := range resyncConfig {
+ factory.customResync[reflect.TypeOf(k)] = v
+ }
+ return factory
+ }
+}
+
+// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory.
+func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption {
+ return func(factory *sharedInformerFactory) *sharedInformerFactory {
+ factory.tweakListOptions = tweakListOptions
+ return factory
+ }
+}
+
+// WithNamespace limits the SharedInformerFactory to the specified namespace.
+func WithNamespace(namespace string) SharedInformerOption {
+ return func(factory *sharedInformerFactory) *sharedInformerFactory {
+ factory.namespace = namespace
+ return factory
+ }
+}
+
+// WithTransform sets a transform on all informers.
+func WithTransform(transform cache.TransformFunc) SharedInformerOption {
+ return func(factory *sharedInformerFactory) *sharedInformerFactory {
+ factory.transform = transform
+ return factory
+ }
+}
+
+// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces.
+func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {
+ return NewSharedInformerFactoryWithOptions(client, defaultResync)
+}
+
+// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory.
+// Listers obtained via this SharedInformerFactory will be subject to the same filters
+// as specified here.
+// Deprecated: Please use NewSharedInformerFactoryWithOptions instead
+func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {
+ return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions))
+}
+
+// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options.
+func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory {
+ factory := &sharedInformerFactory{
+ client: client,
+ namespace: v1.NamespaceAll,
+ defaultResync: defaultResync,
+ informers: make(map[reflect.Type]cache.SharedIndexInformer),
+ startedInformers: make(map[reflect.Type]bool),
+ customResync: make(map[reflect.Type]time.Duration),
+ }
+
+ // Apply all options
+ for _, opt := range options {
+ factory = opt(factory)
+ }
+
+ return factory
+}
+
+func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
+ f.lock.Lock()
+ defer f.lock.Unlock()
+
+ if f.shuttingDown {
+ return
+ }
+
+ for informerType, informer := range f.informers {
+ if !f.startedInformers[informerType] {
+ f.wg.Add(1)
+ // We need a new variable in each loop iteration,
+ // otherwise the goroutine would use the loop variable
+ // and that keeps changing.
+ informer := informer
+ go func() {
+ defer f.wg.Done()
+ informer.Run(stopCh)
+ }()
+ f.startedInformers[informerType] = true
+ }
+ }
+}
+
+func (f *sharedInformerFactory) Shutdown() {
+ f.lock.Lock()
+ f.shuttingDown = true
+ f.lock.Unlock()
+
+ // Will return immediately if there is nothing to wait for.
+ f.wg.Wait()
+}
+
+func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool {
+ informers := func() map[reflect.Type]cache.SharedIndexInformer {
+ f.lock.Lock()
+ defer f.lock.Unlock()
+
+ informers := map[reflect.Type]cache.SharedIndexInformer{}
+ for informerType, informer := range f.informers {
+ if f.startedInformers[informerType] {
+ informers[informerType] = informer
+ }
+ }
+ return informers
+ }()
+
+ res := map[reflect.Type]bool{}
+ for informType, informer := range informers {
+ res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced)
+ }
+ return res
+}
+
+// InformerFor returns the SharedIndexInformer for obj using an internal
+// client.
+func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer {
+ f.lock.Lock()
+ defer f.lock.Unlock()
+
+ informerType := reflect.TypeOf(obj)
+ informer, exists := f.informers[informerType]
+ if exists {
+ return informer
+ }
+
+ resyncPeriod, exists := f.customResync[informerType]
+ if !exists {
+ resyncPeriod = f.defaultResync
+ }
+
+ informer = newFunc(f.client, resyncPeriod)
+ informer.SetTransform(f.transform)
+ f.informers[informerType] = informer
+
+ return informer
+}
+
+// SharedInformerFactory provides shared informers for resources in all known
+// API group versions.
+//
+// It is typically used like this:
+//
+// ctx, cancel := context.Background()
+// defer cancel()
+// factory := NewSharedInformerFactory(client, resyncPeriod)
+// defer factory.WaitForStop() // Returns immediately if nothing was started.
+// genericInformer := factory.ForResource(resource)
+// typedInformer := factory.SomeAPIGroup().V1().SomeType()
+// factory.Start(ctx.Done()) // Start processing these informers.
+// synced := factory.WaitForCacheSync(ctx.Done())
+// for v, ok := range synced {
+// if !ok {
+// fmt.Fprintf(os.Stderr, "caches failed to sync: %v", v)
+// return
+// }
+// }
+//
+// // Creating informers can also be created after Start, but then
+// // Start must be called again:
+// anotherGenericInformer := factory.ForResource(resource)
+// factory.Start(ctx.Done())
+type SharedInformerFactory interface {
+ internalinterfaces.SharedInformerFactory
+
+ // Start initializes all requested informers. They are handled in goroutines
+ // which run until the stop channel gets closed.
+ // Warning: Start does not block. When run in a go-routine, it will race with a later WaitForCacheSync.
+ Start(stopCh <-chan struct{})
+
+ // Shutdown marks a factory as shutting down. At that point no new
+ // informers can be started anymore and Start will return without
+ // doing anything.
+ //
+ // In addition, Shutdown blocks until all goroutines have terminated. For that
+ // to happen, the close channel(s) that they were started with must be closed,
+ // either before Shutdown gets called or while it is waiting.
+ //
+ // Shutdown may be called multiple times, even concurrently. All such calls will
+ // block until all goroutines have terminated.
+ Shutdown()
+
+ // WaitForCacheSync blocks until all started informers' caches were synced
+ // or the stop channel gets closed.
+ WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool
+
+ // ForResource gives generic access to a shared informer of the matching type.
+ ForResource(resource schema.GroupVersionResource) (GenericInformer, error)
+
+ // InformerFor returns the SharedIndexInformer for obj using an internal
+ // client.
+ InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer
+
+ Openr() api.Interface
+}
+
+func (f *sharedInformerFactory) Openr() api.Interface {
+ return api.New(f, f.namespace, f.tweakListOptions)
+}
diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/generic.go b/kubernetes/operator/pkg/generated/informers/externalversions/generic.go
new file mode 100644
index 000000000..6c5038a8a
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/informers/externalversions/generic.go
@@ -0,0 +1,62 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package externalversions
+
+import (
+ fmt "fmt"
+
+ v1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ schema "k8s.io/apimachinery/pkg/runtime/schema"
+ cache "k8s.io/client-go/tools/cache"
+)
+
+// GenericInformer is type of SharedIndexInformer which will locate and delegate to other
+// sharedInformers based on type
+type GenericInformer interface {
+ Informer() cache.SharedIndexInformer
+ Lister() cache.GenericLister
+}
+
+type genericInformer struct {
+ informer cache.SharedIndexInformer
+ resource schema.GroupResource
+}
+
+// Informer returns the SharedIndexInformer.
+func (f *genericInformer) Informer() cache.SharedIndexInformer {
+ return f.informer
+}
+
+// Lister returns the GenericLister.
+func (f *genericInformer) Lister() cache.GenericLister {
+ return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource)
+}
+
+// ForResource gives generic access to a shared informer of the matching type
+// TODO extend this to unknown resources with a client pool
+func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
+ switch resource {
+ // Group=openr.ag, Version=v1alpha1
+ case v1alpha1.SchemeGroupVersion.WithResource("openrags"):
+ return &genericInformer{resource: resource.GroupResource(), informer: f.Openr().V1alpha1().OpenRAGs().Informer()}, nil
+
+ }
+
+ return nil, fmt.Errorf("no informer found for %v", resource)
+}
diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/internalinterfaces/factory_interfaces.go b/kubernetes/operator/pkg/generated/informers/externalversions/internalinterfaces/factory_interfaces.go
new file mode 100644
index 000000000..2ecd8bd32
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/informers/externalversions/internalinterfaces/factory_interfaces.go
@@ -0,0 +1,40 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package internalinterfaces
+
+import (
+ time "time"
+
+ versioned "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"
+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ runtime "k8s.io/apimachinery/pkg/runtime"
+ cache "k8s.io/client-go/tools/cache"
+)
+
+// NewInformerFunc takes versioned.Interface and time.Duration to return a SharedIndexInformer.
+type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer
+
+// SharedInformerFactory a small interface to allow for adding an informer without an import cycle
+type SharedInformerFactory interface {
+ Start(stopCh <-chan struct{})
+ InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
+}
+
+// TweakListOptionsFunc is a function that transforms a v1.ListOptions.
+type TweakListOptionsFunc func(*v1.ListOptions)
diff --git a/kubernetes/operator/pkg/generated/listers/api/v1alpha1/expansion_generated.go b/kubernetes/operator/pkg/generated/listers/api/v1alpha1/expansion_generated.go
new file mode 100644
index 000000000..cb9549d46
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/listers/api/v1alpha1/expansion_generated.go
@@ -0,0 +1,27 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package v1alpha1
+
+// OpenRAGListerExpansion allows custom methods to be added to
+// OpenRAGLister.
+type OpenRAGListerExpansion interface{}
+
+// OpenRAGNamespaceListerExpansion allows custom methods to be added to
+// OpenRAGNamespaceLister.
+type OpenRAGNamespaceListerExpansion interface{}
diff --git a/kubernetes/operator/pkg/generated/listers/api/v1alpha1/openrag.go b/kubernetes/operator/pkg/generated/listers/api/v1alpha1/openrag.go
new file mode 100644
index 000000000..d71dc685a
--- /dev/null
+++ b/kubernetes/operator/pkg/generated/listers/api/v1alpha1/openrag.go
@@ -0,0 +1,70 @@
+/*
+Copyright 2026 The OpenRAG Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+ apiv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+ labels "k8s.io/apimachinery/pkg/labels"
+ listers "k8s.io/client-go/listers"
+ cache "k8s.io/client-go/tools/cache"
+)
+
+// OpenRAGLister helps list OpenRAGs.
+// All objects returned here must be treated as read-only.
+type OpenRAGLister interface {
+ // List lists all OpenRAGs in the indexer.
+ // Objects returned here must be treated as read-only.
+ List(selector labels.Selector) (ret []*apiv1alpha1.OpenRAG, err error)
+ // OpenRAGs returns an object that can list and get OpenRAGs.
+ OpenRAGs(namespace string) OpenRAGNamespaceLister
+ OpenRAGListerExpansion
+}
+
+// openRAGLister implements the OpenRAGLister interface.
+type openRAGLister struct {
+ listers.ResourceIndexer[*apiv1alpha1.OpenRAG]
+}
+
+// NewOpenRAGLister returns a new OpenRAGLister.
+func NewOpenRAGLister(indexer cache.Indexer) OpenRAGLister {
+ return &openRAGLister{listers.New[*apiv1alpha1.OpenRAG](indexer, apiv1alpha1.Resource("openrag"))}
+}
+
+// OpenRAGs returns an object that can list and get OpenRAGs.
+func (s *openRAGLister) OpenRAGs(namespace string) OpenRAGNamespaceLister {
+ return openRAGNamespaceLister{listers.NewNamespaced[*apiv1alpha1.OpenRAG](s.ResourceIndexer, namespace)}
+}
+
+// OpenRAGNamespaceLister helps list and get OpenRAGs.
+// All objects returned here must be treated as read-only.
+type OpenRAGNamespaceLister interface {
+ // List lists all OpenRAGs in the indexer for a given namespace.
+ // Objects returned here must be treated as read-only.
+ List(selector labels.Selector) (ret []*apiv1alpha1.OpenRAG, err error)
+ // Get retrieves the OpenRAG from the indexer for a given namespace and name.
+ // Objects returned here must be treated as read-only.
+ Get(name string) (*apiv1alpha1.OpenRAG, error)
+ OpenRAGNamespaceListerExpansion
+}
+
+// openRAGNamespaceLister implements the OpenRAGNamespaceLister
+// interface.
+type openRAGNamespaceLister struct {
+ listers.ResourceIndexer[*apiv1alpha1.OpenRAG]
+}