-
K8s Dashboard
+
+
-
+
{navigationItems.map((item) => {
+ // Headers (collapsible sections)
+ if (item.isHeader) {
+ const isExpanded = expandedSections.has(item.section!)
+ return (
+ toggleSection(item.section!)}
+ className="w-full flex items-center justify-between px-4 py-2 mt-4 mb-1 text-xs font-semibold text-muted-foreground uppercase tracking-wider hover:text-foreground transition-colors"
+ >
+ {item.label}
+ {isExpanded ? (
+
+ )
+ }
+
+ // Skip items in collapsed sections
+ if (item.section && !expandedSections.has(item.section)) {
+ return null
+ }
+
+ // Regular navigation items
const Icon = item.icon
const isActive = pathname === item.href
+ const marginLeft = item.section ? 'ml-4' : '' // Indent items in sections
+
return (
- {item.label}
-
+ {item.label}
+
)
})}
+ {/* Footer */}
+
+ Built with
{/* Main Content */}
@@ -89,6 +227,7 @@ export function DashboardLayout({ children }: DashboardLayoutProps) {
Cluster: {config.restEndpoint}
diff --git a/ui/components/namespace-switcher.tsx b/ui/components/namespace-switcher.tsx
index d843f48..480ad3d 100644
--- a/ui/components/namespace-switcher.tsx
+++ b/ui/components/namespace-switcher.tsx
@@ -1,6 +1,7 @@
'use client'
-import { useKubernetes, useNamespaces } from '@/hooks'
+import { useNamespaces } from '@/hooks'
+import { usePreferredNamespace } from '@/contexts/NamespaceContext'
import {
Select,
SelectContent,
@@ -13,7 +14,7 @@ import { RefreshCw } from 'lucide-react'
import { Button } from '@/components/ui/button'
export function NamespaceSwitcher() {
- const { namespace, setNamespace } = useKubernetes()
+ const { namespace, setNamespace } = usePreferredNamespace()
const { data, isLoading, error, refetch } = useNamespaces()
const namespaces = data?.items?.map(item => item.metadata?.name).filter(Boolean) || []
diff --git a/ui/components/resources/cronjobs.tsx b/ui/components/resources/cronjobs.tsx
new file mode 100644
index 0000000..9c5a360
--- /dev/null
+++ b/ui/components/resources/cronjobs.tsx
@@ -0,0 +1,292 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import { Badge } from '@/components/ui/badge'
+import {
+ RefreshCw,
+ Plus,
+ Trash2,
+ Eye,
+ AlertCircle,
+ CheckCircle,
+ Clock,
+ Pause,
+ Play
+} from 'lucide-react'
+import {
+ useListBatchV1NamespacedCronJobQuery,
+ useListBatchV1CronJobForAllNamespacesQuery,
+ useDeleteBatchV1NamespacedCronJob,
+ usePatchBatchV1NamespacedCronJob
+} from '@/k8s'
+import { usePreferredNamespace } from '@/contexts/NamespaceContext'
+import type { CronJob } from 'kubernetesjs'
+
+export function CronJobsView() {
+ const [selectedCronJob, setSelectedCronJob] = useState
(null)
+ const { namespace } = usePreferredNamespace()
+
+ // Use k8s hooks directly
+ const query = namespace === '_all'
+ ? useListBatchV1CronJobForAllNamespacesQuery({ path: {}, query: {} })
+ : useListBatchV1NamespacedCronJobQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteCronJob = useDeleteBatchV1NamespacedCronJob()
+ const patchCronJob = usePatchBatchV1NamespacedCronJob()
+
+ const cronjobs = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (cronjob: CronJob) => {
+ const name = cronjob.metadata!.name!
+ const namespace = cronjob.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteCronJob.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete cronjob:', err)
+ alert(`Failed to delete cronjob: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const handleToggleSuspend = async (cronjob: CronJob) => {
+ const name = cronjob.metadata!.name!
+ const namespace = cronjob.metadata!.namespace!
+ const suspend = !cronjob.spec?.suspend
+
+ try {
+ await patchCronJob.mutateAsync({
+ path: { namespace, name },
+ query: {},
+ body: {
+ spec: { suspend }
+ }
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to update cronjob:', err)
+ alert(`Failed to update cronjob: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+
+ const getStatus = (cronjob: CronJob) => {
+ if (cronjob.spec?.suspend) {
+ return 'Suspended'
+ }
+ return cronjob.status?.active && cronjob.status.active.length > 0 ? 'Active' : 'Idle'
+ }
+
+ const getStatusBadge = (status: string) => {
+ switch (status) {
+ case 'Active':
+ return
+
+ case 'Idle':
+ return
+
+ case 'Suspended':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ const getLastScheduleTime = (cronjob: CronJob) => {
+ if (!cronjob.status?.lastScheduleTime) return 'Never'
+ const lastTime = new Date(cronjob.status.lastScheduleTime)
+ const now = new Date()
+ const diff = now.getTime() - lastTime.getTime()
+
+ if (diff < 60000) return 'Just now'
+ if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`
+ if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`
+ return lastTime.toLocaleDateString()
+ }
+
+ const getNextScheduleTime = (cronjob: CronJob) => {
+ if (cronjob.spec?.suspend) return 'Suspended'
+ if (!cronjob.status?.lastScheduleTime && !cronjob.status?.lastSuccessfulTime) {
+ return 'Soon'
+ }
+ // Note: Actual next schedule calculation would require cron parsing
+ return 'Calculating...'
+ }
+
+ return (
+
+ {/* Header */}
+
+
+
CronJobs
+
+ Manage your Kubernetes scheduled jobs
+
+
+
+
+
+
alert('Create CronJob functionality not yet implemented')}>
+
+
+
+
+ {/* Stats Cards */}
+
+
+
+ Total CronJobs
+
+
+ {cronjobs.length}
+
+
+
+
+ Active
+
+
+
+ {cronjobs.filter(cj => getStatus(cj) === 'Active').length}
+
+
+
+
+
+ Suspended
+
+
+
+ {cronjobs.filter(cj => getStatus(cj) === 'Suspended').length}
+
+
+
+
+
+ Running Jobs
+
+
+
+ {cronjobs.reduce((sum, cj) => sum + (cj.status?.active?.length || 0), 0)}
+
+
+
+
+
+ {/* CronJobs Table */}
+
+
+ All CronJobs
+
+ A list of all scheduled jobs in your cluster
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch cronjobs'}
+
+
+
+
+ ) : cronjobs.length === 0 ? (
+
+
No cronjobs found
+
+
+
+
+
+ Name
+ Namespace
+ Status
+ Schedule
+ Last Run
+ Next Run
+ Image
+ Actions
+
+
+
+ {cronjobs.map((cronjob) => (
+
+ {cronjob.metadata?.name}
+ {cronjob.metadata?.namespace}
+ {getStatusBadge(getStatus(cronjob))}
+ {cronjob.spec?.schedule}
+ {getLastScheduleTime(cronjob)}
+ {getNextScheduleTime(cronjob)}
+
+ {cronjob.spec?.jobTemplate?.spec?.template?.spec?.containers?.[0]?.image || 'unknown'}
+
+
+
+
setSelectedCronJob(cronjob)}
+ >
+
+
handleToggleSuspend(cronjob)}
+ >
+ {cronjob.spec?.suspend ?
+
handleDelete(cronjob)}
+ >
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListCoreV1EndpointsForAllNamespacesQuery({ path: {}, query: {} })
+ : useListCoreV1NamespacedEndpointsQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteEndpoint = useDeleteCoreV1NamespacedEndpoints()
+
+ const endpoints = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (endpoint: Endpoints) => {
+ const name = endpoint.metadata!.name!
+ const namespace = endpoint.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteEndpoint.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete endpoint:', err)
+ alert(`Failed to delete endpoint: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getAddressCount = (endpoint: Endpoints): number => {
+ const subsets = endpoint.subsets || []
+ return subsets.reduce((sum, subset) => {
+ const addresses = subset.addresses || []
+ return sum + addresses.length
+ }, 0)
+ }
+
+ const getPortCount = (endpoint: Endpoints): number => {
+ const subsets = endpoint.subsets || []
+ const uniquePorts = new Set()
+ subsets.forEach(subset => {
+ const ports = subset.ports || []
+ ports.forEach(port => {
+ uniquePorts.add(`${port.name || 'unnamed'}:${port.port}/${port.protocol || 'TCP'}`)
+ })
+ })
+ return uniquePorts.size
+ }
+
+ const getStatus = (endpoint: Endpoints) => {
+ const addressCount = getAddressCount(endpoint)
+ if (addressCount === 0) {
+ return 'No Endpoints'
+ }
+ return 'Ready'
+ }
+
+ const getStatusBadge = (status: string) => {
+ switch (status) {
+ case 'Ready':
+ return
+
+ case 'No Endpoints':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ const getEndpointAddresses = (endpoint: Endpoints): string => {
+ const subsets = endpoint.subsets || []
+ const addresses: string[] = []
+
+ subsets.forEach(subset => {
+ const addrs = subset.addresses || []
+ addrs.forEach(addr => {
+ addresses.push(addr.ip)
+ })
+ })
+
+ if (addresses.length === 0) return 'None'
+ if (addresses.length <= 3) return addresses.join(', ')
+ return `${addresses.slice(0, 3).join(', ')} +${addresses.length - 3} more`
+ }
+
+ return (
+
+
+
+
Endpoints
+
+ Network endpoints for services
+
+
+
+
+
+
+
+
+
+
+
+ Total Endpoints
+
+
+ {endpoints.length}
+
+
+
+
+ With Addresses
+
+
+
+ {endpoints.filter(e => getAddressCount(e) > 0).length}
+
+
+
+
+
+ Total Addresses
+
+
+
+ {endpoints.reduce((sum, e) => sum + getAddressCount(e), 0)}
+
+
+
+
+
+ Empty Endpoints
+
+
+
+ {endpoints.filter(e => getAddressCount(e) === 0).length}
+
+
+
+
+
+
+
+ Endpoints
+
+ IP addresses and ports that services route traffic to
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch endpoints'}
+
+
+
+
+ ) : endpoints.length === 0 ? (
+
+
No endpoints found
+
+
+
+
+
+ Name
+ Namespace
+ Status
+ Addresses
+ Ports
+ Created
+ Actions
+
+
+
+ {endpoints.map((endpoint) => (
+
+ {endpoint.metadata?.name}
+ {endpoint.metadata?.namespace}
+ {getStatusBadge(getStatus(endpoint))}
+
+
+ {getEndpointAddresses(endpoint)}
+
+
+
+ {getPortCount(endpoint)} port(s)
+
+
+ {endpoint.metadata?.creationTimestamp
+ ? new Date(endpoint.metadata.creationTimestamp).toLocaleDateString()
+ : 'Unknown'}
+
+
+
+ setSelectedEndpoint(endpoint)}
+ >
+
+ handleDelete(endpoint)}
+ disabled={endpoint.metadata?.name === 'kubernetes'}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListDiscoveryV1EndpointSliceForAllNamespacesQuery({ path: {}, query: {} })
+ : useListDiscoveryV1NamespacedEndpointSliceQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteSlice = useDeleteDiscoveryV1NamespacedEndpointSlice()
+
+ const slices = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (slice: EndpointSlice) => {
+ const name = slice.metadata!.name!
+ const namespace = slice.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteSlice.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete endpoint slice:', err)
+ alert(`Failed to delete endpoint slice: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getEndpointCount = (slice: EndpointSlice): number => {
+ return slice.endpoints?.length || 0
+ }
+
+ const getReadyEndpoints = (slice: EndpointSlice): number => {
+ const endpoints = slice.endpoints || []
+ return endpoints.filter(ep => ep.conditions?.ready === true).length
+ }
+
+ const getServiceName = (slice: EndpointSlice): string => {
+ return slice.metadata?.labels?.['kubernetes.io/service-name'] || 'Unknown'
+ }
+
+ const getAddressType = (slice: EndpointSlice): string => {
+ return slice.addressType || 'Unknown'
+ }
+
+ const getPorts = (slice: EndpointSlice): string => {
+ const ports = slice.ports || []
+ if (ports.length === 0) return 'None'
+ return ports.map(p => `${p.name || 'unnamed'}:${p.port}/${p.protocol || 'TCP'}`).join(', ')
+ }
+
+ const getStatus = (slice: EndpointSlice) => {
+ const total = getEndpointCount(slice)
+ const ready = getReadyEndpoints(slice)
+
+ if (total === 0) return 'Empty'
+ if (ready === total) return 'All Ready'
+ if (ready === 0) return 'None Ready'
+ return 'Partial Ready'
+ }
+
+ const getStatusBadge = (status: string) => {
+ switch (status) {
+ case 'All Ready':
+ return
+
+ case 'Partial Ready':
+ return
+
+ case 'None Ready':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ return (
+
+
+
+
Endpoint Slices
+
+ Scalable network endpoint groupings
+
+
+
+
+
+
+
+
+
+
+
+ Total Slices
+
+
+ {slices.length}
+
+
+
+
+ Total Endpoints
+
+
+
+ {slices.reduce((sum, s) => sum + getEndpointCount(s), 0)}
+
+
+
+
+
+ Ready Endpoints
+
+
+
+ {slices.reduce((sum, s) => sum + getReadyEndpoints(s), 0)}
+
+
+
+
+
+ Services
+
+
+
+ {new Set(slices.map(s => getServiceName(s))).size}
+
+
+
+
+
+
+
+ Endpoint Slices
+
+ Scalable collections of network endpoints
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch endpoint slices'}
+
+
+
+
+ ) : slices.length === 0 ? (
+
+
No endpoint slices found
+
+
+
+
+
+ Name
+ Namespace
+ Service
+ Status
+ Endpoints
+ Address Type
+ Ports
+ Actions
+
+
+
+ {slices.map((slice) => (
+
+ {slice.metadata?.name}
+ {slice.metadata?.namespace}
+
+
+
+
+ {getStatusBadge(getStatus(slice))}
+
+
+
+
+
+ {getAddressType(slice)}
+
+ {getPorts(slice)}
+
+
+ setSelectedSlice(slice)}
+ >
+
+ handleDelete(slice)}
+ disabled={slice.metadata?.name?.includes('kubernetes')}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
('All')
+ const { namespace } = usePreferredNamespace()
+
+ // Note: Events API has changed in newer versions, using v1 events
+ const query = namespace === '_all'
+ ? useListEventsV1EventForAllNamespacesQuery({ path: {}, query: {} })
+ : useListCoreV1NamespacedEventQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+
+ const events = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const getEventType = (event: CoreV1Event): string => {
+ return event.type || 'Normal'
+ }
+
+ const getEventReason = (event: CoreV1Event): string => {
+ return event.reason || 'Unknown'
+ }
+
+ const getEventMessage = (event: CoreV1Event): string => {
+ return event.message || 'No message'
+ }
+
+ const getEventObject = (event: CoreV1Event): string => {
+ const obj = event.involvedObject
+ if (!obj) return 'Unknown'
+ return `${obj.kind}/${obj.name}`
+ }
+
+ const getEventTime = (event: CoreV1Event): string => {
+ const timestamp = event.lastTimestamp || event.firstTimestamp
+ if (!timestamp) return 'Unknown'
+
+ const date = new Date(timestamp)
+ const now = new Date()
+ const diff = now.getTime() - date.getTime()
+
+ if (diff < 60000) return 'Just now'
+ if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`
+ if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`
+ return date.toLocaleDateString()
+ }
+
+ const getEventCount = (event: CoreV1Event): number => {
+ return event.count || 1
+ }
+
+ const getTypeBadge = (type: string) => {
+ switch (type) {
+ case 'Normal':
+ return
+
+ case 'Warning':
+ return
+
+ case 'Error':
+ return
+
+ default:
+ return {type}
+ }
+ }
+
+ const filteredEvents = typeFilter === 'All'
+ ? events
+ : events.filter(e => getEventType(e) === typeFilter)
+
+ const sortedEvents = [...filteredEvents].sort((a, b) => {
+ const timeA = new Date(a.lastTimestamp || a.firstTimestamp || 0).getTime()
+ const timeB = new Date(b.lastTimestamp || b.firstTimestamp || 0).getTime()
+ return timeB - timeA // Most recent first
+ })
+
+ return (
+
+
+
+
Events
+
+ Cluster activity and notifications
+
+
+
+
+ setTypeFilter('All')}
+ >
+ All
+
+ setTypeFilter('Normal')}
+ >
+ Normal
+
+ setTypeFilter('Warning')}
+ >
+ Warning
+
+
+
+
+
+
+
+
+
+
+ Total Events
+
+
+ {events.length}
+
+
+
+
+ Normal
+
+
+
+ {events.filter(e => getEventType(e) === 'Normal').length}
+
+
+
+
+
+ Warnings
+
+
+
+ {events.filter(e => getEventType(e) === 'Warning').length}
+
+
+
+
+
+ Unique Objects
+
+
+
+ {new Set(events.map(getEventObject)).size}
+
+
+
+
+
+
+
+
+
+
+ )}
+
+
+ System events and notifications from the cluster
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch events'}
+
+
+
+
+ ) : sortedEvents.length === 0 ? (
+
+
+ {typeFilter === 'All' ? 'No events found' : `No ${typeFilter} events found`}
+
+
+
+
+
+
+ Time
+ Type
+ Object
+ Namespace
+ Reason
+ Message
+ Count
+
+
+
+ {sortedEvents.map((event, idx) => (
+
+
+
+
+
+ {getTypeBadge(getEventType(event))}
+ {getEventObject(event)}
+ {event.metadata?.namespace || '-'}
+
+ {getEventReason(event)}
+
+
+ {getEventMessage(event)}
+
+
+ {getEventCount(event) > 1 && (
+ {getEventCount(event)}
+ )}
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespacesQuery({ path: {}, query: {} })
+ : useListAutoscalingV2beta2NamespacedHorizontalPodAutoscalerQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteHPA = useDeleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler()
+
+ const hpas = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (hpa: HorizontalPodAutoscaler) => {
+ const name = hpa.metadata!.name!
+ const namespace = hpa.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteHPA.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete HPA:', err)
+ alert(`Failed to delete HPA: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getScaleDirection = (current: number, desired: number) => {
+ if (current < desired) return 'up'
+ if (current > desired) return 'down'
+ return 'stable'
+ }
+
+ const getScaleIcon = (direction: string) => {
+ switch (direction) {
+ case 'up':
+ return
+
+ case 'Unable to Scale':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ const getMetrics = (hpa: HorizontalPodAutoscaler) => {
+ const metrics = hpa.spec?.metrics || []
+ return metrics.map(m => {
+ if (m.type === 'Resource' && m.resource) {
+ return `${m.resource.name} (${m.resource.target?.averageUtilization || 'N/A'}%)`
+ }
+ return m.type || 'Unknown'
+ }).join(', ') || 'No metrics'
+ }
+
+ return (
+
+
+
+
Horizontal Pod Autoscalers
+
+ Automatically scale your workloads based on metrics
+
+
+
+
+
+
alert('Create HPA functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total HPAs
+
+
+ {hpas.length}
+
+
+
+
+ Active
+
+
+
+ {hpas.filter(h => getStatus(h) === 'Active').length}
+
+
+
+
+
+ Scaling Up
+
+
+
+ {hpas.filter(h => {
+ const current = h.status?.currentReplicas || 0
+ const desired = h.status?.desiredReplicas || 0
+ return current < desired
+ }).length}
+
+
+
+
+
+ Total Replicas
+
+
+
+ {hpas.reduce((sum, h) => sum + (h.status?.currentReplicas || 0), 0)}
+
+
+
+
+
+
+
+ Horizontal Pod Autoscalers
+
+ Automatic scaling policies for your workloads
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch HPAs'}
+
+
+
+
+ ) : hpas.length === 0 ? (
+
+
No horizontal pod autoscalers found
+
+
+
+
+
+ Name
+ Namespace
+ Target
+ Status
+ Min/Max
+ Current
+ Metrics
+ Actions
+
+
+
+ {hpas.map((hpa) => {
+ const current = hpa.status?.currentReplicas || 0
+ const desired = hpa.status?.desiredReplicas || 0
+ const direction = getScaleDirection(current, desired)
+
+ return (
+
+ {hpa.metadata?.name}
+ {hpa.metadata?.namespace}
+ {hpa.spec?.scaleTargetRef?.name || 'Unknown'}
+ {getStatusBadge(getStatus(hpa))}
+
+ {hpa.spec?.minReplicas || 1}/{hpa.spec?.maxReplicas || 'N/A'}
+
+
+
+ {current}
+ {getScaleIcon(direction)}
+ {desired !== current && → {desired} }
+
+
+ {getMetrics(hpa)}
+
+
+ setSelectedHPA(hpa)}
+ >
+
+ handleDelete(hpa)}
+ >
+
+
+
+
+ )
+ })}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListNetworkingV1IngressForAllNamespacesQuery({ path: {}, query: {} })
+ : useListNetworkingV1NamespacedIngressQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteIngress = useDeleteNetworkingV1NamespacedIngress()
+
+ const ingresses = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (ingress: Ingress) => {
+ const name = ingress.metadata!.name!
+ const namespace = ingress.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteIngress.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete ingress:', err)
+ alert(`Failed to delete ingress: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getHosts = (ingress: Ingress): string[] => {
+ const rules = ingress.spec?.rules || []
+ return rules.map(rule => rule.host || '*').filter((v, i, a) => a.indexOf(v) === i)
+ }
+
+ const getPaths = (ingress: Ingress): number => {
+ const rules = ingress.spec?.rules || []
+ return rules.reduce((sum, rule) => {
+ const paths = rule.http?.paths || []
+ return sum + paths.length
+ }, 0)
+ }
+
+ const getIngressClass = (ingress: Ingress): string => {
+ return ingress.spec?.ingressClassName || ingress.metadata?.annotations?.['kubernetes.io/ingress.class'] || 'default'
+ }
+
+ const hasTLS = (ingress: Ingress): boolean => {
+ return (ingress.spec?.tls?.length || 0) > 0
+ }
+
+ const getStatus = (ingress: Ingress) => {
+ const loadBalancers = ingress.status?.loadBalancer?.ingress || []
+ if (loadBalancers.length > 0) {
+ return 'Active'
+ }
+ return 'Pending'
+ }
+
+ const getStatusBadge = (status: string) => {
+ switch (status) {
+ case 'Active':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ return (
+
+
+
+
Ingresses
+
+ Manage external access to services
+
+
+
+
+
+
alert('Create Ingress functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Ingresses
+
+
+ {ingresses.length}
+
+
+
+
+ With TLS
+
+
+
+ {ingresses.filter(hasTLS).length}
+
+
+
+
+
+ Total Hosts
+
+
+
+ {new Set(ingresses.flatMap(getHosts)).size}
+
+
+
+
+
+ Total Paths
+
+
+
+ {ingresses.reduce((sum, ing) => sum + getPaths(ing), 0)}
+
+
+
+
+
+
+
+ Ingresses
+
+ HTTP(S) routes from outside the cluster to services within
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch ingresses'}
+
+
+
+
+ ) : ingresses.length === 0 ? (
+
+
No ingresses found
+
+
+
+
+
+ Name
+ Namespace
+ Class
+ Hosts
+ Status
+ TLS
+ Load Balancer
+ Actions
+
+
+
+ {ingresses.map((ingress) => {
+ const hosts = getHosts(ingress)
+ const lbIngresses = ingress.status?.loadBalancer?.ingress || []
+
+ return (
+
+ {ingress.metadata?.name}
+ {ingress.metadata?.namespace}
+
+ {getIngressClass(ingress)}
+
+
+
+ {hosts.slice(0, 2).map((host, idx) => (
+
+ {host}
+
+ ))}
+ {hosts.length > 2 && (
+
+{hosts.length - 2} more
+ )}
+
+ {getStatusBadge(getStatus(ingress))}
+
+ {hasTLS(ingress) ? (
+
+
+ ) : (
+ Disabled
+ )}
+
+
+ {lbIngresses.length > 0 ? (
+
+
+ {lbIngresses[0].ip || lbIngresses[0].hostname || 'Pending'}
+
+
+ ) : (
+ None
+ )}
+
+
+
+ setSelectedIngress(ingress)}
+ >
+
+ handleDelete(ingress)}
+ >
+
+
+
+
+ )
+ })}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ // Use k8s hooks directly
+ const query = namespace === '_all'
+ ? useListBatchV1JobForAllNamespacesQuery({ path: {}, query: {} })
+ : useListBatchV1NamespacedJobQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteJob = useDeleteBatchV1NamespacedJob()
+
+ const jobs = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (job: Job) => {
+ const name = job.metadata!.name!
+ const namespace = job.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteJob.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete job:', err)
+ alert(`Failed to delete job: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getStatus = (job: Job) => {
+ const conditions = job.status?.conditions || []
+ const succeeded = job.status?.succeeded || 0
+ const failed = job.status?.failed || 0
+ const active = job.status?.active || 0
+
+ if (conditions.find(c => c.type === 'Complete' && c.status === 'True')) {
+ return 'Completed'
+ } else if (conditions.find(c => c.type === 'Failed' && c.status === 'True')) {
+ return 'Failed'
+ } else if (active > 0) {
+ return 'Running'
+ } else {
+ return 'Pending'
+ }
+ }
+
+ const getStatusBadge = (status: string) => {
+ switch (status) {
+ case 'Completed':
+ return
+
+ case 'Running':
+ return
+
+ case 'Failed':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ const getDuration = (job: Job) => {
+ if (!job.status?.startTime) return 'Not started'
+ const start = new Date(job.status.startTime).getTime()
+ const end = job.status.completionTime
+ ? new Date(job.status.completionTime).getTime()
+ : Date.now()
+ const duration = Math.floor((end - start) / 1000)
+
+ if (duration < 60) return `${duration}s`
+ if (duration < 3600) return `${Math.floor(duration / 60)}m ${duration % 60}s`
+ return `${Math.floor(duration / 3600)}h ${Math.floor((duration % 3600) / 60)}m`
+ }
+
+ return (
+
+ {/* Header */}
+
+
+
Jobs
+
+ Manage your Kubernetes batch jobs
+
+
+
+
+
+
alert('Create Job functionality not yet implemented')}>
+
+
+
+
+ {/* Stats Cards */}
+
+
+
+ Total Jobs
+
+
+ {jobs.length}
+
+
+
+
+ Running
+
+
+
+ {jobs.filter(job => getStatus(job) === 'Running').length}
+
+
+
+
+
+ Completed
+
+
+
+ {jobs.filter(job => getStatus(job) === 'Completed').length}
+
+
+
+
+
+ Failed
+
+
+
+ {jobs.filter(job => getStatus(job) === 'Failed').length}
+
+
+
+
+
+ {/* Jobs Table */}
+
+
+ All Jobs
+
+ A list of all batch jobs in your cluster
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch jobs'}
+
+
+
+
+ ) : jobs.length === 0 ? (
+
+
No jobs found
+
+
+
+
+
+ Name
+ Namespace
+ Status
+ Completions
+ Duration
+ Image
+ Created
+ Actions
+
+
+
+ {jobs.map((job) => (
+
+ {job.metadata?.name}
+ {job.metadata?.namespace}
+ {getStatusBadge(getStatus(job))}
+
+ {job.status?.succeeded || 0}/{job.spec?.completions || 1}
+
+ {getDuration(job)}
+
+ {job.spec?.template?.spec?.containers?.[0]?.image || 'unknown'}
+
+
+ {job.metadata?.creationTimestamp
+ ? new Date(job.metadata.creationTimestamp).toLocaleDateString()
+ : 'Unknown'}
+
+
+
+ setSelectedJob(job)}
+ >
+
+ handleDelete(job)}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListNetworkingV1NetworkPolicyForAllNamespacesQuery({ path: {}, query: {} })
+ : useListNetworkingV1NamespacedNetworkPolicyQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deletePolicy = useDeleteNetworkingV1NamespacedNetworkPolicy()
+
+ const policies = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (policy: NetworkPolicy) => {
+ const name = policy.metadata!.name!
+ const namespace = policy.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deletePolicy.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete network policy:', err)
+ alert(`Failed to delete network policy: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getPolicyTypes = (policy: NetworkPolicy): string[] => {
+ return policy.spec?.policyTypes || ['Ingress']
+ }
+
+ const getSelector = (policy: NetworkPolicy): string => {
+ const selector = policy.spec?.podSelector
+ if (!selector || !selector.matchLabels || Object.keys(selector.matchLabels).length === 0) {
+ return 'All pods'
+ }
+ return Object.entries(selector.matchLabels)
+ .map(([k, v]) => `${k}=${v}`)
+ .join(', ')
+ }
+
+ const getIngressRules = (policy: NetworkPolicy): number => {
+ return policy.spec?.ingress?.length || 0
+ }
+
+ const getEgressRules = (policy: NetworkPolicy): number => {
+ return policy.spec?.egress?.length || 0
+ }
+
+ const getPolicyDirection = (types: string[]) => {
+ if (types.includes('Ingress') && types.includes('Egress')) {
+ return { icon: ArrowUpDown, label: 'Both' }
+ } else if (types.includes('Ingress')) {
+ return { icon: ArrowLeft, label: 'Ingress' }
+ } else if (types.includes('Egress')) {
+ return { icon: ArrowRight, label: 'Egress' }
+ }
+ return { icon: Shield, label: 'Unknown' }
+ }
+
+ return (
+
+
+
+
Network Policies
+
+ Control traffic flow between pods
+
+
+
+
+
+
alert('Create Network Policy functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Policies
+
+
+ {policies.length}
+
+
+
+
+ Ingress Rules
+
+
+
+ {policies.reduce((sum, p) => sum + getIngressRules(p), 0)}
+
+
+
+
+
+ Egress Rules
+
+
+
+ {policies.reduce((sum, p) => sum + getEgressRules(p), 0)}
+
+
+
+
+
+ Namespaces
+
+
+
+ {new Set(policies.map(p => p.metadata?.namespace)).size}
+
+
+
+
+
+
+
+ Network Policies
+
+ Define how groups of pods are allowed to communicate
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch network policies'}
+
+
+
+
+ ) : policies.length === 0 ? (
+
+
No network policies found
+
+
+
+
+
+ Name
+ Namespace
+ Pod Selector
+ Policy Types
+ Ingress Rules
+ Egress Rules
+ Created
+ Actions
+
+
+
+ {policies.map((policy) => {
+ const types = getPolicyTypes(policy)
+ const direction = getPolicyDirection(types)
+ const DirectionIcon = direction.icon
+
+ return (
+
+ {policy.metadata?.name}
+ {policy.metadata?.namespace}
+ {getSelector(policy)}
+
+
+
+
+
+ 0 ? 'default' : 'secondary'}>
+ {getIngressRules(policy)}
+
+
+
+ 0 ? 'default' : 'secondary'}>
+ {getEgressRules(policy)}
+
+
+
+ {policy.metadata?.creationTimestamp
+ ? new Date(policy.metadata.creationTimestamp).toLocaleDateString()
+ : 'Unknown'}
+
+
+
+ setSelectedPolicy(policy)}
+ >
+
+ handleDelete(policy)}
+ >
+
+
+
+
+ )
+ })}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListPolicyV1PodDisruptionBudgetForAllNamespacesQuery({ path: {}, query: {} })
+ : useListPolicyV1NamespacedPodDisruptionBudgetQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deletePDB = useDeletePolicyV1NamespacedPodDisruptionBudget()
+
+ const pdbs = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (pdb: PodDisruptionBudget) => {
+ const name = pdb.metadata!.name!
+ const namespace = pdb.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deletePDB.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete PDB:', err)
+ alert(`Failed to delete PDB: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getStatus = (pdb: PodDisruptionBudget) => {
+ const currentHealthy = pdb.status?.currentHealthy || 0
+ const desiredHealthy = pdb.status?.desiredHealthy || 0
+ const disruptionsAllowed = pdb.status?.disruptionsAllowed || 0
+
+ if (currentHealthy >= desiredHealthy && disruptionsAllowed > 0) {
+ return 'Ready'
+ } else if (currentHealthy >= desiredHealthy) {
+ return 'Protected'
+ } else {
+ return 'Not Ready'
+ }
+ }
+
+ const getStatusBadge = (status: string) => {
+ switch (status) {
+ case 'Ready':
+ return
+
+ case 'Protected':
+ return
+
+ case 'Not Ready':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ const getSelector = (pdb: PodDisruptionBudget) => {
+ const selector = pdb.spec?.selector
+ if (!selector) return 'No selector'
+
+ if (selector.matchLabels) {
+ return Object.entries(selector.matchLabels)
+ .map(([k, v]) => `${k}=${v}`)
+ .join(', ')
+ }
+
+ return 'Complex selector'
+ }
+
+ return (
+
+
+
+
Pod Disruption Budgets
+
+ Manage disruption policies for your pods
+
+
+
+
+
+
alert('Create PDB functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total PDBs
+
+
+ {pdbs.length}
+
+
+
+
+ Ready
+
+
+
+ {pdbs.filter(pdb => getStatus(pdb) === 'Ready').length}
+
+
+
+
+
+ Protected Pods
+
+
+
+ {pdbs.reduce((sum, pdb) => sum + (pdb.status?.currentHealthy || 0), 0)}
+
+
+
+
+
+ Disruptions Allowed
+
+
+
+ {pdbs.reduce((sum, pdb) => sum + (pdb.status?.disruptionsAllowed || 0), 0)}
+
+
+
+
+
+
+
+ Pod Disruption Budgets
+
+ Policies that limit the number of pods that can be down simultaneously
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch PDBs'}
+
+
+
+
+ ) : pdbs.length === 0 ? (
+
+
No pod disruption budgets found
+
+
+
+
+
+ Name
+ Namespace
+ Status
+ Min Available
+ Max Unavailable
+ Current Healthy
+ Disruptions Allowed
+ Selector
+ Actions
+
+
+
+ {pdbs.map((pdb) => (
+
+ {pdb.metadata?.name}
+ {pdb.metadata?.namespace}
+ {getStatusBadge(getStatus(pdb))}
+
+ {pdb.spec?.minAvailable?.toString() || '-'}
+
+
+ {pdb.spec?.maxUnavailable?.toString() || '-'}
+
+
+ {pdb.status?.currentHealthy || 0}/{pdb.status?.desiredHealthy || 0}
+
+
+
+ {pdb.status?.disruptionsAllowed || 0}
+
+
+
+ {getSelector(pdb)}
+
+
+
+ setSelectedPDB(pdb)}
+ >
+
+ handleDelete(pdb)}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
// Use TanStack Query hooks
- const { namespace } = useKubernetes()
+ const { namespace } = usePreferredNamespace()
const { data, isLoading, error, refetch } = usePods()
const deletePodMutation = useDeletePod()
diff --git a/ui/components/resources/priorityclasses.tsx b/ui/components/resources/priorityclasses.tsx
new file mode 100644
index 0000000..8296512
--- /dev/null
+++ b/ui/components/resources/priorityclasses.tsx
@@ -0,0 +1,223 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import { Badge } from '@/components/ui/badge'
+import {
+ RefreshCw,
+ Plus,
+ Trash2,
+ Eye,
+ AlertCircle,
+ Star,
+ StarOff
+} from 'lucide-react'
+import {
+ useListSchedulingV1PriorityClassQuery,
+ useDeleteSchedulingV1PriorityClass
+} from '@/k8s'
+import type { PriorityClass } from 'kubernetesjs'
+
+export function PriorityClassesView() {
+ const [selectedPriorityClass, setSelectedPriorityClass] = useState(null)
+
+ const { data, isLoading, error, refetch } = useListSchedulingV1PriorityClassQuery({ path: {}, query: {} })
+ const deletePriorityClass = useDeleteSchedulingV1PriorityClass()
+
+ const priorityClasses = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (pc: PriorityClass) => {
+ const name = pc.metadata!.name!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deletePriorityClass.mutateAsync({
+ path: { name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete priority class:', err)
+ alert(`Failed to delete priority class: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getPriorityBadge = (value: number) => {
+ if (value >= 1000000000) {
+ return
+
+ } else if (value >= 900000000) {
+ return
+
+ } else if (value > 0) {
+ return
+ Priority {value}
+
+ } else {
+ return
+
+ }
+ }
+
+ return (
+
+
+
+
Priority Classes
+
+ Manage pod scheduling priorities
+
+
+
+
+
+
alert('Create Priority Class functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Classes
+
+
+ {priorityClasses.length}
+
+
+
+
+ System Classes
+
+
+
+ {priorityClasses.filter(pc => pc.value >= 1000000000).length}
+
+
+
+
+
+ User Classes
+
+
+
+ {priorityClasses.filter(pc => pc.value < 900000000).length}
+
+
+
+
+
+
+
+ Priority Classes
+
+ Classes that define the relative priority of pods
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch priority classes'}
+
+
+
+
+ ) : priorityClasses.length === 0 ? (
+
+
No priority classes found
+
+
+
+
+
+ Name
+ Value
+ Type
+ Global Default
+ Preemption Policy
+ Description
+ Actions
+
+
+
+ {priorityClasses
+ .sort((a, b) => (b.value || 0) - (a.value || 0))
+ .map((pc) => (
+
+ {pc.metadata?.name}
+ {pc.value}
+ {getPriorityBadge(pc.value || 0)}
+
+ {pc.globalDefault ? (
+ Yes
+ ) : (
+ No
+ )}
+
+
+
+ {pc.preemptionPolicy || 'PreemptLowerPriority'}
+
+
+
+ {pc.description || '-'}
+
+
+
+ setSelectedPriorityClass(pc)}
+ >
+
+ handleDelete(pc)}
+ disabled={pc.value >= 1000000000}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListCoreV1PersistentVolumeClaimForAllNamespacesQuery({ path: {}, query: {} })
+ : useListCoreV1NamespacedPersistentVolumeClaimQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deletePVC = useDeleteCoreV1NamespacedPersistentVolumeClaim()
+
+ const pvcs = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (pvc: PersistentVolumeClaim) => {
+ const name = pvc.metadata!.name!
+ const namespace = pvc.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}? This may cause data loss.`)) {
+ try {
+ await deletePVC.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete PVC:', err)
+ alert(`Failed to delete PVC: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getPhase = (pvc: PersistentVolumeClaim): string => {
+ return pvc.status?.phase || 'Unknown'
+ }
+
+ const getStatusBadge = (phase: string) => {
+ switch (phase) {
+ case 'Bound':
+ return
+
+ case 'Pending':
+ return
+
+ case 'Lost':
+ return
+
+ default:
+ return {phase}
+ }
+ }
+
+ const getAccessModes = (pvc: PersistentVolumeClaim): string => {
+ const modes = pvc.spec?.accessModes || []
+ const modeMap: Record = {
+ 'ReadWriteOnce': 'RWO',
+ 'ReadOnlyMany': 'ROX',
+ 'ReadWriteMany': 'RWX',
+ 'ReadWriteOncePod': 'RWOP'
+ }
+ return modes.map(m => modeMap[m] || m).join(', ') || 'None'
+ }
+
+ const getStorageSize = (pvc: PersistentVolumeClaim): string => {
+ const storage = pvc.spec?.resources?.requests?.storage
+ const capacity = pvc.status?.capacity?.storage
+ return capacity || storage || 'Unknown'
+ }
+
+ const getStorageClass = (pvc: PersistentVolumeClaim): string => {
+ return pvc.spec?.storageClassName || 'default'
+ }
+
+ const getVolumeName = (pvc: PersistentVolumeClaim): string => {
+ return pvc.spec?.volumeName || 'Not bound'
+ }
+
+ return (
+
+
+
+
Persistent Volume Claims
+
+ Storage requests by pods
+
+
+
+
+
+
alert('Create PVC functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total PVCs
+
+
+ {pvcs.length}
+
+
+
+
+ Bound
+
+
+
+ {pvcs.filter(pvc => getPhase(pvc) === 'Bound').length}
+
+
+
+
+
+ Pending
+
+
+
+ {pvcs.filter(pvc => getPhase(pvc) === 'Pending').length}
+
+
+
+
+
+ Total Storage
+
+
+
+ {pvcs.reduce((sum, pvc) => {
+ const size = getStorageSize(pvc)
+ const match = size.match(/(\d+)([GMK]i)?/)
+ if (match) {
+ const value = parseInt(match[1])
+ const unit = match[2] || 'Gi'
+ if (unit === 'Gi') return sum + value
+ if (unit === 'Mi') return sum + value / 1024
+ if (unit === 'Ki') return sum + value / (1024 * 1024)
+ }
+ return sum
+ }, 0).toFixed(1)} GB
+
+
+
+
+
+
+
+ Persistent Volume Claims
+
+ Storage volumes requested by applications
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch PVCs'}
+
+
+
+
+ ) : pvcs.length === 0 ? (
+
+
No persistent volume claims found
+
+
+
+
+
+ Name
+ Namespace
+ Status
+ Storage Class
+ Size
+ Access Modes
+ Volume
+ Actions
+
+
+
+ {pvcs.map((pvc) => (
+
+ {pvc.metadata?.name}
+ {pvc.metadata?.namespace}
+ {getStatusBadge(getPhase(pvc))}
+
+
+
+
+
+
+
+
+
+ {getAccessModes(pvc)}
+
+
+ {getVolumeName(pvc)}
+
+
+
+ setSelectedPVC(pvc)}
+ >
+
+ handleDelete(pvc)}
+ disabled={getPhase(pvc) === 'Bound'}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+
+ const { data, isLoading, error, refetch } = useListCoreV1PersistentVolumeQuery({ path: {}, query: {} })
+ const deletePV = useDeleteCoreV1PersistentVolume()
+
+ const pvs = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (pv: PersistentVolume) => {
+ const name = pv.metadata!.name!
+
+ if (confirm(`Are you sure you want to delete ${name}? This may cause data loss.`)) {
+ try {
+ await deletePV.mutateAsync({
+ path: { name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete PV:', err)
+ alert(`Failed to delete PV: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getPhase = (pv: PersistentVolume): string => {
+ return pv.status?.phase || 'Unknown'
+ }
+
+ const getStatusBadge = (phase: string) => {
+ switch (phase) {
+ case 'Available':
+ return
+
+ case 'Bound':
+ return
+
+ case 'Released':
+ return
+
+ case 'Failed':
+ return
+
+ default:
+ return {phase}
+ }
+ }
+
+ const getAccessModes = (pv: PersistentVolume): string => {
+ const modes = pv.spec?.accessModes || []
+ const modeMap: Record = {
+ 'ReadWriteOnce': 'RWO',
+ 'ReadOnlyMany': 'ROX',
+ 'ReadWriteMany': 'RWX',
+ 'ReadWriteOncePod': 'RWOP'
+ }
+ return modes.map(m => modeMap[m] || m).join(', ') || 'None'
+ }
+
+ const getCapacity = (pv: PersistentVolume): string => {
+ return pv.spec?.capacity?.storage || 'Unknown'
+ }
+
+ const getStorageClass = (pv: PersistentVolume): string => {
+ return pv.spec?.storageClassName || 'None'
+ }
+
+ const getReclaimPolicy = (pv: PersistentVolume): string => {
+ return pv.spec?.persistentVolumeReclaimPolicy || 'Retain'
+ }
+
+ const getClaimRef = (pv: PersistentVolume): string => {
+ const ref = pv.spec?.claimRef
+ if (!ref) return 'Unbound'
+ return `${ref.namespace}/${ref.name}`
+ }
+
+ const getVolumeMode = (pv: PersistentVolume): string => {
+ return pv.spec?.volumeMode || 'Filesystem'
+ }
+
+ return (
+
+
+
+
Persistent Volumes
+
+ Cluster-wide storage resources
+
+
+
+
+
+
alert('Create PV functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total PVs
+
+
+ {pvs.length}
+
+
+
+
+ Available
+
+
+
+ {pvs.filter(pv => getPhase(pv) === 'Available').length}
+
+
+
+
+
+ Bound
+
+
+
+ {pvs.filter(pv => getPhase(pv) === 'Bound').length}
+
+
+
+
+
+ Total Capacity
+
+
+
+ {pvs.reduce((sum, pv) => {
+ const size = getCapacity(pv)
+ const match = size.match(/(\d+)([GMK]i)?/)
+ if (match) {
+ const value = parseInt(match[1])
+ const unit = match[2] || 'Gi'
+ if (unit === 'Gi') return sum + value
+ if (unit === 'Mi') return sum + value / 1024
+ if (unit === 'Ki') return sum + value / (1024 * 1024)
+ if (unit === 'Ti') return sum + value * 1024
+ }
+ return sum
+ }, 0).toFixed(1)} GB
+
+
+
+
+
+
+
+ Persistent Volumes
+
+ Physical storage volumes available in the cluster
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch PVs'}
+
+
+
+
+ ) : pvs.length === 0 ? (
+
+
No persistent volumes found
+
+
+
+
+
+ Name
+ Status
+ Claim
+ Storage Class
+ Capacity
+ Access Modes
+ Reclaim Policy
+ Mode
+ Actions
+
+
+
+ {pvs.map((pv) => (
+
+ {pv.metadata?.name}
+ {getStatusBadge(getPhase(pv))}
+
+ {getClaimRef(pv) !== 'Unbound' ? (
+ {getClaimRef(pv)}
+ ) : (
+ Unbound
+ )}
+
+
+ {getStorageClass(pv) !== 'None' ? (
+ {getStorageClass(pv)}
+ ) : (
+ None
+ )}
+
+
+
+
+
+
+ {getAccessModes(pv)}
+
+
+
+ {getReclaimPolicy(pv)}
+
+
+ {getVolumeMode(pv)}
+
+
+ setSelectedPV(pv)}
+ >
+
+ handleDelete(pv)}
+ disabled={getPhase(pv) === 'Bound'}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListCoreV1ResourceQuotaForAllNamespacesQuery({ path: {}, query: {} })
+ : useListCoreV1NamespacedResourceQuotaQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteQuota = useDeleteCoreV1NamespacedResourceQuota()
+
+ const quotas = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (quota: ResourceQuota) => {
+ const name = quota.metadata!.name!
+ const namespace = quota.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteQuota.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete resource quota:', err)
+ alert(`Failed to delete resource quota: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getUsagePercentage = (used: string, hard: string) => {
+ const usedNum = parseInt(used) || 0
+ const hardNum = parseInt(hard) || 0
+ if (hardNum === 0) return 0
+ return Math.round((usedNum / hardNum) * 100)
+ }
+
+ const getUsageBadge = (percentage: number) => {
+ if (percentage >= 90) {
+ return
+
+ } else if (percentage >= 75) {
+ return
+
+ } else {
+ return
+
+ }
+ }
+
+ return (
+
+
+
+
Resource Quotas
+
+ Manage namespace resource limits and usage
+
+
+
+
+
+
alert('Create Resource Quota functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Quotas
+
+
+ {quotas.length}
+
+
+
+
+ Namespaces
+
+
+
+ {new Set(quotas.map(q => q.metadata?.namespace)).size}
+
+
+
+
+
+ Over 75% Usage
+
+
+
+ {quotas.filter(q => {
+ const used = q.status?.used || {}
+ const hard = q.status?.hard || {}
+ return Object.keys(hard).some(key =>
+ getUsagePercentage(used[key] || '0', hard[key]) >= 75
+ )
+ }).length}
+
+
+
+
+
+
+
+ Resource Quotas
+
+ Resource limits and current usage by namespace
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch resource quotas'}
+
+
+
+
+ ) : quotas.length === 0 ? (
+
+
No resource quotas found
+
+
+
+
+
+ Name
+ Namespace
+ Resource
+ Used
+ Hard Limit
+ Usage
+ Actions
+
+
+
+ {quotas.map((quota) => {
+ const hard = quota.status?.hard || {}
+ const used = quota.status?.used || {}
+ const resources = Object.keys(hard)
+
+ return resources.map((resource, idx) => (
+
+ {idx === 0 && (
+ <>
+
+ {quota.metadata?.name}
+
+
+ {quota.metadata?.namespace}
+
+
+ )}
+ {resource}
+ {used[resource] || '0'}
+ {hard[resource]}
+
+ {getUsageBadge(getUsagePercentage(used[resource] || '0', hard[resource]))}
+
+ {idx === 0 && (
+
+
+ setSelectedQuota(quota)}
+ >
+
+ handleDelete(quota)}
+ >
+
+
+
+ )}
+
+ ))
+ })}
+
+
+ )}
+
+
+
(null)
+ const [showClusterBindings, setShowClusterBindings] = useState(false)
+ const { namespace } = usePreferredNamespace()
+
+ // Namespace role bindings
+ const nsQuery = namespace === '_all'
+ ? useListRbacAuthorizationV1RoleBindingForAllNamespacesQuery({ path: {}, query: {} })
+ : useListRbacAuthorizationV1NamespacedRoleBindingQuery({ path: { namespace }, query: {} })
+
+ // Cluster role bindings
+ const clusterQuery = useListRbacAuthorizationV1ClusterRoleBindingQuery({ path: {}, query: {} })
+
+ const query = showClusterBindings ? clusterQuery : nsQuery
+ const { data, isLoading, error, refetch } = query
+
+ const deleteNsBinding = useDeleteRbacAuthorizationV1NamespacedRoleBinding()
+ const deleteClusterBinding = useDeleteRbacAuthorizationV1ClusterRoleBinding()
+
+ const bindings = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (binding: RoleBinding | ClusterRoleBinding) => {
+ const name = binding.metadata!.name!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ if (showClusterBindings) {
+ await deleteClusterBinding.mutateAsync({
+ path: { name },
+ query: {}
+ })
+ } else {
+ const namespace = binding.metadata!.namespace!
+ await deleteNsBinding.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ }
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete role binding:', err)
+ alert(`Failed to delete role binding: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getRoleRef = (binding: RoleBinding | ClusterRoleBinding): string => {
+ const ref = binding.roleRef
+ return `${ref.kind}/${ref.name}`
+ }
+
+ const getSubjects = (binding: RoleBinding | ClusterRoleBinding): string => {
+ const subjects = binding.subjects || []
+ if (subjects.length === 0) return 'None'
+ if (subjects.length === 1) {
+ const s = subjects[0]
+ return `${s.kind}/${s.name}`
+ }
+ return `${subjects.length} subjects`
+ }
+
+ const getSubjectTypes = (binding: RoleBinding | ClusterRoleBinding): string[] => {
+ const subjects = binding.subjects || []
+ const types = new Set(subjects.map(s => s.kind))
+ return Array.from(types)
+ }
+
+ const getSubjectIcon = (types: string[]) => {
+ if (types.includes('ServiceAccount')) return Bot
+ if (types.includes('Group')) return Users
+ if (types.includes('User')) return User
+ return UserCheck
+ }
+
+ const isClusterRole = (binding: RoleBinding | ClusterRoleBinding): boolean => {
+ return binding.roleRef.kind === 'ClusterRole'
+ }
+
+ return (
+
+
+
+
Role Bindings
+
+ Bind roles to users, groups, and service accounts
+
+
+
+
+ setShowClusterBindings(false)}
+ >
+ Namespace
+
+ setShowClusterBindings(true)}
+ >
+ Cluster
+
+
+
+
+
alert('Create Role Binding functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Bindings
+
+
+ {bindings.length}
+
+
+
+
+ Service Accounts
+
+
+
+ {bindings.filter(b => b.subjects?.some(s => s.kind === 'ServiceAccount')).length}
+
+
+
+
+
+ Users/Groups
+
+
+
+ {bindings.filter(b => b.subjects?.some(s => s.kind === 'User' || s.kind === 'Group')).length}
+
+
+
+
+
+ Unique Roles
+
+
+
+ {new Set(bindings.map(getRoleRef)).size}
+
+
+
+
+
+
+
+ {showClusterBindings ? 'Cluster Role Bindings' : 'Namespace Role Bindings'}
+
+ {showClusterBindings
+ ? 'Cluster-wide role assignments'
+ : 'Namespace-scoped role assignments'}
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch role bindings'}
+
+
+
+
+ ) : bindings.length === 0 ? (
+
+
No role bindings found
+
+
+
+
+
+ Name
+ {!showClusterBindings && Namespace }
+ Role
+ Subjects
+ Subject Types
+ Created
+ Actions
+
+
+
+ {bindings.map((binding) => {
+ const subjectTypes = getSubjectTypes(binding)
+ const SubjectIcon = getSubjectIcon(subjectTypes)
+
+ return (
+
+ {binding.metadata?.name}
+ {!showClusterBindings && (
+ {binding.metadata?.namespace}
+ )}
+
+
+ {getRoleRef(binding)}
+
+
+ {getSubjects(binding)}
+
+
+ {subjectTypes.join(', ')}
+
+
+
+ {binding.metadata?.creationTimestamp
+ ? new Date(binding.metadata.creationTimestamp).toLocaleDateString()
+ : 'Unknown'}
+
+
+
+ setSelectedBinding(binding)}
+ >
+
+ handleDelete(binding)}
+ >
+
+
+
+
+ )
+ })}
+
+
+ )}
+
+
+
(null)
+ const [showClusterRoles, setShowClusterRoles] = useState(false)
+ const { namespace } = usePreferredNamespace()
+
+ // Namespace roles
+ const nsQuery = namespace === '_all'
+ ? useListRbacAuthorizationV1RoleForAllNamespacesQuery({ path: {}, query: {} })
+ : useListRbacAuthorizationV1NamespacedRoleQuery({ path: { namespace }, query: {} })
+
+ // Cluster roles
+ const clusterQuery = useListRbacAuthorizationV1ClusterRoleQuery({ path: {}, query: {} })
+
+ const query = showClusterRoles ? clusterQuery : nsQuery
+ const { data, isLoading, error, refetch } = query
+
+ const deleteNsRole = useDeleteRbacAuthorizationV1NamespacedRole()
+ const deleteClusterRole = useDeleteRbacAuthorizationV1ClusterRole()
+
+ const roles = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (role: Role | ClusterRole) => {
+ const name = role.metadata!.name!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ if (showClusterRoles) {
+ await deleteClusterRole.mutateAsync({
+ path: { name },
+ query: {}
+ })
+ } else {
+ const namespace = role.metadata!.namespace!
+ await deleteNsRole.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ }
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete role:', err)
+ alert(`Failed to delete role: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getRuleCount = (role: Role | ClusterRole): number => {
+ return role.rules?.length || 0
+ }
+
+ const getResourceCount = (role: Role | ClusterRole): number => {
+ const rules = role.rules || []
+ const resources = new Set()
+ rules.forEach(rule => {
+ (rule.resources || []).forEach(resource => {
+ resources.add(resource)
+ })
+ })
+ return resources.size
+ }
+
+ const getVerbCount = (role: Role | ClusterRole): number => {
+ const rules = role.rules || []
+ const verbs = new Set()
+ rules.forEach(rule => {
+ (rule.verbs || []).forEach(verb => {
+ verbs.add(verb)
+ })
+ })
+ return verbs.size
+ }
+
+ const hasWildcardAccess = (role: Role | ClusterRole): boolean => {
+ const rules = role.rules || []
+ return rules.some(rule =>
+ rule.verbs?.includes('*') ||
+ rule.resources?.includes('*') ||
+ rule.apiGroups?.includes('*')
+ )
+ }
+
+ const getTopResources = (role: Role | ClusterRole): string => {
+ const rules = role.rules || []
+ const resources: string[] = []
+
+ rules.forEach(rule => {
+ (rule.resources || []).forEach(resource => {
+ if (!resources.includes(resource)) {
+ resources.push(resource)
+ }
+ })
+ })
+
+ if (resources.length === 0) return 'None'
+ if (resources.length <= 3) return resources.join(', ')
+ return `${resources.slice(0, 3).join(', ')} +${resources.length - 3} more`
+ }
+
+ const isSystemRole = (role: Role | ClusterRole): boolean => {
+ const name = role.metadata?.name || ''
+ return name.startsWith('system:') ||
+ name.startsWith('kubernetes-') ||
+ name.includes(':system:') ||
+ (role.metadata?.labels?.['kubernetes.io/bootstrapping'] === 'rbac-defaults')
+ }
+
+ return (
+
+
+
+
Roles
+
+ Define permissions for accessing resources
+
+
+
+
+ setShowClusterRoles(false)}
+ >
+ Namespace
+
+ setShowClusterRoles(true)}
+ >
+ Cluster
+
+
+
+
+
alert('Create Role functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Roles
+
+
+ {roles.length}
+
+
+
+
+ System Roles
+
+
+
+ {roles.filter(isSystemRole).length}
+
+
+
+
+
+ User Defined
+
+
+
+ {roles.filter(r => !isSystemRole(r)).length}
+
+
+
+
+
+ With Wildcards
+
+
+
+ {roles.filter(hasWildcardAccess).length}
+
+
+
+
+
+
+
+ {showClusterRoles ? 'Cluster Roles' : 'Namespace Roles'}
+
+ {showClusterRoles
+ ? 'Cluster-wide permission sets'
+ : 'Namespace-scoped permission sets'}
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch roles'}
+
+
+
+
+ ) : roles.length === 0 ? (
+
+
No roles found
+
+
+
+
+
+ Name
+ {!showClusterRoles && Namespace }
+ Type
+ Rules
+ Resources
+ Verbs
+ Top Resources
+ Actions
+
+
+
+ {roles.map((role) => {
+ const isSystem = isSystemRole(role)
+ const hasWildcard = hasWildcardAccess(role)
+
+ return (
+
+ {role.metadata?.name}
+ {!showClusterRoles && (
+ {role.metadata?.namespace}
+ )}
+
+ {isSystem ? (
+
+
+ ) : (
+
+
+ )}
+
+
+ {getRuleCount(role)}
+
+
+ {getResourceCount(role)}
+
+
+ {getVerbCount(role)}
+
+
+ {hasWildcard && (
+
+
+ )}
+ {getTopResources(role)}
+
+
+
+ setSelectedRole(role)}
+ >
+
+ handleDelete(role)}
+ disabled={isSystem}
+ >
+
+
+
+
+ )
+ })}
+
+
+ )}
+
+
+
(null)
+
+ const { data, isLoading, error, refetch } = useListNodeV1RuntimeClassQuery({ path: {}, query: {} })
+ const deleteRuntimeClass = useDeleteNodeV1RuntimeClass()
+
+ const runtimeClasses = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (rc: RuntimeClass) => {
+ const name = rc.metadata!.name!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteRuntimeClass.mutateAsync({
+ path: { name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete runtime class:', err)
+ alert(`Failed to delete runtime class: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getHandlerBadge = (handler: string) => {
+ const knownHandlers = ['runc', 'nvidia', 'gvisor', 'kata-containers', 'crun']
+ const isKnown = knownHandlers.some(h => handler.toLowerCase().includes(h))
+
+ return (
+
+
+ )
+ }
+
+ return (
+
+
+
+
Runtime Classes
+
+ Container runtime configurations for pods
+
+
+
+
+
+
alert('Create Runtime Class functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Runtime Classes
+
+
+ {runtimeClasses.length}
+
+
+
+
+ Unique Handlers
+
+
+
+ {new Set(runtimeClasses.map(rc => rc.handler)).size}
+
+
+
+
+
+ With Scheduling
+
+
+
+ {runtimeClasses.filter(rc => rc.scheduling).length}
+
+
+
+
+
+
+
+ Runtime Classes
+
+ Available container runtime configurations
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch runtime classes'}
+
+
+
+
+ ) : runtimeClasses.length === 0 ? (
+
+
No runtime classes found
+
+
+
+
+
+ Name
+ Handler
+ Node Selector
+ Tolerations
+ Overhead
+ Actions
+
+
+
+ {runtimeClasses.map((rc) => (
+
+ {rc.metadata?.name}
+ {getHandlerBadge(rc.handler)}
+
+ {rc.scheduling?.nodeSelector ? (
+
+ {Object.entries(rc.scheduling.nodeSelector)
+ .map(([k, v]) => `${k}=${v}`)
+ .join(', ')}
+
+ ) : (
+ None
+ )}
+
+
+ {rc.scheduling?.tolerations?.length ? (
+ {rc.scheduling.tolerations.length} toleration(s)
+ ) : (
+ None
+ )}
+
+
+ {rc.overhead?.podFixed ? (
+
+
+
+
+
+
None
+ )}
+
+
+
+ setSelectedRuntimeClass(rc)}
+ >
+
+ handleDelete(rc)}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ const query = namespace === '_all'
+ ? useListCoreV1ServiceAccountForAllNamespacesQuery({ path: {}, query: {} })
+ : useListCoreV1NamespacedServiceAccountQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteAccount = useDeleteCoreV1NamespacedServiceAccount()
+
+ const accounts = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (account: ServiceAccount) => {
+ const name = account.metadata!.name!
+ const namespace = account.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}? This may affect pods using this service account.`)) {
+ try {
+ await deleteAccount.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete service account:', err)
+ alert(`Failed to delete service account: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getSecretCount = (account: ServiceAccount): number => {
+ return account.secrets?.length || 0
+ }
+
+ const getImagePullSecrets = (account: ServiceAccount): number => {
+ return account.imagePullSecrets?.length || 0
+ }
+
+ const hasAutomountToken = (account: ServiceAccount): boolean => {
+ return account.automountServiceAccountToken !== false
+ }
+
+ const isDefaultAccount = (account: ServiceAccount): boolean => {
+ return account.metadata?.name === 'default'
+ }
+
+ const isSystemAccount = (account: ServiceAccount): boolean => {
+ const name = account.metadata?.name || ''
+ const namespace = account.metadata?.namespace || ''
+ return namespace.startsWith('kube-') ||
+ name.startsWith('system:') ||
+ name.includes('controller') ||
+ name.includes('operator')
+ }
+
+ const getSecretNames = (account: ServiceAccount): string => {
+ const secrets = account.secrets || []
+ if (secrets.length === 0) return 'None'
+ if (secrets.length === 1) return secrets[0].name || 'Unknown'
+ return `${secrets.length} secrets`
+ }
+
+ const getAccountType = (account: ServiceAccount) => {
+ if (isDefaultAccount(account)) return 'Default'
+ if (isSystemAccount(account)) return 'System'
+ return 'User'
+ }
+
+ const getAccountBadge = (type: string) => {
+ switch (type) {
+ case 'Default':
+ return
+
+ case 'System':
+ return
+
+ default:
+ return
+
+ }
+ }
+
+ return (
+
+
+
+
Service Accounts
+
+ Identities for pods to access the Kubernetes API
+
+
+
+
+
+
alert('Create Service Account functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Accounts
+
+
+ {accounts.length}
+
+
+
+
+ User Accounts
+
+
+
+ {accounts.filter(a => getAccountType(a) === 'User').length}
+
+
+
+
+
+ With Secrets
+
+
+
+ {accounts.filter(a => getSecretCount(a) > 0).length}
+
+
+
+
+
+ Automount Enabled
+
+
+
+ {accounts.filter(hasAutomountToken).length}
+
+
+
+
+
+
+
+ Service Accounts
+
+ Pod identities for accessing Kubernetes API and pulling images
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch service accounts'}
+
+
+
+
+ ) : accounts.length === 0 ? (
+
+
No service accounts found
+
+
+
+
+
+ Name
+ Namespace
+ Type
+ Secrets
+ Image Pull Secrets
+ Automount Token
+ Created
+ Actions
+
+
+
+ {accounts.map((account) => {
+ const accountType = getAccountType(account)
+ const isSystem = accountType === 'System'
+ const isDefault = accountType === 'Default'
+
+ return (
+
+ {account.metadata?.name}
+ {account.metadata?.namespace}
+ {getAccountBadge(accountType)}
+
+
+ {getSecretNames(account)}
+
+
+
+ {getImagePullSecrets(account) > 0 ? (
+ {getImagePullSecrets(account)}
+ ) : (
+ None
+ )}
+
+
+ {hasAutomountToken(account) ? (
+
+
+ ) : (
+
+
+ )}
+
+
+ {account.metadata?.creationTimestamp
+ ? new Date(account.metadata.creationTimestamp).toLocaleDateString()
+ : 'Unknown'}
+
+
+
+ setSelectedAccount(account)}
+ >
+
+ handleDelete(account)}
+ disabled={isDefault || isSystem}
+ >
+
+
+
+
+ )
+ })}
+
+
+ )}
+
+
+
(null)
+ const { namespace } = usePreferredNamespace()
+
+ // Use k8s hooks directly
+ const query = namespace === '_all'
+ ? useListAppsV1StatefulSetForAllNamespacesQuery({ path: {}, query: {} })
+ : useListAppsV1NamespacedStatefulSetQuery({ path: { namespace }, query: {} })
+
+ const { data, isLoading, error, refetch } = query
+ const deleteStatefulSet = useDeleteAppsV1NamespacedStatefulSet()
+ const scaleStatefulSet = useReplaceAppsV1NamespacedStatefulSetScale()
+
+ const statefulsets = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleScale = async (ss: StatefulSet) => {
+ const name = ss.metadata!.name!
+ const namespace = ss.metadata!.namespace!
+ const currentReplicas = ss.spec!.replicas || 0
+
+ const newReplicas = prompt(`Scale ${name} to how many replicas?`, currentReplicas.toString())
+ if (newReplicas && !isNaN(Number(newReplicas))) {
+ try {
+ await scaleStatefulSet.mutateAsync({
+ path: { namespace, name },
+ body: {
+ apiVersion: 'autoscaling/v1',
+ kind: 'Scale',
+ metadata: { name, namespace },
+ spec: { replicas: Number(newReplicas) }
+ }
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to scale statefulset:', err)
+ alert(`Failed to scale statefulset: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const handleDelete = async (ss: StatefulSet) => {
+ const name = ss.metadata!.name!
+ const namespace = ss.metadata!.namespace!
+
+ if (confirm(`Are you sure you want to delete ${name}?`)) {
+ try {
+ await deleteStatefulSet.mutateAsync({
+ path: { namespace, name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete statefulset:', err)
+ alert(`Failed to delete statefulset: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getStatus = (ss: StatefulSet) => {
+ const replicas = ss.spec?.replicas || 0
+ const readyReplicas = ss.status?.readyReplicas || 0
+
+ if (readyReplicas === replicas && replicas > 0) {
+ return 'Running'
+ } else if (readyReplicas < replicas) {
+ return 'Updating'
+ } else {
+ return 'Pending'
+ }
+ }
+
+ const getStatusBadge = (status: string) => {
+ switch (status) {
+ case 'Running':
+ return
+
+ case 'Updating':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ return (
+
+ {/* Header */}
+
+
+
StatefulSets
+
+ Manage your Kubernetes stateful applications
+
+
+
+
+
+
alert('Create StatefulSet functionality not yet implemented')}>
+
+
+
+
+ {/* Stats Cards */}
+
+
+
+ Total StatefulSets
+
+
+ {statefulsets.length}
+
+
+
+
+ Running
+
+
+
+ {statefulsets.filter(ss => getStatus(ss) === 'Running').length}
+
+
+
+
+
+ Total Replicas
+
+
+
+ {statefulsets.reduce((sum, ss) => sum + (ss.status?.readyReplicas || 0), 0)}
+
+
+
+
+
+ {/* StatefulSets Table */}
+
+
+ All StatefulSets
+
+ A list of all stateful sets in your cluster
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch statefulsets'}
+
+
+
+
+ ) : statefulsets.length === 0 ? (
+
+
No statefulsets found
+
+
+
+
+
+ Name
+ Namespace
+ Status
+ Replicas
+ Image
+ Created
+ Actions
+
+
+
+ {statefulsets.map((ss) => (
+
+ {ss.metadata?.name}
+ {ss.metadata?.namespace}
+ {getStatusBadge(getStatus(ss))}
+
+ {ss.status?.readyReplicas || 0}/{ss.spec?.replicas || 0}
+
+
+ {ss.spec?.template?.spec?.containers?.[0]?.image || 'unknown'}
+
+
+ {ss.metadata?.creationTimestamp
+ ? new Date(ss.metadata.creationTimestamp).toLocaleDateString()
+ : 'Unknown'}
+
+
+
+ setSelectedStatefulSet(ss)}
+ >
+
+ handleScale(ss)}
+ >
+
+ console.log('Edit', ss.metadata?.name)}
+ >
+
+ handleDelete(ss)}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+
+ const { data, isLoading, error, refetch } = useListStorageV1StorageClassQuery({ path: {}, query: {} })
+ const deleteClass = useDeleteStorageV1StorageClass()
+
+ const storageClasses = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (sc: StorageClass) => {
+ const name = sc.metadata!.name!
+
+ if (confirm(`Are you sure you want to delete ${name}? PVs using this class won't be affected.`)) {
+ try {
+ await deleteClass.mutateAsync({
+ path: { name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete storage class:', err)
+ alert(`Failed to delete storage class: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getProvisioner = (sc: StorageClass): string => {
+ return sc.provisioner || 'Unknown'
+ }
+
+ const getReclaimPolicy = (sc: StorageClass): string => {
+ return sc.reclaimPolicy || 'Delete'
+ }
+
+ const getVolumeBindingMode = (sc: StorageClass): string => {
+ return sc.volumeBindingMode || 'Immediate'
+ }
+
+ const isDefaultClass = (sc: StorageClass): boolean => {
+ const annotations = sc.metadata?.annotations || {}
+ return annotations['storageclass.kubernetes.io/is-default-class'] === 'true' ||
+ annotations['storageclass.beta.kubernetes.io/is-default-class'] === 'true'
+ }
+
+ const getAllowVolumeExpansion = (sc: StorageClass): boolean => {
+ return sc.allowVolumeExpansion === true
+ }
+
+ const getProvisionerBadge = (provisioner: string) => {
+ // Common provisioners
+ if (provisioner.includes('aws-ebs')) {
+ return
+
+ } else if (provisioner.includes('azure-disk')) {
+ return
+
+ } else if (provisioner.includes('gce-pd')) {
+ return
+
+ } else if (provisioner.includes('nfs')) {
+ return
+
+ } else if (provisioner.includes('local')) {
+ return
+
+ }
+ return {provisioner}
+ }
+
+ return (
+
+
+
+
Storage Classes
+
+ Dynamic storage provisioning configurations
+
+
+
+
+
+
alert('Create Storage Class functionality not yet implemented')}>
+
+
+
+
+
+
+
+ Total Classes
+
+
+ {storageClasses.length}
+
+
+
+
+ Default Class
+
+
+
+ {storageClasses.find(isDefaultClass)?.metadata?.name || 'None'}
+
+
+
+
+
+ Expandable
+
+
+
+ {storageClasses.filter(getAllowVolumeExpansion).length}
+
+
+
+
+
+ Provisioners
+
+
+
+ {new Set(storageClasses.map(getProvisioner)).size}
+
+
+
+
+
+
+
+ Storage Classes
+
+ Define different types of storage and their provisioners
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch storage classes'}
+
+
+
+
+ ) : storageClasses.length === 0 ? (
+
+
No storage classes found
+
+
+
+
+
+ Name
+ Provisioner
+ Reclaim Policy
+ Binding Mode
+ Volume Expansion
+ Default
+ Actions
+
+
+
+ {storageClasses.map((sc) => (
+
+ {sc.metadata?.name}
+ {getProvisionerBadge(getProvisioner(sc))}
+
+
+ {getReclaimPolicy(sc)}
+
+
+
+
+ {getVolumeBindingMode(sc) === 'WaitForFirstConsumer' &&
+
+
+ {getAllowVolumeExpansion(sc) ? (
+ Allowed
+ ) : (
+ Not Allowed
+ )}
+
+
+ {isDefaultClass(sc) ? (
+ Yes
+ ) : (
+ No
+ )}
+
+
+
+ setSelectedClass(sc)}
+ >
+
+ handleDelete(sc)}
+ disabled={isDefaultClass(sc)}
+ >
+
+
+
+
+ ))}
+
+
+ )}
+
+
+
(null)
+
+ const { data, isLoading, error, refetch } = useListStorageV1VolumeAttachmentQuery({ path: {}, query: {} })
+ const deleteAttachment = useDeleteStorageV1VolumeAttachment()
+
+ const attachments = data?.items || []
+
+ const handleRefresh = () => refetch()
+
+ const handleDelete = async (va: VolumeAttachment) => {
+ const name = va.metadata!.name!
+
+ if (confirm(`Are you sure you want to delete ${name}? This may disrupt attached volumes.`)) {
+ try {
+ await deleteAttachment.mutateAsync({
+ path: { name },
+ query: {}
+ })
+ refetch()
+ } catch (err) {
+ console.error('Failed to delete volume attachment:', err)
+ alert(`Failed to delete volume attachment: ${err instanceof Error ? err.message : 'Unknown error'}`)
+ }
+ }
+ }
+
+ const getAttachmentStatus = (va: VolumeAttachment): string => {
+ return va.status?.attached ? 'Attached' : 'Detached'
+ }
+
+ const getStatusBadge = (status: string) => {
+ switch (status) {
+ case 'Attached':
+ return
+
+ case 'Detached':
+ return
+
+ default:
+ return {status}
+ }
+ }
+
+ const getAttacher = (va: VolumeAttachment): string => {
+ return va.spec?.attacher || 'Unknown'
+ }
+
+ const getNodeName = (va: VolumeAttachment): string => {
+ return va.spec?.nodeName || 'Unknown'
+ }
+
+ const getPVName = (va: VolumeAttachment): string => {
+ return va.spec?.source?.persistentVolumeName || 'Unknown'
+ }
+
+ const getAttachError = (va: VolumeAttachment): string | null => {
+ const error = va.status?.attachError
+ if (!error) return null
+ return error.message || 'Unknown error'
+ }
+
+ const getDetachError = (va: VolumeAttachment): string | null => {
+ const error = va.status?.detachError
+ if (!error) return null
+ return error.message || 'Unknown error'
+ }
+
+ return (
+
+
+
+
Volume Attachments
+
+ Volume attachments to nodes
+
+
+
+
+
+
+
+
+
+
+
+ Total Attachments
+
+
+ {attachments.length}
+
+
+
+
+ Attached
+
+
+
+ {attachments.filter(va => va.status?.attached).length}
+
+
+
+
+
+ With Errors
+
+
+
+ {attachments.filter(va => getAttachError(va) || getDetachError(va)).length}
+
+
+
+
+
+ Unique Nodes
+
+
+
+ {new Set(attachments.map(getNodeName)).size}
+
+
+
+
+
+
+
+ Volume Attachments
+
+ Connections between persistent volumes and nodes
+
+
+
+ {error ? (
+
+
+
{error instanceof Error ? error.message : 'Failed to fetch volume attachments'}
+
+
+
+
+ ) : attachments.length === 0 ? (
+
+
No volume attachments found
+
+
+
+
+
+ Name
+ Status
+ Node
+ PV Name
+ Attacher
+ Errors
+ Created
+ Actions
+
+
+
+ {attachments.map((va) => {
+ const attachError = getAttachError(va)
+ const detachError = getDetachError(va)
+ const hasError = attachError || detachError
+
+ return (
+
+ {va.metadata?.name}
+ {getStatusBadge(getAttachmentStatus(va))}
+
+
+ {getNodeName(va)}
+
+
+ {getPVName(va)}
+
+ {getAttacher(va)}
+
+
+ {hasError ? (
+
+ {attachError ? 'Attach Error' : 'Detach Error'}
+
+ ) : (
+ None
+ )}
+
+
+ {va.metadata?.creationTimestamp
+ ? new Date(va.metadata.creationTimestamp).toLocaleDateString()
+ : 'Unknown'}
+
+
+
+ setSelectedAttachment(va)}
+ >
+
+ handleDelete(va)}
+ disabled={va.status?.attached}
+ >
+
+
+
+
+ )
+ })}
+
+
+ )}
+
+
+
+ {theme === 'light' ? (
+ Toggle theme
+
+ )
+}
diff --git a/ui/contexts/NamespaceContext.tsx b/ui/contexts/NamespaceContext.tsx
new file mode 100644
index 0000000..c0c1628
--- /dev/null
+++ b/ui/contexts/NamespaceContext.tsx
@@ -0,0 +1,31 @@
+'use client'
+
+import React, { createContext, useContext, useState } from 'react'
+
+interface NamespaceContextValue {
+ namespace: string
+ setNamespace: (ns: string) => void
+}
+
+const NamespaceContext = createContext(undefined)
+
+interface NamespaceProviderProps {
+ children: React.ReactNode
+ initialNamespace?: string
+}
+
+export function NamespaceProvider({ children, initialNamespace = 'default' }: NamespaceProviderProps) {
+ const [namespace, setNamespace] = useState(initialNamespace)
+
+ return (
+
+ {children}
+
+ )
+}
+
+export function usePreferredNamespace(): NamespaceContextValue {
+ const ctx = useContext(NamespaceContext)
+ if (!ctx) throw new Error('usePreferredNamespace must be used within a NamespaceProvider')
+ return ctx
+}
diff --git a/ui/hooks/index.ts b/ui/hooks/index.ts
index c1f70e3..367ef2f 100644
--- a/ui/hooks/index.ts
+++ b/ui/hooks/index.ts
@@ -7,6 +7,3 @@ export * from './useConfigMaps'
export * from './usePods'
export * from './useDaemonSets'
export * from './useReplicaSets'
-
-// Re-export context hook
-export { useKubernetes } from '../contexts/KubernetesContext'
\ No newline at end of file
diff --git a/ui/hooks/useConfigMaps.ts b/ui/hooks/useConfigMaps.ts
index 927cf20..f92c2f4 100644
--- a/ui/hooks/useConfigMaps.ts
+++ b/ui/hooks/useConfigMaps.ts
@@ -1,111 +1,102 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useKubernetes } from '../contexts/KubernetesContext'
+import {
+ useListCoreV1ConfigMapForAllNamespacesQuery,
+ useListCoreV1NamespacedConfigMapQuery,
+ useReadCoreV1NamespacedConfigMapQuery,
+ useCreateCoreV1NamespacedConfigMap,
+ useReplaceCoreV1NamespacedConfigMap,
+ useDeleteCoreV1NamespacedConfigMap,
+} from '../k8s/index'
+import { usePreferredNamespace } from '../contexts/NamespaceContext'
import type { ConfigMap, ConfigMapList } from 'kubernetesjs'
// Query keys
const CONFIGMAPS_KEY = ['configmaps'] as const
export function useConfigMaps(namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...CONFIGMAPS_KEY, ns],
- queryFn: async () => {
- if (ns === '_all') {
- const result = await client.listCoreV1ConfigMapForAllNamespaces({
- query: {},
- })
- return result
- } else {
- const result = await client.listCoreV1NamespacedConfigMap({
- path: { namespace: ns },
- query: {},
- })
- return result
- }
- },
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ if (ns === '_all') {
+ return useListCoreV1ConfigMapForAllNamespacesQuery({ query: {}, path: {} })
+ }
+ return useListCoreV1NamespacedConfigMapQuery({ path: { namespace: ns }, query: {} })
}
export function useConfigMap(name: string, namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...CONFIGMAPS_KEY, ns, name],
- queryFn: async () => {
- const result = await client.readCoreV1NamespacedConfigMap({
- path: { namespace: ns, name },
- query: {},
- })
- return result
- },
- enabled: !!name,
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ return useReadCoreV1NamespacedConfigMapQuery({ path: { namespace: ns, name }, query: {} })
}
export function useCreateConfigMap() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ configMap, namespace }) => {
- const ns = namespace || defaultNamespace
- const result = await client.createCoreV1NamespacedConfigMap({
- path: { namespace: ns },
- query: {},
- body: configMap,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...CONFIGMAPS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useCreateCoreV1NamespacedConfigMap()
+ return {
+ ...base,
+ mutate: (
+ { configMap, namespace }: { configMap: ConfigMap; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace }, query: {}, body: configMap },
+ opts
+ ),
+ mutateAsync: (
+ { configMap, namespace }: { configMap: ConfigMap; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace }, query: {}, body: configMap },
+ opts
+ ),
+ }
}
export function useUpdateConfigMap() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, configMap, namespace }) => {
- const ns = namespace || defaultNamespace
- const result = await client.replaceCoreV1NamespacedConfigMap({
- path: { namespace: ns, name },
- query: {},
- body: configMap,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...CONFIGMAPS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useReplaceCoreV1NamespacedConfigMap()
+ return {
+ ...base,
+ mutate: (
+ { name, configMap, namespace }: { name: string; configMap: ConfigMap; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {}, body: configMap },
+ opts
+ ),
+ mutateAsync: (
+ { name, configMap, namespace }: { name: string; configMap: ConfigMap; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {}, body: configMap },
+ opts
+ ),
+ }
}
export function useDeleteConfigMap() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, namespace }) => {
- const ns = namespace || defaultNamespace
- await client.deleteCoreV1NamespacedConfigMap({
- path: { namespace: ns, name },
- query: {},
- })
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...CONFIGMAPS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useDeleteCoreV1NamespacedConfigMap()
+ return {
+ ...base,
+ mutate: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ mutateAsync: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ }
}
\ No newline at end of file
diff --git a/ui/hooks/useDaemonSets.ts b/ui/hooks/useDaemonSets.ts
index 6c473f7..d4262a3 100644
--- a/ui/hooks/useDaemonSets.ts
+++ b/ui/hooks/useDaemonSets.ts
@@ -1,69 +1,52 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useKubernetes } from '../contexts/KubernetesContext'
+import {
+ useListAppsV1DaemonSetForAllNamespacesQuery,
+ useListAppsV1NamespacedDaemonSetQuery,
+ useReadAppsV1NamespacedDaemonSetQuery,
+ useDeleteAppsV1NamespacedDaemonSet,
+} from '../k8s/index'
+import { usePreferredNamespace } from '../contexts/NamespaceContext'
import type { DaemonSet, DaemonSetList } from 'kubernetesjs'
// Query keys
const DAEMONSETS_KEY = ['daemonsets'] as const
export function useDaemonSets(namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...DAEMONSETS_KEY, ns],
- queryFn: async () => {
- if (ns === '_all') {
- const result = await client.listAppsV1DaemonSetForAllNamespaces({
- query: {},
- })
- return result
- } else {
- const result = await client.listAppsV1NamespacedDaemonSet({
- path: { namespace: ns },
- query: {},
- })
- return result
- }
- },
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ if (ns === '_all') {
+ return useListAppsV1DaemonSetForAllNamespacesQuery({ path: {}, query: {} })
+ }
+ return useListAppsV1NamespacedDaemonSetQuery({ path: { namespace: ns }, query: {} })
}
export function useDaemonSet(name: string, namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...DAEMONSETS_KEY, ns, name],
- queryFn: async () => {
- const result = await client.readAppsV1NamespacedDaemonSet({
- path: { namespace: ns, name },
- query: {},
- })
- return result
- },
- enabled: !!name,
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ return useReadAppsV1NamespacedDaemonSetQuery({ path: { namespace: ns, name }, query: {} })
}
export function useDeleteDaemonSet() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, namespace }) => {
- const ns = namespace || defaultNamespace
- await client.deleteAppsV1NamespacedDaemonSet({
- path: { namespace: ns, name },
- query: {},
- })
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...DAEMONSETS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useDeleteAppsV1NamespacedDaemonSet()
+ return {
+ ...base,
+ mutate: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ mutateAsync: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ }
}
diff --git a/ui/hooks/useDeployments.ts b/ui/hooks/useDeployments.ts
index e939acf..5a342dc 100644
--- a/ui/hooks/useDeployments.ts
+++ b/ui/hooks/useDeployments.ts
@@ -1,145 +1,143 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useKubernetes } from '../contexts/KubernetesContext'
-import type { Deployment, DeploymentList } from 'kubernetesjs'
+import {
+ useListAppsV1DeploymentForAllNamespacesQuery,
+ useListAppsV1NamespacedDeploymentQuery,
+ useReadAppsV1NamespacedDeploymentQuery,
+ useCreateAppsV1NamespacedDeployment,
+ useReplaceAppsV1NamespacedDeployment,
+ useDeleteAppsV1NamespacedDeployment,
+ useReplaceAppsV1NamespacedDeploymentScale,
+} from '../k8s/index'
+import { usePreferredNamespace } from '../contexts/NamespaceContext'
+import type { Deployment, DeploymentList, Scale } from 'kubernetesjs'
// Query keys
const DEPLOYMENTS_KEY = ['deployments'] as const
export function useDeployments(namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...DEPLOYMENTS_KEY, ns],
- queryFn: async () => {
- if (ns === '_all') {
- // Fetch from all namespaces
- const result = await client.listAppsV1DeploymentForAllNamespaces({
- query: {},
- })
- return result
- } else {
- // Fetch from specific namespace
- const result = await client.listAppsV1NamespacedDeployment({
- path: { namespace: ns },
- query: {},
- })
- return result
- }
- },
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ if (ns === '_all') {
+ return useListAppsV1DeploymentForAllNamespacesQuery({ path: {}, query: {} })
+ }
+ return useListAppsV1NamespacedDeploymentQuery({ path: { namespace: ns }, query: {} })
}
export function useDeployment(name: string, namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...DEPLOYMENTS_KEY, ns, name],
- queryFn: async () => {
- const result = await client.readAppsV1NamespacedDeployment({
- path: { namespace: ns, name },
- query: {},
- })
- return result
- },
- enabled: !!name,
- })
+ return useReadAppsV1NamespacedDeploymentQuery({ path: { namespace: ns, name }, query: {} })
}
export function useCreateDeployment() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ deployment, namespace }) => {
- const ns = namespace || defaultNamespace
- const result = await client.createAppsV1NamespacedDeployment({
- path: { namespace: ns },
- query: {},
- body: deployment,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...DEPLOYMENTS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useCreateAppsV1NamespacedDeployment()
+ return {
+ ...base,
+ mutate: (
+ { deployment, namespace }: { deployment: Deployment; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace }, query: {}, body: deployment },
+ opts
+ ),
+ mutateAsync: (
+ { deployment, namespace }: { deployment: Deployment; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace }, query: {}, body: deployment },
+ opts
+ ),
+ }
}
export function useUpdateDeployment() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, deployment, namespace }) => {
- const ns = namespace || defaultNamespace
- const result = await client.replaceAppsV1NamespacedDeployment({
- path: { namespace: ns, name },
- query: {},
- body: deployment,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...DEPLOYMENTS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useReplaceAppsV1NamespacedDeployment()
+ return {
+ ...base,
+ mutate: (
+ { name, deployment, namespace }: { name: string; deployment: Deployment; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {}, body: deployment },
+ opts
+ ),
+ mutateAsync: (
+ { name, deployment, namespace }: { name: string; deployment: Deployment; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {}, body: deployment },
+ opts
+ ),
+ }
}
export function useDeleteDeployment() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, namespace }) => {
- const ns = namespace || defaultNamespace
- await client.deleteAppsV1NamespacedDeployment({
- path: { namespace: ns, name },
- query: {},
- })
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...DEPLOYMENTS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useDeleteAppsV1NamespacedDeployment()
+ return {
+ ...base,
+ mutate: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ mutateAsync: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ }
}
export function useScaleDeployment() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, replicas, namespace }) => {
- const ns = namespace || defaultNamespace
-
- // First, get the current deployment
- const deployment = await client.readAppsV1NamespacedDeployment({
- path: { namespace: ns, name },
- query: {},
- })
-
- // Update the replicas
- if (deployment.spec) {
- deployment.spec.replicas = replicas
- }
-
- // Update the deployment
- const result = await client.replaceAppsV1NamespacedDeployment({
- path: { namespace: ns, name },
- query: {},
- body: deployment,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...DEPLOYMENTS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useReplaceAppsV1NamespacedDeploymentScale()
+ return {
+ ...base,
+ mutate: (
+ { name, replicas, namespace }: { name: string; replicas: number; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ {
+ path: { namespace: namespace || defaultNamespace, name },
+ body: {
+ apiVersion: 'autoscaling/v1',
+ kind: 'Scale',
+ metadata: { name, namespace: namespace || defaultNamespace },
+ spec: { replicas },
+ } as Scale,
+ },
+ opts
+ ),
+ mutateAsync: (
+ { name, replicas, namespace }: { name: string; replicas: number; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ {
+ path: { namespace: namespace || defaultNamespace, name },
+ body: {
+ apiVersion: 'autoscaling/v1',
+ kind: 'Scale',
+ metadata: { name, namespace: namespace || defaultNamespace },
+ spec: { replicas },
+ } as Scale,
+ },
+ opts
+ ),
+ }
}
\ No newline at end of file
diff --git a/ui/hooks/useNamespaces.ts b/ui/hooks/useNamespaces.ts
index 06dd2fa..acd419c 100644
--- a/ui/hooks/useNamespaces.ts
+++ b/ui/hooks/useNamespaces.ts
@@ -1,80 +1,74 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useKubernetes } from '../contexts/KubernetesContext'
+import {
+ useListCoreV1NamespaceQuery,
+ useReadCoreV1NamespaceQuery,
+ useCreateCoreV1Namespace,
+ useDeleteCoreV1Namespace,
+} from '../k8s/index'
import type { Namespace, NamespaceList } from 'kubernetesjs'
// Query keys
const NAMESPACES_KEY = ['namespaces'] as const
export function useNamespaces() {
- const { client } = useKubernetes()
-
- return useQuery({
- queryKey: NAMESPACES_KEY,
- queryFn: async () => {
- const result = await client.listCoreV1Namespace({
- path: {},
- query: {},
- })
- return result
- },
- })
+ return useListCoreV1NamespaceQuery({ path: {}, query: {} })
}
export function useNamespace(name: string) {
- const { client } = useKubernetes()
-
- return useQuery({
- queryKey: [...NAMESPACES_KEY, name],
- queryFn: async () => {
- const result = await client.readCoreV1Namespace({
- path: { name },
- query: {},
- })
- return result
- },
- enabled: !!name,
- })
+ return useReadCoreV1NamespaceQuery({ path: { name }, query: {} })
}
export function useCreateNamespace() {
- const { client } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation }>({
- mutationFn: async ({ name, labels }) => {
- const result = await client.createCoreV1Namespace({
- path: {},
- query: {},
- body: {
- apiVersion: 'v1',
- kind: 'Namespace',
- metadata: {
- name,
- labels,
+ const base = useCreateCoreV1Namespace()
+ return {
+ ...base,
+ mutate: (
+ { name, labels }: { name: string; labels?: Record },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ {
+ path: {},
+ query: {},
+ body: {
+ apiVersion: 'v1',
+ kind: 'Namespace',
+ metadata: { name, labels },
},
},
- })
- return result
- },
- onSuccess: () => {
- queryClient.invalidateQueries({ queryKey: NAMESPACES_KEY })
- },
- })
+ opts
+ ),
+ mutateAsync: (
+ { name, labels }: { name: string; labels?: Record },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ {
+ path: {},
+ query: {},
+ body: {
+ apiVersion: 'v1',
+ kind: 'Namespace',
+ metadata: { name, labels },
+ },
+ },
+ opts
+ ),
+ }
}
export function useDeleteNamespace() {
- const { client } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async (name) => {
- await client.deleteCoreV1Namespace({
- path: { name },
- query: {},
- })
- },
- onSuccess: () => {
- queryClient.invalidateQueries({ queryKey: NAMESPACES_KEY })
- },
- })
+ const base = useDeleteCoreV1Namespace()
+ return {
+ ...base,
+ mutate: (name: string, opts?: Parameters[1]) =>
+ base.mutate(
+ { path: { name }, query: {} },
+ opts
+ ),
+ mutateAsync: (name: string, opts?: Parameters[1]) =>
+ base.mutateAsync(
+ { path: { name }, query: {} },
+ opts
+ ),
+ }
}
\ No newline at end of file
diff --git a/ui/hooks/usePods.ts b/ui/hooks/usePods.ts
index 3bde486..11ae47a 100644
--- a/ui/hooks/usePods.ts
+++ b/ui/hooks/usePods.ts
@@ -1,103 +1,73 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useKubernetes } from '../contexts/KubernetesContext'
+import {
+ useListPodsQuery,
+ useListCoreV1NamespacedPodQuery,
+ useReadCoreV1NamespacedPodQuery,
+ useReadCoreV1NamespacedPodLogQuery,
+ useDeleteCoreV1NamespacedPod,
+} from '../k8s/index'
+import { usePreferredNamespace } from '../contexts/NamespaceContext'
import type { Pod, PodList } from 'kubernetesjs'
// Query keys
const PODS_KEY = ['pods'] as const
export function usePods(namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...PODS_KEY, ns],
- queryFn: async () => {
- if (ns === '_all') {
- const result = await client.listPods({
- query: {},
- })
- return result
- } else {
- const result = await client.listCoreV1NamespacedPod({
- path: { namespace: ns },
- query: {},
- })
- return result
- }
- },
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ if (ns === '_all') {
+ return useListPodsQuery({ path: {}, query: {} })
+ }
+ return useListCoreV1NamespacedPodQuery({ path: { namespace: ns }, query: {} })
}
export function usePod(name: string, namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...PODS_KEY, ns, name],
- queryFn: async () => {
- const result = await client.readCoreV1NamespacedPod({
- path: { namespace: ns, name },
- query: {},
- })
- return result
- },
- enabled: !!name,
- })
+ return useReadCoreV1NamespacedPodQuery({ path: { namespace: ns, name }, query: {} })
}
export function usePodLogs(name: string, namespace?: string, container?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...PODS_KEY, ns, name, 'logs', container],
- queryFn: async () => {
- const result = await client.readCoreV1NamespacedPodLog({
- path: { namespace: ns, name },
- query: container ? { container } : {},
- })
- return result as string
- },
- enabled: !!name,
+ return useReadCoreV1NamespacedPodLogQuery({
+ path: { namespace: ns, name },
+ query: container ? { container } : {},
})
}
export function useDeletePod() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, namespace }) => {
- const ns = namespace || defaultNamespace
- await client.deleteCoreV1NamespacedPod({
- path: { namespace: ns, name },
- query: {},
- })
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...PODS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useDeleteCoreV1NamespacedPod()
+ return {
+ ...base,
+ mutate: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ mutateAsync: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ }
}
export function usePodsForDeployment(deploymentName: string, namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...PODS_KEY, ns, 'deployment', deploymentName],
- queryFn: async () => {
- const result = await client.listCoreV1NamespacedPod({
- path: { namespace: ns },
- query: {
- labelSelector: `app=${deploymentName}`,
- },
- })
- return result
- },
- enabled: !!deploymentName,
+ return useListCoreV1NamespacedPodQuery({
+ path: { namespace: ns },
+ query: { labelSelector: `app=${deploymentName}` },
})
}
\ No newline at end of file
diff --git a/ui/hooks/useReplicaSets.ts b/ui/hooks/useReplicaSets.ts
index 5130bd4..9225c24 100644
--- a/ui/hooks/useReplicaSets.ts
+++ b/ui/hooks/useReplicaSets.ts
@@ -1,103 +1,93 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useKubernetes } from '../contexts/KubernetesContext'
-import type { ReplicaSet, ReplicaSetList } from 'kubernetesjs'
+import {
+ useListAppsV1ReplicaSetForAllNamespacesQuery,
+ useListAppsV1NamespacedReplicaSetQuery,
+ useReadAppsV1NamespacedReplicaSetQuery,
+ useDeleteAppsV1NamespacedReplicaSet,
+ useReplaceAppsV1NamespacedReplicaSetScale,
+} from '../k8s/index'
+import { usePreferredNamespace } from '../contexts/NamespaceContext'
+import type { ReplicaSet, ReplicaSetList, Scale } from 'kubernetesjs'
// Query keys
const REPLICASETS_KEY = ['replicasets'] as const
export function useReplicaSets(namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...REPLICASETS_KEY, ns],
- queryFn: async () => {
- if (ns === '_all') {
- const result = await client.listAppsV1ReplicaSetForAllNamespaces({
- query: {},
- })
- return result
- } else {
- const result = await client.listAppsV1NamespacedReplicaSet({
- path: { namespace: ns },
- query: {},
- })
- return result
- }
- },
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ if (ns === '_all') {
+ return useListAppsV1ReplicaSetForAllNamespacesQuery({ path: {}, query: {} })
+ }
+ return useListAppsV1NamespacedReplicaSetQuery({ path: { namespace: ns }, query: {} })
}
export function useReplicaSet(name: string, namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...REPLICASETS_KEY, ns, name],
- queryFn: async () => {
- const result = await client.readAppsV1NamespacedReplicaSet({
- path: { namespace: ns, name },
- query: {},
- })
- return result
- },
- enabled: !!name,
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ return useReadAppsV1NamespacedReplicaSetQuery({ path: { namespace: ns, name }, query: {} })
}
export function useDeleteReplicaSet() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, namespace }) => {
- const ns = namespace || defaultNamespace
- await client.deleteAppsV1NamespacedReplicaSet({
- path: { namespace: ns, name },
- query: {},
- })
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...REPLICASETS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useDeleteAppsV1NamespacedReplicaSet()
+ return {
+ ...base,
+ mutate: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ mutateAsync: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ }
}
export function useScaleReplicaSet() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, replicas, namespace }) => {
- const ns = namespace || defaultNamespace
-
- // First, get the current replicaset
- const replicaSet = await client.readAppsV1NamespacedReplicaSet({
- path: { namespace: ns, name },
- query: {},
- })
-
- // Update the replicas
- if (replicaSet.spec) {
- replicaSet.spec.replicas = replicas
- }
-
- // Update the replicaset
- const result = await client.replaceAppsV1NamespacedReplicaSet({
- path: { namespace: ns, name },
- query: {},
- body: replicaSet,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...REPLICASETS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useReplaceAppsV1NamespacedReplicaSetScale()
+ return {
+ ...base,
+ mutate: (
+ { name, replicas, namespace }: { name: string; replicas: number; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ {
+ path: { namespace: namespace || defaultNamespace, name },
+ body: {
+ apiVersion: 'autoscaling/v1',
+ kind: 'Scale',
+ metadata: { name, namespace: namespace || defaultNamespace },
+ spec: { replicas },
+ } as Scale,
+ },
+ opts
+ ),
+ mutateAsync: (
+ { name, replicas, namespace }: { name: string; replicas: number; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ {
+ path: { namespace: namespace || defaultNamespace, name },
+ body: {
+ apiVersion: 'autoscaling/v1',
+ kind: 'Scale',
+ metadata: { name, namespace: namespace || defaultNamespace },
+ spec: { replicas },
+ } as Scale,
+ },
+ opts
+ ),
+ }
}
diff --git a/ui/hooks/useSecrets.ts b/ui/hooks/useSecrets.ts
index 2cca9ee..3047afe 100644
--- a/ui/hooks/useSecrets.ts
+++ b/ui/hooks/useSecrets.ts
@@ -1,111 +1,102 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useKubernetes } from '../contexts/KubernetesContext'
+import {
+ useListCoreV1SecretForAllNamespacesQuery,
+ useListCoreV1NamespacedSecretQuery,
+ useReadCoreV1NamespacedSecretQuery,
+ useCreateCoreV1NamespacedSecret,
+ useReplaceCoreV1NamespacedSecret,
+ useDeleteCoreV1NamespacedSecret,
+} from '../k8s/index'
+import { usePreferredNamespace } from '../contexts/NamespaceContext'
import type { Secret, SecretList } from 'kubernetesjs'
// Query keys
const SECRETS_KEY = ['secrets'] as const
export function useSecrets(namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...SECRETS_KEY, ns],
- queryFn: async () => {
- if (ns === '_all') {
- const result = await client.listCoreV1SecretForAllNamespaces({
- query: {},
- })
- return result
- } else {
- const result = await client.listCoreV1NamespacedSecret({
- path: { namespace: ns },
- query: {},
- })
- return result
- }
- },
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ if (ns === '_all') {
+ return useListCoreV1SecretForAllNamespacesQuery({ path: {}, query: {} })
+ }
+ return useListCoreV1NamespacedSecretQuery({ path: { namespace: ns }, query: {} })
}
export function useSecret(name: string, namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...SECRETS_KEY, ns, name],
- queryFn: async () => {
- const result = await client.readCoreV1NamespacedSecret({
- path: { namespace: ns, name },
- query: {},
- })
- return result
- },
- enabled: !!name,
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ return useReadCoreV1NamespacedSecretQuery({ path: { namespace: ns, name }, query: {} })
}
export function useCreateSecret() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ secret, namespace }) => {
- const ns = namespace || defaultNamespace
- const result = await client.createCoreV1NamespacedSecret({
- path: { namespace: ns },
- query: {},
- body: secret,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...SECRETS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useCreateCoreV1NamespacedSecret()
+ return {
+ ...base,
+ mutate: (
+ { secret, namespace }: { secret: Secret; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace }, query: {}, body: secret },
+ opts
+ ),
+ mutateAsync: (
+ { secret, namespace }: { secret: Secret; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace }, query: {}, body: secret },
+ opts
+ ),
+ }
}
export function useUpdateSecret() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, secret, namespace }) => {
- const ns = namespace || defaultNamespace
- const result = await client.replaceCoreV1NamespacedSecret({
- path: { namespace: ns, name },
- query: {},
- body: secret,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...SECRETS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useReplaceCoreV1NamespacedSecret()
+ return {
+ ...base,
+ mutate: (
+ { name, secret, namespace }: { name: string; secret: Secret; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {}, body: secret },
+ opts
+ ),
+ mutateAsync: (
+ { name, secret, namespace }: { name: string; secret: Secret; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {}, body: secret },
+ opts
+ ),
+ }
}
export function useDeleteSecret() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, namespace }) => {
- const ns = namespace || defaultNamespace
- await client.deleteCoreV1NamespacedSecret({
- path: { namespace: ns, name },
- query: {},
- })
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...SECRETS_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useDeleteCoreV1NamespacedSecret()
+ return {
+ ...base,
+ mutate: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ mutateAsync: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ }
}
\ No newline at end of file
diff --git a/ui/hooks/useServices.ts b/ui/hooks/useServices.ts
index a7be032..bea18bb 100644
--- a/ui/hooks/useServices.ts
+++ b/ui/hooks/useServices.ts
@@ -1,111 +1,102 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useKubernetes } from '../contexts/KubernetesContext'
+import {
+ useListCoreV1ServiceForAllNamespacesQuery,
+ useListCoreV1NamespacedServiceQuery,
+ useReadCoreV1NamespacedServiceQuery,
+ useCreateCoreV1NamespacedService,
+ useReplaceCoreV1NamespacedService,
+ useDeleteCoreV1NamespacedService,
+} from '../k8s/index'
+import { usePreferredNamespace } from '../contexts/NamespaceContext'
import type { Service, ServiceList } from 'kubernetesjs'
// Query keys
const SERVICES_KEY = ['services'] as const
export function useServices(namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...SERVICES_KEY, ns],
- queryFn: async () => {
- if (ns === '_all') {
- const result = await client.listCoreV1ServiceForAllNamespaces({
- query: {},
- })
- return result
- } else {
- const result = await client.listCoreV1NamespacedService({
- path: { namespace: ns },
- query: {},
- })
- return result
- }
- },
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ if (ns === '_all') {
+ return useListCoreV1ServiceForAllNamespacesQuery({ path: {}, query: {} })
+ }
+ return useListCoreV1NamespacedServiceQuery({ path: { namespace: ns }, query: {} })
}
export function useService(name: string, namespace?: string) {
- const { client, namespace: defaultNamespace } = useKubernetes()
+ const { namespace: defaultNamespace } = usePreferredNamespace()
const ns = namespace || defaultNamespace
- return useQuery({
- queryKey: [...SERVICES_KEY, ns, name],
- queryFn: async () => {
- const result = await client.readCoreV1NamespacedService({
- path: { namespace: ns, name },
- query: {},
- })
- return result
- },
- enabled: !!name,
- refetchOnMount: 'always',
- staleTime: 0,
- })
+ return useReadCoreV1NamespacedServiceQuery({ path: { namespace: ns, name }, query: {} })
}
export function useCreateService() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ service, namespace }) => {
- const ns = namespace || defaultNamespace
- const result = await client.createCoreV1NamespacedService({
- path: { namespace: ns },
- query: {},
- body: service,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...SERVICES_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useCreateCoreV1NamespacedService()
+ return {
+ ...base,
+ mutate: (
+ { service, namespace }: { service: Service; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace }, query: {}, body: service },
+ opts
+ ),
+ mutateAsync: (
+ { service, namespace }: { service: Service; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace }, query: {}, body: service },
+ opts
+ ),
+ }
}
export function useUpdateService() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, service, namespace }) => {
- const ns = namespace || defaultNamespace
- const result = await client.replaceCoreV1NamespacedService({
- path: { namespace: ns, name },
- query: {},
- body: service,
- })
- return result
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...SERVICES_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useReplaceCoreV1NamespacedService()
+ return {
+ ...base,
+ mutate: (
+ { name, service, namespace }: { name: string; service: Service; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {}, body: service },
+ opts
+ ),
+ mutateAsync: (
+ { name, service, namespace }: { name: string; service: Service; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {}, body: service },
+ opts
+ ),
+ }
}
export function useDeleteService() {
- const { client, namespace: defaultNamespace } = useKubernetes()
- const queryClient = useQueryClient()
-
- return useMutation({
- mutationFn: async ({ name, namespace }) => {
- const ns = namespace || defaultNamespace
- await client.deleteCoreV1NamespacedService({
- path: { namespace: ns, name },
- query: {},
- })
- },
- onSuccess: (_, variables) => {
- const ns = variables.namespace || defaultNamespace
- queryClient.invalidateQueries({ queryKey: [...SERVICES_KEY, ns] })
- },
- })
+ const { namespace: defaultNamespace } = usePreferredNamespace()
+ const base = useDeleteCoreV1NamespacedService()
+ return {
+ ...base,
+ mutate: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutate(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ mutateAsync: (
+ { name, namespace }: { name: string; namespace?: string },
+ opts?: Parameters[1]
+ ) =>
+ base.mutateAsync(
+ { path: { namespace: namespace || defaultNamespace, name }, query: {} },
+ opts
+ ),
+ }
}
\ No newline at end of file
diff --git a/ui/contexts/KubernetesContext.tsx b/ui/k8s/context.tsx
similarity index 72%
rename from ui/contexts/KubernetesContext.tsx
rename to ui/k8s/context.tsx
index 9d7fb9e..d86266d 100644
--- a/ui/contexts/KubernetesContext.tsx
+++ b/ui/k8s/context.tsx
@@ -1,4 +1,3 @@
-'use client'
import React, { createContext, useContext, useMemo, useState } from 'react'
import { KubernetesClient } from 'kubernetesjs'
@@ -7,21 +6,18 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
// Configuration types
export interface KubernetesConfig {
restEndpoint: string
- namespace?: string
headers?: Record
}
// Context types
interface KubernetesContextValue {
- client: KubernetesClient
- config: KubernetesConfig
- namespace: string
- setNamespace: (namespace: string) => void
- updateConfig: (config: Partial) => void
+ client: KubernetesClient;
+ config: KubernetesConfig;
+ updateConfig: (config: Partial) => void;
}
// Create context
-const KubernetesContext = createContext(undefined)
+const KubernetesContext = createContext(undefined);
// Query client for TanStack Query
const queryClient = new QueryClient({
@@ -37,8 +33,8 @@ const queryClient = new QueryClient({
// Provider props
interface KubernetesProviderProps {
- children: React.ReactNode
- initialConfig?: Partial
+ children: React.ReactNode;
+ initialConfig?: Partial;
}
// Provider component
@@ -47,13 +43,10 @@ export function KubernetesProvider({
initialConfig
}: KubernetesProviderProps) {
const [config, setConfig] = useState({
- restEndpoint: initialConfig?.restEndpoint || process.env.NEXT_PUBLIC_K8S_API_URL || '/api/k8s',
- namespace: initialConfig?.namespace || 'default',
+ restEndpoint: initialConfig?.restEndpoint,
headers: initialConfig?.headers || {},
})
- const [namespace, setNamespace] = useState(config.namespace || 'default')
-
// Create client instance
const client = useMemo(() => {
return new KubernetesClient({
@@ -64,16 +57,11 @@ export function KubernetesProvider({
// Update config function
const updateConfig = (newConfig: Partial) => {
setConfig(prev => ({ ...prev, ...newConfig }))
- if (newConfig.namespace) {
- setNamespace(newConfig.namespace)
- }
}
const contextValue: KubernetesContextValue = {
client,
config,
- namespace,
- setNamespace,
updateConfig,
}
@@ -87,7 +75,7 @@ export function KubernetesProvider({
}
// Hook to use Kubernetes context
-export function useKubernetes() {
+export function useKubernetes(): KubernetesContextValue {
const context = useContext(KubernetesContext)
if (!context) {
throw new Error('useKubernetes must be used within a KubernetesProvider')
@@ -96,4 +84,4 @@ export function useKubernetes() {
}
// Export query client for use in hooks
-export { queryClient }
\ No newline at end of file
+export { queryClient }
diff --git a/ui/k8s/index.ts b/ui/k8s/index.ts
new file mode 100644
index 0000000..6464db5
--- /dev/null
+++ b/ui/k8s/index.ts
@@ -0,0 +1,8076 @@
+import { useKubernetes } from "./context";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { GetServiceAccountIssuerOpenIDConfigurationRequest, APIVersions, GetCoreAPIVersionsRequest, APIResourceList, GetCoreV1APIResourcesRequest, ComponentStatusList, ListCoreV1ComponentStatusRequest, ComponentStatus, ReadCoreV1ComponentStatusRequest, ConfigMapList, ListCoreV1ConfigMapForAllNamespacesRequest, EndpointsList, ListCoreV1EndpointsForAllNamespacesRequest, EventList, ListCoreV1EventForAllNamespacesRequest, LimitRangeList, ListCoreV1LimitRangeForAllNamespacesRequest, NamespaceList, ListCoreV1NamespaceRequest, Namespace, CreateCoreV1NamespaceRequest, Binding, CreateCoreV1NamespacedBindingRequest, ListCoreV1NamespacedConfigMapRequest, ConfigMap, CreateCoreV1NamespacedConfigMapRequest, Status, DeleteCoreV1CollectionNamespacedConfigMapRequest, ReadCoreV1NamespacedConfigMapRequest, ReplaceCoreV1NamespacedConfigMapRequest, DeleteCoreV1NamespacedConfigMapRequest, PatchCoreV1NamespacedConfigMapRequest, ListCoreV1NamespacedEndpointsRequest, Endpoints, CreateCoreV1NamespacedEndpointsRequest, DeleteCoreV1CollectionNamespacedEndpointsRequest, ReadCoreV1NamespacedEndpointsRequest, ReplaceCoreV1NamespacedEndpointsRequest, DeleteCoreV1NamespacedEndpointsRequest, PatchCoreV1NamespacedEndpointsRequest, ListCoreV1NamespacedEventRequest, Event, CreateCoreV1NamespacedEventRequest, DeleteCoreV1CollectionNamespacedEventRequest, ReadCoreV1NamespacedEventRequest, ReplaceCoreV1NamespacedEventRequest, DeleteCoreV1NamespacedEventRequest, PatchCoreV1NamespacedEventRequest, ListCoreV1NamespacedLimitRangeRequest, LimitRange, CreateCoreV1NamespacedLimitRangeRequest, DeleteCoreV1CollectionNamespacedLimitRangeRequest, ReadCoreV1NamespacedLimitRangeRequest, ReplaceCoreV1NamespacedLimitRangeRequest, DeleteCoreV1NamespacedLimitRangeRequest, PatchCoreV1NamespacedLimitRangeRequest, PersistentVolumeClaimList, ListCoreV1NamespacedPersistentVolumeClaimRequest, PersistentVolumeClaim, CreateCoreV1NamespacedPersistentVolumeClaimRequest, DeleteCoreV1CollectionNamespacedPersistentVolumeClaimRequest, ReadCoreV1NamespacedPersistentVolumeClaimRequest, ReplaceCoreV1NamespacedPersistentVolumeClaimRequest, DeleteCoreV1NamespacedPersistentVolumeClaimRequest, PatchCoreV1NamespacedPersistentVolumeClaimRequest, ReadCoreV1NamespacedPersistentVolumeClaimStatusRequest, ReplaceCoreV1NamespacedPersistentVolumeClaimStatusRequest, PatchCoreV1NamespacedPersistentVolumeClaimStatusRequest, PodList, ListCoreV1NamespacedPodRequest, Pod, CreateCoreV1NamespacedPodRequest, DeleteCoreV1CollectionNamespacedPodRequest, ReadCoreV1NamespacedPodRequest, ReplaceCoreV1NamespacedPodRequest, DeleteCoreV1NamespacedPodRequest, PatchCoreV1NamespacedPodRequest, ConnectCoreV1GetNamespacedPodAttachRequest, ConnectCoreV1PostNamespacedPodAttachRequest, CreateCoreV1NamespacedPodBindingRequest, Eviction, CreateCoreV1NamespacedPodEvictionRequest, ConnectCoreV1GetNamespacedPodExecRequest, ConnectCoreV1PostNamespacedPodExecRequest, ReadCoreV1NamespacedPodLogRequest, ConnectCoreV1GetNamespacedPodPortforwardRequest, ConnectCoreV1PostNamespacedPodPortforwardRequest, ConnectCoreV1GetNamespacedPodProxyRequest, ConnectCoreV1PostNamespacedPodProxyRequest, ConnectCoreV1PutNamespacedPodProxyRequest, ConnectCoreV1DeleteNamespacedPodProxyRequest, ConnectCoreV1PatchNamespacedPodProxyRequest, ConnectCoreV1GetNamespacedPodProxyWithPathRequest, ConnectCoreV1PostNamespacedPodProxyWithPathRequest, ConnectCoreV1PutNamespacedPodProxyWithPathRequest, ConnectCoreV1DeleteNamespacedPodProxyWithPathRequest, ConnectCoreV1PatchNamespacedPodProxyWithPathRequest, ReadCoreV1NamespacedPodStatusRequest, ReplaceCoreV1NamespacedPodStatusRequest, PatchCoreV1NamespacedPodStatusRequest, PodTemplateList, ListCoreV1NamespacedPodTemplateRequest, PodTemplate, CreateCoreV1NamespacedPodTemplateRequest, DeleteCoreV1CollectionNamespacedPodTemplateRequest, ReadCoreV1NamespacedPodTemplateRequest, ReplaceCoreV1NamespacedPodTemplateRequest, DeleteCoreV1NamespacedPodTemplateRequest, PatchCoreV1NamespacedPodTemplateRequest, ReplicationControllerList, ListCoreV1NamespacedReplicationControllerRequest, ReplicationController, CreateCoreV1NamespacedReplicationControllerRequest, DeleteCoreV1CollectionNamespacedReplicationControllerRequest, ReadCoreV1NamespacedReplicationControllerRequest, ReplaceCoreV1NamespacedReplicationControllerRequest, DeleteCoreV1NamespacedReplicationControllerRequest, PatchCoreV1NamespacedReplicationControllerRequest, Scale, ReadCoreV1NamespacedReplicationControllerScaleRequest, ReplaceCoreV1NamespacedReplicationControllerScaleRequest, PatchCoreV1NamespacedReplicationControllerScaleRequest, ReadCoreV1NamespacedReplicationControllerStatusRequest, ReplaceCoreV1NamespacedReplicationControllerStatusRequest, PatchCoreV1NamespacedReplicationControllerStatusRequest, ResourceQuotaList, ListCoreV1NamespacedResourceQuotaRequest, ResourceQuota, CreateCoreV1NamespacedResourceQuotaRequest, DeleteCoreV1CollectionNamespacedResourceQuotaRequest, ReadCoreV1NamespacedResourceQuotaRequest, ReplaceCoreV1NamespacedResourceQuotaRequest, DeleteCoreV1NamespacedResourceQuotaRequest, PatchCoreV1NamespacedResourceQuotaRequest, ReadCoreV1NamespacedResourceQuotaStatusRequest, ReplaceCoreV1NamespacedResourceQuotaStatusRequest, PatchCoreV1NamespacedResourceQuotaStatusRequest, SecretList, ListCoreV1NamespacedSecretRequest, Secret, CreateCoreV1NamespacedSecretRequest, DeleteCoreV1CollectionNamespacedSecretRequest, ReadCoreV1NamespacedSecretRequest, ReplaceCoreV1NamespacedSecretRequest, DeleteCoreV1NamespacedSecretRequest, PatchCoreV1NamespacedSecretRequest, ServiceAccountList, ListCoreV1NamespacedServiceAccountRequest, ServiceAccount, CreateCoreV1NamespacedServiceAccountRequest, DeleteCoreV1CollectionNamespacedServiceAccountRequest, ReadCoreV1NamespacedServiceAccountRequest, ReplaceCoreV1NamespacedServiceAccountRequest, DeleteCoreV1NamespacedServiceAccountRequest, PatchCoreV1NamespacedServiceAccountRequest, TokenRequest, CreateCoreV1NamespacedServiceAccountTokenRequest, ServiceList, ListCoreV1NamespacedServiceRequest, Service, CreateCoreV1NamespacedServiceRequest, ReadCoreV1NamespacedServiceRequest, ReplaceCoreV1NamespacedServiceRequest, DeleteCoreV1NamespacedServiceRequest, PatchCoreV1NamespacedServiceRequest, ConnectCoreV1GetNamespacedServiceProxyRequest, ConnectCoreV1PostNamespacedServiceProxyRequest, ConnectCoreV1PutNamespacedServiceProxyRequest, ConnectCoreV1DeleteNamespacedServiceProxyRequest, ConnectCoreV1PatchNamespacedServiceProxyRequest, ConnectCoreV1GetNamespacedServiceProxyWithPathRequest, ConnectCoreV1PostNamespacedServiceProxyWithPathRequest, ConnectCoreV1PutNamespacedServiceProxyWithPathRequest, ConnectCoreV1DeleteNamespacedServiceProxyWithPathRequest, ConnectCoreV1PatchNamespacedServiceProxyWithPathRequest, ReadCoreV1NamespacedServiceStatusRequest, ReplaceCoreV1NamespacedServiceStatusRequest, PatchCoreV1NamespacedServiceStatusRequest, ReadCoreV1NamespaceRequest, ReplaceCoreV1NamespaceRequest, DeleteCoreV1NamespaceRequest, PatchCoreV1NamespaceRequest, ReplaceCoreV1NamespaceFinalizeRequest, ReadCoreV1NamespaceStatusRequest, ReplaceCoreV1NamespaceStatusRequest, PatchCoreV1NamespaceStatusRequest, NodeList, ListCoreV1NodeRequest, Node, CreateCoreV1NodeRequest, DeleteCoreV1CollectionNodeRequest, ReadCoreV1NodeRequest, ReplaceCoreV1NodeRequest, DeleteCoreV1NodeRequest, PatchCoreV1NodeRequest, ConnectCoreV1GetNodeProxyRequest, ConnectCoreV1PostNodeProxyRequest, ConnectCoreV1PutNodeProxyRequest, ConnectCoreV1DeleteNodeProxyRequest, ConnectCoreV1PatchNodeProxyRequest, ConnectCoreV1GetNodeProxyWithPathRequest, ConnectCoreV1PostNodeProxyWithPathRequest, ConnectCoreV1PutNodeProxyWithPathRequest, ConnectCoreV1DeleteNodeProxyWithPathRequest, ConnectCoreV1PatchNodeProxyWithPathRequest, ReadCoreV1NodeStatusRequest, ReplaceCoreV1NodeStatusRequest, PatchCoreV1NodeStatusRequest, ListCoreV1PersistentVolumeClaimForAllNamespacesRequest, PersistentVolumeList, ListCoreV1PersistentVolumeRequest, PersistentVolume, CreateCoreV1PersistentVolumeRequest, DeleteCoreV1CollectionPersistentVolumeRequest, ReadCoreV1PersistentVolumeRequest, ReplaceCoreV1PersistentVolumeRequest, DeleteCoreV1PersistentVolumeRequest, PatchCoreV1PersistentVolumeRequest, ReadCoreV1PersistentVolumeStatusRequest, ReplaceCoreV1PersistentVolumeStatusRequest, PatchCoreV1PersistentVolumeStatusRequest, ListCoreV1PodForAllNamespacesRequest, ListCoreV1PodTemplateForAllNamespacesRequest, ListCoreV1ReplicationControllerForAllNamespacesRequest, ListCoreV1ResourceQuotaForAllNamespacesRequest, ListCoreV1SecretForAllNamespacesRequest, ListCoreV1ServiceAccountForAllNamespacesRequest, ListCoreV1ServiceForAllNamespacesRequest, WatchEvent, WatchCoreV1ConfigMapListForAllNamespacesRequest, WatchCoreV1EndpointsListForAllNamespacesRequest, WatchCoreV1EventListForAllNamespacesRequest, WatchCoreV1LimitRangeListForAllNamespacesRequest, WatchCoreV1NamespaceListRequest, WatchCoreV1NamespacedConfigMapListRequest, WatchCoreV1NamespacedConfigMapRequest, WatchCoreV1NamespacedEndpointsListRequest, WatchCoreV1NamespacedEndpointsRequest, WatchCoreV1NamespacedEventListRequest, WatchCoreV1NamespacedEventRequest, WatchCoreV1NamespacedLimitRangeListRequest, WatchCoreV1NamespacedLimitRangeRequest, WatchCoreV1NamespacedPersistentVolumeClaimListRequest, WatchCoreV1NamespacedPersistentVolumeClaimRequest, WatchCoreV1NamespacedPodListRequest, WatchCoreV1NamespacedPodRequest, WatchCoreV1NamespacedPodTemplateListRequest, WatchCoreV1NamespacedPodTemplateRequest, WatchCoreV1NamespacedReplicationControllerListRequest, WatchCoreV1NamespacedReplicationControllerRequest, WatchCoreV1NamespacedResourceQuotaListRequest, WatchCoreV1NamespacedResourceQuotaRequest, WatchCoreV1NamespacedSecretListRequest, WatchCoreV1NamespacedSecretRequest, WatchCoreV1NamespacedServiceAccountListRequest, WatchCoreV1NamespacedServiceAccountRequest, WatchCoreV1NamespacedServiceListRequest, WatchCoreV1NamespacedServiceRequest, WatchCoreV1NamespaceRequest, WatchCoreV1NodeListRequest, WatchCoreV1NodeRequest, WatchCoreV1PersistentVolumeClaimListForAllNamespacesRequest, WatchCoreV1PersistentVolumeListRequest, WatchCoreV1PersistentVolumeRequest, WatchCoreV1PodListForAllNamespacesRequest, WatchCoreV1PodTemplateListForAllNamespacesRequest, WatchCoreV1ReplicationControllerListForAllNamespacesRequest, WatchCoreV1ResourceQuotaListForAllNamespacesRequest, WatchCoreV1SecretListForAllNamespacesRequest, WatchCoreV1ServiceAccountListForAllNamespacesRequest, WatchCoreV1ServiceListForAllNamespacesRequest, APIGroupList, GetAPIVersionsRequest, APIGroup, GetAdmissionregistrationAPIGroupRequest, GetAdmissionregistrationV1APIResourcesRequest, MutatingWebhookConfigurationList, ListAdmissionregistrationV1MutatingWebhookConfigurationRequest, MutatingWebhookConfiguration, CreateAdmissionregistrationV1MutatingWebhookConfigurationRequest, DeleteAdmissionregistrationV1CollectionMutatingWebhookConfigurationRequest, ReadAdmissionregistrationV1MutatingWebhookConfigurationRequest, ReplaceAdmissionregistrationV1MutatingWebhookConfigurationRequest, DeleteAdmissionregistrationV1MutatingWebhookConfigurationRequest, PatchAdmissionregistrationV1MutatingWebhookConfigurationRequest, ValidatingWebhookConfigurationList, ListAdmissionregistrationV1ValidatingWebhookConfigurationRequest, ValidatingWebhookConfiguration, CreateAdmissionregistrationV1ValidatingWebhookConfigurationRequest, DeleteAdmissionregistrationV1CollectionValidatingWebhookConfigurationRequest, ReadAdmissionregistrationV1ValidatingWebhookConfigurationRequest, ReplaceAdmissionregistrationV1ValidatingWebhookConfigurationRequest, DeleteAdmissionregistrationV1ValidatingWebhookConfigurationRequest, PatchAdmissionregistrationV1ValidatingWebhookConfigurationRequest, WatchAdmissionregistrationV1MutatingWebhookConfigurationListRequest, WatchAdmissionregistrationV1MutatingWebhookConfigurationRequest, WatchAdmissionregistrationV1ValidatingWebhookConfigurationListRequest, WatchAdmissionregistrationV1ValidatingWebhookConfigurationRequest, GetApiextensionsAPIGroupRequest, GetApiextensionsV1APIResourcesRequest, CustomResourceDefinitionList, ListApiextensionsV1CustomResourceDefinitionRequest, CustomResourceDefinition, CreateApiextensionsV1CustomResourceDefinitionRequest, DeleteApiextensionsV1CollectionCustomResourceDefinitionRequest, ReadApiextensionsV1CustomResourceDefinitionRequest, ReplaceApiextensionsV1CustomResourceDefinitionRequest, DeleteApiextensionsV1CustomResourceDefinitionRequest, PatchApiextensionsV1CustomResourceDefinitionRequest, ReadApiextensionsV1CustomResourceDefinitionStatusRequest, ReplaceApiextensionsV1CustomResourceDefinitionStatusRequest, PatchApiextensionsV1CustomResourceDefinitionStatusRequest, WatchApiextensionsV1CustomResourceDefinitionListRequest, WatchApiextensionsV1CustomResourceDefinitionRequest, GetApiregistrationAPIGroupRequest, GetApiregistrationV1APIResourcesRequest, APIServiceList, ListApiregistrationV1APIServiceRequest, APIService, CreateApiregistrationV1APIServiceRequest, DeleteApiregistrationV1CollectionAPIServiceRequest, ReadApiregistrationV1APIServiceRequest, ReplaceApiregistrationV1APIServiceRequest, DeleteApiregistrationV1APIServiceRequest, PatchApiregistrationV1APIServiceRequest, ReadApiregistrationV1APIServiceStatusRequest, ReplaceApiregistrationV1APIServiceStatusRequest, PatchApiregistrationV1APIServiceStatusRequest, WatchApiregistrationV1APIServiceListRequest, WatchApiregistrationV1APIServiceRequest, GetAppsAPIGroupRequest, GetAppsV1APIResourcesRequest, ControllerRevisionList, ListAppsV1ControllerRevisionForAllNamespacesRequest, DaemonSetList, ListAppsV1DaemonSetForAllNamespacesRequest, DeploymentList, ListAppsV1DeploymentForAllNamespacesRequest, ListAppsV1NamespacedControllerRevisionRequest, ControllerRevision, CreateAppsV1NamespacedControllerRevisionRequest, DeleteAppsV1CollectionNamespacedControllerRevisionRequest, ReadAppsV1NamespacedControllerRevisionRequest, ReplaceAppsV1NamespacedControllerRevisionRequest, DeleteAppsV1NamespacedControllerRevisionRequest, PatchAppsV1NamespacedControllerRevisionRequest, ListAppsV1NamespacedDaemonSetRequest, DaemonSet, CreateAppsV1NamespacedDaemonSetRequest, DeleteAppsV1CollectionNamespacedDaemonSetRequest, ReadAppsV1NamespacedDaemonSetRequest, ReplaceAppsV1NamespacedDaemonSetRequest, DeleteAppsV1NamespacedDaemonSetRequest, PatchAppsV1NamespacedDaemonSetRequest, ReadAppsV1NamespacedDaemonSetStatusRequest, ReplaceAppsV1NamespacedDaemonSetStatusRequest, PatchAppsV1NamespacedDaemonSetStatusRequest, ListAppsV1NamespacedDeploymentRequest, Deployment, CreateAppsV1NamespacedDeploymentRequest, DeleteAppsV1CollectionNamespacedDeploymentRequest, ReadAppsV1NamespacedDeploymentRequest, ReplaceAppsV1NamespacedDeploymentRequest, DeleteAppsV1NamespacedDeploymentRequest, PatchAppsV1NamespacedDeploymentRequest, ReadAppsV1NamespacedDeploymentScaleRequest, ReplaceAppsV1NamespacedDeploymentScaleRequest, PatchAppsV1NamespacedDeploymentScaleRequest, ReadAppsV1NamespacedDeploymentStatusRequest, ReplaceAppsV1NamespacedDeploymentStatusRequest, PatchAppsV1NamespacedDeploymentStatusRequest, ReplicaSetList, ListAppsV1NamespacedReplicaSetRequest, ReplicaSet, CreateAppsV1NamespacedReplicaSetRequest, DeleteAppsV1CollectionNamespacedReplicaSetRequest, ReadAppsV1NamespacedReplicaSetRequest, ReplaceAppsV1NamespacedReplicaSetRequest, DeleteAppsV1NamespacedReplicaSetRequest, PatchAppsV1NamespacedReplicaSetRequest, ReadAppsV1NamespacedReplicaSetScaleRequest, ReplaceAppsV1NamespacedReplicaSetScaleRequest, PatchAppsV1NamespacedReplicaSetScaleRequest, ReadAppsV1NamespacedReplicaSetStatusRequest, ReplaceAppsV1NamespacedReplicaSetStatusRequest, PatchAppsV1NamespacedReplicaSetStatusRequest, StatefulSetList, ListAppsV1NamespacedStatefulSetRequest, StatefulSet, CreateAppsV1NamespacedStatefulSetRequest, DeleteAppsV1CollectionNamespacedStatefulSetRequest, ReadAppsV1NamespacedStatefulSetRequest, ReplaceAppsV1NamespacedStatefulSetRequest, DeleteAppsV1NamespacedStatefulSetRequest, PatchAppsV1NamespacedStatefulSetRequest, ReadAppsV1NamespacedStatefulSetScaleRequest, ReplaceAppsV1NamespacedStatefulSetScaleRequest, PatchAppsV1NamespacedStatefulSetScaleRequest, ReadAppsV1NamespacedStatefulSetStatusRequest, ReplaceAppsV1NamespacedStatefulSetStatusRequest, PatchAppsV1NamespacedStatefulSetStatusRequest, ListAppsV1ReplicaSetForAllNamespacesRequest, ListAppsV1StatefulSetForAllNamespacesRequest, WatchAppsV1ControllerRevisionListForAllNamespacesRequest, WatchAppsV1DaemonSetListForAllNamespacesRequest, WatchAppsV1DeploymentListForAllNamespacesRequest, WatchAppsV1NamespacedControllerRevisionListRequest, WatchAppsV1NamespacedControllerRevisionRequest, WatchAppsV1NamespacedDaemonSetListRequest, WatchAppsV1NamespacedDaemonSetRequest, WatchAppsV1NamespacedDeploymentListRequest, WatchAppsV1NamespacedDeploymentRequest, WatchAppsV1NamespacedReplicaSetListRequest, WatchAppsV1NamespacedReplicaSetRequest, WatchAppsV1NamespacedStatefulSetListRequest, WatchAppsV1NamespacedStatefulSetRequest, WatchAppsV1ReplicaSetListForAllNamespacesRequest, WatchAppsV1StatefulSetListForAllNamespacesRequest, GetAuthenticationAPIGroupRequest, GetAuthenticationV1APIResourcesRequest, TokenReview, CreateAuthenticationV1TokenReviewRequest, GetAuthorizationAPIGroupRequest, GetAuthorizationV1APIResourcesRequest, LocalSubjectAccessReview, CreateAuthorizationV1NamespacedLocalSubjectAccessReviewRequest, SelfSubjectAccessReview, CreateAuthorizationV1SelfSubjectAccessReviewRequest, SelfSubjectRulesReview, CreateAuthorizationV1SelfSubjectRulesReviewRequest, SubjectAccessReview, CreateAuthorizationV1SubjectAccessReviewRequest, GetAutoscalingAPIGroupRequest, GetAutoscalingV1APIResourcesRequest, HorizontalPodAutoscalerList, ListAutoscalingV1HorizontalPodAutoscalerForAllNamespacesRequest, ListAutoscalingV1NamespacedHorizontalPodAutoscalerRequest, HorizontalPodAutoscaler, CreateAutoscalingV1NamespacedHorizontalPodAutoscalerRequest, DeleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscalerRequest, ReadAutoscalingV1NamespacedHorizontalPodAutoscalerRequest, ReplaceAutoscalingV1NamespacedHorizontalPodAutoscalerRequest, DeleteAutoscalingV1NamespacedHorizontalPodAutoscalerRequest, PatchAutoscalingV1NamespacedHorizontalPodAutoscalerRequest, ReadAutoscalingV1NamespacedHorizontalPodAutoscalerStatusRequest, ReplaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatusRequest, PatchAutoscalingV1NamespacedHorizontalPodAutoscalerStatusRequest, WatchAutoscalingV1HorizontalPodAutoscalerListForAllNamespacesRequest, WatchAutoscalingV1NamespacedHorizontalPodAutoscalerListRequest, WatchAutoscalingV1NamespacedHorizontalPodAutoscalerRequest, GetAutoscalingV2beta2APIResourcesRequest, ListAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespacesRequest, ListAutoscalingV2beta2NamespacedHorizontalPodAutoscalerRequest, CreateAutoscalingV2beta2NamespacedHorizontalPodAutoscalerRequest, DeleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscalerRequest, ReadAutoscalingV2beta2NamespacedHorizontalPodAutoscalerRequest, ReplaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerRequest, DeleteAutoscalingV2beta2NamespacedHorizontalPodAutoscalerRequest, PatchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerRequest, ReadAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatusRequest, ReplaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatusRequest, PatchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatusRequest, WatchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespacesRequest, WatchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerListRequest, WatchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerRequest, GetBatchAPIGroupRequest, GetBatchV1APIResourcesRequest, CronJobList, ListBatchV1CronJobForAllNamespacesRequest, JobList, ListBatchV1JobForAllNamespacesRequest, ListBatchV1NamespacedCronJobRequest, CronJob, CreateBatchV1NamespacedCronJobRequest, DeleteBatchV1CollectionNamespacedCronJobRequest, ReadBatchV1NamespacedCronJobRequest, ReplaceBatchV1NamespacedCronJobRequest, DeleteBatchV1NamespacedCronJobRequest, PatchBatchV1NamespacedCronJobRequest, ReadBatchV1NamespacedCronJobStatusRequest, ReplaceBatchV1NamespacedCronJobStatusRequest, PatchBatchV1NamespacedCronJobStatusRequest, ListBatchV1NamespacedJobRequest, Job, CreateBatchV1NamespacedJobRequest, DeleteBatchV1CollectionNamespacedJobRequest, ReadBatchV1NamespacedJobRequest, ReplaceBatchV1NamespacedJobRequest, DeleteBatchV1NamespacedJobRequest, PatchBatchV1NamespacedJobRequest, ReadBatchV1NamespacedJobStatusRequest, ReplaceBatchV1NamespacedJobStatusRequest, PatchBatchV1NamespacedJobStatusRequest, WatchBatchV1CronJobListForAllNamespacesRequest, WatchBatchV1JobListForAllNamespacesRequest, WatchBatchV1NamespacedCronJobListRequest, WatchBatchV1NamespacedCronJobRequest, WatchBatchV1NamespacedJobListRequest, WatchBatchV1NamespacedJobRequest, GetCertificatesAPIGroupRequest, GetCertificatesV1APIResourcesRequest, CertificateSigningRequestList, ListCertificatesV1CertificateSigningRequestRequest, CertificateSigningRequest, CreateCertificatesV1CertificateSigningRequestRequest, DeleteCertificatesV1CollectionCertificateSigningRequestRequest, ReadCertificatesV1CertificateSigningRequestRequest, ReplaceCertificatesV1CertificateSigningRequestRequest, DeleteCertificatesV1CertificateSigningRequestRequest, PatchCertificatesV1CertificateSigningRequestRequest, ReadCertificatesV1CertificateSigningRequestApprovalRequest, ReplaceCertificatesV1CertificateSigningRequestApprovalRequest, PatchCertificatesV1CertificateSigningRequestApprovalRequest, ReadCertificatesV1CertificateSigningRequestStatusRequest, ReplaceCertificatesV1CertificateSigningRequestStatusRequest, PatchCertificatesV1CertificateSigningRequestStatusRequest, WatchCertificatesV1CertificateSigningRequestListRequest, WatchCertificatesV1CertificateSigningRequestRequest, GetCoordinationAPIGroupRequest, GetCoordinationV1APIResourcesRequest, LeaseList, ListCoordinationV1LeaseForAllNamespacesRequest, ListCoordinationV1NamespacedLeaseRequest, Lease, CreateCoordinationV1NamespacedLeaseRequest, DeleteCoordinationV1CollectionNamespacedLeaseRequest, ReadCoordinationV1NamespacedLeaseRequest, ReplaceCoordinationV1NamespacedLeaseRequest, DeleteCoordinationV1NamespacedLeaseRequest, PatchCoordinationV1NamespacedLeaseRequest, WatchCoordinationV1LeaseListForAllNamespacesRequest, WatchCoordinationV1NamespacedLeaseListRequest, WatchCoordinationV1NamespacedLeaseRequest, GetDiscoveryAPIGroupRequest, GetDiscoveryV1APIResourcesRequest, EndpointSliceList, ListDiscoveryV1EndpointSliceForAllNamespacesRequest, ListDiscoveryV1NamespacedEndpointSliceRequest, EndpointSlice, CreateDiscoveryV1NamespacedEndpointSliceRequest, DeleteDiscoveryV1CollectionNamespacedEndpointSliceRequest, ReadDiscoveryV1NamespacedEndpointSliceRequest, ReplaceDiscoveryV1NamespacedEndpointSliceRequest, DeleteDiscoveryV1NamespacedEndpointSliceRequest, PatchDiscoveryV1NamespacedEndpointSliceRequest, WatchDiscoveryV1EndpointSliceListForAllNamespacesRequest, WatchDiscoveryV1NamespacedEndpointSliceListRequest, WatchDiscoveryV1NamespacedEndpointSliceRequest, GetEventsAPIGroupRequest, GetEventsV1APIResourcesRequest, ListEventsV1EventForAllNamespacesRequest, ListEventsV1NamespacedEventRequest, CreateEventsV1NamespacedEventRequest, DeleteEventsV1CollectionNamespacedEventRequest, ReadEventsV1NamespacedEventRequest, ReplaceEventsV1NamespacedEventRequest, DeleteEventsV1NamespacedEventRequest, PatchEventsV1NamespacedEventRequest, WatchEventsV1EventListForAllNamespacesRequest, WatchEventsV1NamespacedEventListRequest, WatchEventsV1NamespacedEventRequest, GetFlowcontrolApiserverAPIGroupRequest, GetNetworkingAPIGroupRequest, GetNetworkingV1APIResourcesRequest, IngressClassList, ListNetworkingV1IngressClassRequest, IngressClass, CreateNetworkingV1IngressClassRequest, DeleteNetworkingV1CollectionIngressClassRequest, ReadNetworkingV1IngressClassRequest, ReplaceNetworkingV1IngressClassRequest, DeleteNetworkingV1IngressClassRequest, PatchNetworkingV1IngressClassRequest, IngressList, ListNetworkingV1IngressForAllNamespacesRequest, ListNetworkingV1NamespacedIngressRequest, Ingress, CreateNetworkingV1NamespacedIngressRequest, DeleteNetworkingV1CollectionNamespacedIngressRequest, ReadNetworkingV1NamespacedIngressRequest, ReplaceNetworkingV1NamespacedIngressRequest, DeleteNetworkingV1NamespacedIngressRequest, PatchNetworkingV1NamespacedIngressRequest, ReadNetworkingV1NamespacedIngressStatusRequest, ReplaceNetworkingV1NamespacedIngressStatusRequest, PatchNetworkingV1NamespacedIngressStatusRequest, NetworkPolicyList, ListNetworkingV1NamespacedNetworkPolicyRequest, NetworkPolicy, CreateNetworkingV1NamespacedNetworkPolicyRequest, DeleteNetworkingV1CollectionNamespacedNetworkPolicyRequest, ReadNetworkingV1NamespacedNetworkPolicyRequest, ReplaceNetworkingV1NamespacedNetworkPolicyRequest, DeleteNetworkingV1NamespacedNetworkPolicyRequest, PatchNetworkingV1NamespacedNetworkPolicyRequest, ListNetworkingV1NetworkPolicyForAllNamespacesRequest, WatchNetworkingV1IngressClassListRequest, WatchNetworkingV1IngressClassRequest, WatchNetworkingV1IngressListForAllNamespacesRequest, WatchNetworkingV1NamespacedIngressListRequest, WatchNetworkingV1NamespacedIngressRequest, WatchNetworkingV1NamespacedNetworkPolicyListRequest, WatchNetworkingV1NamespacedNetworkPolicyRequest, WatchNetworkingV1NetworkPolicyListForAllNamespacesRequest, GetNodeAPIGroupRequest, GetNodeV1APIResourcesRequest, RuntimeClassList, ListNodeV1RuntimeClassRequest, RuntimeClass, CreateNodeV1RuntimeClassRequest, DeleteNodeV1CollectionRuntimeClassRequest, ReadNodeV1RuntimeClassRequest, ReplaceNodeV1RuntimeClassRequest, DeleteNodeV1RuntimeClassRequest, PatchNodeV1RuntimeClassRequest, WatchNodeV1RuntimeClassListRequest, WatchNodeV1RuntimeClassRequest, GetPolicyAPIGroupRequest, GetPolicyV1APIResourcesRequest, PodDisruptionBudgetList, ListPolicyV1NamespacedPodDisruptionBudgetRequest, PodDisruptionBudget, CreatePolicyV1NamespacedPodDisruptionBudgetRequest, DeletePolicyV1CollectionNamespacedPodDisruptionBudgetRequest, ReadPolicyV1NamespacedPodDisruptionBudgetRequest, ReplacePolicyV1NamespacedPodDisruptionBudgetRequest, DeletePolicyV1NamespacedPodDisruptionBudgetRequest, PatchPolicyV1NamespacedPodDisruptionBudgetRequest, ReadPolicyV1NamespacedPodDisruptionBudgetStatusRequest, ReplacePolicyV1NamespacedPodDisruptionBudgetStatusRequest, PatchPolicyV1NamespacedPodDisruptionBudgetStatusRequest, ListPolicyV1PodDisruptionBudgetForAllNamespacesRequest, WatchPolicyV1NamespacedPodDisruptionBudgetListRequest, WatchPolicyV1NamespacedPodDisruptionBudgetRequest, WatchPolicyV1PodDisruptionBudgetListForAllNamespacesRequest, GetRbacAuthorizationAPIGroupRequest, GetRbacAuthorizationV1APIResourcesRequest, ClusterRoleBindingList, ListRbacAuthorizationV1ClusterRoleBindingRequest, ClusterRoleBinding, CreateRbacAuthorizationV1ClusterRoleBindingRequest, DeleteRbacAuthorizationV1CollectionClusterRoleBindingRequest, ReadRbacAuthorizationV1ClusterRoleBindingRequest, ReplaceRbacAuthorizationV1ClusterRoleBindingRequest, DeleteRbacAuthorizationV1ClusterRoleBindingRequest, PatchRbacAuthorizationV1ClusterRoleBindingRequest, ClusterRoleList, ListRbacAuthorizationV1ClusterRoleRequest, ClusterRole, CreateRbacAuthorizationV1ClusterRoleRequest, DeleteRbacAuthorizationV1CollectionClusterRoleRequest, ReadRbacAuthorizationV1ClusterRoleRequest, ReplaceRbacAuthorizationV1ClusterRoleRequest, DeleteRbacAuthorizationV1ClusterRoleRequest, PatchRbacAuthorizationV1ClusterRoleRequest, RoleBindingList, ListRbacAuthorizationV1NamespacedRoleBindingRequest, RoleBinding, CreateRbacAuthorizationV1NamespacedRoleBindingRequest, DeleteRbacAuthorizationV1CollectionNamespacedRoleBindingRequest, ReadRbacAuthorizationV1NamespacedRoleBindingRequest, ReplaceRbacAuthorizationV1NamespacedRoleBindingRequest, DeleteRbacAuthorizationV1NamespacedRoleBindingRequest, PatchRbacAuthorizationV1NamespacedRoleBindingRequest, RoleList, ListRbacAuthorizationV1NamespacedRoleRequest, Role, CreateRbacAuthorizationV1NamespacedRoleRequest, DeleteRbacAuthorizationV1CollectionNamespacedRoleRequest, ReadRbacAuthorizationV1NamespacedRoleRequest, ReplaceRbacAuthorizationV1NamespacedRoleRequest, DeleteRbacAuthorizationV1NamespacedRoleRequest, PatchRbacAuthorizationV1NamespacedRoleRequest, ListRbacAuthorizationV1RoleBindingForAllNamespacesRequest, ListRbacAuthorizationV1RoleForAllNamespacesRequest, WatchRbacAuthorizationV1ClusterRoleBindingListRequest, WatchRbacAuthorizationV1ClusterRoleBindingRequest, WatchRbacAuthorizationV1ClusterRoleListRequest, WatchRbacAuthorizationV1ClusterRoleRequest, WatchRbacAuthorizationV1NamespacedRoleBindingListRequest, WatchRbacAuthorizationV1NamespacedRoleBindingRequest, WatchRbacAuthorizationV1NamespacedRoleListRequest, WatchRbacAuthorizationV1NamespacedRoleRequest, WatchRbacAuthorizationV1RoleBindingListForAllNamespacesRequest, WatchRbacAuthorizationV1RoleListForAllNamespacesRequest, GetSchedulingAPIGroupRequest, GetSchedulingV1APIResourcesRequest, PriorityClassList, ListSchedulingV1PriorityClassRequest, PriorityClass, CreateSchedulingV1PriorityClassRequest, DeleteSchedulingV1CollectionPriorityClassRequest, ReadSchedulingV1PriorityClassRequest, ReplaceSchedulingV1PriorityClassRequest, DeleteSchedulingV1PriorityClassRequest, PatchSchedulingV1PriorityClassRequest, WatchSchedulingV1PriorityClassListRequest, WatchSchedulingV1PriorityClassRequest, GetStorageAPIGroupRequest, GetStorageV1APIResourcesRequest, CSIDriverList, ListStorageV1CSIDriverRequest, CSIDriver, CreateStorageV1CSIDriverRequest, DeleteStorageV1CollectionCSIDriverRequest, ReadStorageV1CSIDriverRequest, ReplaceStorageV1CSIDriverRequest, DeleteStorageV1CSIDriverRequest, PatchStorageV1CSIDriverRequest, CSINodeList, ListStorageV1CSINodeRequest, CSINode, CreateStorageV1CSINodeRequest, DeleteStorageV1CollectionCSINodeRequest, ReadStorageV1CSINodeRequest, ReplaceStorageV1CSINodeRequest, DeleteStorageV1CSINodeRequest, PatchStorageV1CSINodeRequest, StorageClassList, ListStorageV1StorageClassRequest, StorageClass, CreateStorageV1StorageClassRequest, DeleteStorageV1CollectionStorageClassRequest, ReadStorageV1StorageClassRequest, ReplaceStorageV1StorageClassRequest, DeleteStorageV1StorageClassRequest, PatchStorageV1StorageClassRequest, VolumeAttachmentList, ListStorageV1VolumeAttachmentRequest, VolumeAttachment, CreateStorageV1VolumeAttachmentRequest, DeleteStorageV1CollectionVolumeAttachmentRequest, ReadStorageV1VolumeAttachmentRequest, ReplaceStorageV1VolumeAttachmentRequest, DeleteStorageV1VolumeAttachmentRequest, PatchStorageV1VolumeAttachmentRequest, ReadStorageV1VolumeAttachmentStatusRequest, ReplaceStorageV1VolumeAttachmentStatusRequest, PatchStorageV1VolumeAttachmentStatusRequest, WatchStorageV1CSIDriverListRequest, WatchStorageV1CSIDriverRequest, WatchStorageV1CSINodeListRequest, WatchStorageV1CSINodeRequest, WatchStorageV1StorageClassListRequest, WatchStorageV1StorageClassRequest, WatchStorageV1VolumeAttachmentListRequest, WatchStorageV1VolumeAttachmentRequest, LogFileListHandlerRequest, LogFileHandlerRequest, GetServiceAccountIssuerOpenIDKeysetRequest, Info, GetCodeVersionRequest } from "kubernetesjs";
+const WELL_KNOWN_OPENID_CONFIGURATION_KEY = ["well_known_openid_configuration"];
+const API_KEY = ["api"];
+const API_V1_KEY = ["api_v1"];
+const API_V1_COMPONENTSTATUSES_KEY = ["api_v1_componentstatuses"];
+const API_V1_COMPONENTSTATUSES_NAME_KEY = ["api_v1_componentstatuses_name"];
+const API_V1_CONFIGMAPS_KEY = ["api_v1_configmaps"];
+const API_V1_ENDPOINTS_KEY = ["api_v1_endpoints"];
+const API_V1_EVENTS_KEY = ["api_v1_events"];
+const API_V1_LIMITRANGES_KEY = ["api_v1_limitranges"];
+const API_V1_NAMESPACES_KEY = ["api_v1_namespaces"];
+const API_V1_NAMESPACES_NAMESPACE_BINDINGS_KEY = ["api_v1_namespaces_namespace_bindings"];
+const API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_KEY = ["api_v1_namespaces_namespace_configmaps"];
+const API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_NAME_KEY = ["api_v1_namespaces_namespace_configmaps_name"];
+const API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_KEY = ["api_v1_namespaces_namespace_endpoints"];
+const API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_NAME_KEY = ["api_v1_namespaces_namespace_endpoints_name"];
+const API_V1_NAMESPACES_NAMESPACE_EVENTS_KEY = ["api_v1_namespaces_namespace_events"];
+const API_V1_NAMESPACES_NAMESPACE_EVENTS_NAME_KEY = ["api_v1_namespaces_namespace_events_name"];
+const API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_KEY = ["api_v1_namespaces_namespace_limitranges"];
+const API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_NAME_KEY = ["api_v1_namespaces_namespace_limitranges_name"];
+const API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_KEY = ["api_v1_namespaces_namespace_persistentvolumeclaims"];
+const API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_KEY = ["api_v1_namespaces_namespace_persistentvolumeclaims_name"];
+const API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_STATUS_KEY = ["api_v1_namespaces_namespace_persistentvolumeclaims_name_status"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_KEY = ["api_v1_namespaces_namespace_pods"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_KEY = ["api_v1_namespaces_namespace_pods_name"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_ATTACH_KEY = ["api_v1_namespaces_namespace_pods_name_attach"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_BINDING_KEY = ["api_v1_namespaces_namespace_pods_name_binding"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_EVICTION_KEY = ["api_v1_namespaces_namespace_pods_name_eviction"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_EXEC_KEY = ["api_v1_namespaces_namespace_pods_name_exec"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_LOG_KEY = ["api_v1_namespaces_namespace_pods_name_log"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PORTFORWARD_KEY = ["api_v1_namespaces_namespace_pods_name_portforward"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_KEY = ["api_v1_namespaces_namespace_pods_name_proxy"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_PATH_KEY = ["api_v1_namespaces_namespace_pods_name_proxy_path"];
+const API_V1_NAMESPACES_NAMESPACE_PODS_NAME_STATUS_KEY = ["api_v1_namespaces_namespace_pods_name_status"];
+const API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_KEY = ["api_v1_namespaces_namespace_podtemplates"];
+const API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_NAME_KEY = ["api_v1_namespaces_namespace_podtemplates_name"];
+const API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_KEY = ["api_v1_namespaces_namespace_replicationcontrollers"];
+const API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_KEY = ["api_v1_namespaces_namespace_replicationcontrollers_name"];
+const API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_SCALE_KEY = ["api_v1_namespaces_namespace_replicationcontrollers_name_scale"];
+const API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_STATUS_KEY = ["api_v1_namespaces_namespace_replicationcontrollers_name_status"];
+const API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_KEY = ["api_v1_namespaces_namespace_resourcequotas"];
+const API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_KEY = ["api_v1_namespaces_namespace_resourcequotas_name"];
+const API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_STATUS_KEY = ["api_v1_namespaces_namespace_resourcequotas_name_status"];
+const API_V1_NAMESPACES_NAMESPACE_SECRETS_KEY = ["api_v1_namespaces_namespace_secrets"];
+const API_V1_NAMESPACES_NAMESPACE_SECRETS_NAME_KEY = ["api_v1_namespaces_namespace_secrets_name"];
+const API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_KEY = ["api_v1_namespaces_namespace_serviceaccounts"];
+const API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_NAME_KEY = ["api_v1_namespaces_namespace_serviceaccounts_name"];
+const API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_NAME_TOKEN_KEY = ["api_v1_namespaces_namespace_serviceaccounts_name_token"];
+const API_V1_NAMESPACES_NAMESPACE_SERVICES_KEY = ["api_v1_namespaces_namespace_services"];
+const API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_KEY = ["api_v1_namespaces_namespace_services_name"];
+const API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_PROXY_KEY = ["api_v1_namespaces_namespace_services_name_proxy"];
+const API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_PROXY_PATH_KEY = ["api_v1_namespaces_namespace_services_name_proxy_path"];
+const API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_STATUS_KEY = ["api_v1_namespaces_namespace_services_name_status"];
+const API_V1_NAMESPACES_NAME_KEY = ["api_v1_namespaces_name"];
+const API_V1_NAMESPACES_NAME_FINALIZE_KEY = ["api_v1_namespaces_name_finalize"];
+const API_V1_NAMESPACES_NAME_STATUS_KEY = ["api_v1_namespaces_name_status"];
+const API_V1_NODES_KEY = ["api_v1_nodes"];
+const API_V1_NODES_NAME_KEY = ["api_v1_nodes_name"];
+const API_V1_NODES_NAME_PROXY_KEY = ["api_v1_nodes_name_proxy"];
+const API_V1_NODES_NAME_PROXY_PATH_KEY = ["api_v1_nodes_name_proxy_path"];
+const API_V1_NODES_NAME_STATUS_KEY = ["api_v1_nodes_name_status"];
+const API_V1_PERSISTENTVOLUMECLAIMS_KEY = ["api_v1_persistentvolumeclaims"];
+const API_V1_PERSISTENTVOLUMES_KEY = ["api_v1_persistentvolumes"];
+const API_V1_PERSISTENTVOLUMES_NAME_KEY = ["api_v1_persistentvolumes_name"];
+const API_V1_PERSISTENTVOLUMES_NAME_STATUS_KEY = ["api_v1_persistentvolumes_name_status"];
+const API_V1_PODS_KEY = ["api_v1_pods"];
+const API_V1_PODTEMPLATES_KEY = ["api_v1_podtemplates"];
+const API_V1_REPLICATIONCONTROLLERS_KEY = ["api_v1_replicationcontrollers"];
+const API_V1_RESOURCEQUOTAS_KEY = ["api_v1_resourcequotas"];
+const API_V1_SECRETS_KEY = ["api_v1_secrets"];
+const API_V1_SERVICEACCOUNTS_KEY = ["api_v1_serviceaccounts"];
+const API_V1_SERVICES_KEY = ["api_v1_services"];
+const API_V1_WATCH_CONFIGMAPS_KEY = ["api_v1_watch_configmaps"];
+const API_V1_WATCH_ENDPOINTS_KEY = ["api_v1_watch_endpoints"];
+const API_V1_WATCH_EVENTS_KEY = ["api_v1_watch_events"];
+const API_V1_WATCH_LIMITRANGES_KEY = ["api_v1_watch_limitranges"];
+const API_V1_WATCH_NAMESPACES_KEY = ["api_v1_watch_namespaces"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_CONFIGMAPS_KEY = ["api_v1_watch_namespaces_namespace_configmaps"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_CONFIGMAPS_NAME_KEY = ["api_v1_watch_namespaces_namespace_configmaps_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_ENDPOINTS_KEY = ["api_v1_watch_namespaces_namespace_endpoints"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_ENDPOINTS_NAME_KEY = ["api_v1_watch_namespaces_namespace_endpoints_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_EVENTS_KEY = ["api_v1_watch_namespaces_namespace_events"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_EVENTS_NAME_KEY = ["api_v1_watch_namespaces_namespace_events_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_LIMITRANGES_KEY = ["api_v1_watch_namespaces_namespace_limitranges"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_LIMITRANGES_NAME_KEY = ["api_v1_watch_namespaces_namespace_limitranges_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_KEY = ["api_v1_watch_namespaces_namespace_persistentvolumeclaims"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_KEY = ["api_v1_watch_namespaces_namespace_persistentvolumeclaims_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_PODS_KEY = ["api_v1_watch_namespaces_namespace_pods"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_PODS_NAME_KEY = ["api_v1_watch_namespaces_namespace_pods_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_PODTEMPLATES_KEY = ["api_v1_watch_namespaces_namespace_podtemplates"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_PODTEMPLATES_NAME_KEY = ["api_v1_watch_namespaces_namespace_podtemplates_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_KEY = ["api_v1_watch_namespaces_namespace_replicationcontrollers"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_KEY = ["api_v1_watch_namespaces_namespace_replicationcontrollers_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_KEY = ["api_v1_watch_namespaces_namespace_resourcequotas"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_KEY = ["api_v1_watch_namespaces_namespace_resourcequotas_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_SECRETS_KEY = ["api_v1_watch_namespaces_namespace_secrets"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_SECRETS_NAME_KEY = ["api_v1_watch_namespaces_namespace_secrets_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_KEY = ["api_v1_watch_namespaces_namespace_serviceaccounts"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_NAME_KEY = ["api_v1_watch_namespaces_namespace_serviceaccounts_name"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_SERVICES_KEY = ["api_v1_watch_namespaces_namespace_services"];
+const API_V1_WATCH_NAMESPACES_NAMESPACE_SERVICES_NAME_KEY = ["api_v1_watch_namespaces_namespace_services_name"];
+const API_V1_WATCH_NAMESPACES_NAME_KEY = ["api_v1_watch_namespaces_name"];
+const API_V1_WATCH_NODES_KEY = ["api_v1_watch_nodes"];
+const API_V1_WATCH_NODES_NAME_KEY = ["api_v1_watch_nodes_name"];
+const API_V1_WATCH_PERSISTENTVOLUMECLAIMS_KEY = ["api_v1_watch_persistentvolumeclaims"];
+const API_V1_WATCH_PERSISTENTVOLUMES_KEY = ["api_v1_watch_persistentvolumes"];
+const API_V1_WATCH_PERSISTENTVOLUMES_NAME_KEY = ["api_v1_watch_persistentvolumes_name"];
+const API_V1_WATCH_PODS_KEY = ["api_v1_watch_pods"];
+const API_V1_WATCH_PODTEMPLATES_KEY = ["api_v1_watch_podtemplates"];
+const API_V1_WATCH_REPLICATIONCONTROLLERS_KEY = ["api_v1_watch_replicationcontrollers"];
+const API_V1_WATCH_RESOURCEQUOTAS_KEY = ["api_v1_watch_resourcequotas"];
+const API_V1_WATCH_SECRETS_KEY = ["api_v1_watch_secrets"];
+const API_V1_WATCH_SERVICEACCOUNTS_KEY = ["api_v1_watch_serviceaccounts"];
+const API_V1_WATCH_SERVICES_KEY = ["api_v1_watch_services"];
+const APIS_KEY = ["apis"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_KEY = ["apis_admissionregistration_k8s_io"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_KEY = ["apis_admissionregistration_k8s_io_v1"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_MUTATINGWEBHOOKCONFIGURATIONS_KEY = ["apis_admissionregistration_k8s_io_v1_mutatingwebhookconfigurations"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_MUTATINGWEBHOOKCONFIGURATIONS_NAME_KEY = ["apis_admissionregistration_k8s_io_v1_mutatingwebhookconfigurations_name"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_VALIDATINGWEBHOOKCONFIGURATIONS_KEY = ["apis_admissionregistration_k8s_io_v1_validatingwebhookconfigurations"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_VALIDATINGWEBHOOKCONFIGURATIONS_NAME_KEY = ["apis_admissionregistration_k8s_io_v1_validatingwebhookconfigurations_name"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_WATCH_MUTATINGWEBHOOKCONFIGURATIONS_KEY = ["apis_admissionregistration_k8s_io_v1_watch_mutatingwebhookconfigurations"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_WATCH_MUTATINGWEBHOOKCONFIGURATIONS_NAME_KEY = ["apis_admissionregistration_k8s_io_v1_watch_mutatingwebhookconfigurations_name"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_WATCH_VALIDATINGWEBHOOKCONFIGURATIONS_KEY = ["apis_admissionregistration_k8s_io_v1_watch_validatingwebhookconfigurations"];
+const APIS_ADMISSIONREGISTRATION_K8S_IO_V1_WATCH_VALIDATINGWEBHOOKCONFIGURATIONS_NAME_KEY = ["apis_admissionregistration_k8s_io_v1_watch_validatingwebhookconfigurations_name"];
+const APIS_APIEXTENSIONS_K8S_IO_KEY = ["apis_apiextensions_k8s_io"];
+const APIS_APIEXTENSIONS_K8S_IO_V1_KEY = ["apis_apiextensions_k8s_io_v1"];
+const APIS_APIEXTENSIONS_K8S_IO_V1_CUSTOMRESOURCEDEFINITIONS_KEY = ["apis_apiextensions_k8s_io_v1_customresourcedefinitions"];
+const APIS_APIEXTENSIONS_K8S_IO_V1_CUSTOMRESOURCEDEFINITIONS_NAME_KEY = ["apis_apiextensions_k8s_io_v1_customresourcedefinitions_name"];
+const APIS_APIEXTENSIONS_K8S_IO_V1_CUSTOMRESOURCEDEFINITIONS_NAME_STATUS_KEY = ["apis_apiextensions_k8s_io_v1_customresourcedefinitions_name_status"];
+const APIS_APIEXTENSIONS_K8S_IO_V1_WATCH_CUSTOMRESOURCEDEFINITIONS_KEY = ["apis_apiextensions_k8s_io_v1_watch_customresourcedefinitions"];
+const APIS_APIEXTENSIONS_K8S_IO_V1_WATCH_CUSTOMRESOURCEDEFINITIONS_NAME_KEY = ["apis_apiextensions_k8s_io_v1_watch_customresourcedefinitions_name"];
+const APIS_APIREGISTRATION_K8S_IO_KEY = ["apis_apiregistration_k8s_io"];
+const APIS_APIREGISTRATION_K8S_IO_V1_KEY = ["apis_apiregistration_k8s_io_v1"];
+const APIS_APIREGISTRATION_K8S_IO_V1_APISERVICES_KEY = ["apis_apiregistration_k8s_io_v1_apiservices"];
+const APIS_APIREGISTRATION_K8S_IO_V1_APISERVICES_NAME_KEY = ["apis_apiregistration_k8s_io_v1_apiservices_name"];
+const APIS_APIREGISTRATION_K8S_IO_V1_APISERVICES_NAME_STATUS_KEY = ["apis_apiregistration_k8s_io_v1_apiservices_name_status"];
+const APIS_APIREGISTRATION_K8S_IO_V1_WATCH_APISERVICES_KEY = ["apis_apiregistration_k8s_io_v1_watch_apiservices"];
+const APIS_APIREGISTRATION_K8S_IO_V1_WATCH_APISERVICES_NAME_KEY = ["apis_apiregistration_k8s_io_v1_watch_apiservices_name"];
+const APIS_APPS_KEY = ["apis_apps"];
+const APIS_APPS_V1_KEY = ["apis_apps_v1"];
+const APIS_APPS_V1_CONTROLLERREVISIONS_KEY = ["apis_apps_v1_controllerrevisions"];
+const APIS_APPS_V1_DAEMONSETS_KEY = ["apis_apps_v1_daemonsets"];
+const APIS_APPS_V1_DEPLOYMENTS_KEY = ["apis_apps_v1_deployments"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_CONTROLLERREVISIONS_KEY = ["apis_apps_v1_namespaces_namespace_controllerrevisions"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_CONTROLLERREVISIONS_NAME_KEY = ["apis_apps_v1_namespaces_namespace_controllerrevisions_name"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_DAEMONSETS_KEY = ["apis_apps_v1_namespaces_namespace_daemonsets"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_DAEMONSETS_NAME_KEY = ["apis_apps_v1_namespaces_namespace_daemonsets_name"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_DAEMONSETS_NAME_STATUS_KEY = ["apis_apps_v1_namespaces_namespace_daemonsets_name_status"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_DEPLOYMENTS_KEY = ["apis_apps_v1_namespaces_namespace_deployments"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_DEPLOYMENTS_NAME_KEY = ["apis_apps_v1_namespaces_namespace_deployments_name"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_DEPLOYMENTS_NAME_SCALE_KEY = ["apis_apps_v1_namespaces_namespace_deployments_name_scale"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_DEPLOYMENTS_NAME_STATUS_KEY = ["apis_apps_v1_namespaces_namespace_deployments_name_status"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_REPLICASETS_KEY = ["apis_apps_v1_namespaces_namespace_replicasets"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_REPLICASETS_NAME_KEY = ["apis_apps_v1_namespaces_namespace_replicasets_name"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_REPLICASETS_NAME_SCALE_KEY = ["apis_apps_v1_namespaces_namespace_replicasets_name_scale"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_REPLICASETS_NAME_STATUS_KEY = ["apis_apps_v1_namespaces_namespace_replicasets_name_status"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_STATEFULSETS_KEY = ["apis_apps_v1_namespaces_namespace_statefulsets"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_STATEFULSETS_NAME_KEY = ["apis_apps_v1_namespaces_namespace_statefulsets_name"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_STATEFULSETS_NAME_SCALE_KEY = ["apis_apps_v1_namespaces_namespace_statefulsets_name_scale"];
+const APIS_APPS_V1_NAMESPACES_NAMESPACE_STATEFULSETS_NAME_STATUS_KEY = ["apis_apps_v1_namespaces_namespace_statefulsets_name_status"];
+const APIS_APPS_V1_REPLICASETS_KEY = ["apis_apps_v1_replicasets"];
+const APIS_APPS_V1_STATEFULSETS_KEY = ["apis_apps_v1_statefulsets"];
+const APIS_APPS_V1_WATCH_CONTROLLERREVISIONS_KEY = ["apis_apps_v1_watch_controllerrevisions"];
+const APIS_APPS_V1_WATCH_DAEMONSETS_KEY = ["apis_apps_v1_watch_daemonsets"];
+const APIS_APPS_V1_WATCH_DEPLOYMENTS_KEY = ["apis_apps_v1_watch_deployments"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_CONTROLLERREVISIONS_KEY = ["apis_apps_v1_watch_namespaces_namespace_controllerrevisions"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_CONTROLLERREVISIONS_NAME_KEY = ["apis_apps_v1_watch_namespaces_namespace_controllerrevisions_name"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_DAEMONSETS_KEY = ["apis_apps_v1_watch_namespaces_namespace_daemonsets"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_DAEMONSETS_NAME_KEY = ["apis_apps_v1_watch_namespaces_namespace_daemonsets_name"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_DEPLOYMENTS_KEY = ["apis_apps_v1_watch_namespaces_namespace_deployments"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_DEPLOYMENTS_NAME_KEY = ["apis_apps_v1_watch_namespaces_namespace_deployments_name"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_REPLICASETS_KEY = ["apis_apps_v1_watch_namespaces_namespace_replicasets"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_REPLICASETS_NAME_KEY = ["apis_apps_v1_watch_namespaces_namespace_replicasets_name"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_STATEFULSETS_KEY = ["apis_apps_v1_watch_namespaces_namespace_statefulsets"];
+const APIS_APPS_V1_WATCH_NAMESPACES_NAMESPACE_STATEFULSETS_NAME_KEY = ["apis_apps_v1_watch_namespaces_namespace_statefulsets_name"];
+const APIS_APPS_V1_WATCH_REPLICASETS_KEY = ["apis_apps_v1_watch_replicasets"];
+const APIS_APPS_V1_WATCH_STATEFULSETS_KEY = ["apis_apps_v1_watch_statefulsets"];
+const APIS_AUTHENTICATION_K8S_IO_KEY = ["apis_authentication_k8s_io"];
+const APIS_AUTHENTICATION_K8S_IO_V1_KEY = ["apis_authentication_k8s_io_v1"];
+const APIS_AUTHENTICATION_K8S_IO_V1_TOKENREVIEWS_KEY = ["apis_authentication_k8s_io_v1_tokenreviews"];
+const APIS_AUTHORIZATION_K8S_IO_KEY = ["apis_authorization_k8s_io"];
+const APIS_AUTHORIZATION_K8S_IO_V1_KEY = ["apis_authorization_k8s_io_v1"];
+const APIS_AUTHORIZATION_K8S_IO_V1_NAMESPACES_NAMESPACE_LOCALSUBJECTACCESSREVIEWS_KEY = ["apis_authorization_k8s_io_v1_namespaces_namespace_localsubjectaccessreviews"];
+const APIS_AUTHORIZATION_K8S_IO_V1_SELFSUBJECTACCESSREVIEWS_KEY = ["apis_authorization_k8s_io_v1_selfsubjectaccessreviews"];
+const APIS_AUTHORIZATION_K8S_IO_V1_SELFSUBJECTRULESREVIEWS_KEY = ["apis_authorization_k8s_io_v1_selfsubjectrulesreviews"];
+const APIS_AUTHORIZATION_K8S_IO_V1_SUBJECTACCESSREVIEWS_KEY = ["apis_authorization_k8s_io_v1_subjectaccessreviews"];
+const APIS_AUTOSCALING_KEY = ["apis_autoscaling"];
+const APIS_AUTOSCALING_V1_KEY = ["apis_autoscaling_v1"];
+const APIS_AUTOSCALING_V1_HORIZONTALPODAUTOSCALERS_KEY = ["apis_autoscaling_v1_horizontalpodautoscalers"];
+const APIS_AUTOSCALING_V1_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_KEY = ["apis_autoscaling_v1_namespaces_namespace_horizontalpodautoscalers"];
+const APIS_AUTOSCALING_V1_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_NAME_KEY = ["apis_autoscaling_v1_namespaces_namespace_horizontalpodautoscalers_name"];
+const APIS_AUTOSCALING_V1_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_NAME_STATUS_KEY = ["apis_autoscaling_v1_namespaces_namespace_horizontalpodautoscalers_name_status"];
+const APIS_AUTOSCALING_V1_WATCH_HORIZONTALPODAUTOSCALERS_KEY = ["apis_autoscaling_v1_watch_horizontalpodautoscalers"];
+const APIS_AUTOSCALING_V1_WATCH_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_KEY = ["apis_autoscaling_v1_watch_namespaces_namespace_horizontalpodautoscalers"];
+const APIS_AUTOSCALING_V1_WATCH_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_NAME_KEY = ["apis_autoscaling_v1_watch_namespaces_namespace_horizontalpodautoscalers_name"];
+const APIS_AUTOSCALING_V2BETA2_KEY = ["apis_autoscaling_v2beta2"];
+const APIS_AUTOSCALING_V2BETA2_HORIZONTALPODAUTOSCALERS_KEY = ["apis_autoscaling_v2beta2_horizontalpodautoscalers"];
+const APIS_AUTOSCALING_V2BETA2_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_KEY = ["apis_autoscaling_v2beta2_namespaces_namespace_horizontalpodautoscalers"];
+const APIS_AUTOSCALING_V2BETA2_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_NAME_KEY = ["apis_autoscaling_v2beta2_namespaces_namespace_horizontalpodautoscalers_name"];
+const APIS_AUTOSCALING_V2BETA2_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_NAME_STATUS_KEY = ["apis_autoscaling_v2beta2_namespaces_namespace_horizontalpodautoscalers_name_status"];
+const APIS_AUTOSCALING_V2BETA2_WATCH_HORIZONTALPODAUTOSCALERS_KEY = ["apis_autoscaling_v2beta2_watch_horizontalpodautoscalers"];
+const APIS_AUTOSCALING_V2BETA2_WATCH_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_KEY = ["apis_autoscaling_v2beta2_watch_namespaces_namespace_horizontalpodautoscalers"];
+const APIS_AUTOSCALING_V2BETA2_WATCH_NAMESPACES_NAMESPACE_HORIZONTALPODAUTOSCALERS_NAME_KEY = ["apis_autoscaling_v2beta2_watch_namespaces_namespace_horizontalpodautoscalers_name"];
+const APIS_BATCH_KEY = ["apis_batch"];
+const APIS_BATCH_V1_KEY = ["apis_batch_v1"];
+const APIS_BATCH_V1_CRONJOBS_KEY = ["apis_batch_v1_cronjobs"];
+const APIS_BATCH_V1_JOBS_KEY = ["apis_batch_v1_jobs"];
+const APIS_BATCH_V1_NAMESPACES_NAMESPACE_CRONJOBS_KEY = ["apis_batch_v1_namespaces_namespace_cronjobs"];
+const APIS_BATCH_V1_NAMESPACES_NAMESPACE_CRONJOBS_NAME_KEY = ["apis_batch_v1_namespaces_namespace_cronjobs_name"];
+const APIS_BATCH_V1_NAMESPACES_NAMESPACE_CRONJOBS_NAME_STATUS_KEY = ["apis_batch_v1_namespaces_namespace_cronjobs_name_status"];
+const APIS_BATCH_V1_NAMESPACES_NAMESPACE_JOBS_KEY = ["apis_batch_v1_namespaces_namespace_jobs"];
+const APIS_BATCH_V1_NAMESPACES_NAMESPACE_JOBS_NAME_KEY = ["apis_batch_v1_namespaces_namespace_jobs_name"];
+const APIS_BATCH_V1_NAMESPACES_NAMESPACE_JOBS_NAME_STATUS_KEY = ["apis_batch_v1_namespaces_namespace_jobs_name_status"];
+const APIS_BATCH_V1_WATCH_CRONJOBS_KEY = ["apis_batch_v1_watch_cronjobs"];
+const APIS_BATCH_V1_WATCH_JOBS_KEY = ["apis_batch_v1_watch_jobs"];
+const APIS_BATCH_V1_WATCH_NAMESPACES_NAMESPACE_CRONJOBS_KEY = ["apis_batch_v1_watch_namespaces_namespace_cronjobs"];
+const APIS_BATCH_V1_WATCH_NAMESPACES_NAMESPACE_CRONJOBS_NAME_KEY = ["apis_batch_v1_watch_namespaces_namespace_cronjobs_name"];
+const APIS_BATCH_V1_WATCH_NAMESPACES_NAMESPACE_JOBS_KEY = ["apis_batch_v1_watch_namespaces_namespace_jobs"];
+const APIS_BATCH_V1_WATCH_NAMESPACES_NAMESPACE_JOBS_NAME_KEY = ["apis_batch_v1_watch_namespaces_namespace_jobs_name"];
+const APIS_CERTIFICATES_K8S_IO_KEY = ["apis_certificates_k8s_io"];
+const APIS_CERTIFICATES_K8S_IO_V1_KEY = ["apis_certificates_k8s_io_v1"];
+const APIS_CERTIFICATES_K8S_IO_V1_CERTIFICATESIGNINGREQUESTS_KEY = ["apis_certificates_k8s_io_v1_certificatesigningrequests"];
+const APIS_CERTIFICATES_K8S_IO_V1_CERTIFICATESIGNINGREQUESTS_NAME_KEY = ["apis_certificates_k8s_io_v1_certificatesigningrequests_name"];
+const APIS_CERTIFICATES_K8S_IO_V1_CERTIFICATESIGNINGREQUESTS_NAME_APPROVAL_KEY = ["apis_certificates_k8s_io_v1_certificatesigningrequests_name_approval"];
+const APIS_CERTIFICATES_K8S_IO_V1_CERTIFICATESIGNINGREQUESTS_NAME_STATUS_KEY = ["apis_certificates_k8s_io_v1_certificatesigningrequests_name_status"];
+const APIS_CERTIFICATES_K8S_IO_V1_WATCH_CERTIFICATESIGNINGREQUESTS_KEY = ["apis_certificates_k8s_io_v1_watch_certificatesigningrequests"];
+const APIS_CERTIFICATES_K8S_IO_V1_WATCH_CERTIFICATESIGNINGREQUESTS_NAME_KEY = ["apis_certificates_k8s_io_v1_watch_certificatesigningrequests_name"];
+const APIS_COORDINATION_K8S_IO_KEY = ["apis_coordination_k8s_io"];
+const APIS_COORDINATION_K8S_IO_V1_KEY = ["apis_coordination_k8s_io_v1"];
+const APIS_COORDINATION_K8S_IO_V1_LEASES_KEY = ["apis_coordination_k8s_io_v1_leases"];
+const APIS_COORDINATION_K8S_IO_V1_NAMESPACES_NAMESPACE_LEASES_KEY = ["apis_coordination_k8s_io_v1_namespaces_namespace_leases"];
+const APIS_COORDINATION_K8S_IO_V1_NAMESPACES_NAMESPACE_LEASES_NAME_KEY = ["apis_coordination_k8s_io_v1_namespaces_namespace_leases_name"];
+const APIS_COORDINATION_K8S_IO_V1_WATCH_LEASES_KEY = ["apis_coordination_k8s_io_v1_watch_leases"];
+const APIS_COORDINATION_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_LEASES_KEY = ["apis_coordination_k8s_io_v1_watch_namespaces_namespace_leases"];
+const APIS_COORDINATION_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_LEASES_NAME_KEY = ["apis_coordination_k8s_io_v1_watch_namespaces_namespace_leases_name"];
+const APIS_DISCOVERY_K8S_IO_KEY = ["apis_discovery_k8s_io"];
+const APIS_DISCOVERY_K8S_IO_V1_KEY = ["apis_discovery_k8s_io_v1"];
+const APIS_DISCOVERY_K8S_IO_V1_ENDPOINTSLICES_KEY = ["apis_discovery_k8s_io_v1_endpointslices"];
+const APIS_DISCOVERY_K8S_IO_V1_NAMESPACES_NAMESPACE_ENDPOINTSLICES_KEY = ["apis_discovery_k8s_io_v1_namespaces_namespace_endpointslices"];
+const APIS_DISCOVERY_K8S_IO_V1_NAMESPACES_NAMESPACE_ENDPOINTSLICES_NAME_KEY = ["apis_discovery_k8s_io_v1_namespaces_namespace_endpointslices_name"];
+const APIS_DISCOVERY_K8S_IO_V1_WATCH_ENDPOINTSLICES_KEY = ["apis_discovery_k8s_io_v1_watch_endpointslices"];
+const APIS_DISCOVERY_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_ENDPOINTSLICES_KEY = ["apis_discovery_k8s_io_v1_watch_namespaces_namespace_endpointslices"];
+const APIS_DISCOVERY_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_ENDPOINTSLICES_NAME_KEY = ["apis_discovery_k8s_io_v1_watch_namespaces_namespace_endpointslices_name"];
+const APIS_EVENTS_K8S_IO_KEY = ["apis_events_k8s_io"];
+const APIS_EVENTS_K8S_IO_V1_KEY = ["apis_events_k8s_io_v1"];
+const APIS_EVENTS_K8S_IO_V1_EVENTS_KEY = ["apis_events_k8s_io_v1_events"];
+const APIS_EVENTS_K8S_IO_V1_NAMESPACES_NAMESPACE_EVENTS_KEY = ["apis_events_k8s_io_v1_namespaces_namespace_events"];
+const APIS_EVENTS_K8S_IO_V1_NAMESPACES_NAMESPACE_EVENTS_NAME_KEY = ["apis_events_k8s_io_v1_namespaces_namespace_events_name"];
+const APIS_EVENTS_K8S_IO_V1_WATCH_EVENTS_KEY = ["apis_events_k8s_io_v1_watch_events"];
+const APIS_EVENTS_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_EVENTS_KEY = ["apis_events_k8s_io_v1_watch_namespaces_namespace_events"];
+const APIS_EVENTS_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_EVENTS_NAME_KEY = ["apis_events_k8s_io_v1_watch_namespaces_namespace_events_name"];
+const APIS_FLOWCONTROL_APISERVER_K8S_IO_KEY = ["apis_flowcontrol_apiserver_k8s_io"];
+const APIS_NETWORKING_K8S_IO_KEY = ["apis_networking_k8s_io"];
+const APIS_NETWORKING_K8S_IO_V1_KEY = ["apis_networking_k8s_io_v1"];
+const APIS_NETWORKING_K8S_IO_V1_INGRESSCLASSES_KEY = ["apis_networking_k8s_io_v1_ingressclasses"];
+const APIS_NETWORKING_K8S_IO_V1_INGRESSCLASSES_NAME_KEY = ["apis_networking_k8s_io_v1_ingressclasses_name"];
+const APIS_NETWORKING_K8S_IO_V1_INGRESSES_KEY = ["apis_networking_k8s_io_v1_ingresses"];
+const APIS_NETWORKING_K8S_IO_V1_NAMESPACES_NAMESPACE_INGRESSES_KEY = ["apis_networking_k8s_io_v1_namespaces_namespace_ingresses"];
+const APIS_NETWORKING_K8S_IO_V1_NAMESPACES_NAMESPACE_INGRESSES_NAME_KEY = ["apis_networking_k8s_io_v1_namespaces_namespace_ingresses_name"];
+const APIS_NETWORKING_K8S_IO_V1_NAMESPACES_NAMESPACE_INGRESSES_NAME_STATUS_KEY = ["apis_networking_k8s_io_v1_namespaces_namespace_ingresses_name_status"];
+const APIS_NETWORKING_K8S_IO_V1_NAMESPACES_NAMESPACE_NETWORKPOLICIES_KEY = ["apis_networking_k8s_io_v1_namespaces_namespace_networkpolicies"];
+const APIS_NETWORKING_K8S_IO_V1_NAMESPACES_NAMESPACE_NETWORKPOLICIES_NAME_KEY = ["apis_networking_k8s_io_v1_namespaces_namespace_networkpolicies_name"];
+const APIS_NETWORKING_K8S_IO_V1_NETWORKPOLICIES_KEY = ["apis_networking_k8s_io_v1_networkpolicies"];
+const APIS_NETWORKING_K8S_IO_V1_WATCH_INGRESSCLASSES_KEY = ["apis_networking_k8s_io_v1_watch_ingressclasses"];
+const APIS_NETWORKING_K8S_IO_V1_WATCH_INGRESSCLASSES_NAME_KEY = ["apis_networking_k8s_io_v1_watch_ingressclasses_name"];
+const APIS_NETWORKING_K8S_IO_V1_WATCH_INGRESSES_KEY = ["apis_networking_k8s_io_v1_watch_ingresses"];
+const APIS_NETWORKING_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_INGRESSES_KEY = ["apis_networking_k8s_io_v1_watch_namespaces_namespace_ingresses"];
+const APIS_NETWORKING_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_INGRESSES_NAME_KEY = ["apis_networking_k8s_io_v1_watch_namespaces_namespace_ingresses_name"];
+const APIS_NETWORKING_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_NETWORKPOLICIES_KEY = ["apis_networking_k8s_io_v1_watch_namespaces_namespace_networkpolicies"];
+const APIS_NETWORKING_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_NETWORKPOLICIES_NAME_KEY = ["apis_networking_k8s_io_v1_watch_namespaces_namespace_networkpolicies_name"];
+const APIS_NETWORKING_K8S_IO_V1_WATCH_NETWORKPOLICIES_KEY = ["apis_networking_k8s_io_v1_watch_networkpolicies"];
+const APIS_NODE_K8S_IO_KEY = ["apis_node_k8s_io"];
+const APIS_NODE_K8S_IO_V1_KEY = ["apis_node_k8s_io_v1"];
+const APIS_NODE_K8S_IO_V1_RUNTIMECLASSES_KEY = ["apis_node_k8s_io_v1_runtimeclasses"];
+const APIS_NODE_K8S_IO_V1_RUNTIMECLASSES_NAME_KEY = ["apis_node_k8s_io_v1_runtimeclasses_name"];
+const APIS_NODE_K8S_IO_V1_WATCH_RUNTIMECLASSES_KEY = ["apis_node_k8s_io_v1_watch_runtimeclasses"];
+const APIS_NODE_K8S_IO_V1_WATCH_RUNTIMECLASSES_NAME_KEY = ["apis_node_k8s_io_v1_watch_runtimeclasses_name"];
+const APIS_POLICY_KEY = ["apis_policy"];
+const APIS_POLICY_V1_KEY = ["apis_policy_v1"];
+const APIS_POLICY_V1_NAMESPACES_NAMESPACE_PODDISRUPTIONBUDGETS_KEY = ["apis_policy_v1_namespaces_namespace_poddisruptionbudgets"];
+const APIS_POLICY_V1_NAMESPACES_NAMESPACE_PODDISRUPTIONBUDGETS_NAME_KEY = ["apis_policy_v1_namespaces_namespace_poddisruptionbudgets_name"];
+const APIS_POLICY_V1_NAMESPACES_NAMESPACE_PODDISRUPTIONBUDGETS_NAME_STATUS_KEY = ["apis_policy_v1_namespaces_namespace_poddisruptionbudgets_name_status"];
+const APIS_POLICY_V1_PODDISRUPTIONBUDGETS_KEY = ["apis_policy_v1_poddisruptionbudgets"];
+const APIS_POLICY_V1_WATCH_NAMESPACES_NAMESPACE_PODDISRUPTIONBUDGETS_KEY = ["apis_policy_v1_watch_namespaces_namespace_poddisruptionbudgets"];
+const APIS_POLICY_V1_WATCH_NAMESPACES_NAMESPACE_PODDISRUPTIONBUDGETS_NAME_KEY = ["apis_policy_v1_watch_namespaces_namespace_poddisruptionbudgets_name"];
+const APIS_POLICY_V1_WATCH_PODDISRUPTIONBUDGETS_KEY = ["apis_policy_v1_watch_poddisruptionbudgets"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_KEY = ["apis_rbac_authorization_k8s_io"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_KEY = ["apis_rbac_authorization_k8s_io_v1"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_CLUSTERROLEBINDINGS_KEY = ["apis_rbac_authorization_k8s_io_v1_clusterrolebindings"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_CLUSTERROLEBINDINGS_NAME_KEY = ["apis_rbac_authorization_k8s_io_v1_clusterrolebindings_name"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_CLUSTERROLES_KEY = ["apis_rbac_authorization_k8s_io_v1_clusterroles"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_CLUSTERROLES_NAME_KEY = ["apis_rbac_authorization_k8s_io_v1_clusterroles_name"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_NAMESPACES_NAMESPACE_ROLEBINDINGS_KEY = ["apis_rbac_authorization_k8s_io_v1_namespaces_namespace_rolebindings"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_NAMESPACES_NAMESPACE_ROLEBINDINGS_NAME_KEY = ["apis_rbac_authorization_k8s_io_v1_namespaces_namespace_rolebindings_name"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_NAMESPACES_NAMESPACE_ROLES_KEY = ["apis_rbac_authorization_k8s_io_v1_namespaces_namespace_roles"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_NAMESPACES_NAMESPACE_ROLES_NAME_KEY = ["apis_rbac_authorization_k8s_io_v1_namespaces_namespace_roles_name"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_ROLEBINDINGS_KEY = ["apis_rbac_authorization_k8s_io_v1_rolebindings"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_ROLES_KEY = ["apis_rbac_authorization_k8s_io_v1_roles"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_CLUSTERROLEBINDINGS_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_clusterrolebindings"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_CLUSTERROLEBINDINGS_NAME_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_clusterrolebindings_name"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_CLUSTERROLES_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_clusterroles"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_CLUSTERROLES_NAME_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_clusterroles_name"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_ROLEBINDINGS_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_namespaces_namespace_rolebindings"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_ROLEBINDINGS_NAME_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_namespaces_namespace_rolebindings_name"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_ROLES_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_namespaces_namespace_roles"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_NAMESPACES_NAMESPACE_ROLES_NAME_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_namespaces_namespace_roles_name"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_ROLEBINDINGS_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_rolebindings"];
+const APIS_RBAC_AUTHORIZATION_K8S_IO_V1_WATCH_ROLES_KEY = ["apis_rbac_authorization_k8s_io_v1_watch_roles"];
+const APIS_SCHEDULING_K8S_IO_KEY = ["apis_scheduling_k8s_io"];
+const APIS_SCHEDULING_K8S_IO_V1_KEY = ["apis_scheduling_k8s_io_v1"];
+const APIS_SCHEDULING_K8S_IO_V1_PRIORITYCLASSES_KEY = ["apis_scheduling_k8s_io_v1_priorityclasses"];
+const APIS_SCHEDULING_K8S_IO_V1_PRIORITYCLASSES_NAME_KEY = ["apis_scheduling_k8s_io_v1_priorityclasses_name"];
+const APIS_SCHEDULING_K8S_IO_V1_WATCH_PRIORITYCLASSES_KEY = ["apis_scheduling_k8s_io_v1_watch_priorityclasses"];
+const APIS_SCHEDULING_K8S_IO_V1_WATCH_PRIORITYCLASSES_NAME_KEY = ["apis_scheduling_k8s_io_v1_watch_priorityclasses_name"];
+const APIS_STORAGE_K8S_IO_KEY = ["apis_storage_k8s_io"];
+const APIS_STORAGE_K8S_IO_V1_KEY = ["apis_storage_k8s_io_v1"];
+const APIS_STORAGE_K8S_IO_V1_CSIDRIVERS_KEY = ["apis_storage_k8s_io_v1_csidrivers"];
+const APIS_STORAGE_K8S_IO_V1_CSIDRIVERS_NAME_KEY = ["apis_storage_k8s_io_v1_csidrivers_name"];
+const APIS_STORAGE_K8S_IO_V1_CSINODES_KEY = ["apis_storage_k8s_io_v1_csinodes"];
+const APIS_STORAGE_K8S_IO_V1_CSINODES_NAME_KEY = ["apis_storage_k8s_io_v1_csinodes_name"];
+const APIS_STORAGE_K8S_IO_V1_STORAGECLASSES_KEY = ["apis_storage_k8s_io_v1_storageclasses"];
+const APIS_STORAGE_K8S_IO_V1_STORAGECLASSES_NAME_KEY = ["apis_storage_k8s_io_v1_storageclasses_name"];
+const APIS_STORAGE_K8S_IO_V1_VOLUMEATTACHMENTS_KEY = ["apis_storage_k8s_io_v1_volumeattachments"];
+const APIS_STORAGE_K8S_IO_V1_VOLUMEATTACHMENTS_NAME_KEY = ["apis_storage_k8s_io_v1_volumeattachments_name"];
+const APIS_STORAGE_K8S_IO_V1_VOLUMEATTACHMENTS_NAME_STATUS_KEY = ["apis_storage_k8s_io_v1_volumeattachments_name_status"];
+const APIS_STORAGE_K8S_IO_V1_WATCH_CSIDRIVERS_KEY = ["apis_storage_k8s_io_v1_watch_csidrivers"];
+const APIS_STORAGE_K8S_IO_V1_WATCH_CSIDRIVERS_NAME_KEY = ["apis_storage_k8s_io_v1_watch_csidrivers_name"];
+const APIS_STORAGE_K8S_IO_V1_WATCH_CSINODES_KEY = ["apis_storage_k8s_io_v1_watch_csinodes"];
+const APIS_STORAGE_K8S_IO_V1_WATCH_CSINODES_NAME_KEY = ["apis_storage_k8s_io_v1_watch_csinodes_name"];
+const APIS_STORAGE_K8S_IO_V1_WATCH_STORAGECLASSES_KEY = ["apis_storage_k8s_io_v1_watch_storageclasses"];
+const APIS_STORAGE_K8S_IO_V1_WATCH_STORAGECLASSES_NAME_KEY = ["apis_storage_k8s_io_v1_watch_storageclasses_name"];
+const APIS_STORAGE_K8S_IO_V1_WATCH_VOLUMEATTACHMENTS_KEY = ["apis_storage_k8s_io_v1_watch_volumeattachments"];
+const APIS_STORAGE_K8S_IO_V1_WATCH_VOLUMEATTACHMENTS_NAME_KEY = ["apis_storage_k8s_io_v1_watch_volumeattachments_name"];
+const LOGS_KEY = ["logs"];
+const LOGS_LOGPATH_KEY = ["logs_logpath"];
+const OPENID_V1_JWKS_KEY = ["openid_v1_jwks"];
+const VERSION_KEY = ["version"];
+export function useGetServiceAccountIssuerOpenIDConfigurationQuery(params: GetServiceAccountIssuerOpenIDConfigurationRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...WELL_KNOWN_OPENID_CONFIGURATION_KEY],
+ queryFn: async () => {
+ return await client.getServiceAccountIssuerOpenIDConfiguration(params);
+ },
+ enabled: true
+ });
+}
+export function useGetCoreAPIVersionsQuery(params: GetCoreAPIVersionsRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_KEY],
+ queryFn: async () => {
+ return await client.getCoreAPIVersions(params);
+ },
+ enabled: true
+ });
+}
+export function useGetCoreV1APIResourcesQuery(params: GetCoreV1APIResourcesRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_KEY],
+ queryFn: async () => {
+ return await client.getCoreV1APIResources(params);
+ },
+ enabled: true
+ });
+}
+export function useListCoreV1ComponentStatusQuery(params: ListCoreV1ComponentStatusRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_COMPONENTSTATUSES_KEY],
+ queryFn: async () => {
+ return await client.listCoreV1ComponentStatus(params);
+ },
+ enabled: true
+ });
+}
+export function useReadCoreV1ComponentStatusQuery(params: ReadCoreV1ComponentStatusRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_COMPONENTSTATUSES_NAME_KEY, params.path.name],
+ queryFn: async () => {
+ return await client.readCoreV1ComponentStatus(params);
+ },
+ enabled: params.path.name !== undefined
+ });
+}
+export function useListCoreV1ConfigMapForAllNamespacesQuery(params: ListCoreV1ConfigMapForAllNamespacesRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_CONFIGMAPS_KEY],
+ queryFn: async () => {
+ return await client.listCoreV1ConfigMapForAllNamespaces(params);
+ },
+ enabled: true
+ });
+}
+export function useListCoreV1EndpointsForAllNamespacesQuery(params: ListCoreV1EndpointsForAllNamespacesRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_ENDPOINTS_KEY],
+ queryFn: async () => {
+ return await client.listCoreV1EndpointsForAllNamespaces(params);
+ },
+ enabled: true
+ });
+}
+export function useListCoreV1EventForAllNamespacesQuery(params: ListCoreV1EventForAllNamespacesRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_EVENTS_KEY],
+ queryFn: async () => {
+ return await client.listCoreV1EventForAllNamespaces(params);
+ },
+ enabled: true
+ });
+}
+export function useListCoreV1LimitRangeForAllNamespacesQuery(params: ListCoreV1LimitRangeForAllNamespacesRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_LIMITRANGES_KEY],
+ queryFn: async () => {
+ return await client.listCoreV1LimitRangeForAllNamespaces(params);
+ },
+ enabled: true
+ });
+}
+export function useListCoreV1NamespaceQuery(params: ListCoreV1NamespaceRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_KEY],
+ queryFn: async () => {
+ return await client.listCoreV1Namespace(params);
+ },
+ enabled: true
+ });
+}
+export function useCreateCoreV1Namespace() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1Namespace(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_KEY]
+ });
+ }
+ });
+}
+export function useCreateCoreV1NamespacedBinding() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedBinding(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_BINDINGS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedConfigMapQuery(params: ListCoreV1NamespacedConfigMapRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedConfigMap(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedConfigMap() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedConfigMap(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedConfigMap() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedConfigMap(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedConfigMapQuery(params: ReadCoreV1NamespacedConfigMapRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedConfigMap(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedConfigMap() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedConfigMap(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedConfigMap() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedConfigMap(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedConfigMap() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedConfigMap(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_CONFIGMAPS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedEndpointsQuery(params: ListCoreV1NamespacedEndpointsRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedEndpoints(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedEndpoints() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedEndpoints(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedEndpoints() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedEndpoints(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedEndpointsQuery(params: ReadCoreV1NamespacedEndpointsRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedEndpoints(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedEndpoints() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedEndpoints(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedEndpoints() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedEndpoints(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedEndpoints() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedEndpoints(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_ENDPOINTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedEventQuery(params: ListCoreV1NamespacedEventRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_EVENTS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedEvent(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedEvent() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedEvent(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_EVENTS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedEvent() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedEvent(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_EVENTS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedEventQuery(params: ReadCoreV1NamespacedEventRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_EVENTS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedEvent(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedEvent() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedEvent(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_EVENTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedEvent() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedEvent(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_EVENTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedEvent() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedEvent(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_EVENTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedLimitRangeQuery(params: ListCoreV1NamespacedLimitRangeRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedLimitRange(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedLimitRange() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedLimitRange(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedLimitRange() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedLimitRange(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedLimitRangeQuery(params: ReadCoreV1NamespacedLimitRangeRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedLimitRange(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedLimitRange() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedLimitRange(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedLimitRange() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedLimitRange(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedLimitRange() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedLimitRange(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_LIMITRANGES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedPersistentVolumeClaimQuery(params: ListCoreV1NamespacedPersistentVolumeClaimRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedPersistentVolumeClaim(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedPersistentVolumeClaim() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedPersistentVolumeClaim(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedPersistentVolumeClaim() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedPersistentVolumeClaim(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedPersistentVolumeClaimQuery(params: ReadCoreV1NamespacedPersistentVolumeClaimRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedPersistentVolumeClaim(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedPersistentVolumeClaim() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedPersistentVolumeClaim(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedPersistentVolumeClaim() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedPersistentVolumeClaim(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedPersistentVolumeClaim() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedPersistentVolumeClaim(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedPersistentVolumeClaimStatusQuery(params: ReadCoreV1NamespacedPersistentVolumeClaimStatusRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_STATUS_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedPersistentVolumeClaimStatus(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedPersistentVolumeClaimStatus() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedPersistentVolumeClaimStatus(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_STATUS_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedPersistentVolumeClaimStatus() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedPersistentVolumeClaimStatus(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PERSISTENTVOLUMECLAIMS_NAME_STATUS_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedPodQuery(params: ListCoreV1NamespacedPodRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedPod(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedPod() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedPod(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedPod() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedPod(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedPodQuery(params: ReadCoreV1NamespacedPodRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedPod(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedPod() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedPod(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedPod() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedPod(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedPod() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedPod(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1GetNamespacedPodAttachQuery(params: ConnectCoreV1GetNamespacedPodAttachRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_ATTACH_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.connectCoreV1GetNamespacedPodAttach(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useConnectCoreV1PostNamespacedPodAttach() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PostNamespacedPodAttach(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_ATTACH_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useCreateCoreV1NamespacedPodBinding() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedPodBinding(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_BINDING_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useCreateCoreV1NamespacedPodEviction() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedPodEviction(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_EVICTION_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1GetNamespacedPodExecQuery(params: ConnectCoreV1GetNamespacedPodExecRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_EXEC_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.connectCoreV1GetNamespacedPodExec(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useConnectCoreV1PostNamespacedPodExec() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PostNamespacedPodExec(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_EXEC_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedPodLogQuery(params: ReadCoreV1NamespacedPodLogRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_LOG_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedPodLog(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useConnectCoreV1GetNamespacedPodPortforwardQuery(params: ConnectCoreV1GetNamespacedPodPortforwardRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PORTFORWARD_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.connectCoreV1GetNamespacedPodPortforward(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useConnectCoreV1PostNamespacedPodPortforward() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PostNamespacedPodPortforward(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PORTFORWARD_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1GetNamespacedPodProxyQuery(params: ConnectCoreV1GetNamespacedPodProxyRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.connectCoreV1GetNamespacedPodProxy(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useConnectCoreV1PostNamespacedPodProxy() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PostNamespacedPodProxy(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1PutNamespacedPodProxy() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PutNamespacedPodProxy(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1DeleteNamespacedPodProxy() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1DeleteNamespacedPodProxy(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1PatchNamespacedPodProxy() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PatchNamespacedPodProxy(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1GetNamespacedPodProxyWithPathQuery(params: ConnectCoreV1GetNamespacedPodProxyWithPathRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_PATH_KEY, params.path.name, params.path.namespace, params.path.path],
+ queryFn: async () => {
+ return await client.connectCoreV1GetNamespacedPodProxyWithPath(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined && params.path.path !== undefined
+ });
+}
+export function useConnectCoreV1PostNamespacedPodProxyWithPath() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PostNamespacedPodProxyWithPath(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_PATH_KEY, response.path.name, response.path.namespace, response.path.path]
+ });
+ }
+ });
+}
+export function useConnectCoreV1PutNamespacedPodProxyWithPath() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PutNamespacedPodProxyWithPath(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_PATH_KEY, response.path.name, response.path.namespace, response.path.path]
+ });
+ }
+ });
+}
+export function useConnectCoreV1DeleteNamespacedPodProxyWithPath() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1DeleteNamespacedPodProxyWithPath(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_PATH_KEY, response.path.name, response.path.namespace, response.path.path]
+ });
+ }
+ });
+}
+export function useConnectCoreV1PatchNamespacedPodProxyWithPath() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PatchNamespacedPodProxyWithPath(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_PROXY_PATH_KEY, response.path.name, response.path.namespace, response.path.path]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedPodStatusQuery(params: ReadCoreV1NamespacedPodStatusRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_STATUS_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedPodStatus(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedPodStatus() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedPodStatus(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_STATUS_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedPodStatus() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedPodStatus(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODS_NAME_STATUS_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedPodTemplateQuery(params: ListCoreV1NamespacedPodTemplateRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedPodTemplate(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedPodTemplate() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedPodTemplate(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedPodTemplate() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedPodTemplate(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedPodTemplateQuery(params: ReadCoreV1NamespacedPodTemplateRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedPodTemplate(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedPodTemplate() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedPodTemplate(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedPodTemplate() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedPodTemplate(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedPodTemplate() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedPodTemplate(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_PODTEMPLATES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedReplicationControllerQuery(params: ListCoreV1NamespacedReplicationControllerRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedReplicationController(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedReplicationController() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedReplicationController(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedReplicationController() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedReplicationController(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedReplicationControllerQuery(params: ReadCoreV1NamespacedReplicationControllerRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedReplicationController(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedReplicationController() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedReplicationController(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedReplicationController() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedReplicationController(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedReplicationController() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedReplicationController(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedReplicationControllerScaleQuery(params: ReadCoreV1NamespacedReplicationControllerScaleRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_SCALE_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedReplicationControllerScale(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedReplicationControllerScale() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedReplicationControllerScale(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_SCALE_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedReplicationControllerScale() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedReplicationControllerScale(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_SCALE_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedReplicationControllerStatusQuery(params: ReadCoreV1NamespacedReplicationControllerStatusRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_STATUS_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedReplicationControllerStatus(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedReplicationControllerStatus() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedReplicationControllerStatus(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_STATUS_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedReplicationControllerStatus() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedReplicationControllerStatus(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_REPLICATIONCONTROLLERS_NAME_STATUS_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedResourceQuotaQuery(params: ListCoreV1NamespacedResourceQuotaRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedResourceQuota(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedResourceQuota() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedResourceQuota(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedResourceQuota() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedResourceQuota(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedResourceQuotaQuery(params: ReadCoreV1NamespacedResourceQuotaRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedResourceQuota(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedResourceQuota() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedResourceQuota(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedResourceQuota() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedResourceQuota(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedResourceQuota() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedResourceQuota(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedResourceQuotaStatusQuery(params: ReadCoreV1NamespacedResourceQuotaStatusRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_STATUS_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedResourceQuotaStatus(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedResourceQuotaStatus() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedResourceQuotaStatus(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_STATUS_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedResourceQuotaStatus() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedResourceQuotaStatus(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_RESOURCEQUOTAS_NAME_STATUS_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedSecretQuery(params: ListCoreV1NamespacedSecretRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SECRETS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedSecret(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedSecret() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedSecret(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SECRETS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedSecret() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedSecret(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SECRETS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedSecretQuery(params: ReadCoreV1NamespacedSecretRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SECRETS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedSecret(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedSecret() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedSecret(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SECRETS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedSecret() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedSecret(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SECRETS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedSecret() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedSecret(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SECRETS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedServiceAccountQuery(params: ListCoreV1NamespacedServiceAccountRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedServiceAccount(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedServiceAccount() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedServiceAccount(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1CollectionNamespacedServiceAccount() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1CollectionNamespacedServiceAccount(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedServiceAccountQuery(params: ReadCoreV1NamespacedServiceAccountRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedServiceAccount(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedServiceAccount() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedServiceAccount(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedServiceAccount() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedServiceAccount(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedServiceAccount() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedServiceAccount(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useCreateCoreV1NamespacedServiceAccountToken() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedServiceAccountToken(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICEACCOUNTS_NAME_TOKEN_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useListCoreV1NamespacedServiceQuery(params: ListCoreV1NamespacedServiceRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_KEY, params.path.namespace],
+ queryFn: async () => {
+ return await client.listCoreV1NamespacedService(params);
+ },
+ enabled: params.path.namespace !== undefined
+ });
+}
+export function useCreateCoreV1NamespacedService() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.createCoreV1NamespacedService(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_KEY, response.path.namespace]
+ });
+ }
+ });
+}
+export function useReadCoreV1NamespacedServiceQuery(params: ReadCoreV1NamespacedServiceRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.readCoreV1NamespacedService(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useReplaceCoreV1NamespacedService() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.replaceCoreV1NamespacedService(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useDeleteCoreV1NamespacedService() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.deleteCoreV1NamespacedService(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function usePatchCoreV1NamespacedService() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.patchCoreV1NamespacedService(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1GetNamespacedServiceProxyQuery(params: ConnectCoreV1GetNamespacedServiceProxyRequest) {
+ const client = useKubernetes().client;
+ return useQuery({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_PROXY_KEY, params.path.name, params.path.namespace],
+ queryFn: async () => {
+ return await client.connectCoreV1GetNamespacedServiceProxy(params);
+ },
+ enabled: params.path.name !== undefined && params.path.namespace !== undefined
+ });
+}
+export function useConnectCoreV1PostNamespacedServiceProxy() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PostNamespacedServiceProxy(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_PROXY_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1PutNamespacedServiceProxy() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PutNamespacedServiceProxy(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_PROXY_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1DeleteNamespacedServiceProxy() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1DeleteNamespacedServiceProxy(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_PROXY_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1PatchNamespacedServiceProxy() {
+ const client = useKubernetes().client;
+ const queryClient = useQueryClient();
+ return useMutation({
+ mutationFn: async request => {
+ return client.connectCoreV1PatchNamespacedServiceProxy(request);
+ },
+ onSuccess: (_, response) => {
+ queryClient.invalidateQueries({
+ queryKey: [...API_V1_NAMESPACES_NAMESPACE_SERVICES_NAME_PROXY_KEY, response.path.name, response.path.namespace]
+ });
+ }
+ });
+}
+export function useConnectCoreV1GetNamespacedServiceProxyWithPathQuery(params: ConnectCoreV1GetNamespacedServiceProxyWithPathRequest) {
+ const client = useKubernetes().client;
+ return useQuery