@k8slens/kubernetes-contracts 1.0.0

package/README.md

@@ -0,0 +1,31 @@
+# @k8slens/kubernetes-contracts
+
+What names and types a Kubernetes resource: every API version as a typed specifier, every kind Lens itself knows as a typed kind, and the types of the Kubernetes API, generated from [`@kubernetes/client-node`](https://github.com/kubernetes-client/javascript).
+
+```ts
+import { podKind, coreV1, type V1PodSpec, type KubeResource } from "@k8slens/kubernetes-contracts";
+
+type ServedPod = KubeResource<typeof podKind, typeof coreV1>; // metadata.name, metadata.uid and spec are required
+```
+
+- `getKubernetesApiVersion` and `getKubeResourceKind` declare an API version and a kind of your own, typed; `coreV1`, `appsV1`, `autoscalingV2`, ... and `podKind`, `deploymentKind`, ... are the built-in ones.
+- The schema types are named as client-node names them, the API version first: `V1Pod`, `V1PodSpec`, `V2HorizontalPodAutoscaler`. A kind carries its `apiVersion` and `kind` as literals, timestamps are the strings the API serves (`Time`, `MicroTime`), ports that may be named are `IntOrString`, and what the schema leaves open is `unknown`. Property names are the wire names. The few names client-node had to disambiguate keep their group prefix: `CoreV1Event` is the core `Event`, `EventsV1Event` the one of `events.k8s.io`.
+- `PodV1`, `DeploymentV1`, ... are the built-in kinds' resources as the API serves them, with the fields a served resource always carries made required.
+
+## Regenerating
+
+`src/generated/` is generated by `generator/` from the installed `@kubernetes/client-node` and the list of built-in kinds in `generator/built-in-kinds.ts`, and committed. When Dependabot bumps client-node, CI fails until the types are regenerated:
+
+```bash
+npm run generate --workspace @k8slens/kubernetes-contracts
+```
+
+`npm run generate:check --workspace @k8slens/kubernetes-contracts` is what CI runs. Which Kubernetes release the types describe, and which client-node version they came from, is recorded in the `kubernetes` field of `package.json` and in the header of every generated module.
+
+## Versioning
+
+Semver from conventional commits, like every `@k8slens` package: a regeneration that only adds fields is a `feat`, one that removes an API version is a breaking change. The Kubernetes release is not the package version.
+
+## Provenance
+
+Derived from `@kubernetes/client-node` (Apache-2.0), itself generated from the Kubernetes OpenAPI specification (Apache-2.0). This package is MIT like its siblings; the notices travel in the generated modules' headers. The field documentation is kept on purpose: it is the Kubernetes API reference, which is what an extension author needs at the call site.

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./src/generated/kubernetes-types";
+export { getKubernetesApiVersion, type KubernetesApiVersion } from "./src/kubernetes-api-version";
+export * from "./src/generated/api-versions";
+export { getKubeResourceKind, type KubeResource, type KubeResourceApiVersion, type KubeResourceBase, type KubeResourceKind, type KubeResourceShapes, type KubeResourceShapesOf, type KubeResourceType, } from "./src/kube-resource-kind";
+export * from "./src/generated/kinds";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAClG,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EACL,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,GACtB,MAAM,0BAA0B,CAAC;AAClC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,260 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  admissionregistrationV1: () => admissionregistrationV1,
+  admissionregistrationV1alpha1: () => admissionregistrationV1alpha1,
+  admissionregistrationV1beta1: () => admissionregistrationV1beta1,
+  apiextensionsV1: () => apiextensionsV1,
+  apiregistrationV1: () => apiregistrationV1,
+  appsV1: () => appsV1,
+  authenticationV1: () => authenticationV1,
+  authorizationV1: () => authorizationV1,
+  autoscalingV1: () => autoscalingV1,
+  autoscalingV2: () => autoscalingV2,
+  batchV1: () => batchV1,
+  certificatesV1: () => certificatesV1,
+  certificatesV1alpha1: () => certificatesV1alpha1,
+  certificatesV1beta1: () => certificatesV1beta1,
+  clusterRoleBindingKind: () => clusterRoleBindingKind,
+  clusterRoleKind: () => clusterRoleKind,
+  configMapKind: () => configMapKind,
+  coordinationV1: () => coordinationV1,
+  coordinationV1alpha2: () => coordinationV1alpha2,
+  coordinationV1beta1: () => coordinationV1beta1,
+  coreV1: () => coreV1,
+  cronJobKind: () => cronJobKind,
+  customResourceDefinitionKind: () => customResourceDefinitionKind,
+  daemonSetKind: () => daemonSetKind,
+  deploymentKind: () => deploymentKind,
+  discoveryV1: () => discoveryV1,
+  endpointSliceKind: () => endpointSliceKind,
+  endpointsKind: () => endpointsKind,
+  eventsV1: () => eventsV1,
+  flowcontrolApiserverV1: () => flowcontrolApiserverV1,
+  getKubeResourceKind: () => getKubeResourceKind,
+  getKubernetesApiVersion: () => getKubernetesApiVersion,
+  horizontalPodAutoscalerKind: () => horizontalPodAutoscalerKind,
+  ingressClassKind: () => ingressClassKind,
+  ingressKind: () => ingressKind,
+  internalApiserverV1alpha1: () => internalApiserverV1alpha1,
+  jobKind: () => jobKind,
+  leaseKind: () => leaseKind,
+  limitRangeKind: () => limitRangeKind,
+  mutatingWebhookConfigurationKind: () => mutatingWebhookConfigurationKind,
+  namespaceKind: () => namespaceKind,
+  networkPolicyKind: () => networkPolicyKind,
+  networkingV1: () => networkingV1,
+  networkingV1beta1: () => networkingV1beta1,
+  nodeKind: () => nodeKind,
+  nodeV1: () => nodeV1,
+  persistentVolumeClaimKind: () => persistentVolumeClaimKind,
+  persistentVolumeKind: () => persistentVolumeKind,
+  podDisruptionBudgetKind: () => podDisruptionBudgetKind,
+  podKind: () => podKind,
+  policyV1: () => policyV1,
+  priorityClassKind: () => priorityClassKind,
+  rbacAuthorizationV1: () => rbacAuthorizationV1,
+  replicaSetKind: () => replicaSetKind,
+  replicationControllerKind: () => replicationControllerKind,
+  resourceQuotaKind: () => resourceQuotaKind,
+  resourceV1: () => resourceV1,
+  resourceV1alpha3: () => resourceV1alpha3,
+  resourceV1beta1: () => resourceV1beta1,
+  resourceV1beta2: () => resourceV1beta2,
+  roleBindingKind: () => roleBindingKind,
+  roleKind: () => roleKind,
+  runtimeClassKind: () => runtimeClassKind,
+  schedulingV1: () => schedulingV1,
+  schedulingV1alpha2: () => schedulingV1alpha2,
+  secretKind: () => secretKind,
+  serviceAccountKind: () => serviceAccountKind,
+  serviceKind: () => serviceKind,
+  statefulSetKind: () => statefulSetKind,
+  storageClassKind: () => storageClassKind,
+  storageV1: () => storageV1,
+  storageV1beta1: () => storageV1beta1,
+  storagemigrationV1beta1: () => storagemigrationV1beta1,
+  validatingWebhookConfigurationKind: () => validatingWebhookConfigurationKind
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/kubernetes-api-version.ts
+var import_injectable = require("@k8slens/injectable");
+var getKubernetesApiVersion = (apiVersion) => (0, import_injectable.getTypedSpecifier)()(apiVersion);
+
+// src/generated/api-versions.ts
+var admissionregistrationV1 = getKubernetesApiVersion("admissionregistration.k8s.io/v1");
+var admissionregistrationV1alpha1 = getKubernetesApiVersion("admissionregistration.k8s.io/v1alpha1");
+var admissionregistrationV1beta1 = getKubernetesApiVersion("admissionregistration.k8s.io/v1beta1");
+var apiextensionsV1 = getKubernetesApiVersion("apiextensions.k8s.io/v1");
+var apiregistrationV1 = getKubernetesApiVersion("apiregistration.k8s.io/v1");
+var appsV1 = getKubernetesApiVersion("apps/v1");
+var authenticationV1 = getKubernetesApiVersion("authentication.k8s.io/v1");
+var authorizationV1 = getKubernetesApiVersion("authorization.k8s.io/v1");
+var autoscalingV1 = getKubernetesApiVersion("autoscaling/v1");
+var autoscalingV2 = getKubernetesApiVersion("autoscaling/v2");
+var batchV1 = getKubernetesApiVersion("batch/v1");
+var certificatesV1 = getKubernetesApiVersion("certificates.k8s.io/v1");
+var certificatesV1alpha1 = getKubernetesApiVersion("certificates.k8s.io/v1alpha1");
+var certificatesV1beta1 = getKubernetesApiVersion("certificates.k8s.io/v1beta1");
+var coordinationV1 = getKubernetesApiVersion("coordination.k8s.io/v1");
+var coordinationV1alpha2 = getKubernetesApiVersion("coordination.k8s.io/v1alpha2");
+var coordinationV1beta1 = getKubernetesApiVersion("coordination.k8s.io/v1beta1");
+var coreV1 = getKubernetesApiVersion("v1");
+var discoveryV1 = getKubernetesApiVersion("discovery.k8s.io/v1");
+var eventsV1 = getKubernetesApiVersion("events.k8s.io/v1");
+var flowcontrolApiserverV1 = getKubernetesApiVersion("flowcontrol.apiserver.k8s.io/v1");
+var internalApiserverV1alpha1 = getKubernetesApiVersion("internal.apiserver.k8s.io/v1alpha1");
+var networkingV1 = getKubernetesApiVersion("networking.k8s.io/v1");
+var networkingV1beta1 = getKubernetesApiVersion("networking.k8s.io/v1beta1");
+var nodeV1 = getKubernetesApiVersion("node.k8s.io/v1");
+var policyV1 = getKubernetesApiVersion("policy/v1");
+var rbacAuthorizationV1 = getKubernetesApiVersion("rbac.authorization.k8s.io/v1");
+var resourceV1 = getKubernetesApiVersion("resource.k8s.io/v1");
+var resourceV1alpha3 = getKubernetesApiVersion("resource.k8s.io/v1alpha3");
+var resourceV1beta1 = getKubernetesApiVersion("resource.k8s.io/v1beta1");
+var resourceV1beta2 = getKubernetesApiVersion("resource.k8s.io/v1beta2");
+var schedulingV1 = getKubernetesApiVersion("scheduling.k8s.io/v1");
+var schedulingV1alpha2 = getKubernetesApiVersion("scheduling.k8s.io/v1alpha2");
+var storagemigrationV1beta1 = getKubernetesApiVersion("storagemigration.k8s.io/v1beta1");
+var storageV1 = getKubernetesApiVersion("storage.k8s.io/v1");
+var storageV1beta1 = getKubernetesApiVersion("storage.k8s.io/v1beta1");
+
+// src/kube-resource-kind.ts
+var import_injectable2 = require("@k8slens/injectable");
+var getKubeResourceKind = (kind) => (0, import_injectable2.getTypedSpecifier)()(kind);
+
+// src/generated/kinds.ts
+var clusterRoleKind = getKubeResourceKind("ClusterRole");
+var clusterRoleBindingKind = getKubeResourceKind("ClusterRoleBinding");
+var configMapKind = getKubeResourceKind("ConfigMap");
+var cronJobKind = getKubeResourceKind("CronJob");
+var customResourceDefinitionKind = getKubeResourceKind("CustomResourceDefinition");
+var daemonSetKind = getKubeResourceKind("DaemonSet");
+var deploymentKind = getKubeResourceKind("Deployment");
+var endpointsKind = getKubeResourceKind("Endpoints");
+var endpointSliceKind = getKubeResourceKind("EndpointSlice");
+var horizontalPodAutoscalerKind = getKubeResourceKind("HorizontalPodAutoscaler");
+var ingressKind = getKubeResourceKind("Ingress");
+var ingressClassKind = getKubeResourceKind("IngressClass");
+var jobKind = getKubeResourceKind("Job");
+var leaseKind = getKubeResourceKind("Lease");
+var limitRangeKind = getKubeResourceKind("LimitRange");
+var mutatingWebhookConfigurationKind = getKubeResourceKind("MutatingWebhookConfiguration");
+var namespaceKind = getKubeResourceKind("Namespace");
+var networkPolicyKind = getKubeResourceKind("NetworkPolicy");
+var nodeKind = getKubeResourceKind("Node");
+var persistentVolumeKind = getKubeResourceKind("PersistentVolume");
+var persistentVolumeClaimKind = getKubeResourceKind("PersistentVolumeClaim");
+var podKind = getKubeResourceKind("Pod");
+var podDisruptionBudgetKind = getKubeResourceKind("PodDisruptionBudget");
+var priorityClassKind = getKubeResourceKind("PriorityClass");
+var replicaSetKind = getKubeResourceKind("ReplicaSet");
+var replicationControllerKind = getKubeResourceKind("ReplicationController");
+var resourceQuotaKind = getKubeResourceKind("ResourceQuota");
+var roleKind = getKubeResourceKind("Role");
+var roleBindingKind = getKubeResourceKind("RoleBinding");
+var runtimeClassKind = getKubeResourceKind("RuntimeClass");
+var secretKind = getKubeResourceKind("Secret");
+var serviceKind = getKubeResourceKind("Service");
+var serviceAccountKind = getKubeResourceKind("ServiceAccount");
+var statefulSetKind = getKubeResourceKind("StatefulSet");
+var storageClassKind = getKubeResourceKind("StorageClass");
+var validatingWebhookConfigurationKind = getKubeResourceKind("ValidatingWebhookConfiguration");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  admissionregistrationV1,
+  admissionregistrationV1alpha1,
+  admissionregistrationV1beta1,
+  apiextensionsV1,
+  apiregistrationV1,
+  appsV1,
+  authenticationV1,
+  authorizationV1,
+  autoscalingV1,
+  autoscalingV2,
+  batchV1,
+  certificatesV1,
+  certificatesV1alpha1,
+  certificatesV1beta1,
+  clusterRoleBindingKind,
+  clusterRoleKind,
+  configMapKind,
+  coordinationV1,
+  coordinationV1alpha2,
+  coordinationV1beta1,
+  coreV1,
+  cronJobKind,
+  customResourceDefinitionKind,
+  daemonSetKind,
+  deploymentKind,
+  discoveryV1,
+  endpointSliceKind,
+  endpointsKind,
+  eventsV1,
+  flowcontrolApiserverV1,
+  getKubeResourceKind,
+  getKubernetesApiVersion,
+  horizontalPodAutoscalerKind,
+  ingressClassKind,
+  ingressKind,
+  internalApiserverV1alpha1,
+  jobKind,
+  leaseKind,
+  limitRangeKind,
+  mutatingWebhookConfigurationKind,
+  namespaceKind,
+  networkPolicyKind,
+  networkingV1,
+  networkingV1beta1,
+  nodeKind,
+  nodeV1,
+  persistentVolumeClaimKind,
+  persistentVolumeKind,
+  podDisruptionBudgetKind,
+  podKind,
+  policyV1,
+  priorityClassKind,
+  rbacAuthorizationV1,
+  replicaSetKind,
+  replicationControllerKind,
+  resourceQuotaKind,
+  resourceV1,
+  resourceV1alpha3,
+  resourceV1beta1,
+  resourceV1beta2,
+  roleBindingKind,
+  roleKind,
+  runtimeClassKind,
+  schedulingV1,
+  schedulingV1alpha2,
+  secretKind,
+  serviceAccountKind,
+  serviceKind,
+  statefulSetKind,
+  storageClassKind,
+  storageV1,
+  storageV1beta1,
+  storagemigrationV1beta1,
+  validatingWebhookConfigurationKind
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../index.ts", "../src/kubernetes-api-version.ts", "../src/generated/api-versions.ts", "../src/kube-resource-kind.ts", "../src/generated/kinds.ts"],
  "sourcesContent": ["export * from \"./src/generated/kubernetes-types\";\nexport { getKubernetesApiVersion, type KubernetesApiVersion } from \"./src/kubernetes-api-version\";\nexport * from \"./src/generated/api-versions\";\nexport {\n  getKubeResourceKind,\n  type KubeResource,\n  type KubeResourceApiVersion,\n  type KubeResourceBase,\n  type KubeResourceKind,\n  type KubeResourceShapes,\n  type KubeResourceShapesOf,\n  type KubeResourceType,\n} from \"./src/kube-resource-kind\";\nexport * from \"./src/generated/kinds\";\n", "import { getTypedSpecifier, type TypedSpecifier } from \"@k8slens/injectable\";\n\n/**\n * Identifies one Kubernetes API version, the `apiVersion` of a resource: `v1`\n * for the core group, `<group>/<version>` for every other group. At runtime it\n * is that string verbatim, so it is usable as a `.for()` key wherever a contract\n * is keyed by API version; at the type level it is a distinct specifier, so a\n * kind, an id or a plain string cannot be passed where an API version belongs.\n *\n * Create one with {@link getKubernetesApiVersion}; the versions Lens itself\n * serves are exported ready-made, e.g. {@link coreV1} and {@link appsV1}.\n */\nexport type KubernetesApiVersion<S extends string = string> = TypedSpecifier<S, { kubernetesApiVersion: S }>;\n\n/**\n * Declares a Kubernetes API version. The argument is the `apiVersion` verbatim,\n * as it appears in every resource of that version.\n *\n * @example\n * ```ts\n * export const backupsV1 = getKubernetesApiVersion(\"backups.example.com/v1\");\n * ```\n */\nexport const getKubernetesApiVersion = <S extends string>(apiVersion: S) =>\n  getTypedSpecifier<{ kubernetesApiVersion: S }>()(apiVersion);\n", "/**\n * Every API version @kubernetes/client-node serves, as a typed specifier.\n *\n * GENERATED by packages/technical-features/_kube/kubernetes-contracts/generator. DO NOT EDIT.\n * Regenerate with `npm run generate --workspace @k8slens/kubernetes-contracts`.\n *\n * Derived from @kubernetes/client-node 2.0.0 (Apache-2.0), itself generated from the\n * Kubernetes OpenAPI specification, release-1.36 (Apache-2.0).\n */\n\nimport { getKubernetesApiVersion } from \"../kubernetes-api-version\";\n\n/** The `admissionregistration.k8s.io/v1` API version. */\nexport const admissionregistrationV1 = getKubernetesApiVersion(\"admissionregistration.k8s.io/v1\");\n\n/** The `admissionregistration.k8s.io/v1alpha1` API version. */\nexport const admissionregistrationV1alpha1 = getKubernetesApiVersion(\"admissionregistration.k8s.io/v1alpha1\");\n\n/** The `admissionregistration.k8s.io/v1beta1` API version. */\nexport const admissionregistrationV1beta1 = getKubernetesApiVersion(\"admissionregistration.k8s.io/v1beta1\");\n\n/** The `apiextensions.k8s.io/v1` API version. */\nexport const apiextensionsV1 = getKubernetesApiVersion(\"apiextensions.k8s.io/v1\");\n\n/** The `apiregistration.k8s.io/v1` API version. */\nexport const apiregistrationV1 = getKubernetesApiVersion(\"apiregistration.k8s.io/v1\");\n\n/** The `apps/v1` API version. */\nexport const appsV1 = getKubernetesApiVersion(\"apps/v1\");\n\n/** The `authentication.k8s.io/v1` API version. */\nexport const authenticationV1 = getKubernetesApiVersion(\"authentication.k8s.io/v1\");\n\n/** The `authorization.k8s.io/v1` API version. */\nexport const authorizationV1 = getKubernetesApiVersion(\"authorization.k8s.io/v1\");\n\n/** The `autoscaling/v1` API version. */\nexport const autoscalingV1 = getKubernetesApiVersion(\"autoscaling/v1\");\n\n/** The `autoscaling/v2` API version. */\nexport const autoscalingV2 = getKubernetesApiVersion(\"autoscaling/v2\");\n\n/** The `batch/v1` API version. */\nexport const batchV1 = getKubernetesApiVersion(\"batch/v1\");\n\n/** The `certificates.k8s.io/v1` API version. */\nexport const certificatesV1 = getKubernetesApiVersion(\"certificates.k8s.io/v1\");\n\n/** The `certificates.k8s.io/v1alpha1` API version. */\nexport const certificatesV1alpha1 = getKubernetesApiVersion(\"certificates.k8s.io/v1alpha1\");\n\n/** The `certificates.k8s.io/v1beta1` API version. */\nexport const certificatesV1beta1 = getKubernetesApiVersion(\"certificates.k8s.io/v1beta1\");\n\n/** The `coordination.k8s.io/v1` API version. */\nexport const coordinationV1 = getKubernetesApiVersion(\"coordination.k8s.io/v1\");\n\n/** The `coordination.k8s.io/v1alpha2` API version. */\nexport const coordinationV1alpha2 = getKubernetesApiVersion(\"coordination.k8s.io/v1alpha2\");\n\n/** The `coordination.k8s.io/v1beta1` API version. */\nexport const coordinationV1beta1 = getKubernetesApiVersion(\"coordination.k8s.io/v1beta1\");\n\n/** The `v1` API version. */\nexport const coreV1 = getKubernetesApiVersion(\"v1\");\n\n/** The `discovery.k8s.io/v1` API version. */\nexport const discoveryV1 = getKubernetesApiVersion(\"discovery.k8s.io/v1\");\n\n/** The `events.k8s.io/v1` API version. */\nexport const eventsV1 = getKubernetesApiVersion(\"events.k8s.io/v1\");\n\n/** The `flowcontrol.apiserver.k8s.io/v1` API version. */\nexport const flowcontrolApiserverV1 = getKubernetesApiVersion(\"flowcontrol.apiserver.k8s.io/v1\");\n\n/** The `internal.apiserver.k8s.io/v1alpha1` API version. */\nexport const internalApiserverV1alpha1 = getKubernetesApiVersion(\"internal.apiserver.k8s.io/v1alpha1\");\n\n/** The `networking.k8s.io/v1` API version. */\nexport const networkingV1 = getKubernetesApiVersion(\"networking.k8s.io/v1\");\n\n/** The `networking.k8s.io/v1beta1` API version. */\nexport const networkingV1beta1 = getKubernetesApiVersion(\"networking.k8s.io/v1beta1\");\n\n/** The `node.k8s.io/v1` API version. */\nexport const nodeV1 = getKubernetesApiVersion(\"node.k8s.io/v1\");\n\n/** The `policy/v1` API version. */\nexport const policyV1 = getKubernetesApiVersion(\"policy/v1\");\n\n/** The `rbac.authorization.k8s.io/v1` API version. */\nexport const rbacAuthorizationV1 = getKubernetesApiVersion(\"rbac.authorization.k8s.io/v1\");\n\n/** The `resource.k8s.io/v1` API version. */\nexport const resourceV1 = getKubernetesApiVersion(\"resource.k8s.io/v1\");\n\n/** The `resource.k8s.io/v1alpha3` API version. */\nexport const resourceV1alpha3 = getKubernetesApiVersion(\"resource.k8s.io/v1alpha3\");\n\n/** The `resource.k8s.io/v1beta1` API version. */\nexport const resourceV1beta1 = getKubernetesApiVersion(\"resource.k8s.io/v1beta1\");\n\n/** The `resource.k8s.io/v1beta2` API version. */\nexport const resourceV1beta2 = getKubernetesApiVersion(\"resource.k8s.io/v1beta2\");\n\n/** The `scheduling.k8s.io/v1` API version. */\nexport const schedulingV1 = getKubernetesApiVersion(\"scheduling.k8s.io/v1\");\n\n/** The `scheduling.k8s.io/v1alpha2` API version. */\nexport const schedulingV1alpha2 = getKubernetesApiVersion(\"scheduling.k8s.io/v1alpha2\");\n\n/** The `storagemigration.k8s.io/v1beta1` API version. */\nexport const storagemigrationV1beta1 = getKubernetesApiVersion(\"storagemigration.k8s.io/v1beta1\");\n\n/** The `storage.k8s.io/v1` API version. */\nexport const storageV1 = getKubernetesApiVersion(\"storage.k8s.io/v1\");\n\n/** The `storage.k8s.io/v1beta1` API version. */\nexport const storageV1beta1 = getKubernetesApiVersion(\"storage.k8s.io/v1beta1\");\n", "import { getTypedSpecifier, type TypedSpecifier, type TypedSpecifierType } from \"@k8slens/injectable\";\nimport type { KubernetesApiVersion } from \"./kubernetes-api-version\";\n\n/**\n * The shapes of a kind's resources, one per API version the kind is served in,\n * keyed by the `apiVersion` verbatim: `{ \"v1\": PodV1 }`, `{ \"autoscaling/v1\": HpaV1; \"autoscaling/v2\": HpaV2 }`.\n */\nexport type KubeResourceShapes = Record<string, {}>;\n\n/**\n * Identifies one Kubernetes resource kind, such as `Pod` or a custom resource's\n * kind. At runtime a kind is the Kubernetes `kind` string verbatim, so it is\n * usable as a `.for()` key wherever a contract is keyed by kind; at the type\n * level it carries the shape of the kind's resources per API version, so a\n * contract keyed by kind and then API version knows the exact resource it\n * handles.\n *\n * Create one with {@link getKubeResourceKind}.\n */\nexport type KubeResourceKind<Shapes extends KubeResourceShapes = KubeResourceShapes> = TypedSpecifier<\n  string,\n  { kubeResource: Shapes }\n>;\n\ntype IsAny<T> = 0 extends 1 & T ? true : false;\n\n/** The per-API-version shapes a {@link KubeResourceKind} was declared with; every shape when the kind is erased to `any`. */\nexport type KubeResourceShapesOf<TKind extends KubeResourceKind> = IsAny<TKind> extends true\n  ? KubeResourceShapes\n  : TypedSpecifierType<\"kubeResource\", TKind>;\n\n/**\n * An API version a {@link KubeResourceKind} is declared for: a\n * {@link KubernetesApiVersion} among the keys of the kind's shapes. Anything\n * else fails to compile where a versioned contract asks for one.\n */\nexport type KubeResourceApiVersion<TKind extends KubeResourceKind> = KubernetesApiVersion &\n  keyof KubeResourceShapesOf<TKind>;\n\n/**\n * The resource shape a {@link KubeResourceKind} was declared with for one API\n * version; every declared version at once when the version is left out, and\n * nothing beyond the common fields for a kind declared without shapes.\n */\nexport type KubeResourceType<\n  TKind extends KubeResourceKind,\n  TApiVersion extends keyof KubeResourceShapesOf<TKind> = keyof KubeResourceShapesOf<TKind>,\n> = [ShapeKeyFor<KubeResourceShapesOf<TKind>, TApiVersion>] extends [never]\n  ? {}\n  : KubeResourceShapesOf<TKind>[ShapeKeyFor<KubeResourceShapesOf<TKind>, TApiVersion>];\n\n/**\n * The key of `Shapes` an API version selects. An API version is a branded string,\n * and indexing with a branded string yields nothing, so the key is found by\n * matching the version against each key instead.\n */\ntype ShapeKeyFor<Shapes, TApiVersion> = {\n  [Key in keyof Shapes]: TApiVersion extends Key ? Key : never;\n}[keyof Shapes];\n\n/**\n * What every served resource carries, whatever its kind: the identity Lens keys\n * resources by. Intersected with a kind's shape, so a shape that leaves these\n * optional (schema-derived shapes do) still promises them once served.\n */\nexport interface KubeResourceBase {\n  kind: string;\n  apiVersion: string;\n\n  metadata: {\n    uid: string;\n    name: string;\n    selfLink: string;\n  };\n}\n\n/**\n * A resource of a {@link KubeResourceKind} in one API version, as Lens serves\n * it: the shape the kind was declared with for that version, with the fields\n * every served resource has guaranteed.\n */\nexport type KubeResource<\n  TKind extends KubeResourceKind = KubeResourceKind,\n  TApiVersion extends keyof KubeResourceShapesOf<TKind> = keyof KubeResourceShapesOf<TKind>,\n> = KubeResourceType<TKind, TApiVersion> & KubeResourceBase;\n\n/**\n * Declares a Kubernetes resource kind. The type parameter maps each API version\n * the kind is served in to the shape of its resources in that version; the\n * argument is the Kubernetes `kind` verbatim, as it appears in the `kind` field\n * of every such resource.\n *\n * @example\n * ```ts\n * export const backupKind = getKubeResourceKind<{\n *   \"backups.example.com/v1\": {\n *     kind: \"Backup\";\n *     metadata: { name: string; namespace: string };\n *     spec: { schedule: string; retentionDays: number };\n *     status?: { lastRun?: string };\n *   };\n * }>(\"Backup\");\n * ```\n */\nexport const getKubeResourceKind = <Shapes extends KubeResourceShapes = KubeResourceShapes>(kind: string) =>\n  getTypedSpecifier<{ kubeResource: Shapes }>()(kind);\n", "/**\n * The kinds Lens itself knows, declared for extensions: each resource type as the API\n * serves it, with the fields a served resource always carries made required, and the\n * typed kind to hand to any contract keyed by kind.\n *\n * GENERATED by packages/technical-features/_kube/kubernetes-contracts/generator. DO NOT EDIT.\n * Regenerate with `npm run generate --workspace @k8slens/kubernetes-contracts`.\n *\n * Derived from @kubernetes/client-node 2.0.0 (Apache-2.0), itself generated from the\n * Kubernetes OpenAPI specification, release-1.36 (Apache-2.0).\n */\n\nimport { getKubeResourceKind } from \"../kube-resource-kind\";\n\nimport type {\n  V1ClusterRole,\n  V1ClusterRoleBinding,\n  V1ConfigMap,\n  V1CronJob,\n  V1CustomResourceDefinition,\n  V1DaemonSet,\n  V1Deployment,\n  V1EndpointSlice,\n  V1Endpoints,\n  V1HorizontalPodAutoscaler,\n  V1Ingress,\n  V1IngressClass,\n  V1Job,\n  V1Lease,\n  V1LimitRange,\n  V1MutatingWebhookConfiguration,\n  V1Namespace,\n  V1NetworkPolicy,\n  V1Node,\n  V1ObjectMeta,\n  V1PersistentVolume,\n  V1PersistentVolumeClaim,\n  V1Pod,\n  V1PodDisruptionBudget,\n  V1PriorityClass,\n  V1ReplicaSet,\n  V1ReplicationController,\n  V1ResourceQuota,\n  V1Role,\n  V1RoleBinding,\n  V1RuntimeClass,\n  V1Secret,\n  V1Service,\n  V1ServiceAccount,\n  V1StatefulSet,\n  V1StorageClass,\n  V1ValidatingWebhookConfiguration,\n  V2HorizontalPodAutoscaler,\n} from \"./kubernetes-types\";\n\n/**\n * The metadata of a namespaced resource as the API serves it: the schema leaves\n * every field optional because the same type also describes what a client sends,\n * but a served resource always carries these.\n */\nexport type ServedNamespacedObjectMeta = V1ObjectMeta & {\n  name: string;\n  namespace: string;\n  uid: string;\n};\n\n/**\n * The metadata of a cluster-scoped resource as the API serves it: the schema leaves\n * every field optional because the same type also describes what a client sends,\n * but a served resource always carries these.\n */\nexport type ServedClusterScopedObjectMeta = V1ObjectMeta & {\n  name: string;\n  uid: string;\n};\n\n/**\n * A ClusterRole as `rbac.authorization.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served ClusterRole always carries made required.\n */\nexport type ClusterRoleV1 = Omit<V1ClusterRole, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"ClusterRole\";\n  apiVersion: \"rbac.authorization.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n};\n\n/**\n * The ClusterRole kind, declared for `rbac.authorization.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: clusterRoleKind, apiVersion: rbacAuthorizationV1, ... })`.\n */\nexport const clusterRoleKind = getKubeResourceKind<{\n  \"rbac.authorization.k8s.io/v1\": ClusterRoleV1;\n}>(\"ClusterRole\");\n\n/**\n * A ClusterRoleBinding as `rbac.authorization.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served ClusterRoleBinding always carries made required.\n */\nexport type ClusterRoleBindingV1 = Omit<V1ClusterRoleBinding, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"ClusterRoleBinding\";\n  apiVersion: \"rbac.authorization.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n};\n\n/**\n * The ClusterRoleBinding kind, declared for `rbac.authorization.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: clusterRoleBindingKind, apiVersion: rbacAuthorizationV1, ... })`.\n */\nexport const clusterRoleBindingKind = getKubeResourceKind<{\n  \"rbac.authorization.k8s.io/v1\": ClusterRoleBindingV1;\n}>(\"ClusterRoleBinding\");\n\n/**\n * A ConfigMap as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served ConfigMap always carries made required.\n */\nexport type ConfigMapV1 = Omit<V1ConfigMap, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"ConfigMap\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n};\n\n/**\n * The ConfigMap kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: configMapKind, apiVersion: coreV1, ... })`.\n */\nexport const configMapKind = getKubeResourceKind<{\n  v1: ConfigMapV1;\n}>(\"ConfigMap\");\n\n/**\n * A CronJob as `batch/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served CronJob always carries made required.\n */\nexport type CronJobV1 = Omit<V1CronJob, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"CronJob\";\n  apiVersion: \"batch/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1CronJob[\"spec\"]>;\n};\n\n/**\n * The CronJob kind, declared for `batch/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: cronJobKind, apiVersion: batchV1, ... })`.\n */\nexport const cronJobKind = getKubeResourceKind<{\n  \"batch/v1\": CronJobV1;\n}>(\"CronJob\");\n\n/**\n * A CustomResourceDefinition as `apiextensions.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served CustomResourceDefinition always carries made required.\n */\nexport type CustomResourceDefinitionV1 = Omit<\n  V1CustomResourceDefinition,\n  \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"\n> & {\n  kind: \"CustomResourceDefinition\";\n  apiVersion: \"apiextensions.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n  spec: NonNullable<V1CustomResourceDefinition[\"spec\"]>;\n};\n\n/**\n * The CustomResourceDefinition kind, declared for `apiextensions.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: customResourceDefinitionKind, apiVersion: apiextensionsV1, ... })`.\n */\nexport const customResourceDefinitionKind = getKubeResourceKind<{\n  \"apiextensions.k8s.io/v1\": CustomResourceDefinitionV1;\n}>(\"CustomResourceDefinition\");\n\n/**\n * A DaemonSet as `apps/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served DaemonSet always carries made required.\n */\nexport type DaemonSetV1 = Omit<V1DaemonSet, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"DaemonSet\";\n  apiVersion: \"apps/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1DaemonSet[\"spec\"]>;\n};\n\n/**\n * The DaemonSet kind, declared for `apps/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: daemonSetKind, apiVersion: appsV1, ... })`.\n */\nexport const daemonSetKind = getKubeResourceKind<{\n  \"apps/v1\": DaemonSetV1;\n}>(\"DaemonSet\");\n\n/**\n * A Deployment as `apps/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Deployment always carries made required.\n */\nexport type DeploymentV1 = Omit<V1Deployment, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"Deployment\";\n  apiVersion: \"apps/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1Deployment[\"spec\"]>;\n};\n\n/**\n * The Deployment kind, declared for `apps/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: deploymentKind, apiVersion: appsV1, ... })`.\n */\nexport const deploymentKind = getKubeResourceKind<{\n  \"apps/v1\": DeploymentV1;\n}>(\"Deployment\");\n\n/**\n * A Endpoints as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Endpoints always carries made required.\n */\nexport type EndpointsV1 = Omit<V1Endpoints, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"Endpoints\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n};\n\n/**\n * The Endpoints kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: endpointsKind, apiVersion: coreV1, ... })`.\n */\nexport const endpointsKind = getKubeResourceKind<{\n  v1: EndpointsV1;\n}>(\"Endpoints\");\n\n/**\n * A EndpointSlice as `discovery.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served EndpointSlice always carries made required.\n */\nexport type EndpointSliceV1 = Omit<V1EndpointSlice, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"EndpointSlice\";\n  apiVersion: \"discovery.k8s.io/v1\";\n  metadata: ServedNamespacedObjectMeta;\n};\n\n/**\n * The EndpointSlice kind, declared for `discovery.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: endpointSliceKind, apiVersion: discoveryV1, ... })`.\n */\nexport const endpointSliceKind = getKubeResourceKind<{\n  \"discovery.k8s.io/v1\": EndpointSliceV1;\n}>(\"EndpointSlice\");\n\n/**\n * A HorizontalPodAutoscaler as `autoscaling/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served HorizontalPodAutoscaler always carries made required.\n */\nexport type HorizontalPodAutoscalerV1 = Omit<V1HorizontalPodAutoscaler, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"HorizontalPodAutoscaler\";\n  apiVersion: \"autoscaling/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1HorizontalPodAutoscaler[\"spec\"]>;\n};\n\n/**\n * A HorizontalPodAutoscaler as `autoscaling/v2` serves it: the Kubernetes API schema of the kind, with the\n * fields a served HorizontalPodAutoscaler always carries made required.\n */\nexport type HorizontalPodAutoscalerV2 = Omit<V2HorizontalPodAutoscaler, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"HorizontalPodAutoscaler\";\n  apiVersion: \"autoscaling/v2\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V2HorizontalPodAutoscaler[\"spec\"]>;\n};\n\n/**\n * The HorizontalPodAutoscaler kind, declared for `autoscaling/v1`, `autoscaling/v2`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: horizontalPodAutoscalerKind, apiVersion: autoscalingV1, ... })`.\n */\nexport const horizontalPodAutoscalerKind = getKubeResourceKind<{\n  \"autoscaling/v1\": HorizontalPodAutoscalerV1;\n  \"autoscaling/v2\": HorizontalPodAutoscalerV2;\n}>(\"HorizontalPodAutoscaler\");\n\n/**\n * A Ingress as `networking.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Ingress always carries made required.\n */\nexport type IngressV1 = Omit<V1Ingress, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"Ingress\";\n  apiVersion: \"networking.k8s.io/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1Ingress[\"spec\"]>;\n};\n\n/**\n * The Ingress kind, declared for `networking.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: ingressKind, apiVersion: networkingV1, ... })`.\n */\nexport const ingressKind = getKubeResourceKind<{\n  \"networking.k8s.io/v1\": IngressV1;\n}>(\"Ingress\");\n\n/**\n * A IngressClass as `networking.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served IngressClass always carries made required.\n */\nexport type IngressClassV1 = Omit<V1IngressClass, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"IngressClass\";\n  apiVersion: \"networking.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n  spec: NonNullable<V1IngressClass[\"spec\"]>;\n};\n\n/**\n * The IngressClass kind, declared for `networking.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: ingressClassKind, apiVersion: networkingV1, ... })`.\n */\nexport const ingressClassKind = getKubeResourceKind<{\n  \"networking.k8s.io/v1\": IngressClassV1;\n}>(\"IngressClass\");\n\n/**\n * A Job as `batch/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Job always carries made required.\n */\nexport type JobV1 = Omit<V1Job, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"Job\";\n  apiVersion: \"batch/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1Job[\"spec\"]>;\n};\n\n/**\n * The Job kind, declared for `batch/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: jobKind, apiVersion: batchV1, ... })`.\n */\nexport const jobKind = getKubeResourceKind<{\n  \"batch/v1\": JobV1;\n}>(\"Job\");\n\n/**\n * A Lease as `coordination.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Lease always carries made required.\n */\nexport type LeaseV1 = Omit<V1Lease, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"Lease\";\n  apiVersion: \"coordination.k8s.io/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1Lease[\"spec\"]>;\n};\n\n/**\n * The Lease kind, declared for `coordination.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: leaseKind, apiVersion: coordinationV1, ... })`.\n */\nexport const leaseKind = getKubeResourceKind<{\n  \"coordination.k8s.io/v1\": LeaseV1;\n}>(\"Lease\");\n\n/**\n * A LimitRange as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served LimitRange always carries made required.\n */\nexport type LimitRangeV1 = Omit<V1LimitRange, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"LimitRange\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1LimitRange[\"spec\"]>;\n};\n\n/**\n * The LimitRange kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: limitRangeKind, apiVersion: coreV1, ... })`.\n */\nexport const limitRangeKind = getKubeResourceKind<{\n  v1: LimitRangeV1;\n}>(\"LimitRange\");\n\n/**\n * A MutatingWebhookConfiguration as `admissionregistration.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served MutatingWebhookConfiguration always carries made required.\n */\nexport type MutatingWebhookConfigurationV1 = Omit<\n  V1MutatingWebhookConfiguration,\n  \"kind\" | \"apiVersion\" | \"metadata\"\n> & {\n  kind: \"MutatingWebhookConfiguration\";\n  apiVersion: \"admissionregistration.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n};\n\n/**\n * The MutatingWebhookConfiguration kind, declared for `admissionregistration.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: mutatingWebhookConfigurationKind, apiVersion: admissionregistrationV1, ... })`.\n */\nexport const mutatingWebhookConfigurationKind = getKubeResourceKind<{\n  \"admissionregistration.k8s.io/v1\": MutatingWebhookConfigurationV1;\n}>(\"MutatingWebhookConfiguration\");\n\n/**\n * A Namespace as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Namespace always carries made required.\n */\nexport type NamespaceV1 = Omit<V1Namespace, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"Namespace\";\n  apiVersion: \"v1\";\n  metadata: ServedClusterScopedObjectMeta;\n  spec: NonNullable<V1Namespace[\"spec\"]>;\n};\n\n/**\n * The Namespace kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: namespaceKind, apiVersion: coreV1, ... })`.\n */\nexport const namespaceKind = getKubeResourceKind<{\n  v1: NamespaceV1;\n}>(\"Namespace\");\n\n/**\n * A NetworkPolicy as `networking.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served NetworkPolicy always carries made required.\n */\nexport type NetworkPolicyV1 = Omit<V1NetworkPolicy, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"NetworkPolicy\";\n  apiVersion: \"networking.k8s.io/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1NetworkPolicy[\"spec\"]>;\n};\n\n/**\n * The NetworkPolicy kind, declared for `networking.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: networkPolicyKind, apiVersion: networkingV1, ... })`.\n */\nexport const networkPolicyKind = getKubeResourceKind<{\n  \"networking.k8s.io/v1\": NetworkPolicyV1;\n}>(\"NetworkPolicy\");\n\n/**\n * A Node as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Node always carries made required.\n */\nexport type NodeV1 = Omit<V1Node, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"Node\";\n  apiVersion: \"v1\";\n  metadata: ServedClusterScopedObjectMeta;\n  spec: NonNullable<V1Node[\"spec\"]>;\n};\n\n/**\n * The Node kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: nodeKind, apiVersion: coreV1, ... })`.\n */\nexport const nodeKind = getKubeResourceKind<{\n  v1: NodeV1;\n}>(\"Node\");\n\n/**\n * A PersistentVolume as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served PersistentVolume always carries made required.\n */\nexport type PersistentVolumeV1 = Omit<V1PersistentVolume, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"PersistentVolume\";\n  apiVersion: \"v1\";\n  metadata: ServedClusterScopedObjectMeta;\n  spec: NonNullable<V1PersistentVolume[\"spec\"]>;\n};\n\n/**\n * The PersistentVolume kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: persistentVolumeKind, apiVersion: coreV1, ... })`.\n */\nexport const persistentVolumeKind = getKubeResourceKind<{\n  v1: PersistentVolumeV1;\n}>(\"PersistentVolume\");\n\n/**\n * A PersistentVolumeClaim as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served PersistentVolumeClaim always carries made required.\n */\nexport type PersistentVolumeClaimV1 = Omit<V1PersistentVolumeClaim, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"PersistentVolumeClaim\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1PersistentVolumeClaim[\"spec\"]>;\n};\n\n/**\n * The PersistentVolumeClaim kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: persistentVolumeClaimKind, apiVersion: coreV1, ... })`.\n */\nexport const persistentVolumeClaimKind = getKubeResourceKind<{\n  v1: PersistentVolumeClaimV1;\n}>(\"PersistentVolumeClaim\");\n\n/**\n * A Pod as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Pod always carries made required.\n */\nexport type PodV1 = Omit<V1Pod, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"Pod\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1Pod[\"spec\"]>;\n};\n\n/**\n * The Pod kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: podKind, apiVersion: coreV1, ... })`.\n */\nexport const podKind = getKubeResourceKind<{\n  v1: PodV1;\n}>(\"Pod\");\n\n/**\n * A PodDisruptionBudget as `policy/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served PodDisruptionBudget always carries made required.\n */\nexport type PodDisruptionBudgetV1 = Omit<V1PodDisruptionBudget, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"PodDisruptionBudget\";\n  apiVersion: \"policy/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1PodDisruptionBudget[\"spec\"]>;\n};\n\n/**\n * The PodDisruptionBudget kind, declared for `policy/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: podDisruptionBudgetKind, apiVersion: policyV1, ... })`.\n */\nexport const podDisruptionBudgetKind = getKubeResourceKind<{\n  \"policy/v1\": PodDisruptionBudgetV1;\n}>(\"PodDisruptionBudget\");\n\n/**\n * A PriorityClass as `scheduling.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served PriorityClass always carries made required.\n */\nexport type PriorityClassV1 = Omit<V1PriorityClass, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"PriorityClass\";\n  apiVersion: \"scheduling.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n};\n\n/**\n * The PriorityClass kind, declared for `scheduling.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: priorityClassKind, apiVersion: schedulingV1, ... })`.\n */\nexport const priorityClassKind = getKubeResourceKind<{\n  \"scheduling.k8s.io/v1\": PriorityClassV1;\n}>(\"PriorityClass\");\n\n/**\n * A ReplicaSet as `apps/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served ReplicaSet always carries made required.\n */\nexport type ReplicaSetV1 = Omit<V1ReplicaSet, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"ReplicaSet\";\n  apiVersion: \"apps/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1ReplicaSet[\"spec\"]>;\n};\n\n/**\n * The ReplicaSet kind, declared for `apps/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: replicaSetKind, apiVersion: appsV1, ... })`.\n */\nexport const replicaSetKind = getKubeResourceKind<{\n  \"apps/v1\": ReplicaSetV1;\n}>(\"ReplicaSet\");\n\n/**\n * A ReplicationController as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served ReplicationController always carries made required.\n */\nexport type ReplicationControllerV1 = Omit<V1ReplicationController, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"ReplicationController\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1ReplicationController[\"spec\"]>;\n};\n\n/**\n * The ReplicationController kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: replicationControllerKind, apiVersion: coreV1, ... })`.\n */\nexport const replicationControllerKind = getKubeResourceKind<{\n  v1: ReplicationControllerV1;\n}>(\"ReplicationController\");\n\n/**\n * A ResourceQuota as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served ResourceQuota always carries made required.\n */\nexport type ResourceQuotaV1 = Omit<V1ResourceQuota, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"ResourceQuota\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1ResourceQuota[\"spec\"]>;\n};\n\n/**\n * The ResourceQuota kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: resourceQuotaKind, apiVersion: coreV1, ... })`.\n */\nexport const resourceQuotaKind = getKubeResourceKind<{\n  v1: ResourceQuotaV1;\n}>(\"ResourceQuota\");\n\n/**\n * A Role as `rbac.authorization.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Role always carries made required.\n */\nexport type RoleV1 = Omit<V1Role, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"Role\";\n  apiVersion: \"rbac.authorization.k8s.io/v1\";\n  metadata: ServedNamespacedObjectMeta;\n};\n\n/**\n * The Role kind, declared for `rbac.authorization.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: roleKind, apiVersion: rbacAuthorizationV1, ... })`.\n */\nexport const roleKind = getKubeResourceKind<{\n  \"rbac.authorization.k8s.io/v1\": RoleV1;\n}>(\"Role\");\n\n/**\n * A RoleBinding as `rbac.authorization.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served RoleBinding always carries made required.\n */\nexport type RoleBindingV1 = Omit<V1RoleBinding, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"RoleBinding\";\n  apiVersion: \"rbac.authorization.k8s.io/v1\";\n  metadata: ServedNamespacedObjectMeta;\n};\n\n/**\n * The RoleBinding kind, declared for `rbac.authorization.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: roleBindingKind, apiVersion: rbacAuthorizationV1, ... })`.\n */\nexport const roleBindingKind = getKubeResourceKind<{\n  \"rbac.authorization.k8s.io/v1\": RoleBindingV1;\n}>(\"RoleBinding\");\n\n/**\n * A RuntimeClass as `node.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served RuntimeClass always carries made required.\n */\nexport type RuntimeClassV1 = Omit<V1RuntimeClass, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"RuntimeClass\";\n  apiVersion: \"node.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n};\n\n/**\n * The RuntimeClass kind, declared for `node.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: runtimeClassKind, apiVersion: nodeV1, ... })`.\n */\nexport const runtimeClassKind = getKubeResourceKind<{\n  \"node.k8s.io/v1\": RuntimeClassV1;\n}>(\"RuntimeClass\");\n\n/**\n * A Secret as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Secret always carries made required.\n */\nexport type SecretV1 = Omit<V1Secret, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"Secret\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n};\n\n/**\n * The Secret kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: secretKind, apiVersion: coreV1, ... })`.\n */\nexport const secretKind = getKubeResourceKind<{\n  v1: SecretV1;\n}>(\"Secret\");\n\n/**\n * A Service as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served Service always carries made required.\n */\nexport type ServiceV1 = Omit<V1Service, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"Service\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1Service[\"spec\"]>;\n};\n\n/**\n * The Service kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: serviceKind, apiVersion: coreV1, ... })`.\n */\nexport const serviceKind = getKubeResourceKind<{\n  v1: ServiceV1;\n}>(\"Service\");\n\n/**\n * A ServiceAccount as `v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served ServiceAccount always carries made required.\n */\nexport type ServiceAccountV1 = Omit<V1ServiceAccount, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"ServiceAccount\";\n  apiVersion: \"v1\";\n  metadata: ServedNamespacedObjectMeta;\n};\n\n/**\n * The ServiceAccount kind, declared for `v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: serviceAccountKind, apiVersion: coreV1, ... })`.\n */\nexport const serviceAccountKind = getKubeResourceKind<{\n  v1: ServiceAccountV1;\n}>(\"ServiceAccount\");\n\n/**\n * A StatefulSet as `apps/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served StatefulSet always carries made required.\n */\nexport type StatefulSetV1 = Omit<V1StatefulSet, \"kind\" | \"apiVersion\" | \"metadata\" | \"spec\"> & {\n  kind: \"StatefulSet\";\n  apiVersion: \"apps/v1\";\n  metadata: ServedNamespacedObjectMeta;\n  spec: NonNullable<V1StatefulSet[\"spec\"]>;\n};\n\n/**\n * The StatefulSet kind, declared for `apps/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: statefulSetKind, apiVersion: appsV1, ... })`.\n */\nexport const statefulSetKind = getKubeResourceKind<{\n  \"apps/v1\": StatefulSetV1;\n}>(\"StatefulSet\");\n\n/**\n * A StorageClass as `storage.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served StorageClass always carries made required.\n */\nexport type StorageClassV1 = Omit<V1StorageClass, \"kind\" | \"apiVersion\" | \"metadata\"> & {\n  kind: \"StorageClass\";\n  apiVersion: \"storage.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n};\n\n/**\n * The StorageClass kind, declared for `storage.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: storageClassKind, apiVersion: storageV1, ... })`.\n */\nexport const storageClassKind = getKubeResourceKind<{\n  \"storage.k8s.io/v1\": StorageClassV1;\n}>(\"StorageClass\");\n\n/**\n * A ValidatingWebhookConfiguration as `admissionregistration.k8s.io/v1` serves it: the Kubernetes API schema of the kind, with the\n * fields a served ValidatingWebhookConfiguration always carries made required.\n */\nexport type ValidatingWebhookConfigurationV1 = Omit<\n  V1ValidatingWebhookConfiguration,\n  \"kind\" | \"apiVersion\" | \"metadata\"\n> & {\n  kind: \"ValidatingWebhookConfiguration\";\n  apiVersion: \"admissionregistration.k8s.io/v1\";\n  metadata: ServedClusterScopedObjectMeta;\n};\n\n/**\n * The ValidatingWebhookConfiguration kind, declared for `admissionregistration.k8s.io/v1`. Hand it to any contract keyed by\n * kind, e.g. `buildDetailsPanelSectionBunch({ kind: validatingWebhookConfigurationKind, apiVersion: admissionregistrationV1, ... })`.\n */\nexport const validatingWebhookConfigurationKind = getKubeResourceKind<{\n  \"admissionregistration.k8s.io/v1\": ValidatingWebhookConfigurationV1;\n}>(\"ValidatingWebhookConfiguration\");\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,wBAAuD;AAuBhD,IAAM,0BAA0B,CAAmB,mBACxD,qCAA+C,EAAE,UAAU;;;ACXtD,IAAM,0BAA0B,wBAAwB,iCAAiC;AAGzF,IAAM,gCAAgC,wBAAwB,uCAAuC;AAGrG,IAAM,+BAA+B,wBAAwB,sCAAsC;AAGnG,IAAM,kBAAkB,wBAAwB,yBAAyB;AAGzE,IAAM,oBAAoB,wBAAwB,2BAA2B;AAG7E,IAAM,SAAS,wBAAwB,SAAS;AAGhD,IAAM,mBAAmB,wBAAwB,0BAA0B;AAG3E,IAAM,kBAAkB,wBAAwB,yBAAyB;AAGzE,IAAM,gBAAgB,wBAAwB,gBAAgB;AAG9D,IAAM,gBAAgB,wBAAwB,gBAAgB;AAG9D,IAAM,UAAU,wBAAwB,UAAU;AAGlD,IAAM,iBAAiB,wBAAwB,wBAAwB;AAGvE,IAAM,uBAAuB,wBAAwB,8BAA8B;AAGnF,IAAM,sBAAsB,wBAAwB,6BAA6B;AAGjF,IAAM,iBAAiB,wBAAwB,wBAAwB;AAGvE,IAAM,uBAAuB,wBAAwB,8BAA8B;AAGnF,IAAM,sBAAsB,wBAAwB,6BAA6B;AAGjF,IAAM,SAAS,wBAAwB,IAAI;AAG3C,IAAM,cAAc,wBAAwB,qBAAqB;AAGjE,IAAM,WAAW,wBAAwB,kBAAkB;AAG3D,IAAM,yBAAyB,wBAAwB,iCAAiC;AAGxF,IAAM,4BAA4B,wBAAwB,oCAAoC;AAG9F,IAAM,eAAe,wBAAwB,sBAAsB;AAGnE,IAAM,oBAAoB,wBAAwB,2BAA2B;AAG7E,IAAM,SAAS,wBAAwB,gBAAgB;AAGvD,IAAM,WAAW,wBAAwB,WAAW;AAGpD,IAAM,sBAAsB,wBAAwB,8BAA8B;AAGlF,IAAM,aAAa,wBAAwB,oBAAoB;AAG/D,IAAM,mBAAmB,wBAAwB,0BAA0B;AAG3E,IAAM,kBAAkB,wBAAwB,yBAAyB;AAGzE,IAAM,kBAAkB,wBAAwB,yBAAyB;AAGzE,IAAM,eAAe,wBAAwB,sBAAsB;AAGnE,IAAM,qBAAqB,wBAAwB,4BAA4B;AAG/E,IAAM,0BAA0B,wBAAwB,iCAAiC;AAGzF,IAAM,YAAY,wBAAwB,mBAAmB;AAG7D,IAAM,iBAAiB,wBAAwB,wBAAwB;;;ACtH9E,IAAAA,qBAAgF;AAwGzE,IAAM,sBAAsB,CAAyD,aAC1F,sCAA4C,EAAE,IAAI;;;ACf7C,IAAM,kBAAkB,oBAE5B,aAAa;AAgBT,IAAM,yBAAyB,oBAEnC,oBAAoB;AAgBhB,IAAM,gBAAgB,oBAE1B,WAAW;AAiBP,IAAM,cAAc,oBAExB,SAAS;AAoBL,IAAM,+BAA+B,oBAEzC,0BAA0B;AAiBtB,IAAM,gBAAgB,oBAE1B,WAAW;AAiBP,IAAM,iBAAiB,oBAE3B,YAAY;AAgBR,IAAM,gBAAgB,oBAE1B,WAAW;AAgBP,IAAM,oBAAoB,oBAE9B,eAAe;AA4BX,IAAM,8BAA8B,oBAGxC,yBAAyB;AAiBrB,IAAM,cAAc,oBAExB,SAAS;AAiBL,IAAM,mBAAmB,oBAE7B,cAAc;AAiBV,IAAM,UAAU,oBAEpB,KAAK;AAiBD,IAAM,YAAY,oBAEtB,OAAO;AAiBH,IAAM,iBAAiB,oBAE3B,YAAY;AAmBR,IAAM,mCAAmC,oBAE7C,8BAA8B;AAiB1B,IAAM,gBAAgB,oBAE1B,WAAW;AAiBP,IAAM,oBAAoB,oBAE9B,eAAe;AAiBX,IAAM,WAAW,oBAErB,MAAM;AAiBF,IAAM,uBAAuB,oBAEjC,kBAAkB;AAiBd,IAAM,4BAA4B,oBAEtC,uBAAuB;AAiBnB,IAAM,UAAU,oBAEpB,KAAK;AAiBD,IAAM,0BAA0B,oBAEpC,qBAAqB;AAgBjB,IAAM,oBAAoB,oBAE9B,eAAe;AAiBX,IAAM,iBAAiB,oBAE3B,YAAY;AAiBR,IAAM,4BAA4B,oBAEtC,uBAAuB;AAiBnB,IAAM,oBAAoB,oBAE9B,eAAe;AAgBX,IAAM,WAAW,oBAErB,MAAM;AAgBF,IAAM,kBAAkB,oBAE5B,aAAa;AAgBT,IAAM,mBAAmB,oBAE7B,cAAc;AAgBV,IAAM,aAAa,oBAEvB,QAAQ;AAiBJ,IAAM,cAAc,oBAExB,SAAS;AAgBL,IAAM,qBAAqB,oBAE/B,gBAAgB;AAiBZ,IAAM,kBAAkB,oBAE5B,aAAa;AAgBT,IAAM,mBAAmB,oBAE7B,cAAc;AAmBV,IAAM,qCAAqC,oBAE/C,gCAAgC;",
  "names": ["import_injectable"]
}


package/dist/src/generated/api-versions.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Every API version @kubernetes/client-node serves, as a typed specifier.
+ *
+ * GENERATED by packages/technical-features/_kube/kubernetes-contracts/generator. DO NOT EDIT.
+ * Regenerate with `npm run generate --workspace @k8slens/kubernetes-contracts`.
+ *
+ * Derived from @kubernetes/client-node 2.0.0 (Apache-2.0), itself generated from the
+ * Kubernetes OpenAPI specification, release-1.36 (Apache-2.0).
+ */
+/** The `admissionregistration.k8s.io/v1` API version. */
+export declare const admissionregistrationV1: import("@k8slens/injectable").TypedSpecifier<"admissionregistration.k8s.io/v1", {
+    kubernetesApiVersion: "admissionregistration.k8s.io/v1";
+}>;
+/** The `admissionregistration.k8s.io/v1alpha1` API version. */
+export declare const admissionregistrationV1alpha1: import("@k8slens/injectable").TypedSpecifier<"admissionregistration.k8s.io/v1alpha1", {
+    kubernetesApiVersion: "admissionregistration.k8s.io/v1alpha1";
+}>;
+/** The `admissionregistration.k8s.io/v1beta1` API version. */
+export declare const admissionregistrationV1beta1: import("@k8slens/injectable").TypedSpecifier<"admissionregistration.k8s.io/v1beta1", {
+    kubernetesApiVersion: "admissionregistration.k8s.io/v1beta1";
+}>;
+/** The `apiextensions.k8s.io/v1` API version. */
+export declare const apiextensionsV1: import("@k8slens/injectable").TypedSpecifier<"apiextensions.k8s.io/v1", {
+    kubernetesApiVersion: "apiextensions.k8s.io/v1";
+}>;
+/** The `apiregistration.k8s.io/v1` API version. */
+export declare const apiregistrationV1: import("@k8slens/injectable").TypedSpecifier<"apiregistration.k8s.io/v1", {
+    kubernetesApiVersion: "apiregistration.k8s.io/v1";
+}>;
+/** The `apps/v1` API version. */
+export declare const appsV1: import("@k8slens/injectable").TypedSpecifier<"apps/v1", {
+    kubernetesApiVersion: "apps/v1";
+}>;
+/** The `authentication.k8s.io/v1` API version. */
+export declare const authenticationV1: import("@k8slens/injectable").TypedSpecifier<"authentication.k8s.io/v1", {
+    kubernetesApiVersion: "authentication.k8s.io/v1";
+}>;
+/** The `authorization.k8s.io/v1` API version. */
+export declare const authorizationV1: import("@k8slens/injectable").TypedSpecifier<"authorization.k8s.io/v1", {
+    kubernetesApiVersion: "authorization.k8s.io/v1";
+}>;
+/** The `autoscaling/v1` API version. */
+export declare const autoscalingV1: import("@k8slens/injectable").TypedSpecifier<"autoscaling/v1", {
+    kubernetesApiVersion: "autoscaling/v1";
+}>;
+/** The `autoscaling/v2` API version. */
+export declare const autoscalingV2: import("@k8slens/injectable").TypedSpecifier<"autoscaling/v2", {
+    kubernetesApiVersion: "autoscaling/v2";
+}>;
+/** The `batch/v1` API version. */
+export declare const batchV1: import("@k8slens/injectable").TypedSpecifier<"batch/v1", {
+    kubernetesApiVersion: "batch/v1";
+}>;
+/** The `certificates.k8s.io/v1` API version. */
+export declare const certificatesV1: import("@k8slens/injectable").TypedSpecifier<"certificates.k8s.io/v1", {
+    kubernetesApiVersion: "certificates.k8s.io/v1";
+}>;
+/** The `certificates.k8s.io/v1alpha1` API version. */
+export declare const certificatesV1alpha1: import("@k8slens/injectable").TypedSpecifier<"certificates.k8s.io/v1alpha1", {
+    kubernetesApiVersion: "certificates.k8s.io/v1alpha1";
+}>;
+/** The `certificates.k8s.io/v1beta1` API version. */
+export declare const certificatesV1beta1: import("@k8slens/injectable").TypedSpecifier<"certificates.k8s.io/v1beta1", {
+    kubernetesApiVersion: "certificates.k8s.io/v1beta1";
+}>;
+/** The `coordination.k8s.io/v1` API version. */
+export declare const coordinationV1: import("@k8slens/injectable").TypedSpecifier<"coordination.k8s.io/v1", {
+    kubernetesApiVersion: "coordination.k8s.io/v1";
+}>;
+/** The `coordination.k8s.io/v1alpha2` API version. */
+export declare const coordinationV1alpha2: import("@k8slens/injectable").TypedSpecifier<"coordination.k8s.io/v1alpha2", {
+    kubernetesApiVersion: "coordination.k8s.io/v1alpha2";
+}>;
+/** The `coordination.k8s.io/v1beta1` API version. */
+export declare const coordinationV1beta1: import("@k8slens/injectable").TypedSpecifier<"coordination.k8s.io/v1beta1", {
+    kubernetesApiVersion: "coordination.k8s.io/v1beta1";
+}>;
+/** The `v1` API version. */
+export declare const coreV1: import("@k8slens/injectable").TypedSpecifier<"v1", {
+    kubernetesApiVersion: "v1";
+}>;
+/** The `discovery.k8s.io/v1` API version. */
+export declare const discoveryV1: import("@k8slens/injectable").TypedSpecifier<"discovery.k8s.io/v1", {
+    kubernetesApiVersion: "discovery.k8s.io/v1";
+}>;
+/** The `events.k8s.io/v1` API version. */
+export declare const eventsV1: import("@k8slens/injectable").TypedSpecifier<"events.k8s.io/v1", {
+    kubernetesApiVersion: "events.k8s.io/v1";
+}>;
+/** The `flowcontrol.apiserver.k8s.io/v1` API version. */
+export declare const flowcontrolApiserverV1: import("@k8slens/injectable").TypedSpecifier<"flowcontrol.apiserver.k8s.io/v1", {
+    kubernetesApiVersion: "flowcontrol.apiserver.k8s.io/v1";
+}>;
+/** The `internal.apiserver.k8s.io/v1alpha1` API version. */
+export declare const internalApiserverV1alpha1: import("@k8slens/injectable").TypedSpecifier<"internal.apiserver.k8s.io/v1alpha1", {
+    kubernetesApiVersion: "internal.apiserver.k8s.io/v1alpha1";
+}>;
+/** The `networking.k8s.io/v1` API version. */
+export declare const networkingV1: import("@k8slens/injectable").TypedSpecifier<"networking.k8s.io/v1", {
+    kubernetesApiVersion: "networking.k8s.io/v1";
+}>;
+/** The `networking.k8s.io/v1beta1` API version. */
+export declare const networkingV1beta1: import("@k8slens/injectable").TypedSpecifier<"networking.k8s.io/v1beta1", {
+    kubernetesApiVersion: "networking.k8s.io/v1beta1";
+}>;
+/** The `node.k8s.io/v1` API version. */
+export declare const nodeV1: import("@k8slens/injectable").TypedSpecifier<"node.k8s.io/v1", {
+    kubernetesApiVersion: "node.k8s.io/v1";
+}>;
+/** The `policy/v1` API version. */
+export declare const policyV1: import("@k8slens/injectable").TypedSpecifier<"policy/v1", {
+    kubernetesApiVersion: "policy/v1";
+}>;
+/** The `rbac.authorization.k8s.io/v1` API version. */
+export declare const rbacAuthorizationV1: import("@k8slens/injectable").TypedSpecifier<"rbac.authorization.k8s.io/v1", {
+    kubernetesApiVersion: "rbac.authorization.k8s.io/v1";
+}>;
+/** The `resource.k8s.io/v1` API version. */
+export declare const resourceV1: import("@k8slens/injectable").TypedSpecifier<"resource.k8s.io/v1", {
+    kubernetesApiVersion: "resource.k8s.io/v1";
+}>;
+/** The `resource.k8s.io/v1alpha3` API version. */
+export declare const resourceV1alpha3: import("@k8slens/injectable").TypedSpecifier<"resource.k8s.io/v1alpha3", {
+    kubernetesApiVersion: "resource.k8s.io/v1alpha3";
+}>;
+/** The `resource.k8s.io/v1beta1` API version. */
+export declare const resourceV1beta1: import("@k8slens/injectable").TypedSpecifier<"resource.k8s.io/v1beta1", {
+    kubernetesApiVersion: "resource.k8s.io/v1beta1";
+}>;
+/** The `resource.k8s.io/v1beta2` API version. */
+export declare const resourceV1beta2: import("@k8slens/injectable").TypedSpecifier<"resource.k8s.io/v1beta2", {
+    kubernetesApiVersion: "resource.k8s.io/v1beta2";
+}>;
+/** The `scheduling.k8s.io/v1` API version. */
+export declare const schedulingV1: import("@k8slens/injectable").TypedSpecifier<"scheduling.k8s.io/v1", {
+    kubernetesApiVersion: "scheduling.k8s.io/v1";
+}>;
+/** The `scheduling.k8s.io/v1alpha2` API version. */
+export declare const schedulingV1alpha2: import("@k8slens/injectable").TypedSpecifier<"scheduling.k8s.io/v1alpha2", {
+    kubernetesApiVersion: "scheduling.k8s.io/v1alpha2";
+}>;
+/** The `storagemigration.k8s.io/v1beta1` API version. */
+export declare const storagemigrationV1beta1: import("@k8slens/injectable").TypedSpecifier<"storagemigration.k8s.io/v1beta1", {
+    kubernetesApiVersion: "storagemigration.k8s.io/v1beta1";
+}>;
+/** The `storage.k8s.io/v1` API version. */
+export declare const storageV1: import("@k8slens/injectable").TypedSpecifier<"storage.k8s.io/v1", {
+    kubernetesApiVersion: "storage.k8s.io/v1";
+}>;
+/** The `storage.k8s.io/v1beta1` API version. */
+export declare const storageV1beta1: import("@k8slens/injectable").TypedSpecifier<"storage.k8s.io/v1beta1", {
+    kubernetesApiVersion: "storage.k8s.io/v1beta1";
+}>;
+//# sourceMappingURL=api-versions.d.ts.map

package/dist/src/generated/api-versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-versions.d.ts","sourceRoot":"","sources":["../../../src/generated/api-versions.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,yDAAyD;AACzD,eAAO,MAAM,uBAAuB;;EAA6D,CAAC;AAElG,+DAA+D;AAC/D,eAAO,MAAM,6BAA6B;;EAAmE,CAAC;AAE9G,8DAA8D;AAC9D,eAAO,MAAM,4BAA4B;;EAAkE,CAAC;AAE5G,iDAAiD;AACjD,eAAO,MAAM,eAAe;;EAAqD,CAAC;AAElF,mDAAmD;AACnD,eAAO,MAAM,iBAAiB;;EAAuD,CAAC;AAEtF,iCAAiC;AACjC,eAAO,MAAM,MAAM;;EAAqC,CAAC;AAEzD,kDAAkD;AAClD,eAAO,MAAM,gBAAgB;;EAAsD,CAAC;AAEpF,iDAAiD;AACjD,eAAO,MAAM,eAAe;;EAAqD,CAAC;AAElF,wCAAwC;AACxC,eAAO,MAAM,aAAa;;EAA4C,CAAC;AAEvE,wCAAwC;AACxC,eAAO,MAAM,aAAa;;EAA4C,CAAC;AAEvE,kCAAkC;AAClC,eAAO,MAAM,OAAO;;EAAsC,CAAC;AAE3D,gDAAgD;AAChD,eAAO,MAAM,cAAc;;EAAoD,CAAC;AAEhF,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;EAA0D,CAAC;AAE5F,qDAAqD;AACrD,eAAO,MAAM,mBAAmB;;EAAyD,CAAC;AAE1F,gDAAgD;AAChD,eAAO,MAAM,cAAc;;EAAoD,CAAC;AAEhF,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;EAA0D,CAAC;AAE5F,qDAAqD;AACrD,eAAO,MAAM,mBAAmB;;EAAyD,CAAC;AAE1F,4BAA4B;AAC5B,eAAO,MAAM,MAAM;;EAAgC,CAAC;AAEpD,6CAA6C;AAC7C,eAAO,MAAM,WAAW;;EAAiD,CAAC;AAE1E,0CAA0C;AAC1C,eAAO,MAAM,QAAQ;;EAA8C,CAAC;AAEpE,yDAAyD;AACzD,eAAO,MAAM,sBAAsB;;EAA6D,CAAC;AAEjG,4DAA4D;AAC5D,eAAO,MAAM,yBAAyB;;EAAgE,CAAC;AAEvG,8CAA8C;AAC9C,eAAO,MAAM,YAAY;;EAAkD,CAAC;AAE5E,mDAAmD;AACnD,eAAO,MAAM,iBAAiB;;EAAuD,CAAC;AAEtF,wCAAwC;AACxC,eAAO,MAAM,MAAM;;EAA4C,CAAC;AAEhE,mCAAmC;AACnC,eAAO,MAAM,QAAQ;;EAAuC,CAAC;AAE7D,sDAAsD;AACtD,eAAO,MAAM,mBAAmB;;EAA0D,CAAC;AAE3F,4CAA4C;AAC5C,eAAO,MAAM,UAAU;;EAAgD,CAAC;AAExE,kDAAkD;AAClD,eAAO,MAAM,gBAAgB;;EAAsD,CAAC;AAEpF,iDAAiD;AACjD,eAAO,MAAM,eAAe;;EAAqD,CAAC;AAElF,iDAAiD;AACjD,eAAO,MAAM,eAAe;;EAAqD,CAAC;AAElF,8CAA8C;AAC9C,eAAO,MAAM,YAAY;;EAAkD,CAAC;AAE5E,oDAAoD;AACpD,eAAO,MAAM,kBAAkB;;EAAwD,CAAC;AAExF,yDAAyD;AACzD,eAAO,MAAM,uBAAuB;;EAA6D,CAAC;AAElG,2CAA2C;AAC3C,eAAO,MAAM,SAAS;;EAA+C,CAAC;AAEtE,gDAAgD;AAChD,eAAO,MAAM,cAAc;;EAAoD,CAAC"}