kubectl

type Deployment ResourceWithSpec[DeploymentSpec, DeploymentStatus]

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

type DeploymentStatus struct {
	AvailableReplicas int `json:"availableReplicas" yaml:"availableReplicas"`
	ReadyReplicas     int `json:"readyReplicas"     yaml:"readyReplicas"`
	Replicas          int `json:"replicas"          yaml:"replicas"`
	UpdatedReplicas   int `json:"updatedReplicas"   yaml:"updatedReplicas"`
}

type DryRunType string

type Ingress ResourceWithSpec[IngressSpec, IngressStatus]

type IngressPath struct {
	Path     string `json:"path"     yaml:"path"`
	PathType string `json:"pathType" yaml:"pathType"`
}

type IngressRule struct {
	Host *string         `json:"host" yaml:"host"`
	Http IngressRuleHttp `json:"http" yaml:"http"`
}

type IngressRuleHttp struct {
	Paths []IngressPath `json:"paths" yaml:"paths"`
}

type IngressSpec struct {
	IngressClassName string        `json:"ingressClassName" yaml:"ingressClassName"`
	Tls              []IngressTls  `json:"tls"              yaml:"tls"`
	Rules            []IngressRule `json:"rules"            yaml:"rules"`
}

type IngressStatus struct {
	LoadBalancer LoadBalancer `json:"loadBalancer" yaml:"loadBalancer"`
}

type IngressTls struct {
	Hosts      []string `json:"hosts"      yaml:"hosts"`
	SecretName string   `json:"secretName" yaml:"secretName"`
}

type KubeCliFlags struct {
	// The namespace to filter the command or create resources
	Namespace string
	// The dry-run type, defaults to empty
	DryRun DryRunType
	// The expected output, typically JSON or YAML
	Output OutputType
}

type KubeCluster struct {
	Name    string          `yaml:"name"`
	Cluster KubeClusterData `yaml:"cluster"`
}

type KubeClusterData struct {
	CertificateAuthorityData string `yaml:"certificate-authority-data"`
	Server                   string `yaml:"server"`
}

type KubeConfig struct {
	ApiVersion     string          `yaml:"apiVersion"`
	Clusters       []*KubeCluster  `yaml:"clusters"`
	Contexts       []*KubeContext  `yaml:"contexts"`
	Users          []*KubeUser     `yaml:"users"`
	Kind           string          `yaml:"kind"`
	CurrentContext string          `yaml:"current-context"`
	Preferences    KubePreferences `yaml:"preferences"`
}

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

type KubeContext struct {
	Name    string          `yaml:"name"`
	Context KubeContextData `yaml:"context"`
}

type KubeContextData struct {
	Cluster   string `yaml:"cluster"`
	Namespace string `yaml:"namespace"`
	User      string `yaml:"user"`
}

type KubePreferences map[string]any

type KubeUser struct {
	Name         string       `yaml:"name"`
	KubeUserData KubeUserData `yaml:"user"`
}

type KubeUserData map[string]any

type KubectlCli interface {
	tools.ExternalTool
	// Sets the current working directory
	Cwd(cwd string)
	// Sets the env vars available to the CLI
	SetEnv(env map[string]string)
	// Sets the KUBECONFIG environment variable
	SetKubeConfig(kubeConfig string)
	// Applies one or more files from the specified path
	Apply(ctx context.Context, path string, flags *KubeCliFlags) error
	// Applies manifests from the specified input
	ApplyWithStdIn(ctx context.Context, input string, flags *KubeCliFlags) (*exec.RunResult, error)
	// Applies manifests from the specified file path
	ApplyWithFile(ctx context.Context, filePath string, flags *KubeCliFlags) (*exec.RunResult, error)
	// Views the current k8s configuration including available clusters, contexts & users
	ConfigView(ctx context.Context, merge bool, flatten bool, flags *KubeCliFlags) (*exec.RunResult, error)
	// Sets the k8s context to use for future CLI commands
	ConfigUseContext(ctx context.Context, name string, flags *KubeCliFlags) (*exec.RunResult, error)
	// Creates a new k8s namespace with the specified name
	CreateNamespace(ctx context.Context, name string, flags *KubeCliFlags) (*exec.RunResult, error)
	// Executes a k8s CLI command from the specified arguments and flags
	Exec(ctx context.Context, flags *KubeCliFlags, args ...string) (exec.RunResult, error)
	// Gets the deployment rollout status
	RolloutStatus(ctx context.Context, deploymentName string, flags *KubeCliFlags) (*exec.RunResult, error)
	// Applies the manifests at the specified path using kustomize
	ApplyWithKustomize(ctx context.Context, path string, flags *KubeCliFlags) error
}

type List[T any] struct {
	Resource
	Items []T `json:"items" yaml:"items"`
}

type LoadBalancer struct {
	Ingress []LoadBalancerIngress `json:"ingress" yaml:"ingress"`
}

type LoadBalancerIngress struct {
	Ip string `json:"ip" yaml:"ip"`
}

type OutputType string

type Port struct {
	Port int `json:"port"`
	// The target port can be a valid port number or well known service name like 'redis'
	TargetPort any    `json:"targetPort" yaml:"targetPort"`
	Protocol   string `json:"protocol"   yaml:"protocol"`
}

type Resource struct {
	ApiVersion string           `json:"apiVersion" yaml:"apiVersion"`
	Kind       string           `json:"kind"       yaml:"kind"`
	Metadata   ResourceMetadata `json:"metadata"   yaml:"metadata"`
}

type ResourceFilterFn[T comparable] func(resource T) bool

type ResourceMetadata struct {
	Name        string `json:"name"      yaml:"name"`
	Namespace   string `json:"namespace" yaml:"namespace"`
	Annotations map[string]any
}

type ResourceType string

type ResourceWithSpec[T any, S any] struct {
	Resource
	Spec   T `json:"spec"   yaml:"spec"`
	Status S `json:"status" yaml:"status"`
}

type Service ResourceWithSpec[ServiceSpec, ServiceStatus]

type ServiceSpec struct {
	Type       ServiceType `json:"type"       yaml:"type"`
	ClusterIp  string      `json:"clusterIP"  yaml:"clusterIP"`
	ClusterIps []string    `json:"clusterIPs" yaml:"clusterIPs"`
	Ports      []Port      `json:"ports"      yaml:"ports"`
}

type ServiceStatus struct {
	LoadBalancer LoadBalancer `json:"loadBalancer" yaml:"loadBalancer"`
}

type ServiceType string