diff --git a/api/api-rules/violation_exceptions.list b/api/api-rules/violation_exceptions.list index 21aeefa21a5..7f0453e4c6d 100644 --- a/api/api-rules/violation_exceptions.list +++ b/api/api-rules/violation_exceptions.list @@ -531,6 +531,7 @@ API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,K API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,KubeControllerManagerConfiguration,ServiceController API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,KubeControllerManagerConfiguration,StatefulSetController API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,KubeControllerManagerConfiguration,TTLAfterFinishedController +API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,KubeControllerManagerConfiguration,ValidatingAdmissionPolicyStatusController API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,LegacySATokenCleanerConfiguration,CleanUpPeriod API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,NamespaceControllerConfiguration,ConcurrentNamespaceSyncs API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,NamespaceControllerConfiguration,NamespaceSyncPeriod @@ -567,6 +568,7 @@ API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,S API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,SAControllerConfiguration,ServiceAccountKeyFile API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,StatefulSetControllerConfiguration,ConcurrentStatefulSetSyncs API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,TTLAfterFinishedControllerConfiguration,ConcurrentTTLSyncs +API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,ValidatingAdmissionPolicyStatusControllerConfiguration,ConcurrentPolicySyncs API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,VolumeConfiguration,EnableDynamicProvisioning API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,VolumeConfiguration,EnableHostPathProvisioning API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,VolumeConfiguration,FlexVolumePluginDir diff --git a/cmd/kube-apiserver/app/server.go b/cmd/kube-apiserver/app/server.go index b021bac2574..dad9383ed48 100644 --- a/cmd/kube-apiserver/app/server.go +++ b/cmd/kube-apiserver/app/server.go @@ -35,7 +35,6 @@ import ( utilnet "k8s.io/apimachinery/pkg/util/net" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apiserver/pkg/admission" - "k8s.io/apiserver/pkg/cel/openapi/resolver" genericapifilters "k8s.io/apiserver/pkg/endpoints/filters" genericapiserver "k8s.io/apiserver/pkg/server" "k8s.io/apiserver/pkg/server/egressselector" @@ -45,7 +44,6 @@ import ( "k8s.io/client-go/dynamic" clientgoinformers "k8s.io/client-go/informers" clientset "k8s.io/client-go/kubernetes" - k8sscheme "k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/rest" "k8s.io/client-go/util/keyutil" cliflag "k8s.io/component-base/cli/flag" @@ -285,8 +283,7 @@ func CreateKubeAPIServerConfig(opts options.CompletedOptions) ( CloudConfigFile: opts.CloudProvider.CloudConfigFile, } serviceResolver := buildServiceResolver(opts.EnableAggregatorRouting, genericConfig.LoopbackClientConfig.Host, versionedInformers) - schemaResolver := resolver.NewDefinitionsSchemaResolver(k8sscheme.Scheme, genericConfig.OpenAPIConfig.GetDefinitions) - pluginInitializers, admissionPostStartHook, err := admissionConfig.New(proxyTransport, genericConfig.EgressSelector, serviceResolver, genericConfig.TracerProvider, schemaResolver) + pluginInitializers, admissionPostStartHook, err := admissionConfig.New(proxyTransport, genericConfig.EgressSelector, serviceResolver, genericConfig.TracerProvider) if err != nil { return nil, nil, nil, fmt.Errorf("failed to create admission plugin initializer: %v", err) } diff --git a/cmd/kube-controller-manager/app/controllermanager.go b/cmd/kube-controller-manager/app/controllermanager.go index e0350af380a..e0ebfc9dbba 100644 --- a/cmd/kube-controller-manager/app/controllermanager.go +++ b/cmd/kube-controller-manager/app/controllermanager.go @@ -484,6 +484,9 @@ func NewControllerInitializers(loopMode ControllerLoopMode) map[string]InitFunc if utilfeature.DefaultFeatureGate.Enabled(kubefeatures.LegacyServiceAccountTokenCleanUp) { register(names.LegacyServiceAccountTokenCleanerController, startLegacySATokenCleaner) } + if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.ValidatingAdmissionPolicy) { + register("validatingadmissionpolicy-status-controller", startValidatingAdmissionPolicyStatusController) + } return controllers } diff --git a/cmd/kube-controller-manager/app/options/options.go b/cmd/kube-controller-manager/app/options/options.go index ce209c640b7..1c3e4edb178 100644 --- a/cmd/kube-controller-manager/app/options/options.go +++ b/cmd/kube-controller-manager/app/options/options.go @@ -62,31 +62,32 @@ type KubeControllerManagerOptions struct { KubeCloudShared *cpoptions.KubeCloudSharedOptions ServiceController *cpoptions.ServiceControllerOptions - AttachDetachController *AttachDetachControllerOptions - CSRSigningController *CSRSigningControllerOptions - DaemonSetController *DaemonSetControllerOptions - DeploymentController *DeploymentControllerOptions - StatefulSetController *StatefulSetControllerOptions - DeprecatedFlags *DeprecatedControllerOptions - EndpointController *EndpointControllerOptions - EndpointSliceController *EndpointSliceControllerOptions - EndpointSliceMirroringController *EndpointSliceMirroringControllerOptions - EphemeralVolumeController *EphemeralVolumeControllerOptions - GarbageCollectorController *GarbageCollectorControllerOptions - HPAController *HPAControllerOptions - JobController *JobControllerOptions - CronJobController *CronJobControllerOptions - LegacySATokenCleaner *LegacySATokenCleanerOptions - NamespaceController *NamespaceControllerOptions - NodeIPAMController *NodeIPAMControllerOptions - NodeLifecycleController *NodeLifecycleControllerOptions - PersistentVolumeBinderController *PersistentVolumeBinderControllerOptions - PodGCController *PodGCControllerOptions - ReplicaSetController *ReplicaSetControllerOptions - ReplicationController *ReplicationControllerOptions - ResourceQuotaController *ResourceQuotaControllerOptions - SAController *SAControllerOptions - TTLAfterFinishedController *TTLAfterFinishedControllerOptions + AttachDetachController *AttachDetachControllerOptions + CSRSigningController *CSRSigningControllerOptions + DaemonSetController *DaemonSetControllerOptions + DeploymentController *DeploymentControllerOptions + StatefulSetController *StatefulSetControllerOptions + DeprecatedFlags *DeprecatedControllerOptions + EndpointController *EndpointControllerOptions + EndpointSliceController *EndpointSliceControllerOptions + EndpointSliceMirroringController *EndpointSliceMirroringControllerOptions + EphemeralVolumeController *EphemeralVolumeControllerOptions + GarbageCollectorController *GarbageCollectorControllerOptions + HPAController *HPAControllerOptions + JobController *JobControllerOptions + CronJobController *CronJobControllerOptions + LegacySATokenCleaner *LegacySATokenCleanerOptions + NamespaceController *NamespaceControllerOptions + NodeIPAMController *NodeIPAMControllerOptions + NodeLifecycleController *NodeLifecycleControllerOptions + PersistentVolumeBinderController *PersistentVolumeBinderControllerOptions + PodGCController *PodGCControllerOptions + ReplicaSetController *ReplicaSetControllerOptions + ReplicationController *ReplicationControllerOptions + ResourceQuotaController *ResourceQuotaControllerOptions + SAController *SAControllerOptions + TTLAfterFinishedController *TTLAfterFinishedControllerOptions + ValidatingAdmissionPolicyStatusController *ValidatingAdmissionPolicyStatusControllerOptions SecureServing *apiserveroptions.SecureServingOptionsWithLoopback Authentication *apiserveroptions.DelegatingAuthenticationOptions @@ -186,6 +187,9 @@ func NewKubeControllerManagerOptions() (*KubeControllerManagerOptions, error) { TTLAfterFinishedController: &TTLAfterFinishedControllerOptions{ &componentConfig.TTLAfterFinishedController, }, + ValidatingAdmissionPolicyStatusController: &ValidatingAdmissionPolicyStatusControllerOptions{ + &componentConfig.ValidatingAdmissionPolicyStatusController, + }, SecureServing: apiserveroptions.NewSecureServingOptions().WithLoopback(), Authentication: apiserveroptions.NewDelegatingAuthenticationOptions(), Authorization: apiserveroptions.NewDelegatingAuthorizationOptions(), @@ -261,6 +265,7 @@ func (s *KubeControllerManagerOptions) Flags(allControllers []string, disabledBy s.ResourceQuotaController.AddFlags(fss.FlagSet(names.ResourceQuotaController)) s.SAController.AddFlags(fss.FlagSet(names.ServiceAccountController)) s.TTLAfterFinishedController.AddFlags(fss.FlagSet(names.TTLAfterFinishedController)) + s.ValidatingAdmissionPolicyStatusController.AddFlags(fss.FlagSet(names.ValidatingAdmissionPolicyStatusController)) s.Metrics.AddFlags(fss.FlagSet("metrics")) logsapi.AddFlags(s.Logs, fss.FlagSet("logs")) @@ -359,6 +364,9 @@ func (s *KubeControllerManagerOptions) ApplyTo(c *kubecontrollerconfig.Config, a if err := s.TTLAfterFinishedController.ApplyTo(&c.ComponentConfig.TTLAfterFinishedController); err != nil { return err } + if err := s.ValidatingAdmissionPolicyStatusController.ApplyTo(&c.ComponentConfig.ValidatingAdmissionPolicyStatusController); err != nil { + return err + } if err := s.SecureServing.ApplyTo(&c.SecureServing, &c.LoopbackClientConfig); err != nil { return err } diff --git a/cmd/kube-controller-manager/app/options/options_test.go b/cmd/kube-controller-manager/app/options/options_test.go index 571a64dbea7..97d42092f83 100644 --- a/cmd/kube-controller-manager/app/options/options_test.go +++ b/cmd/kube-controller-manager/app/options/options_test.go @@ -63,6 +63,7 @@ import ( serviceaccountconfig "k8s.io/kubernetes/pkg/controller/serviceaccount/config" statefulsetconfig "k8s.io/kubernetes/pkg/controller/statefulset/config" ttlafterfinishedconfig "k8s.io/kubernetes/pkg/controller/ttlafterfinished/config" + validatingadmissionpolicystatusconfig "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config" attachdetachconfig "k8s.io/kubernetes/pkg/controller/volume/attachdetach/config" ephemeralvolumeconfig "k8s.io/kubernetes/pkg/controller/volume/ephemeral/config" persistentvolumeconfig "k8s.io/kubernetes/pkg/controller/volume/persistentvolume/config" @@ -101,6 +102,7 @@ var args = []string{ "--concurrent-service-syncs=2", "--concurrent-serviceaccount-token-syncs=10", "--concurrent_rc_syncs=10", + "--concurrent-validating-admission-policy-status-syncs=9", "--configure-cloud-routes=false", "--contention-profiling=true", "--controller-start-interval=2m", @@ -409,6 +411,11 @@ func TestAddFlags(t *testing.T) { ConcurrentTTLSyncs: 8, }, }, + ValidatingAdmissionPolicyStatusController: &ValidatingAdmissionPolicyStatusControllerOptions{ + &validatingadmissionpolicystatusconfig.ValidatingAdmissionPolicyStatusControllerConfiguration{ + ConcurrentPolicySyncs: 9, + }, + }, SecureServing: (&apiserveroptions.SecureServingOptions{ BindPort: 10001, BindAddress: netutils.ParseIPSloppy("192.168.4.21"), @@ -640,6 +647,9 @@ func TestApplyTo(t *testing.T) { TTLAfterFinishedController: ttlafterfinishedconfig.TTLAfterFinishedControllerConfiguration{ ConcurrentTTLSyncs: 8, }, + ValidatingAdmissionPolicyStatusController: validatingadmissionpolicystatusconfig.ValidatingAdmissionPolicyStatusControllerConfiguration{ + ConcurrentPolicySyncs: 9, + }, }, } diff --git a/cmd/kube-controller-manager/app/options/validatingadmissionpolicycontroller.go b/cmd/kube-controller-manager/app/options/validatingadmissionpolicycontroller.go new file mode 100644 index 00000000000..121e7f9045e --- /dev/null +++ b/cmd/kube-controller-manager/app/options/validatingadmissionpolicycontroller.go @@ -0,0 +1,63 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package options + +import ( + "fmt" + + "github.com/spf13/pflag" + + validatingadmissionpolicystatusconfig "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config" +) + +// ValidatingAdmissionPolicyStatusControllerOptions holds the ValidatingAdmissionPolicyStatusController options. +type ValidatingAdmissionPolicyStatusControllerOptions struct { + *validatingadmissionpolicystatusconfig.ValidatingAdmissionPolicyStatusControllerConfiguration +} + +// AddFlags adds flags related to ValidatingAdmissionPolicyStatusController for controller manager to the specified FlagSet. +func (o *ValidatingAdmissionPolicyStatusControllerOptions) AddFlags(fs *pflag.FlagSet) { + if o == nil { + return + } + + fs.Int32Var(&o.ConcurrentPolicySyncs, "concurrent-validating-admission-policy-status-syncs", o.ConcurrentPolicySyncs, "The number of ValidatingAdmissionPolicyStatusController workers that are allowed to sync concurrently.") +} + +// ApplyTo fills up ValidatingAdmissionPolicyStatusController config with options. +func (o *ValidatingAdmissionPolicyStatusControllerOptions) ApplyTo(cfg *validatingadmissionpolicystatusconfig.ValidatingAdmissionPolicyStatusControllerConfiguration) error { + if o == nil { + return nil + } + + cfg.ConcurrentPolicySyncs = o.ConcurrentPolicySyncs + + return nil +} + +// Validate checks validation of ValidatingAdmissionPolicyStatusControllerOptions. +func (o *ValidatingAdmissionPolicyStatusControllerOptions) Validate() []error { + if o == nil { + return nil + } + var errs []error + if o.ConcurrentPolicySyncs <= 0 { + // omits controller or flag names because the CLI already includes these in the message. + errs = append(errs, fmt.Errorf("must be positive, got %d", o.ConcurrentPolicySyncs)) + } + return errs +} diff --git a/cmd/kube-controller-manager/app/validatingadmissionpolicystatus.go b/cmd/kube-controller-manager/app/validatingadmissionpolicystatus.go new file mode 100644 index 00000000000..ff6b314e371 --- /dev/null +++ b/cmd/kube-controller-manager/app/validatingadmissionpolicystatus.go @@ -0,0 +1,51 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package app + +import ( + "context" + + admissionregistrationv1alpha1 "k8s.io/api/admissionregistration/v1alpha1" + pluginvalidatingadmissionpolicy "k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy" + "k8s.io/apiserver/pkg/cel/openapi/resolver" + "k8s.io/client-go/kubernetes/scheme" + "k8s.io/controller-manager/controller" + "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus" + "k8s.io/kubernetes/pkg/generated/openapi" +) + +var validatingAdmissionPolicyResource = admissionregistrationv1alpha1.SchemeGroupVersion.WithResource("validatingadmissionpolicies") + +func startValidatingAdmissionPolicyStatusController(ctx context.Context, controllerContext ControllerContext) (controller.Interface, bool, error) { + // intended check against served resource but not feature gate. + // KCM won't start the controller without the feature gate set. + if !controllerContext.AvailableResources[validatingAdmissionPolicyResource] { + return nil, false, nil + } + typeChecker := &pluginvalidatingadmissionpolicy.TypeChecker{ + SchemaResolver: resolver.NewDefinitionsSchemaResolver(scheme.Scheme, openapi.GetOpenAPIDefinitions), + RestMapper: controllerContext.RESTMapper, + } + c, err := validatingadmissionpolicystatus.NewController( + controllerContext.InformerFactory.Admissionregistration().V1alpha1().ValidatingAdmissionPolicies(), + controllerContext.ClientBuilder.ClientOrDie("validatingadmissionpolicy-status-controller").AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies(), + typeChecker, + ) + + go c.Run(ctx, int(controllerContext.ComponentConfig.ValidatingAdmissionPolicyStatusController.ConcurrentPolicySyncs)) + return nil, true, err +} diff --git a/cmd/kube-controller-manager/names/controller_names.go b/cmd/kube-controller-manager/names/controller_names.go index a3d606291db..9004514fd3c 100644 --- a/cmd/kube-controller-manager/names/controller_names.go +++ b/cmd/kube-controller-manager/names/controller_names.go @@ -86,6 +86,7 @@ const ( StorageVersionGarbageCollectorController = "storageversion-garbage-collector-controller" ResourceClaimController = "resourceclaim-controller" LegacyServiceAccountTokenCleanerController = "legacy-serviceaccount-token-cleaner-controller" + ValidatingAdmissionPolicyStatusController = "validatingadmissionpolicy-status-controller" ) // KCMControllerAliases returns a mapping of aliases to canonical controller names diff --git a/pkg/controller/apis/config/types.go b/pkg/controller/apis/config/types.go index 108bf81a7e3..880a4fd4928 100644 --- a/pkg/controller/apis/config/types.go +++ b/pkg/controller/apis/config/types.go @@ -41,6 +41,7 @@ import ( serviceaccountconfig "k8s.io/kubernetes/pkg/controller/serviceaccount/config" statefulsetconfig "k8s.io/kubernetes/pkg/controller/statefulset/config" ttlafterfinishedconfig "k8s.io/kubernetes/pkg/controller/ttlafterfinished/config" + validatingadmissionpolicystatusconfig "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config" attachdetachconfig "k8s.io/kubernetes/pkg/controller/volume/attachdetach/config" ephemeralvolumeconfig "k8s.io/kubernetes/pkg/controller/volume/ephemeral/config" persistentvolumeconfig "k8s.io/kubernetes/pkg/controller/volume/persistentvolume/config" @@ -132,6 +133,9 @@ type KubeControllerManagerConfiguration struct { // TTLAfterFinishedControllerConfiguration holds configuration for // TTLAfterFinishedController related features. TTLAfterFinishedController ttlafterfinishedconfig.TTLAfterFinishedControllerConfiguration + // ValidatingAdmissionPolicyStatusControllerConfiguration holds configuration for + // ValidatingAdmissionPolicyStatusController related features. + ValidatingAdmissionPolicyStatusController validatingadmissionpolicystatusconfig.ValidatingAdmissionPolicyStatusControllerConfiguration } // DeprecatedControllerConfiguration contains elements be deprecated. diff --git a/pkg/controller/apis/config/v1alpha1/defaults.go b/pkg/controller/apis/config/v1alpha1/defaults.go index 078f8edc63b..c1d35f3c267 100644 --- a/pkg/controller/apis/config/v1alpha1/defaults.go +++ b/pkg/controller/apis/config/v1alpha1/defaults.go @@ -41,6 +41,7 @@ import ( serviceaccountconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/serviceaccount/config/v1alpha1" statefulsetconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/statefulset/config/v1alpha1" ttlafterfinishedconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/ttlafterfinished/config/v1alpha1" + validatingadmissionpolicystatusv1alpha1 "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1" attachdetachconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/volume/attachdetach/config/v1alpha1" ephemeralvolumeconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/volume/ephemeral/config/v1alpha1" persistentvolumeconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/volume/persistentvolume/config/v1alpha1" @@ -112,4 +113,6 @@ func SetDefaults_KubeControllerManagerConfiguration(obj *kubectrlmgrconfigv1alph ttlafterfinishedconfigv1alpha1.RecommendedDefaultTTLAfterFinishedControllerConfiguration(&obj.TTLAfterFinishedController) // Use the default RecommendedDefaultPersistentVolumeBinderControllerConfiguration options persistentvolumeconfigv1alpha1.RecommendedDefaultPersistentVolumeBinderControllerConfiguration(&obj.PersistentVolumeBinderController) + // Use the default RecommendedDefaultValidatingAdmissionPolicyStatusControllerConfiguration options + validatingadmissionpolicystatusv1alpha1.RecommendedDefaultValidatingAdmissionPolicyStatusControllerConfiguration(&obj.ValidatingAdmissionPolicyStatusController) } diff --git a/pkg/controller/apis/config/v1alpha1/zz_generated.conversion.go b/pkg/controller/apis/config/v1alpha1/zz_generated.conversion.go index 91f54cc6171..182671d0b3a 100644 --- a/pkg/controller/apis/config/v1alpha1/zz_generated.conversion.go +++ b/pkg/controller/apis/config/v1alpha1/zz_generated.conversion.go @@ -50,6 +50,7 @@ import ( serviceaccountconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/serviceaccount/config/v1alpha1" statefulsetconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/statefulset/config/v1alpha1" ttlafterfinishedconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/ttlafterfinished/config/v1alpha1" + validatingadmissionpolicystatusconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1" attachdetachconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/volume/attachdetach/config/v1alpha1" ephemeralconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/volume/ephemeral/config/v1alpha1" persistentvolumeconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/volume/persistentvolume/config/v1alpha1" @@ -220,6 +221,9 @@ func autoConvert_v1alpha1_KubeControllerManagerConfiguration_To_config_KubeContr if err := ttlafterfinishedconfigv1alpha1.Convert_v1alpha1_TTLAfterFinishedControllerConfiguration_To_config_TTLAfterFinishedControllerConfiguration(&in.TTLAfterFinishedController, &out.TTLAfterFinishedController, s); err != nil { return err } + if err := validatingadmissionpolicystatusconfigv1alpha1.Convert_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration_To_config_ValidatingAdmissionPolicyStatusControllerConfiguration(&in.ValidatingAdmissionPolicyStatusController, &out.ValidatingAdmissionPolicyStatusController, s); err != nil { + return err + } return nil } @@ -313,6 +317,9 @@ func autoConvert_config_KubeControllerManagerConfiguration_To_v1alpha1_KubeContr if err := ttlafterfinishedconfigv1alpha1.Convert_config_TTLAfterFinishedControllerConfiguration_To_v1alpha1_TTLAfterFinishedControllerConfiguration(&in.TTLAfterFinishedController, &out.TTLAfterFinishedController, s); err != nil { return err } + if err := validatingadmissionpolicystatusconfigv1alpha1.Convert_config_ValidatingAdmissionPolicyStatusControllerConfiguration_To_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration(&in.ValidatingAdmissionPolicyStatusController, &out.ValidatingAdmissionPolicyStatusController, s); err != nil { + return err + } return nil } diff --git a/pkg/controller/apis/config/zz_generated.deepcopy.go b/pkg/controller/apis/config/zz_generated.deepcopy.go index 10aca159bae..22c3bbf6182 100644 --- a/pkg/controller/apis/config/zz_generated.deepcopy.go +++ b/pkg/controller/apis/config/zz_generated.deepcopy.go @@ -73,6 +73,7 @@ func (in *KubeControllerManagerConfiguration) DeepCopyInto(out *KubeControllerMa out.SAController = in.SAController out.ServiceController = in.ServiceController out.TTLAfterFinishedController = in.TTLAfterFinishedController + out.ValidatingAdmissionPolicyStatusController = in.ValidatingAdmissionPolicyStatusController return } diff --git a/pkg/controller/validatingadmissionpolicystatus/OWNERS b/pkg/controller/validatingadmissionpolicystatus/OWNERS new file mode 100644 index 00000000000..8667a8f834b --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/OWNERS @@ -0,0 +1,6 @@ +# See the OWNERS docs at https://go.k8s.io/owners + +reviewers: + - jiahuif +labels: + - sig/api-machinery diff --git a/pkg/controller/validatingadmissionpolicystatus/config/doc.go b/pkg/controller/validatingadmissionpolicystatus/config/doc.go new file mode 100644 index 00000000000..9fc384bba0e --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/doc.go @@ -0,0 +1,19 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// +k8s:deepcopy-gen=package + +package config // import "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config" diff --git a/pkg/controller/validatingadmissionpolicystatus/config/types.go b/pkg/controller/validatingadmissionpolicystatus/config/types.go new file mode 100644 index 00000000000..bf5384d2de6 --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/types.go @@ -0,0 +1,26 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package config + +// ValidatingAdmissionPolicyStatusControllerConfiguration contains elements describing ValidatingAdmissionPolicyStatusController. +type ValidatingAdmissionPolicyStatusControllerConfiguration struct { + // ConcurrentPolicySyncs is the number of policy objects that are + // allowed to sync concurrently. Larger number = quicker type checking, + // but more CPU (and network) load. + // The default value is 5. + ConcurrentPolicySyncs int32 +} diff --git a/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/conversion.go b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/conversion.go new file mode 100644 index 00000000000..27c10126de5 --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/conversion.go @@ -0,0 +1,40 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1alpha1 + +import ( + "k8s.io/apimachinery/pkg/conversion" + "k8s.io/kube-controller-manager/config/v1alpha1" + "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config" +) + +// Important! The public back-and-forth conversion functions for the types in this package +// need to be manually exposed like this in order for other packages that reference +// this package to be able to call these conversion functions in an autogenerated manner. +// TODO: Fix the bug in conversion-gen so it automatically discovers these Convert_* functions +// in autogenerated code as well. This is a limitation that affects all controller configurations +// This issue was introduced in #72800 + +// Convert_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration_To_config_ValidatingAdmissionPolicyStatusControllerConfiguration is an autogenerated conversion function. +func Convert_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration_To_config_ValidatingAdmissionPolicyStatusControllerConfiguration(in *v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration, out *config.ValidatingAdmissionPolicyStatusControllerConfiguration, s conversion.Scope) error { + return autoConvert_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration_To_config_ValidatingAdmissionPolicyStatusControllerConfiguration(in, out, s) +} + +// Convert_config_ValidatingAdmissionPolicyStatusControllerConfiguration_To_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration is an autogenerated conversion function. +func Convert_config_ValidatingAdmissionPolicyStatusControllerConfiguration_To_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration(in *config.ValidatingAdmissionPolicyStatusControllerConfiguration, out *v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration, s conversion.Scope) error { + return autoConvert_config_ValidatingAdmissionPolicyStatusControllerConfiguration_To_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration(in, out, s) +} diff --git a/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/defaults.go b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/defaults.go new file mode 100644 index 00000000000..61e42be2106 --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/defaults.go @@ -0,0 +1,36 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1alpha1 + +import ( + kubectrlmgrconfigv1alpha1 "k8s.io/kube-controller-manager/config/v1alpha1" +) + +// RecommendedDefaultValidatingAdmissionPolicyStatusControllerConfiguration defaults a pointer to a +// ValidatingAdmissionPolicyStatusControllerConfiguration struct. This will set the recommended default +// values, but they may be subject to change between API versions. This function +// is intentionally not registered in the scheme as a "normal" `SetDefaults_Foo` +// function to allow consumers of this type to set whatever defaults for their +// embedded configs. Forcing consumers to use these defaults would be problematic +// as defaulting in the scheme is done as part of the conversion, and there would +// be no easy way to opt-out. Instead, if you want to use this defaulting method +// run it in your wrapper struct of this type in its `SetDefaults_` method. +func RecommendedDefaultValidatingAdmissionPolicyStatusControllerConfiguration(obj *kubectrlmgrconfigv1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration) { + if obj.ConcurrentPolicySyncs == 0 { + obj.ConcurrentPolicySyncs = 5 + } +} diff --git a/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/defaults_test.go b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/defaults_test.go new file mode 100644 index 00000000000..2c8e6a06645 --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/defaults_test.go @@ -0,0 +1,31 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1alpha1 + +import ( + "testing" + + kubectrlmgrconfigv1alpha1 "k8s.io/kube-controller-manager/config/v1alpha1" +) + +func TestRecommendedDefaultValidatingAdmissionPolicyStatusControllerConfiguration(t *testing.T) { + config := new(kubectrlmgrconfigv1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration) + RecommendedDefaultValidatingAdmissionPolicyStatusControllerConfiguration(config) + if config.ConcurrentPolicySyncs != 5 { + t.Errorf("incorrect default value, expected 5 but got %v", config.ConcurrentPolicySyncs) + } +} diff --git a/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/doc.go b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/doc.go new file mode 100644 index 00000000000..9295a268e5e --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/doc.go @@ -0,0 +1,21 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// +k8s:deepcopy-gen=package +// +k8s:conversion-gen=k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config +// +k8s:conversion-gen-external-types=k8s.io/kube-controller-manager/config/v1alpha1 + +package v1alpha1 // import "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1" diff --git a/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/register.go b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/register.go new file mode 100644 index 00000000000..c3c6ee5b4df --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/register.go @@ -0,0 +1,31 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1alpha1 + +import ( + "k8s.io/apimachinery/pkg/runtime" +) + +var ( + // SchemeBuilder is the scheme builder with scheme init functions to run for this API package + SchemeBuilder runtime.SchemeBuilder + // localSchemeBuilder extends the SchemeBuilder instance with the external types. In this package, + // defaulting and conversion init funcs are registered as well. + localSchemeBuilder = &SchemeBuilder + // AddToScheme is a global function that registers this API group & version to a scheme + AddToScheme = localSchemeBuilder.AddToScheme +) diff --git a/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/zz_generated.conversion.go b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/zz_generated.conversion.go new file mode 100644 index 00000000000..2a5cec8325e --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/zz_generated.conversion.go @@ -0,0 +1,92 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by conversion-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + conversion "k8s.io/apimachinery/pkg/conversion" + runtime "k8s.io/apimachinery/pkg/runtime" + v1alpha1 "k8s.io/kube-controller-manager/config/v1alpha1" + config "k8s.io/kubernetes/pkg/controller/validatingadmissionpolicystatus/config" +) + +func init() { + localSchemeBuilder.Register(RegisterConversions) +} + +// RegisterConversions adds conversion functions to the given scheme. +// Public to allow building arbitrary schemes. +func RegisterConversions(s *runtime.Scheme) error { + if err := s.AddGeneratedConversionFunc((*v1alpha1.GroupResource)(nil), (*v1.GroupResource)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha1_GroupResource_To_v1_GroupResource(a.(*v1alpha1.GroupResource), b.(*v1.GroupResource), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*v1.GroupResource)(nil), (*v1alpha1.GroupResource)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1_GroupResource_To_v1alpha1_GroupResource(a.(*v1.GroupResource), b.(*v1alpha1.GroupResource), scope) + }); err != nil { + return err + } + if err := s.AddConversionFunc((*config.ValidatingAdmissionPolicyStatusControllerConfiguration)(nil), (*v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_config_ValidatingAdmissionPolicyStatusControllerConfiguration_To_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration(a.(*config.ValidatingAdmissionPolicyStatusControllerConfiguration), b.(*v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration), scope) + }); err != nil { + return err + } + if err := s.AddConversionFunc((*v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration)(nil), (*config.ValidatingAdmissionPolicyStatusControllerConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration_To_config_ValidatingAdmissionPolicyStatusControllerConfiguration(a.(*v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration), b.(*config.ValidatingAdmissionPolicyStatusControllerConfiguration), scope) + }); err != nil { + return err + } + return nil +} + +func autoConvert_v1alpha1_GroupResource_To_v1_GroupResource(in *v1alpha1.GroupResource, out *v1.GroupResource, s conversion.Scope) error { + out.Group = in.Group + out.Resource = in.Resource + return nil +} + +// Convert_v1alpha1_GroupResource_To_v1_GroupResource is an autogenerated conversion function. +func Convert_v1alpha1_GroupResource_To_v1_GroupResource(in *v1alpha1.GroupResource, out *v1.GroupResource, s conversion.Scope) error { + return autoConvert_v1alpha1_GroupResource_To_v1_GroupResource(in, out, s) +} + +func autoConvert_v1_GroupResource_To_v1alpha1_GroupResource(in *v1.GroupResource, out *v1alpha1.GroupResource, s conversion.Scope) error { + out.Group = in.Group + out.Resource = in.Resource + return nil +} + +// Convert_v1_GroupResource_To_v1alpha1_GroupResource is an autogenerated conversion function. +func Convert_v1_GroupResource_To_v1alpha1_GroupResource(in *v1.GroupResource, out *v1alpha1.GroupResource, s conversion.Scope) error { + return autoConvert_v1_GroupResource_To_v1alpha1_GroupResource(in, out, s) +} + +func autoConvert_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration_To_config_ValidatingAdmissionPolicyStatusControllerConfiguration(in *v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration, out *config.ValidatingAdmissionPolicyStatusControllerConfiguration, s conversion.Scope) error { + out.ConcurrentPolicySyncs = in.ConcurrentPolicySyncs + return nil +} + +func autoConvert_config_ValidatingAdmissionPolicyStatusControllerConfiguration_To_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration(in *config.ValidatingAdmissionPolicyStatusControllerConfiguration, out *v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration, s conversion.Scope) error { + out.ConcurrentPolicySyncs = in.ConcurrentPolicySyncs + return nil +} diff --git a/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/zz_generated.deepcopy.go b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/zz_generated.deepcopy.go new file mode 100644 index 00000000000..61f6555edfc --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/v1alpha1/zz_generated.deepcopy.go @@ -0,0 +1,22 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v1alpha1 diff --git a/pkg/controller/validatingadmissionpolicystatus/config/zz_generated.deepcopy.go b/pkg/controller/validatingadmissionpolicystatus/config/zz_generated.deepcopy.go new file mode 100644 index 00000000000..a762afc78de --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/config/zz_generated.deepcopy.go @@ -0,0 +1,38 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package config + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ValidatingAdmissionPolicyStatusControllerConfiguration) DeepCopyInto(out *ValidatingAdmissionPolicyStatusControllerConfiguration) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicyStatusControllerConfiguration. +func (in *ValidatingAdmissionPolicyStatusControllerConfiguration) DeepCopy() *ValidatingAdmissionPolicyStatusControllerConfiguration { + if in == nil { + return nil + } + out := new(ValidatingAdmissionPolicyStatusControllerConfiguration) + in.DeepCopyInto(out) + return out +} diff --git a/pkg/controller/validatingadmissionpolicystatus/controller.go b/pkg/controller/validatingadmissionpolicystatus/controller.go new file mode 100644 index 00000000000..6b887c38d72 --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/controller.go @@ -0,0 +1,162 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package validatingadmissionpolicystatus + +import ( + "context" + "fmt" + "time" + + "k8s.io/api/admissionregistration/v1alpha1" + kerrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy" + admissionregistrationv1alpha1apply "k8s.io/client-go/applyconfigurations/admissionregistration/v1alpha1" + informerv1alpha1 "k8s.io/client-go/informers/admissionregistration/v1alpha1" + admissionregistrationv1alpha1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/util/workqueue" +) + +// ControllerName has "Status" in it to differentiate this controller with the other that runs in API server. +const ControllerName = "validatingadmissionpolicy-status" + +// Controller is the ValidatingAdmissionPolicy Status controller that reconciles the Status field of each policy object. +// This controller runs type checks against referred types for each policy definition. +type Controller struct { + policyInformer informerv1alpha1.ValidatingAdmissionPolicyInformer + policyQueue workqueue.RateLimitingInterface + policySynced cache.InformerSynced + policyClient admissionregistrationv1alpha1.ValidatingAdmissionPolicyInterface + + // typeChecker checks the policy's expressions for type errors. + // Type of params is defined in policy.Spec.ParamsKind + // Types of object are calculated from policy.Spec.MatchingConstraints + typeChecker *validatingadmissionpolicy.TypeChecker +} + +func (c *Controller) Run(ctx context.Context, workers int) { + defer utilruntime.HandleCrash() + + if !cache.WaitForNamedCacheSync(ControllerName, ctx.Done(), c.policySynced) { + return + } + + defer c.policyQueue.ShutDown() + for i := 0; i < workers; i++ { + go wait.UntilWithContext(ctx, c.runWorker, time.Second) + } + + <-ctx.Done() +} + +func NewController(policyInformer informerv1alpha1.ValidatingAdmissionPolicyInformer, policyClient admissionregistrationv1alpha1.ValidatingAdmissionPolicyInterface, typeChecker *validatingadmissionpolicy.TypeChecker) (*Controller, error) { + c := &Controller{ + policyInformer: policyInformer, + policyQueue: workqueue.NewRateLimitingQueueWithConfig(workqueue.DefaultControllerRateLimiter(), workqueue.RateLimitingQueueConfig{Name: ControllerName}), + policyClient: policyClient, + typeChecker: typeChecker, + } + reg, err := policyInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{ + AddFunc: func(obj interface{}) { + c.enqueuePolicy(obj) + }, + UpdateFunc: func(oldObj, newObj interface{}) { + c.enqueuePolicy(newObj) + }, + }) + if err != nil { + return nil, err + } + c.policySynced = reg.HasSynced + return c, nil +} + +func (c *Controller) enqueuePolicy(policy any) { + if policy, ok := policy.(*v1alpha1.ValidatingAdmissionPolicy); ok { + // policy objects are cluster-scoped, no point include its namespace. + key := policy.ObjectMeta.Name + if key == "" { + utilruntime.HandleError(fmt.Errorf("cannot get name of object %v", policy)) + } + c.policyQueue.Add(key) + } +} + +func (c *Controller) runWorker(ctx context.Context) { + for c.processNextWorkItem(ctx) { + } +} + +func (c *Controller) processNextWorkItem(ctx context.Context) bool { + key, shutdown := c.policyQueue.Get() + if shutdown { + return false + } + defer c.policyQueue.Done(key) + + err := func() error { + key, ok := key.(string) + if !ok { + return fmt.Errorf("expect a string but got %v", key) + } + policy, err := c.policyInformer.Lister().Get(key) + if err != nil { + if kerrors.IsNotFound(err) { + // If not found, the policy is being deleting, do nothing. + return nil + } + return err + } + return c.reconcile(ctx, policy) + }() + + if err == nil { + c.policyQueue.Forget(key) + return true + } + + utilruntime.HandleError(err) + c.policyQueue.AddRateLimited(key) + + return true +} + +func (c *Controller) reconcile(ctx context.Context, policy *v1alpha1.ValidatingAdmissionPolicy) error { + if policy == nil { + return nil + } + if policy.Generation <= policy.Status.ObservedGeneration { + return nil + } + warnings := c.typeChecker.Check(policy) + warningsConfig := make([]*admissionregistrationv1alpha1apply.ExpressionWarningApplyConfiguration, 0, len(warnings)) + for _, warning := range warnings { + warningsConfig = append(warningsConfig, admissionregistrationv1alpha1apply.ExpressionWarning(). + WithFieldRef(warning.FieldRef). + WithWarning(warning.Warning)) + } + applyConfig := admissionregistrationv1alpha1apply.ValidatingAdmissionPolicy(policy.Name). + WithStatus(admissionregistrationv1alpha1apply.ValidatingAdmissionPolicyStatus(). + WithObservedGeneration(policy.Generation). + WithTypeChecking(admissionregistrationv1alpha1apply.TypeChecking(). + WithExpressionWarnings(warningsConfig...))) + _, err := c.policyClient.ApplyStatus(ctx, applyConfig, metav1.ApplyOptions{FieldManager: ControllerName, Force: true}) + return err +} diff --git a/pkg/controller/validatingadmissionpolicystatus/controller_test.go b/pkg/controller/validatingadmissionpolicystatus/controller_test.go new file mode 100644 index 00000000000..af7232b4f48 --- /dev/null +++ b/pkg/controller/validatingadmissionpolicystatus/controller_test.go @@ -0,0 +1,224 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package validatingadmissionpolicystatus + +import ( + "context" + "strings" + "testing" + "time" + + admissionregistrationv1 "k8s.io/api/admissionregistration/v1" + admissionregistrationv1alpha1 "k8s.io/api/admissionregistration/v1alpha1" + "k8s.io/apimachinery/pkg/api/meta/testrestmapper" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy" + "k8s.io/apiserver/pkg/cel/openapi/resolver" + "k8s.io/client-go/informers" + "k8s.io/client-go/kubernetes/fake" + "k8s.io/client-go/kubernetes/scheme" + "k8s.io/kubernetes/pkg/generated/openapi" +) + +func TestTypeChecking(t *testing.T) { + for _, tc := range []struct { + name string + policy *admissionregistrationv1alpha1.ValidatingAdmissionPolicy + assertFieldRef func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) // warning.fieldRef + assertWarnings func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) // warning.warning + }{ + { + name: "deployment with correct expression", + policy: withGVRMatch([]string{"apps"}, []string{"v1"}, []string{"deployments"}, withValidations([]admissionregistrationv1alpha1.Validation{ + { + Expression: "object.spec.replicas > 1", + }, + }, makePolicy("replicated-deployment"))), + assertFieldRef: toHaveLengthOf(0), + assertWarnings: toHaveLengthOf(0), + }, + { + name: "deployment with type confusion", + policy: withGVRMatch([]string{"apps"}, []string{"v1"}, []string{"deployments"}, withValidations([]admissionregistrationv1alpha1.Validation{ + { + Expression: "object.spec.replicas < 100", // this one passes + }, + { + Expression: "object.spec.replicas > '1'", // '1' should be int + }, + }, makePolicy("confused-deployment"))), + assertFieldRef: toBe("spec.validations[1].expression"), + assertWarnings: toHaveSubstring(`found no matching overload for '_>_' applied to '(int, string)'`), + }, + { + name: "two expressions different type checking errors", + policy: withGVRMatch([]string{"apps"}, []string{"v1"}, []string{"deployments"}, withValidations([]admissionregistrationv1alpha1.Validation{ + { + Expression: "object.spec.nonExistingFirst > 1", + }, + { + Expression: "object.spec.replicas > '1'", // '1' should be int + }, + }, makePolicy("confused-deployment"))), + assertFieldRef: toBe("spec.validations[0].expression", "spec.validations[1].expression"), + assertWarnings: toHaveSubstring( + "undefined field 'nonExistingFirst'", + `found no matching overload for '_>_' applied to '(int, string)'`, + ), + }, + { + name: "one expression, two warnings", + policy: withGVRMatch([]string{"apps"}, []string{"v1"}, []string{"deployments"}, withValidations([]admissionregistrationv1alpha1.Validation{ + { + Expression: "object.spec.replicas < 100", // this one passes + }, + { + Expression: "object.spec.replicas > '1' && object.spec.nonExisting == 1", + }, + }, makePolicy("confused-deployment"))), + assertFieldRef: toBe("spec.validations[1].expression"), + assertWarnings: toHaveMultipleSubstrings([]string{"undefined field 'nonExisting'", `found no matching overload for '_>_' applied to '(int, string)'`}), + }, + } { + t.Run(tc.name, func(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + defer cancel() + policy := tc.policy.DeepCopy() + policy.ObjectMeta.Generation = 1 // fake storage does not do this automatically + client := fake.NewSimpleClientset(policy) + informerFactory := informers.NewSharedInformerFactory(client, 0) + typeChecker := &validatingadmissionpolicy.TypeChecker{ + SchemaResolver: resolver.NewDefinitionsSchemaResolver(scheme.Scheme, openapi.GetOpenAPIDefinitions), + RestMapper: testrestmapper.TestOnlyStaticRESTMapper(scheme.Scheme), + } + controller, err := NewController( + informerFactory.Admissionregistration().V1alpha1().ValidatingAdmissionPolicies(), + client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies(), + typeChecker, + ) + if err != nil { + t.Fatalf("cannot create controller: %v", err) + } + go informerFactory.Start(ctx.Done()) + go controller.Run(ctx, 1) + err = wait.PollUntilContextCancel(ctx, time.Second, false, func(ctx context.Context) (done bool, err error) { + name := policy.Name + // wait until the typeChecking is set, which means the type checking + // is complete. + updated, err := client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Get(ctx, name, metav1.GetOptions{}) + if err != nil { + return false, err + } + if updated.Status.TypeChecking != nil { + policy = updated + return true, nil + } + return false, nil + }) + if err != nil { + t.Fatal(err) + } + tc.assertFieldRef(policy.Status.TypeChecking.ExpressionWarnings, t) + tc.assertWarnings(policy.Status.TypeChecking.ExpressionWarnings, t) + if err != nil { + t.Fatalf("failed to initialize controller: %v", err) + } + }) + } + +} + +func toBe(expected ...string) func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { + return func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { + if len(expected) != len(warnings) { + t.Fatalf("mismatched length, expect %d, got %d", len(expected), len(warnings)) + } + for i := range expected { + if expected[i] != warnings[i].FieldRef { + t.Errorf("expected %q but got %q", expected[i], warnings[i].FieldRef) + } + } + } +} + +func toHaveSubstring(substrings ...string) func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { + return func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { + if len(substrings) != len(warnings) { + t.Fatalf("mismatched length, expect %d, got %d", len(substrings), len(warnings)) + } + for i := range substrings { + if !strings.Contains(warnings[i].Warning, substrings[i]) { + t.Errorf("missing expected substring %q in %v", substrings[i], warnings[i]) + } + } + } +} + +func toHaveMultipleSubstrings(substrings ...[]string) func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { + return func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { + if len(substrings) != len(warnings) { + t.Fatalf("mismatched length, expect %d, got %d", len(substrings), len(warnings)) + } + for i, expectedSubstrings := range substrings { + for _, s := range expectedSubstrings { + if !strings.Contains(warnings[i].Warning, s) { + t.Errorf("missing expected substring %q in %v", substrings[i], warnings[i]) + } + } + } + } +} + +func toHaveLengthOf(n int) func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { + return func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { + if n != len(warnings) { + t.Fatalf("mismatched length, expect %d, got %d", n, len(warnings)) + } + } +} + +func withGVRMatch(groups []string, versions []string, resources []string, policy *admissionregistrationv1alpha1.ValidatingAdmissionPolicy) *admissionregistrationv1alpha1.ValidatingAdmissionPolicy { + policy.Spec.MatchConstraints = &admissionregistrationv1alpha1.MatchResources{ + ResourceRules: []admissionregistrationv1alpha1.NamedRuleWithOperations{ + { + RuleWithOperations: admissionregistrationv1alpha1.RuleWithOperations{ + Operations: []admissionregistrationv1.OperationType{ + "*", + }, + Rule: admissionregistrationv1.Rule{ + APIGroups: groups, + APIVersions: versions, + Resources: resources, + }, + }, + }, + }, + } + return policy +} + +func withValidations(validations []admissionregistrationv1alpha1.Validation, policy *admissionregistrationv1alpha1.ValidatingAdmissionPolicy) *admissionregistrationv1alpha1.ValidatingAdmissionPolicy { + policy.Spec.Validations = validations + return policy +} + +func makePolicy(name string) *admissionregistrationv1alpha1.ValidatingAdmissionPolicy { + return &admissionregistrationv1alpha1.ValidatingAdmissionPolicy{ + ObjectMeta: metav1.ObjectMeta{Name: name}, + } +} diff --git a/pkg/generated/openapi/zz_generated.openapi.go b/pkg/generated/openapi/zz_generated.openapi.go index bcecc80a114..34bf9911eef 100644 --- a/pkg/generated/openapi/zz_generated.openapi.go +++ b/pkg/generated/openapi/zz_generated.openapi.go @@ -35,1137 +35,1138 @@ import ( func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition { return map[string]common.OpenAPIDefinition{ - "k8s.io/api/admissionregistration/v1.MatchCondition": schema_k8sio_api_admissionregistration_v1_MatchCondition(ref), - "k8s.io/api/admissionregistration/v1.MutatingWebhook": schema_k8sio_api_admissionregistration_v1_MutatingWebhook(ref), - "k8s.io/api/admissionregistration/v1.MutatingWebhookConfiguration": schema_k8sio_api_admissionregistration_v1_MutatingWebhookConfiguration(ref), - "k8s.io/api/admissionregistration/v1.MutatingWebhookConfigurationList": schema_k8sio_api_admissionregistration_v1_MutatingWebhookConfigurationList(ref), - "k8s.io/api/admissionregistration/v1.Rule": schema_k8sio_api_admissionregistration_v1_Rule(ref), - "k8s.io/api/admissionregistration/v1.RuleWithOperations": schema_k8sio_api_admissionregistration_v1_RuleWithOperations(ref), - "k8s.io/api/admissionregistration/v1.ServiceReference": schema_k8sio_api_admissionregistration_v1_ServiceReference(ref), - "k8s.io/api/admissionregistration/v1.ValidatingWebhook": schema_k8sio_api_admissionregistration_v1_ValidatingWebhook(ref), - "k8s.io/api/admissionregistration/v1.ValidatingWebhookConfiguration": schema_k8sio_api_admissionregistration_v1_ValidatingWebhookConfiguration(ref), - "k8s.io/api/admissionregistration/v1.ValidatingWebhookConfigurationList": schema_k8sio_api_admissionregistration_v1_ValidatingWebhookConfigurationList(ref), - "k8s.io/api/admissionregistration/v1.WebhookClientConfig": schema_k8sio_api_admissionregistration_v1_WebhookClientConfig(ref), - "k8s.io/api/admissionregistration/v1alpha1.AuditAnnotation": schema_k8sio_api_admissionregistration_v1alpha1_AuditAnnotation(ref), - "k8s.io/api/admissionregistration/v1alpha1.ExpressionWarning": schema_k8sio_api_admissionregistration_v1alpha1_ExpressionWarning(ref), - "k8s.io/api/admissionregistration/v1alpha1.MatchCondition": schema_k8sio_api_admissionregistration_v1alpha1_MatchCondition(ref), - "k8s.io/api/admissionregistration/v1alpha1.MatchResources": schema_k8sio_api_admissionregistration_v1alpha1_MatchResources(ref), - "k8s.io/api/admissionregistration/v1alpha1.NamedRuleWithOperations": schema_k8sio_api_admissionregistration_v1alpha1_NamedRuleWithOperations(ref), - "k8s.io/api/admissionregistration/v1alpha1.ParamKind": schema_k8sio_api_admissionregistration_v1alpha1_ParamKind(ref), - "k8s.io/api/admissionregistration/v1alpha1.ParamRef": schema_k8sio_api_admissionregistration_v1alpha1_ParamRef(ref), - "k8s.io/api/admissionregistration/v1alpha1.TypeChecking": schema_k8sio_api_admissionregistration_v1alpha1_TypeChecking(ref), - "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicy": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicy(ref), - "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyBinding": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyBinding(ref), - "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyBindingList": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyBindingList(ref), - "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyBindingSpec": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyBindingSpec(ref), - "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyList": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyList(ref), - "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicySpec": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicySpec(ref), - "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyStatus": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyStatus(ref), - "k8s.io/api/admissionregistration/v1alpha1.Validation": schema_k8sio_api_admissionregistration_v1alpha1_Validation(ref), - "k8s.io/api/admissionregistration/v1beta1.MatchCondition": schema_k8sio_api_admissionregistration_v1beta1_MatchCondition(ref), - "k8s.io/api/admissionregistration/v1beta1.MutatingWebhook": schema_k8sio_api_admissionregistration_v1beta1_MutatingWebhook(ref), - "k8s.io/api/admissionregistration/v1beta1.MutatingWebhookConfiguration": schema_k8sio_api_admissionregistration_v1beta1_MutatingWebhookConfiguration(ref), - "k8s.io/api/admissionregistration/v1beta1.MutatingWebhookConfigurationList": schema_k8sio_api_admissionregistration_v1beta1_MutatingWebhookConfigurationList(ref), - "k8s.io/api/admissionregistration/v1beta1.ServiceReference": schema_k8sio_api_admissionregistration_v1beta1_ServiceReference(ref), - "k8s.io/api/admissionregistration/v1beta1.ValidatingWebhook": schema_k8sio_api_admissionregistration_v1beta1_ValidatingWebhook(ref), - "k8s.io/api/admissionregistration/v1beta1.ValidatingWebhookConfiguration": schema_k8sio_api_admissionregistration_v1beta1_ValidatingWebhookConfiguration(ref), - "k8s.io/api/admissionregistration/v1beta1.ValidatingWebhookConfigurationList": schema_k8sio_api_admissionregistration_v1beta1_ValidatingWebhookConfigurationList(ref), - "k8s.io/api/admissionregistration/v1beta1.WebhookClientConfig": schema_k8sio_api_admissionregistration_v1beta1_WebhookClientConfig(ref), - "k8s.io/api/apidiscovery/v2beta1.APIGroupDiscovery": schema_k8sio_api_apidiscovery_v2beta1_APIGroupDiscovery(ref), - "k8s.io/api/apidiscovery/v2beta1.APIGroupDiscoveryList": schema_k8sio_api_apidiscovery_v2beta1_APIGroupDiscoveryList(ref), - "k8s.io/api/apidiscovery/v2beta1.APIResourceDiscovery": schema_k8sio_api_apidiscovery_v2beta1_APIResourceDiscovery(ref), - "k8s.io/api/apidiscovery/v2beta1.APISubresourceDiscovery": schema_k8sio_api_apidiscovery_v2beta1_APISubresourceDiscovery(ref), - "k8s.io/api/apidiscovery/v2beta1.APIVersionDiscovery": schema_k8sio_api_apidiscovery_v2beta1_APIVersionDiscovery(ref), - "k8s.io/api/apiserverinternal/v1alpha1.ServerStorageVersion": schema_k8sio_api_apiserverinternal_v1alpha1_ServerStorageVersion(ref), - "k8s.io/api/apiserverinternal/v1alpha1.StorageVersion": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersion(ref), - "k8s.io/api/apiserverinternal/v1alpha1.StorageVersionCondition": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersionCondition(ref), - "k8s.io/api/apiserverinternal/v1alpha1.StorageVersionList": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersionList(ref), - "k8s.io/api/apiserverinternal/v1alpha1.StorageVersionSpec": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersionSpec(ref), - "k8s.io/api/apiserverinternal/v1alpha1.StorageVersionStatus": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersionStatus(ref), - "k8s.io/api/apps/v1.ControllerRevision": schema_k8sio_api_apps_v1_ControllerRevision(ref), - "k8s.io/api/apps/v1.ControllerRevisionList": schema_k8sio_api_apps_v1_ControllerRevisionList(ref), - "k8s.io/api/apps/v1.DaemonSet": schema_k8sio_api_apps_v1_DaemonSet(ref), - "k8s.io/api/apps/v1.DaemonSetCondition": schema_k8sio_api_apps_v1_DaemonSetCondition(ref), - "k8s.io/api/apps/v1.DaemonSetList": schema_k8sio_api_apps_v1_DaemonSetList(ref), - "k8s.io/api/apps/v1.DaemonSetSpec": schema_k8sio_api_apps_v1_DaemonSetSpec(ref), - "k8s.io/api/apps/v1.DaemonSetStatus": schema_k8sio_api_apps_v1_DaemonSetStatus(ref), - "k8s.io/api/apps/v1.DaemonSetUpdateStrategy": schema_k8sio_api_apps_v1_DaemonSetUpdateStrategy(ref), - "k8s.io/api/apps/v1.Deployment": schema_k8sio_api_apps_v1_Deployment(ref), - "k8s.io/api/apps/v1.DeploymentCondition": schema_k8sio_api_apps_v1_DeploymentCondition(ref), - "k8s.io/api/apps/v1.DeploymentList": schema_k8sio_api_apps_v1_DeploymentList(ref), - "k8s.io/api/apps/v1.DeploymentSpec": schema_k8sio_api_apps_v1_DeploymentSpec(ref), - "k8s.io/api/apps/v1.DeploymentStatus": schema_k8sio_api_apps_v1_DeploymentStatus(ref), - "k8s.io/api/apps/v1.DeploymentStrategy": schema_k8sio_api_apps_v1_DeploymentStrategy(ref), - "k8s.io/api/apps/v1.ReplicaSet": schema_k8sio_api_apps_v1_ReplicaSet(ref), - "k8s.io/api/apps/v1.ReplicaSetCondition": schema_k8sio_api_apps_v1_ReplicaSetCondition(ref), - "k8s.io/api/apps/v1.ReplicaSetList": schema_k8sio_api_apps_v1_ReplicaSetList(ref), - "k8s.io/api/apps/v1.ReplicaSetSpec": schema_k8sio_api_apps_v1_ReplicaSetSpec(ref), - "k8s.io/api/apps/v1.ReplicaSetStatus": schema_k8sio_api_apps_v1_ReplicaSetStatus(ref), - "k8s.io/api/apps/v1.RollingUpdateDaemonSet": schema_k8sio_api_apps_v1_RollingUpdateDaemonSet(ref), - "k8s.io/api/apps/v1.RollingUpdateDeployment": schema_k8sio_api_apps_v1_RollingUpdateDeployment(ref), - "k8s.io/api/apps/v1.RollingUpdateStatefulSetStrategy": schema_k8sio_api_apps_v1_RollingUpdateStatefulSetStrategy(ref), - "k8s.io/api/apps/v1.StatefulSet": schema_k8sio_api_apps_v1_StatefulSet(ref), - "k8s.io/api/apps/v1.StatefulSetCondition": schema_k8sio_api_apps_v1_StatefulSetCondition(ref), - "k8s.io/api/apps/v1.StatefulSetList": schema_k8sio_api_apps_v1_StatefulSetList(ref), - "k8s.io/api/apps/v1.StatefulSetOrdinals": schema_k8sio_api_apps_v1_StatefulSetOrdinals(ref), - "k8s.io/api/apps/v1.StatefulSetPersistentVolumeClaimRetentionPolicy": schema_k8sio_api_apps_v1_StatefulSetPersistentVolumeClaimRetentionPolicy(ref), - "k8s.io/api/apps/v1.StatefulSetSpec": schema_k8sio_api_apps_v1_StatefulSetSpec(ref), - "k8s.io/api/apps/v1.StatefulSetStatus": schema_k8sio_api_apps_v1_StatefulSetStatus(ref), - "k8s.io/api/apps/v1.StatefulSetUpdateStrategy": schema_k8sio_api_apps_v1_StatefulSetUpdateStrategy(ref), - "k8s.io/api/apps/v1beta1.ControllerRevision": schema_k8sio_api_apps_v1beta1_ControllerRevision(ref), - "k8s.io/api/apps/v1beta1.ControllerRevisionList": schema_k8sio_api_apps_v1beta1_ControllerRevisionList(ref), - "k8s.io/api/apps/v1beta1.Deployment": schema_k8sio_api_apps_v1beta1_Deployment(ref), - "k8s.io/api/apps/v1beta1.DeploymentCondition": schema_k8sio_api_apps_v1beta1_DeploymentCondition(ref), - "k8s.io/api/apps/v1beta1.DeploymentList": schema_k8sio_api_apps_v1beta1_DeploymentList(ref), - "k8s.io/api/apps/v1beta1.DeploymentRollback": schema_k8sio_api_apps_v1beta1_DeploymentRollback(ref), - "k8s.io/api/apps/v1beta1.DeploymentSpec": schema_k8sio_api_apps_v1beta1_DeploymentSpec(ref), - "k8s.io/api/apps/v1beta1.DeploymentStatus": schema_k8sio_api_apps_v1beta1_DeploymentStatus(ref), - "k8s.io/api/apps/v1beta1.DeploymentStrategy": schema_k8sio_api_apps_v1beta1_DeploymentStrategy(ref), - "k8s.io/api/apps/v1beta1.RollbackConfig": schema_k8sio_api_apps_v1beta1_RollbackConfig(ref), - "k8s.io/api/apps/v1beta1.RollingUpdateDeployment": schema_k8sio_api_apps_v1beta1_RollingUpdateDeployment(ref), - "k8s.io/api/apps/v1beta1.RollingUpdateStatefulSetStrategy": schema_k8sio_api_apps_v1beta1_RollingUpdateStatefulSetStrategy(ref), - "k8s.io/api/apps/v1beta1.Scale": schema_k8sio_api_apps_v1beta1_Scale(ref), - "k8s.io/api/apps/v1beta1.ScaleSpec": schema_k8sio_api_apps_v1beta1_ScaleSpec(ref), - "k8s.io/api/apps/v1beta1.ScaleStatus": schema_k8sio_api_apps_v1beta1_ScaleStatus(ref), - "k8s.io/api/apps/v1beta1.StatefulSet": schema_k8sio_api_apps_v1beta1_StatefulSet(ref), - "k8s.io/api/apps/v1beta1.StatefulSetCondition": schema_k8sio_api_apps_v1beta1_StatefulSetCondition(ref), - "k8s.io/api/apps/v1beta1.StatefulSetList": schema_k8sio_api_apps_v1beta1_StatefulSetList(ref), - "k8s.io/api/apps/v1beta1.StatefulSetOrdinals": schema_k8sio_api_apps_v1beta1_StatefulSetOrdinals(ref), - "k8s.io/api/apps/v1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy": schema_k8sio_api_apps_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy(ref), - "k8s.io/api/apps/v1beta1.StatefulSetSpec": schema_k8sio_api_apps_v1beta1_StatefulSetSpec(ref), - "k8s.io/api/apps/v1beta1.StatefulSetStatus": schema_k8sio_api_apps_v1beta1_StatefulSetStatus(ref), - "k8s.io/api/apps/v1beta1.StatefulSetUpdateStrategy": schema_k8sio_api_apps_v1beta1_StatefulSetUpdateStrategy(ref), - "k8s.io/api/apps/v1beta2.ControllerRevision": schema_k8sio_api_apps_v1beta2_ControllerRevision(ref), - "k8s.io/api/apps/v1beta2.ControllerRevisionList": schema_k8sio_api_apps_v1beta2_ControllerRevisionList(ref), - "k8s.io/api/apps/v1beta2.DaemonSet": schema_k8sio_api_apps_v1beta2_DaemonSet(ref), - "k8s.io/api/apps/v1beta2.DaemonSetCondition": schema_k8sio_api_apps_v1beta2_DaemonSetCondition(ref), - "k8s.io/api/apps/v1beta2.DaemonSetList": schema_k8sio_api_apps_v1beta2_DaemonSetList(ref), - "k8s.io/api/apps/v1beta2.DaemonSetSpec": schema_k8sio_api_apps_v1beta2_DaemonSetSpec(ref), - "k8s.io/api/apps/v1beta2.DaemonSetStatus": schema_k8sio_api_apps_v1beta2_DaemonSetStatus(ref), - "k8s.io/api/apps/v1beta2.DaemonSetUpdateStrategy": schema_k8sio_api_apps_v1beta2_DaemonSetUpdateStrategy(ref), - "k8s.io/api/apps/v1beta2.Deployment": schema_k8sio_api_apps_v1beta2_Deployment(ref), - "k8s.io/api/apps/v1beta2.DeploymentCondition": schema_k8sio_api_apps_v1beta2_DeploymentCondition(ref), - "k8s.io/api/apps/v1beta2.DeploymentList": schema_k8sio_api_apps_v1beta2_DeploymentList(ref), - "k8s.io/api/apps/v1beta2.DeploymentSpec": schema_k8sio_api_apps_v1beta2_DeploymentSpec(ref), - "k8s.io/api/apps/v1beta2.DeploymentStatus": schema_k8sio_api_apps_v1beta2_DeploymentStatus(ref), - "k8s.io/api/apps/v1beta2.DeploymentStrategy": schema_k8sio_api_apps_v1beta2_DeploymentStrategy(ref), - "k8s.io/api/apps/v1beta2.ReplicaSet": schema_k8sio_api_apps_v1beta2_ReplicaSet(ref), - "k8s.io/api/apps/v1beta2.ReplicaSetCondition": schema_k8sio_api_apps_v1beta2_ReplicaSetCondition(ref), - "k8s.io/api/apps/v1beta2.ReplicaSetList": schema_k8sio_api_apps_v1beta2_ReplicaSetList(ref), - "k8s.io/api/apps/v1beta2.ReplicaSetSpec": schema_k8sio_api_apps_v1beta2_ReplicaSetSpec(ref), - "k8s.io/api/apps/v1beta2.ReplicaSetStatus": schema_k8sio_api_apps_v1beta2_ReplicaSetStatus(ref), - "k8s.io/api/apps/v1beta2.RollingUpdateDaemonSet": schema_k8sio_api_apps_v1beta2_RollingUpdateDaemonSet(ref), - "k8s.io/api/apps/v1beta2.RollingUpdateDeployment": schema_k8sio_api_apps_v1beta2_RollingUpdateDeployment(ref), - "k8s.io/api/apps/v1beta2.RollingUpdateStatefulSetStrategy": schema_k8sio_api_apps_v1beta2_RollingUpdateStatefulSetStrategy(ref), - "k8s.io/api/apps/v1beta2.Scale": schema_k8sio_api_apps_v1beta2_Scale(ref), - "k8s.io/api/apps/v1beta2.ScaleSpec": schema_k8sio_api_apps_v1beta2_ScaleSpec(ref), - "k8s.io/api/apps/v1beta2.ScaleStatus": schema_k8sio_api_apps_v1beta2_ScaleStatus(ref), - "k8s.io/api/apps/v1beta2.StatefulSet": schema_k8sio_api_apps_v1beta2_StatefulSet(ref), - "k8s.io/api/apps/v1beta2.StatefulSetCondition": schema_k8sio_api_apps_v1beta2_StatefulSetCondition(ref), - "k8s.io/api/apps/v1beta2.StatefulSetList": schema_k8sio_api_apps_v1beta2_StatefulSetList(ref), - "k8s.io/api/apps/v1beta2.StatefulSetOrdinals": schema_k8sio_api_apps_v1beta2_StatefulSetOrdinals(ref), - "k8s.io/api/apps/v1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy": schema_k8sio_api_apps_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy(ref), - "k8s.io/api/apps/v1beta2.StatefulSetSpec": schema_k8sio_api_apps_v1beta2_StatefulSetSpec(ref), - "k8s.io/api/apps/v1beta2.StatefulSetStatus": schema_k8sio_api_apps_v1beta2_StatefulSetStatus(ref), - "k8s.io/api/apps/v1beta2.StatefulSetUpdateStrategy": schema_k8sio_api_apps_v1beta2_StatefulSetUpdateStrategy(ref), - "k8s.io/api/authentication/v1.BoundObjectReference": schema_k8sio_api_authentication_v1_BoundObjectReference(ref), - "k8s.io/api/authentication/v1.SelfSubjectReview": schema_k8sio_api_authentication_v1_SelfSubjectReview(ref), - "k8s.io/api/authentication/v1.SelfSubjectReviewStatus": schema_k8sio_api_authentication_v1_SelfSubjectReviewStatus(ref), - "k8s.io/api/authentication/v1.TokenRequest": schema_k8sio_api_authentication_v1_TokenRequest(ref), - "k8s.io/api/authentication/v1.TokenRequestSpec": schema_k8sio_api_authentication_v1_TokenRequestSpec(ref), - "k8s.io/api/authentication/v1.TokenRequestStatus": schema_k8sio_api_authentication_v1_TokenRequestStatus(ref), - "k8s.io/api/authentication/v1.TokenReview": schema_k8sio_api_authentication_v1_TokenReview(ref), - "k8s.io/api/authentication/v1.TokenReviewSpec": schema_k8sio_api_authentication_v1_TokenReviewSpec(ref), - "k8s.io/api/authentication/v1.TokenReviewStatus": schema_k8sio_api_authentication_v1_TokenReviewStatus(ref), - "k8s.io/api/authentication/v1.UserInfo": schema_k8sio_api_authentication_v1_UserInfo(ref), - "k8s.io/api/authentication/v1alpha1.SelfSubjectReview": schema_k8sio_api_authentication_v1alpha1_SelfSubjectReview(ref), - "k8s.io/api/authentication/v1alpha1.SelfSubjectReviewStatus": schema_k8sio_api_authentication_v1alpha1_SelfSubjectReviewStatus(ref), - "k8s.io/api/authentication/v1beta1.SelfSubjectReview": schema_k8sio_api_authentication_v1beta1_SelfSubjectReview(ref), - "k8s.io/api/authentication/v1beta1.SelfSubjectReviewStatus": schema_k8sio_api_authentication_v1beta1_SelfSubjectReviewStatus(ref), - "k8s.io/api/authentication/v1beta1.TokenReview": schema_k8sio_api_authentication_v1beta1_TokenReview(ref), - "k8s.io/api/authentication/v1beta1.TokenReviewSpec": schema_k8sio_api_authentication_v1beta1_TokenReviewSpec(ref), - "k8s.io/api/authentication/v1beta1.TokenReviewStatus": schema_k8sio_api_authentication_v1beta1_TokenReviewStatus(ref), - "k8s.io/api/authentication/v1beta1.UserInfo": schema_k8sio_api_authentication_v1beta1_UserInfo(ref), - "k8s.io/api/authorization/v1.LocalSubjectAccessReview": schema_k8sio_api_authorization_v1_LocalSubjectAccessReview(ref), - "k8s.io/api/authorization/v1.NonResourceAttributes": schema_k8sio_api_authorization_v1_NonResourceAttributes(ref), - "k8s.io/api/authorization/v1.NonResourceRule": schema_k8sio_api_authorization_v1_NonResourceRule(ref), - "k8s.io/api/authorization/v1.ResourceAttributes": schema_k8sio_api_authorization_v1_ResourceAttributes(ref), - "k8s.io/api/authorization/v1.ResourceRule": schema_k8sio_api_authorization_v1_ResourceRule(ref), - "k8s.io/api/authorization/v1.SelfSubjectAccessReview": schema_k8sio_api_authorization_v1_SelfSubjectAccessReview(ref), - "k8s.io/api/authorization/v1.SelfSubjectAccessReviewSpec": schema_k8sio_api_authorization_v1_SelfSubjectAccessReviewSpec(ref), - "k8s.io/api/authorization/v1.SelfSubjectRulesReview": schema_k8sio_api_authorization_v1_SelfSubjectRulesReview(ref), - "k8s.io/api/authorization/v1.SelfSubjectRulesReviewSpec": schema_k8sio_api_authorization_v1_SelfSubjectRulesReviewSpec(ref), - "k8s.io/api/authorization/v1.SubjectAccessReview": schema_k8sio_api_authorization_v1_SubjectAccessReview(ref), - "k8s.io/api/authorization/v1.SubjectAccessReviewSpec": schema_k8sio_api_authorization_v1_SubjectAccessReviewSpec(ref), - "k8s.io/api/authorization/v1.SubjectAccessReviewStatus": schema_k8sio_api_authorization_v1_SubjectAccessReviewStatus(ref), - "k8s.io/api/authorization/v1.SubjectRulesReviewStatus": schema_k8sio_api_authorization_v1_SubjectRulesReviewStatus(ref), - "k8s.io/api/authorization/v1beta1.LocalSubjectAccessReview": schema_k8sio_api_authorization_v1beta1_LocalSubjectAccessReview(ref), - "k8s.io/api/authorization/v1beta1.NonResourceAttributes": schema_k8sio_api_authorization_v1beta1_NonResourceAttributes(ref), - "k8s.io/api/authorization/v1beta1.NonResourceRule": schema_k8sio_api_authorization_v1beta1_NonResourceRule(ref), - "k8s.io/api/authorization/v1beta1.ResourceAttributes": schema_k8sio_api_authorization_v1beta1_ResourceAttributes(ref), - "k8s.io/api/authorization/v1beta1.ResourceRule": schema_k8sio_api_authorization_v1beta1_ResourceRule(ref), - "k8s.io/api/authorization/v1beta1.SelfSubjectAccessReview": schema_k8sio_api_authorization_v1beta1_SelfSubjectAccessReview(ref), - "k8s.io/api/authorization/v1beta1.SelfSubjectAccessReviewSpec": schema_k8sio_api_authorization_v1beta1_SelfSubjectAccessReviewSpec(ref), - "k8s.io/api/authorization/v1beta1.SelfSubjectRulesReview": schema_k8sio_api_authorization_v1beta1_SelfSubjectRulesReview(ref), - "k8s.io/api/authorization/v1beta1.SelfSubjectRulesReviewSpec": schema_k8sio_api_authorization_v1beta1_SelfSubjectRulesReviewSpec(ref), - "k8s.io/api/authorization/v1beta1.SubjectAccessReview": schema_k8sio_api_authorization_v1beta1_SubjectAccessReview(ref), - "k8s.io/api/authorization/v1beta1.SubjectAccessReviewSpec": schema_k8sio_api_authorization_v1beta1_SubjectAccessReviewSpec(ref), - "k8s.io/api/authorization/v1beta1.SubjectAccessReviewStatus": schema_k8sio_api_authorization_v1beta1_SubjectAccessReviewStatus(ref), - "k8s.io/api/authorization/v1beta1.SubjectRulesReviewStatus": schema_k8sio_api_authorization_v1beta1_SubjectRulesReviewStatus(ref), - "k8s.io/api/autoscaling/v1.ContainerResourceMetricSource": schema_k8sio_api_autoscaling_v1_ContainerResourceMetricSource(ref), - "k8s.io/api/autoscaling/v1.ContainerResourceMetricStatus": schema_k8sio_api_autoscaling_v1_ContainerResourceMetricStatus(ref), - "k8s.io/api/autoscaling/v1.CrossVersionObjectReference": schema_k8sio_api_autoscaling_v1_CrossVersionObjectReference(ref), - "k8s.io/api/autoscaling/v1.ExternalMetricSource": schema_k8sio_api_autoscaling_v1_ExternalMetricSource(ref), - "k8s.io/api/autoscaling/v1.ExternalMetricStatus": schema_k8sio_api_autoscaling_v1_ExternalMetricStatus(ref), - "k8s.io/api/autoscaling/v1.HorizontalPodAutoscaler": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscaler(ref), - "k8s.io/api/autoscaling/v1.HorizontalPodAutoscalerCondition": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscalerCondition(ref), - "k8s.io/api/autoscaling/v1.HorizontalPodAutoscalerList": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscalerList(ref), - "k8s.io/api/autoscaling/v1.HorizontalPodAutoscalerSpec": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscalerSpec(ref), - "k8s.io/api/autoscaling/v1.HorizontalPodAutoscalerStatus": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscalerStatus(ref), - "k8s.io/api/autoscaling/v1.MetricSpec": schema_k8sio_api_autoscaling_v1_MetricSpec(ref), - "k8s.io/api/autoscaling/v1.MetricStatus": schema_k8sio_api_autoscaling_v1_MetricStatus(ref), - "k8s.io/api/autoscaling/v1.ObjectMetricSource": schema_k8sio_api_autoscaling_v1_ObjectMetricSource(ref), - "k8s.io/api/autoscaling/v1.ObjectMetricStatus": schema_k8sio_api_autoscaling_v1_ObjectMetricStatus(ref), - "k8s.io/api/autoscaling/v1.PodsMetricSource": schema_k8sio_api_autoscaling_v1_PodsMetricSource(ref), - "k8s.io/api/autoscaling/v1.PodsMetricStatus": schema_k8sio_api_autoscaling_v1_PodsMetricStatus(ref), - "k8s.io/api/autoscaling/v1.ResourceMetricSource": schema_k8sio_api_autoscaling_v1_ResourceMetricSource(ref), - "k8s.io/api/autoscaling/v1.ResourceMetricStatus": schema_k8sio_api_autoscaling_v1_ResourceMetricStatus(ref), - "k8s.io/api/autoscaling/v1.Scale": schema_k8sio_api_autoscaling_v1_Scale(ref), - "k8s.io/api/autoscaling/v1.ScaleSpec": schema_k8sio_api_autoscaling_v1_ScaleSpec(ref), - "k8s.io/api/autoscaling/v1.ScaleStatus": schema_k8sio_api_autoscaling_v1_ScaleStatus(ref), - "k8s.io/api/autoscaling/v2.ContainerResourceMetricSource": schema_k8sio_api_autoscaling_v2_ContainerResourceMetricSource(ref), - "k8s.io/api/autoscaling/v2.ContainerResourceMetricStatus": schema_k8sio_api_autoscaling_v2_ContainerResourceMetricStatus(ref), - "k8s.io/api/autoscaling/v2.CrossVersionObjectReference": schema_k8sio_api_autoscaling_v2_CrossVersionObjectReference(ref), - "k8s.io/api/autoscaling/v2.ExternalMetricSource": schema_k8sio_api_autoscaling_v2_ExternalMetricSource(ref), - "k8s.io/api/autoscaling/v2.ExternalMetricStatus": schema_k8sio_api_autoscaling_v2_ExternalMetricStatus(ref), - "k8s.io/api/autoscaling/v2.HPAScalingPolicy": schema_k8sio_api_autoscaling_v2_HPAScalingPolicy(ref), - "k8s.io/api/autoscaling/v2.HPAScalingRules": schema_k8sio_api_autoscaling_v2_HPAScalingRules(ref), - "k8s.io/api/autoscaling/v2.HorizontalPodAutoscaler": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscaler(ref), - "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerBehavior": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerBehavior(ref), - "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerCondition": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerCondition(ref), - "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerList": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerList(ref), - "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerSpec": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerSpec(ref), - "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerStatus": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerStatus(ref), - "k8s.io/api/autoscaling/v2.MetricIdentifier": schema_k8sio_api_autoscaling_v2_MetricIdentifier(ref), - "k8s.io/api/autoscaling/v2.MetricSpec": schema_k8sio_api_autoscaling_v2_MetricSpec(ref), - "k8s.io/api/autoscaling/v2.MetricStatus": schema_k8sio_api_autoscaling_v2_MetricStatus(ref), - "k8s.io/api/autoscaling/v2.MetricTarget": schema_k8sio_api_autoscaling_v2_MetricTarget(ref), - "k8s.io/api/autoscaling/v2.MetricValueStatus": schema_k8sio_api_autoscaling_v2_MetricValueStatus(ref), - "k8s.io/api/autoscaling/v2.ObjectMetricSource": schema_k8sio_api_autoscaling_v2_ObjectMetricSource(ref), - "k8s.io/api/autoscaling/v2.ObjectMetricStatus": schema_k8sio_api_autoscaling_v2_ObjectMetricStatus(ref), - "k8s.io/api/autoscaling/v2.PodsMetricSource": schema_k8sio_api_autoscaling_v2_PodsMetricSource(ref), - "k8s.io/api/autoscaling/v2.PodsMetricStatus": schema_k8sio_api_autoscaling_v2_PodsMetricStatus(ref), - "k8s.io/api/autoscaling/v2.ResourceMetricSource": schema_k8sio_api_autoscaling_v2_ResourceMetricSource(ref), - "k8s.io/api/autoscaling/v2.ResourceMetricStatus": schema_k8sio_api_autoscaling_v2_ResourceMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta1.ContainerResourceMetricSource": schema_k8sio_api_autoscaling_v2beta1_ContainerResourceMetricSource(ref), - "k8s.io/api/autoscaling/v2beta1.ContainerResourceMetricStatus": schema_k8sio_api_autoscaling_v2beta1_ContainerResourceMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta1.CrossVersionObjectReference": schema_k8sio_api_autoscaling_v2beta1_CrossVersionObjectReference(ref), - "k8s.io/api/autoscaling/v2beta1.ExternalMetricSource": schema_k8sio_api_autoscaling_v2beta1_ExternalMetricSource(ref), - "k8s.io/api/autoscaling/v2beta1.ExternalMetricStatus": schema_k8sio_api_autoscaling_v2beta1_ExternalMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscaler": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscaler(ref), - "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscalerCondition": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscalerCondition(ref), - "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscalerList": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscalerList(ref), - "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscalerSpec": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscalerSpec(ref), - "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscalerStatus": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscalerStatus(ref), - "k8s.io/api/autoscaling/v2beta1.MetricSpec": schema_k8sio_api_autoscaling_v2beta1_MetricSpec(ref), - "k8s.io/api/autoscaling/v2beta1.MetricStatus": schema_k8sio_api_autoscaling_v2beta1_MetricStatus(ref), - "k8s.io/api/autoscaling/v2beta1.ObjectMetricSource": schema_k8sio_api_autoscaling_v2beta1_ObjectMetricSource(ref), - "k8s.io/api/autoscaling/v2beta1.ObjectMetricStatus": schema_k8sio_api_autoscaling_v2beta1_ObjectMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta1.PodsMetricSource": schema_k8sio_api_autoscaling_v2beta1_PodsMetricSource(ref), - "k8s.io/api/autoscaling/v2beta1.PodsMetricStatus": schema_k8sio_api_autoscaling_v2beta1_PodsMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta1.ResourceMetricSource": schema_k8sio_api_autoscaling_v2beta1_ResourceMetricSource(ref), - "k8s.io/api/autoscaling/v2beta1.ResourceMetricStatus": schema_k8sio_api_autoscaling_v2beta1_ResourceMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta2.ContainerResourceMetricSource": schema_k8sio_api_autoscaling_v2beta2_ContainerResourceMetricSource(ref), - "k8s.io/api/autoscaling/v2beta2.ContainerResourceMetricStatus": schema_k8sio_api_autoscaling_v2beta2_ContainerResourceMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta2.CrossVersionObjectReference": schema_k8sio_api_autoscaling_v2beta2_CrossVersionObjectReference(ref), - "k8s.io/api/autoscaling/v2beta2.ExternalMetricSource": schema_k8sio_api_autoscaling_v2beta2_ExternalMetricSource(ref), - "k8s.io/api/autoscaling/v2beta2.ExternalMetricStatus": schema_k8sio_api_autoscaling_v2beta2_ExternalMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta2.HPAScalingPolicy": schema_k8sio_api_autoscaling_v2beta2_HPAScalingPolicy(ref), - "k8s.io/api/autoscaling/v2beta2.HPAScalingRules": schema_k8sio_api_autoscaling_v2beta2_HPAScalingRules(ref), - "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscaler": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscaler(ref), - "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerBehavior": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerBehavior(ref), - "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerCondition": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerCondition(ref), - "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerList": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerList(ref), - "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerSpec": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerSpec(ref), - "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerStatus": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerStatus(ref), - "k8s.io/api/autoscaling/v2beta2.MetricIdentifier": schema_k8sio_api_autoscaling_v2beta2_MetricIdentifier(ref), - "k8s.io/api/autoscaling/v2beta2.MetricSpec": schema_k8sio_api_autoscaling_v2beta2_MetricSpec(ref), - "k8s.io/api/autoscaling/v2beta2.MetricStatus": schema_k8sio_api_autoscaling_v2beta2_MetricStatus(ref), - "k8s.io/api/autoscaling/v2beta2.MetricTarget": schema_k8sio_api_autoscaling_v2beta2_MetricTarget(ref), - "k8s.io/api/autoscaling/v2beta2.MetricValueStatus": schema_k8sio_api_autoscaling_v2beta2_MetricValueStatus(ref), - "k8s.io/api/autoscaling/v2beta2.ObjectMetricSource": schema_k8sio_api_autoscaling_v2beta2_ObjectMetricSource(ref), - "k8s.io/api/autoscaling/v2beta2.ObjectMetricStatus": schema_k8sio_api_autoscaling_v2beta2_ObjectMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta2.PodsMetricSource": schema_k8sio_api_autoscaling_v2beta2_PodsMetricSource(ref), - "k8s.io/api/autoscaling/v2beta2.PodsMetricStatus": schema_k8sio_api_autoscaling_v2beta2_PodsMetricStatus(ref), - "k8s.io/api/autoscaling/v2beta2.ResourceMetricSource": schema_k8sio_api_autoscaling_v2beta2_ResourceMetricSource(ref), - "k8s.io/api/autoscaling/v2beta2.ResourceMetricStatus": schema_k8sio_api_autoscaling_v2beta2_ResourceMetricStatus(ref), - "k8s.io/api/batch/v1.CronJob": schema_k8sio_api_batch_v1_CronJob(ref), - "k8s.io/api/batch/v1.CronJobList": schema_k8sio_api_batch_v1_CronJobList(ref), - "k8s.io/api/batch/v1.CronJobSpec": schema_k8sio_api_batch_v1_CronJobSpec(ref), - "k8s.io/api/batch/v1.CronJobStatus": schema_k8sio_api_batch_v1_CronJobStatus(ref), - "k8s.io/api/batch/v1.Job": schema_k8sio_api_batch_v1_Job(ref), - "k8s.io/api/batch/v1.JobCondition": schema_k8sio_api_batch_v1_JobCondition(ref), - "k8s.io/api/batch/v1.JobList": schema_k8sio_api_batch_v1_JobList(ref), - "k8s.io/api/batch/v1.JobSpec": schema_k8sio_api_batch_v1_JobSpec(ref), - "k8s.io/api/batch/v1.JobStatus": schema_k8sio_api_batch_v1_JobStatus(ref), - "k8s.io/api/batch/v1.JobTemplateSpec": schema_k8sio_api_batch_v1_JobTemplateSpec(ref), - "k8s.io/api/batch/v1.PodFailurePolicy": schema_k8sio_api_batch_v1_PodFailurePolicy(ref), - "k8s.io/api/batch/v1.PodFailurePolicyOnExitCodesRequirement": schema_k8sio_api_batch_v1_PodFailurePolicyOnExitCodesRequirement(ref), - "k8s.io/api/batch/v1.PodFailurePolicyOnPodConditionsPattern": schema_k8sio_api_batch_v1_PodFailurePolicyOnPodConditionsPattern(ref), - "k8s.io/api/batch/v1.PodFailurePolicyRule": schema_k8sio_api_batch_v1_PodFailurePolicyRule(ref), - "k8s.io/api/batch/v1.UncountedTerminatedPods": schema_k8sio_api_batch_v1_UncountedTerminatedPods(ref), - "k8s.io/api/batch/v1beta1.CronJob": schema_k8sio_api_batch_v1beta1_CronJob(ref), - "k8s.io/api/batch/v1beta1.CronJobList": schema_k8sio_api_batch_v1beta1_CronJobList(ref), - "k8s.io/api/batch/v1beta1.CronJobSpec": schema_k8sio_api_batch_v1beta1_CronJobSpec(ref), - "k8s.io/api/batch/v1beta1.CronJobStatus": schema_k8sio_api_batch_v1beta1_CronJobStatus(ref), - "k8s.io/api/batch/v1beta1.JobTemplateSpec": schema_k8sio_api_batch_v1beta1_JobTemplateSpec(ref), - "k8s.io/api/certificates/v1.CertificateSigningRequest": schema_k8sio_api_certificates_v1_CertificateSigningRequest(ref), - "k8s.io/api/certificates/v1.CertificateSigningRequestCondition": schema_k8sio_api_certificates_v1_CertificateSigningRequestCondition(ref), - "k8s.io/api/certificates/v1.CertificateSigningRequestList": schema_k8sio_api_certificates_v1_CertificateSigningRequestList(ref), - "k8s.io/api/certificates/v1.CertificateSigningRequestSpec": schema_k8sio_api_certificates_v1_CertificateSigningRequestSpec(ref), - "k8s.io/api/certificates/v1.CertificateSigningRequestStatus": schema_k8sio_api_certificates_v1_CertificateSigningRequestStatus(ref), - "k8s.io/api/certificates/v1alpha1.ClusterTrustBundle": schema_k8sio_api_certificates_v1alpha1_ClusterTrustBundle(ref), - "k8s.io/api/certificates/v1alpha1.ClusterTrustBundleList": schema_k8sio_api_certificates_v1alpha1_ClusterTrustBundleList(ref), - "k8s.io/api/certificates/v1alpha1.ClusterTrustBundleSpec": schema_k8sio_api_certificates_v1alpha1_ClusterTrustBundleSpec(ref), - "k8s.io/api/certificates/v1beta1.CertificateSigningRequest": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequest(ref), - "k8s.io/api/certificates/v1beta1.CertificateSigningRequestCondition": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequestCondition(ref), - "k8s.io/api/certificates/v1beta1.CertificateSigningRequestList": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequestList(ref), - "k8s.io/api/certificates/v1beta1.CertificateSigningRequestSpec": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequestSpec(ref), - "k8s.io/api/certificates/v1beta1.CertificateSigningRequestStatus": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequestStatus(ref), - "k8s.io/api/coordination/v1.Lease": schema_k8sio_api_coordination_v1_Lease(ref), - "k8s.io/api/coordination/v1.LeaseList": schema_k8sio_api_coordination_v1_LeaseList(ref), - "k8s.io/api/coordination/v1.LeaseSpec": schema_k8sio_api_coordination_v1_LeaseSpec(ref), - "k8s.io/api/coordination/v1beta1.Lease": schema_k8sio_api_coordination_v1beta1_Lease(ref), - "k8s.io/api/coordination/v1beta1.LeaseList": schema_k8sio_api_coordination_v1beta1_LeaseList(ref), - "k8s.io/api/coordination/v1beta1.LeaseSpec": schema_k8sio_api_coordination_v1beta1_LeaseSpec(ref), - "k8s.io/api/core/v1.AWSElasticBlockStoreVolumeSource": schema_k8sio_api_core_v1_AWSElasticBlockStoreVolumeSource(ref), - "k8s.io/api/core/v1.Affinity": schema_k8sio_api_core_v1_Affinity(ref), - "k8s.io/api/core/v1.AttachedVolume": schema_k8sio_api_core_v1_AttachedVolume(ref), - "k8s.io/api/core/v1.AvoidPods": schema_k8sio_api_core_v1_AvoidPods(ref), - "k8s.io/api/core/v1.AzureDiskVolumeSource": schema_k8sio_api_core_v1_AzureDiskVolumeSource(ref), - "k8s.io/api/core/v1.AzureFilePersistentVolumeSource": schema_k8sio_api_core_v1_AzureFilePersistentVolumeSource(ref), - "k8s.io/api/core/v1.AzureFileVolumeSource": schema_k8sio_api_core_v1_AzureFileVolumeSource(ref), - "k8s.io/api/core/v1.Binding": schema_k8sio_api_core_v1_Binding(ref), - "k8s.io/api/core/v1.CSIPersistentVolumeSource": schema_k8sio_api_core_v1_CSIPersistentVolumeSource(ref), - "k8s.io/api/core/v1.CSIVolumeSource": schema_k8sio_api_core_v1_CSIVolumeSource(ref), - "k8s.io/api/core/v1.Capabilities": schema_k8sio_api_core_v1_Capabilities(ref), - "k8s.io/api/core/v1.CephFSPersistentVolumeSource": schema_k8sio_api_core_v1_CephFSPersistentVolumeSource(ref), - "k8s.io/api/core/v1.CephFSVolumeSource": schema_k8sio_api_core_v1_CephFSVolumeSource(ref), - "k8s.io/api/core/v1.CinderPersistentVolumeSource": schema_k8sio_api_core_v1_CinderPersistentVolumeSource(ref), - "k8s.io/api/core/v1.CinderVolumeSource": schema_k8sio_api_core_v1_CinderVolumeSource(ref), - "k8s.io/api/core/v1.ClaimSource": schema_k8sio_api_core_v1_ClaimSource(ref), - "k8s.io/api/core/v1.ClientIPConfig": schema_k8sio_api_core_v1_ClientIPConfig(ref), - "k8s.io/api/core/v1.ComponentCondition": schema_k8sio_api_core_v1_ComponentCondition(ref), - "k8s.io/api/core/v1.ComponentStatus": schema_k8sio_api_core_v1_ComponentStatus(ref), - "k8s.io/api/core/v1.ComponentStatusList": schema_k8sio_api_core_v1_ComponentStatusList(ref), - "k8s.io/api/core/v1.ConfigMap": schema_k8sio_api_core_v1_ConfigMap(ref), - "k8s.io/api/core/v1.ConfigMapEnvSource": schema_k8sio_api_core_v1_ConfigMapEnvSource(ref), - "k8s.io/api/core/v1.ConfigMapKeySelector": schema_k8sio_api_core_v1_ConfigMapKeySelector(ref), - "k8s.io/api/core/v1.ConfigMapList": schema_k8sio_api_core_v1_ConfigMapList(ref), - "k8s.io/api/core/v1.ConfigMapNodeConfigSource": schema_k8sio_api_core_v1_ConfigMapNodeConfigSource(ref), - "k8s.io/api/core/v1.ConfigMapProjection": schema_k8sio_api_core_v1_ConfigMapProjection(ref), - "k8s.io/api/core/v1.ConfigMapVolumeSource": schema_k8sio_api_core_v1_ConfigMapVolumeSource(ref), - "k8s.io/api/core/v1.Container": schema_k8sio_api_core_v1_Container(ref), - "k8s.io/api/core/v1.ContainerImage": schema_k8sio_api_core_v1_ContainerImage(ref), - "k8s.io/api/core/v1.ContainerPort": schema_k8sio_api_core_v1_ContainerPort(ref), - "k8s.io/api/core/v1.ContainerResizePolicy": schema_k8sio_api_core_v1_ContainerResizePolicy(ref), - "k8s.io/api/core/v1.ContainerState": schema_k8sio_api_core_v1_ContainerState(ref), - "k8s.io/api/core/v1.ContainerStateRunning": schema_k8sio_api_core_v1_ContainerStateRunning(ref), - "k8s.io/api/core/v1.ContainerStateTerminated": schema_k8sio_api_core_v1_ContainerStateTerminated(ref), - "k8s.io/api/core/v1.ContainerStateWaiting": schema_k8sio_api_core_v1_ContainerStateWaiting(ref), - "k8s.io/api/core/v1.ContainerStatus": schema_k8sio_api_core_v1_ContainerStatus(ref), - "k8s.io/api/core/v1.DaemonEndpoint": schema_k8sio_api_core_v1_DaemonEndpoint(ref), - "k8s.io/api/core/v1.DownwardAPIProjection": schema_k8sio_api_core_v1_DownwardAPIProjection(ref), - "k8s.io/api/core/v1.DownwardAPIVolumeFile": schema_k8sio_api_core_v1_DownwardAPIVolumeFile(ref), - "k8s.io/api/core/v1.DownwardAPIVolumeSource": schema_k8sio_api_core_v1_DownwardAPIVolumeSource(ref), - "k8s.io/api/core/v1.EmptyDirVolumeSource": schema_k8sio_api_core_v1_EmptyDirVolumeSource(ref), - "k8s.io/api/core/v1.EndpointAddress": schema_k8sio_api_core_v1_EndpointAddress(ref), - "k8s.io/api/core/v1.EndpointPort": schema_k8sio_api_core_v1_EndpointPort(ref), - "k8s.io/api/core/v1.EndpointSubset": schema_k8sio_api_core_v1_EndpointSubset(ref), - "k8s.io/api/core/v1.Endpoints": schema_k8sio_api_core_v1_Endpoints(ref), - "k8s.io/api/core/v1.EndpointsList": schema_k8sio_api_core_v1_EndpointsList(ref), - "k8s.io/api/core/v1.EnvFromSource": schema_k8sio_api_core_v1_EnvFromSource(ref), - "k8s.io/api/core/v1.EnvVar": schema_k8sio_api_core_v1_EnvVar(ref), - "k8s.io/api/core/v1.EnvVarSource": schema_k8sio_api_core_v1_EnvVarSource(ref), - "k8s.io/api/core/v1.EphemeralContainer": schema_k8sio_api_core_v1_EphemeralContainer(ref), - "k8s.io/api/core/v1.EphemeralContainerCommon": schema_k8sio_api_core_v1_EphemeralContainerCommon(ref), - "k8s.io/api/core/v1.EphemeralVolumeSource": schema_k8sio_api_core_v1_EphemeralVolumeSource(ref), - "k8s.io/api/core/v1.Event": schema_k8sio_api_core_v1_Event(ref), - "k8s.io/api/core/v1.EventList": schema_k8sio_api_core_v1_EventList(ref), - "k8s.io/api/core/v1.EventSeries": schema_k8sio_api_core_v1_EventSeries(ref), - "k8s.io/api/core/v1.EventSource": schema_k8sio_api_core_v1_EventSource(ref), - "k8s.io/api/core/v1.ExecAction": schema_k8sio_api_core_v1_ExecAction(ref), - "k8s.io/api/core/v1.FCVolumeSource": schema_k8sio_api_core_v1_FCVolumeSource(ref), - "k8s.io/api/core/v1.FlexPersistentVolumeSource": schema_k8sio_api_core_v1_FlexPersistentVolumeSource(ref), - "k8s.io/api/core/v1.FlexVolumeSource": schema_k8sio_api_core_v1_FlexVolumeSource(ref), - "k8s.io/api/core/v1.FlockerVolumeSource": schema_k8sio_api_core_v1_FlockerVolumeSource(ref), - "k8s.io/api/core/v1.GCEPersistentDiskVolumeSource": schema_k8sio_api_core_v1_GCEPersistentDiskVolumeSource(ref), - "k8s.io/api/core/v1.GRPCAction": schema_k8sio_api_core_v1_GRPCAction(ref), - "k8s.io/api/core/v1.GitRepoVolumeSource": schema_k8sio_api_core_v1_GitRepoVolumeSource(ref), - "k8s.io/api/core/v1.GlusterfsPersistentVolumeSource": schema_k8sio_api_core_v1_GlusterfsPersistentVolumeSource(ref), - "k8s.io/api/core/v1.GlusterfsVolumeSource": schema_k8sio_api_core_v1_GlusterfsVolumeSource(ref), - "k8s.io/api/core/v1.HTTPGetAction": schema_k8sio_api_core_v1_HTTPGetAction(ref), - "k8s.io/api/core/v1.HTTPHeader": schema_k8sio_api_core_v1_HTTPHeader(ref), - "k8s.io/api/core/v1.HostAlias": schema_k8sio_api_core_v1_HostAlias(ref), - "k8s.io/api/core/v1.HostPathVolumeSource": schema_k8sio_api_core_v1_HostPathVolumeSource(ref), - "k8s.io/api/core/v1.ISCSIPersistentVolumeSource": schema_k8sio_api_core_v1_ISCSIPersistentVolumeSource(ref), - "k8s.io/api/core/v1.ISCSIVolumeSource": schema_k8sio_api_core_v1_ISCSIVolumeSource(ref), - "k8s.io/api/core/v1.KeyToPath": schema_k8sio_api_core_v1_KeyToPath(ref), - "k8s.io/api/core/v1.Lifecycle": schema_k8sio_api_core_v1_Lifecycle(ref), - "k8s.io/api/core/v1.LifecycleHandler": schema_k8sio_api_core_v1_LifecycleHandler(ref), - "k8s.io/api/core/v1.LimitRange": schema_k8sio_api_core_v1_LimitRange(ref), - "k8s.io/api/core/v1.LimitRangeItem": schema_k8sio_api_core_v1_LimitRangeItem(ref), - "k8s.io/api/core/v1.LimitRangeList": schema_k8sio_api_core_v1_LimitRangeList(ref), - "k8s.io/api/core/v1.LimitRangeSpec": schema_k8sio_api_core_v1_LimitRangeSpec(ref), - "k8s.io/api/core/v1.List": schema_k8sio_api_core_v1_List(ref), - "k8s.io/api/core/v1.LoadBalancerIngress": schema_k8sio_api_core_v1_LoadBalancerIngress(ref), - "k8s.io/api/core/v1.LoadBalancerStatus": schema_k8sio_api_core_v1_LoadBalancerStatus(ref), - "k8s.io/api/core/v1.LocalObjectReference": schema_k8sio_api_core_v1_LocalObjectReference(ref), - "k8s.io/api/core/v1.LocalVolumeSource": schema_k8sio_api_core_v1_LocalVolumeSource(ref), - "k8s.io/api/core/v1.NFSVolumeSource": schema_k8sio_api_core_v1_NFSVolumeSource(ref), - "k8s.io/api/core/v1.Namespace": schema_k8sio_api_core_v1_Namespace(ref), - "k8s.io/api/core/v1.NamespaceCondition": schema_k8sio_api_core_v1_NamespaceCondition(ref), - "k8s.io/api/core/v1.NamespaceList": schema_k8sio_api_core_v1_NamespaceList(ref), - "k8s.io/api/core/v1.NamespaceSpec": schema_k8sio_api_core_v1_NamespaceSpec(ref), - "k8s.io/api/core/v1.NamespaceStatus": schema_k8sio_api_core_v1_NamespaceStatus(ref), - "k8s.io/api/core/v1.Node": schema_k8sio_api_core_v1_Node(ref), - "k8s.io/api/core/v1.NodeAddress": schema_k8sio_api_core_v1_NodeAddress(ref), - "k8s.io/api/core/v1.NodeAffinity": schema_k8sio_api_core_v1_NodeAffinity(ref), - "k8s.io/api/core/v1.NodeCondition": schema_k8sio_api_core_v1_NodeCondition(ref), - "k8s.io/api/core/v1.NodeConfigSource": schema_k8sio_api_core_v1_NodeConfigSource(ref), - "k8s.io/api/core/v1.NodeConfigStatus": schema_k8sio_api_core_v1_NodeConfigStatus(ref), - "k8s.io/api/core/v1.NodeDaemonEndpoints": schema_k8sio_api_core_v1_NodeDaemonEndpoints(ref), - "k8s.io/api/core/v1.NodeList": schema_k8sio_api_core_v1_NodeList(ref), - "k8s.io/api/core/v1.NodeProxyOptions": schema_k8sio_api_core_v1_NodeProxyOptions(ref), - "k8s.io/api/core/v1.NodeResources": schema_k8sio_api_core_v1_NodeResources(ref), - "k8s.io/api/core/v1.NodeSelector": schema_k8sio_api_core_v1_NodeSelector(ref), - "k8s.io/api/core/v1.NodeSelectorRequirement": schema_k8sio_api_core_v1_NodeSelectorRequirement(ref), - "k8s.io/api/core/v1.NodeSelectorTerm": schema_k8sio_api_core_v1_NodeSelectorTerm(ref), - "k8s.io/api/core/v1.NodeSpec": schema_k8sio_api_core_v1_NodeSpec(ref), - "k8s.io/api/core/v1.NodeStatus": schema_k8sio_api_core_v1_NodeStatus(ref), - "k8s.io/api/core/v1.NodeSystemInfo": schema_k8sio_api_core_v1_NodeSystemInfo(ref), - "k8s.io/api/core/v1.ObjectFieldSelector": schema_k8sio_api_core_v1_ObjectFieldSelector(ref), - "k8s.io/api/core/v1.ObjectReference": schema_k8sio_api_core_v1_ObjectReference(ref), - "k8s.io/api/core/v1.PersistentVolume": schema_k8sio_api_core_v1_PersistentVolume(ref), - "k8s.io/api/core/v1.PersistentVolumeClaim": schema_k8sio_api_core_v1_PersistentVolumeClaim(ref), - "k8s.io/api/core/v1.PersistentVolumeClaimCondition": schema_k8sio_api_core_v1_PersistentVolumeClaimCondition(ref), - "k8s.io/api/core/v1.PersistentVolumeClaimList": schema_k8sio_api_core_v1_PersistentVolumeClaimList(ref), - "k8s.io/api/core/v1.PersistentVolumeClaimSpec": schema_k8sio_api_core_v1_PersistentVolumeClaimSpec(ref), - "k8s.io/api/core/v1.PersistentVolumeClaimStatus": schema_k8sio_api_core_v1_PersistentVolumeClaimStatus(ref), - "k8s.io/api/core/v1.PersistentVolumeClaimTemplate": schema_k8sio_api_core_v1_PersistentVolumeClaimTemplate(ref), - "k8s.io/api/core/v1.PersistentVolumeClaimVolumeSource": schema_k8sio_api_core_v1_PersistentVolumeClaimVolumeSource(ref), - "k8s.io/api/core/v1.PersistentVolumeList": schema_k8sio_api_core_v1_PersistentVolumeList(ref), - "k8s.io/api/core/v1.PersistentVolumeSource": schema_k8sio_api_core_v1_PersistentVolumeSource(ref), - "k8s.io/api/core/v1.PersistentVolumeSpec": schema_k8sio_api_core_v1_PersistentVolumeSpec(ref), - "k8s.io/api/core/v1.PersistentVolumeStatus": schema_k8sio_api_core_v1_PersistentVolumeStatus(ref), - "k8s.io/api/core/v1.PhotonPersistentDiskVolumeSource": schema_k8sio_api_core_v1_PhotonPersistentDiskVolumeSource(ref), - "k8s.io/api/core/v1.Pod": schema_k8sio_api_core_v1_Pod(ref), - "k8s.io/api/core/v1.PodAffinity": schema_k8sio_api_core_v1_PodAffinity(ref), - "k8s.io/api/core/v1.PodAffinityTerm": schema_k8sio_api_core_v1_PodAffinityTerm(ref), - "k8s.io/api/core/v1.PodAntiAffinity": schema_k8sio_api_core_v1_PodAntiAffinity(ref), - "k8s.io/api/core/v1.PodAttachOptions": schema_k8sio_api_core_v1_PodAttachOptions(ref), - "k8s.io/api/core/v1.PodCondition": schema_k8sio_api_core_v1_PodCondition(ref), - "k8s.io/api/core/v1.PodDNSConfig": schema_k8sio_api_core_v1_PodDNSConfig(ref), - "k8s.io/api/core/v1.PodDNSConfigOption": schema_k8sio_api_core_v1_PodDNSConfigOption(ref), - "k8s.io/api/core/v1.PodExecOptions": schema_k8sio_api_core_v1_PodExecOptions(ref), - "k8s.io/api/core/v1.PodIP": schema_k8sio_api_core_v1_PodIP(ref), - "k8s.io/api/core/v1.PodList": schema_k8sio_api_core_v1_PodList(ref), - "k8s.io/api/core/v1.PodLogOptions": schema_k8sio_api_core_v1_PodLogOptions(ref), - "k8s.io/api/core/v1.PodOS": schema_k8sio_api_core_v1_PodOS(ref), - "k8s.io/api/core/v1.PodPortForwardOptions": schema_k8sio_api_core_v1_PodPortForwardOptions(ref), - "k8s.io/api/core/v1.PodProxyOptions": schema_k8sio_api_core_v1_PodProxyOptions(ref), - "k8s.io/api/core/v1.PodReadinessGate": schema_k8sio_api_core_v1_PodReadinessGate(ref), - "k8s.io/api/core/v1.PodResourceClaim": schema_k8sio_api_core_v1_PodResourceClaim(ref), - "k8s.io/api/core/v1.PodResourceClaimStatus": schema_k8sio_api_core_v1_PodResourceClaimStatus(ref), - "k8s.io/api/core/v1.PodSchedulingGate": schema_k8sio_api_core_v1_PodSchedulingGate(ref), - "k8s.io/api/core/v1.PodSecurityContext": schema_k8sio_api_core_v1_PodSecurityContext(ref), - "k8s.io/api/core/v1.PodSignature": schema_k8sio_api_core_v1_PodSignature(ref), - "k8s.io/api/core/v1.PodSpec": schema_k8sio_api_core_v1_PodSpec(ref), - "k8s.io/api/core/v1.PodStatus": schema_k8sio_api_core_v1_PodStatus(ref), - "k8s.io/api/core/v1.PodStatusResult": schema_k8sio_api_core_v1_PodStatusResult(ref), - "k8s.io/api/core/v1.PodTemplate": schema_k8sio_api_core_v1_PodTemplate(ref), - "k8s.io/api/core/v1.PodTemplateList": schema_k8sio_api_core_v1_PodTemplateList(ref), - "k8s.io/api/core/v1.PodTemplateSpec": schema_k8sio_api_core_v1_PodTemplateSpec(ref), - "k8s.io/api/core/v1.PortStatus": schema_k8sio_api_core_v1_PortStatus(ref), - "k8s.io/api/core/v1.PortworxVolumeSource": schema_k8sio_api_core_v1_PortworxVolumeSource(ref), - "k8s.io/api/core/v1.PreferAvoidPodsEntry": schema_k8sio_api_core_v1_PreferAvoidPodsEntry(ref), - "k8s.io/api/core/v1.PreferredSchedulingTerm": schema_k8sio_api_core_v1_PreferredSchedulingTerm(ref), - "k8s.io/api/core/v1.Probe": schema_k8sio_api_core_v1_Probe(ref), - "k8s.io/api/core/v1.ProbeHandler": schema_k8sio_api_core_v1_ProbeHandler(ref), - "k8s.io/api/core/v1.ProjectedVolumeSource": schema_k8sio_api_core_v1_ProjectedVolumeSource(ref), - "k8s.io/api/core/v1.QuobyteVolumeSource": schema_k8sio_api_core_v1_QuobyteVolumeSource(ref), - "k8s.io/api/core/v1.RBDPersistentVolumeSource": schema_k8sio_api_core_v1_RBDPersistentVolumeSource(ref), - "k8s.io/api/core/v1.RBDVolumeSource": schema_k8sio_api_core_v1_RBDVolumeSource(ref), - "k8s.io/api/core/v1.RangeAllocation": schema_k8sio_api_core_v1_RangeAllocation(ref), - "k8s.io/api/core/v1.ReplicationController": schema_k8sio_api_core_v1_ReplicationController(ref), - "k8s.io/api/core/v1.ReplicationControllerCondition": schema_k8sio_api_core_v1_ReplicationControllerCondition(ref), - "k8s.io/api/core/v1.ReplicationControllerList": schema_k8sio_api_core_v1_ReplicationControllerList(ref), - "k8s.io/api/core/v1.ReplicationControllerSpec": schema_k8sio_api_core_v1_ReplicationControllerSpec(ref), - "k8s.io/api/core/v1.ReplicationControllerStatus": schema_k8sio_api_core_v1_ReplicationControllerStatus(ref), - "k8s.io/api/core/v1.ResourceClaim": schema_k8sio_api_core_v1_ResourceClaim(ref), - "k8s.io/api/core/v1.ResourceFieldSelector": schema_k8sio_api_core_v1_ResourceFieldSelector(ref), - "k8s.io/api/core/v1.ResourceQuota": schema_k8sio_api_core_v1_ResourceQuota(ref), - "k8s.io/api/core/v1.ResourceQuotaList": schema_k8sio_api_core_v1_ResourceQuotaList(ref), - "k8s.io/api/core/v1.ResourceQuotaSpec": schema_k8sio_api_core_v1_ResourceQuotaSpec(ref), - "k8s.io/api/core/v1.ResourceQuotaStatus": schema_k8sio_api_core_v1_ResourceQuotaStatus(ref), - "k8s.io/api/core/v1.ResourceRequirements": schema_k8sio_api_core_v1_ResourceRequirements(ref), - "k8s.io/api/core/v1.SELinuxOptions": schema_k8sio_api_core_v1_SELinuxOptions(ref), - "k8s.io/api/core/v1.ScaleIOPersistentVolumeSource": schema_k8sio_api_core_v1_ScaleIOPersistentVolumeSource(ref), - "k8s.io/api/core/v1.ScaleIOVolumeSource": schema_k8sio_api_core_v1_ScaleIOVolumeSource(ref), - "k8s.io/api/core/v1.ScopeSelector": schema_k8sio_api_core_v1_ScopeSelector(ref), - "k8s.io/api/core/v1.ScopedResourceSelectorRequirement": schema_k8sio_api_core_v1_ScopedResourceSelectorRequirement(ref), - "k8s.io/api/core/v1.SeccompProfile": schema_k8sio_api_core_v1_SeccompProfile(ref), - "k8s.io/api/core/v1.Secret": schema_k8sio_api_core_v1_Secret(ref), - "k8s.io/api/core/v1.SecretEnvSource": schema_k8sio_api_core_v1_SecretEnvSource(ref), - "k8s.io/api/core/v1.SecretKeySelector": schema_k8sio_api_core_v1_SecretKeySelector(ref), - "k8s.io/api/core/v1.SecretList": schema_k8sio_api_core_v1_SecretList(ref), - "k8s.io/api/core/v1.SecretProjection": schema_k8sio_api_core_v1_SecretProjection(ref), - "k8s.io/api/core/v1.SecretReference": schema_k8sio_api_core_v1_SecretReference(ref), - "k8s.io/api/core/v1.SecretVolumeSource": schema_k8sio_api_core_v1_SecretVolumeSource(ref), - "k8s.io/api/core/v1.SecurityContext": schema_k8sio_api_core_v1_SecurityContext(ref), - "k8s.io/api/core/v1.SerializedReference": schema_k8sio_api_core_v1_SerializedReference(ref), - "k8s.io/api/core/v1.Service": schema_k8sio_api_core_v1_Service(ref), - "k8s.io/api/core/v1.ServiceAccount": schema_k8sio_api_core_v1_ServiceAccount(ref), - "k8s.io/api/core/v1.ServiceAccountList": schema_k8sio_api_core_v1_ServiceAccountList(ref), - "k8s.io/api/core/v1.ServiceAccountTokenProjection": schema_k8sio_api_core_v1_ServiceAccountTokenProjection(ref), - "k8s.io/api/core/v1.ServiceList": schema_k8sio_api_core_v1_ServiceList(ref), - "k8s.io/api/core/v1.ServicePort": schema_k8sio_api_core_v1_ServicePort(ref), - "k8s.io/api/core/v1.ServiceProxyOptions": schema_k8sio_api_core_v1_ServiceProxyOptions(ref), - "k8s.io/api/core/v1.ServiceSpec": schema_k8sio_api_core_v1_ServiceSpec(ref), - "k8s.io/api/core/v1.ServiceStatus": schema_k8sio_api_core_v1_ServiceStatus(ref), - "k8s.io/api/core/v1.SessionAffinityConfig": schema_k8sio_api_core_v1_SessionAffinityConfig(ref), - "k8s.io/api/core/v1.StorageOSPersistentVolumeSource": schema_k8sio_api_core_v1_StorageOSPersistentVolumeSource(ref), - "k8s.io/api/core/v1.StorageOSVolumeSource": schema_k8sio_api_core_v1_StorageOSVolumeSource(ref), - "k8s.io/api/core/v1.Sysctl": schema_k8sio_api_core_v1_Sysctl(ref), - "k8s.io/api/core/v1.TCPSocketAction": schema_k8sio_api_core_v1_TCPSocketAction(ref), - "k8s.io/api/core/v1.Taint": schema_k8sio_api_core_v1_Taint(ref), - "k8s.io/api/core/v1.Toleration": schema_k8sio_api_core_v1_Toleration(ref), - "k8s.io/api/core/v1.TopologySelectorLabelRequirement": schema_k8sio_api_core_v1_TopologySelectorLabelRequirement(ref), - "k8s.io/api/core/v1.TopologySelectorTerm": schema_k8sio_api_core_v1_TopologySelectorTerm(ref), - "k8s.io/api/core/v1.TopologySpreadConstraint": schema_k8sio_api_core_v1_TopologySpreadConstraint(ref), - "k8s.io/api/core/v1.TypedLocalObjectReference": schema_k8sio_api_core_v1_TypedLocalObjectReference(ref), - "k8s.io/api/core/v1.TypedObjectReference": schema_k8sio_api_core_v1_TypedObjectReference(ref), - "k8s.io/api/core/v1.Volume": schema_k8sio_api_core_v1_Volume(ref), - "k8s.io/api/core/v1.VolumeDevice": schema_k8sio_api_core_v1_VolumeDevice(ref), - "k8s.io/api/core/v1.VolumeMount": schema_k8sio_api_core_v1_VolumeMount(ref), - "k8s.io/api/core/v1.VolumeNodeAffinity": schema_k8sio_api_core_v1_VolumeNodeAffinity(ref), - "k8s.io/api/core/v1.VolumeProjection": schema_k8sio_api_core_v1_VolumeProjection(ref), - "k8s.io/api/core/v1.VolumeSource": schema_k8sio_api_core_v1_VolumeSource(ref), - "k8s.io/api/core/v1.VsphereVirtualDiskVolumeSource": schema_k8sio_api_core_v1_VsphereVirtualDiskVolumeSource(ref), - "k8s.io/api/core/v1.WeightedPodAffinityTerm": schema_k8sio_api_core_v1_WeightedPodAffinityTerm(ref), - "k8s.io/api/core/v1.WindowsSecurityContextOptions": schema_k8sio_api_core_v1_WindowsSecurityContextOptions(ref), - "k8s.io/api/discovery/v1.Endpoint": schema_k8sio_api_discovery_v1_Endpoint(ref), - "k8s.io/api/discovery/v1.EndpointConditions": schema_k8sio_api_discovery_v1_EndpointConditions(ref), - "k8s.io/api/discovery/v1.EndpointHints": schema_k8sio_api_discovery_v1_EndpointHints(ref), - "k8s.io/api/discovery/v1.EndpointPort": schema_k8sio_api_discovery_v1_EndpointPort(ref), - "k8s.io/api/discovery/v1.EndpointSlice": schema_k8sio_api_discovery_v1_EndpointSlice(ref), - "k8s.io/api/discovery/v1.EndpointSliceList": schema_k8sio_api_discovery_v1_EndpointSliceList(ref), - "k8s.io/api/discovery/v1.ForZone": schema_k8sio_api_discovery_v1_ForZone(ref), - "k8s.io/api/discovery/v1beta1.Endpoint": schema_k8sio_api_discovery_v1beta1_Endpoint(ref), - "k8s.io/api/discovery/v1beta1.EndpointConditions": schema_k8sio_api_discovery_v1beta1_EndpointConditions(ref), - "k8s.io/api/discovery/v1beta1.EndpointHints": schema_k8sio_api_discovery_v1beta1_EndpointHints(ref), - "k8s.io/api/discovery/v1beta1.EndpointPort": schema_k8sio_api_discovery_v1beta1_EndpointPort(ref), - "k8s.io/api/discovery/v1beta1.EndpointSlice": schema_k8sio_api_discovery_v1beta1_EndpointSlice(ref), - "k8s.io/api/discovery/v1beta1.EndpointSliceList": schema_k8sio_api_discovery_v1beta1_EndpointSliceList(ref), - "k8s.io/api/discovery/v1beta1.ForZone": schema_k8sio_api_discovery_v1beta1_ForZone(ref), - "k8s.io/api/events/v1.Event": schema_k8sio_api_events_v1_Event(ref), - "k8s.io/api/events/v1.EventList": schema_k8sio_api_events_v1_EventList(ref), - "k8s.io/api/events/v1.EventSeries": schema_k8sio_api_events_v1_EventSeries(ref), - "k8s.io/api/events/v1beta1.Event": schema_k8sio_api_events_v1beta1_Event(ref), - "k8s.io/api/events/v1beta1.EventList": schema_k8sio_api_events_v1beta1_EventList(ref), - "k8s.io/api/events/v1beta1.EventSeries": schema_k8sio_api_events_v1beta1_EventSeries(ref), - "k8s.io/api/extensions/v1beta1.DaemonSet": schema_k8sio_api_extensions_v1beta1_DaemonSet(ref), - "k8s.io/api/extensions/v1beta1.DaemonSetCondition": schema_k8sio_api_extensions_v1beta1_DaemonSetCondition(ref), - "k8s.io/api/extensions/v1beta1.DaemonSetList": schema_k8sio_api_extensions_v1beta1_DaemonSetList(ref), - "k8s.io/api/extensions/v1beta1.DaemonSetSpec": schema_k8sio_api_extensions_v1beta1_DaemonSetSpec(ref), - "k8s.io/api/extensions/v1beta1.DaemonSetStatus": schema_k8sio_api_extensions_v1beta1_DaemonSetStatus(ref), - "k8s.io/api/extensions/v1beta1.DaemonSetUpdateStrategy": schema_k8sio_api_extensions_v1beta1_DaemonSetUpdateStrategy(ref), - "k8s.io/api/extensions/v1beta1.Deployment": schema_k8sio_api_extensions_v1beta1_Deployment(ref), - "k8s.io/api/extensions/v1beta1.DeploymentCondition": schema_k8sio_api_extensions_v1beta1_DeploymentCondition(ref), - "k8s.io/api/extensions/v1beta1.DeploymentList": schema_k8sio_api_extensions_v1beta1_DeploymentList(ref), - "k8s.io/api/extensions/v1beta1.DeploymentRollback": schema_k8sio_api_extensions_v1beta1_DeploymentRollback(ref), - "k8s.io/api/extensions/v1beta1.DeploymentSpec": schema_k8sio_api_extensions_v1beta1_DeploymentSpec(ref), - "k8s.io/api/extensions/v1beta1.DeploymentStatus": schema_k8sio_api_extensions_v1beta1_DeploymentStatus(ref), - "k8s.io/api/extensions/v1beta1.DeploymentStrategy": schema_k8sio_api_extensions_v1beta1_DeploymentStrategy(ref), - "k8s.io/api/extensions/v1beta1.HTTPIngressPath": schema_k8sio_api_extensions_v1beta1_HTTPIngressPath(ref), - "k8s.io/api/extensions/v1beta1.HTTPIngressRuleValue": schema_k8sio_api_extensions_v1beta1_HTTPIngressRuleValue(ref), - "k8s.io/api/extensions/v1beta1.IPBlock": schema_k8sio_api_extensions_v1beta1_IPBlock(ref), - "k8s.io/api/extensions/v1beta1.Ingress": schema_k8sio_api_extensions_v1beta1_Ingress(ref), - "k8s.io/api/extensions/v1beta1.IngressBackend": schema_k8sio_api_extensions_v1beta1_IngressBackend(ref), - "k8s.io/api/extensions/v1beta1.IngressList": schema_k8sio_api_extensions_v1beta1_IngressList(ref), - "k8s.io/api/extensions/v1beta1.IngressLoadBalancerIngress": schema_k8sio_api_extensions_v1beta1_IngressLoadBalancerIngress(ref), - "k8s.io/api/extensions/v1beta1.IngressLoadBalancerStatus": schema_k8sio_api_extensions_v1beta1_IngressLoadBalancerStatus(ref), - "k8s.io/api/extensions/v1beta1.IngressPortStatus": schema_k8sio_api_extensions_v1beta1_IngressPortStatus(ref), - "k8s.io/api/extensions/v1beta1.IngressRule": schema_k8sio_api_extensions_v1beta1_IngressRule(ref), - "k8s.io/api/extensions/v1beta1.IngressRuleValue": schema_k8sio_api_extensions_v1beta1_IngressRuleValue(ref), - "k8s.io/api/extensions/v1beta1.IngressSpec": schema_k8sio_api_extensions_v1beta1_IngressSpec(ref), - "k8s.io/api/extensions/v1beta1.IngressStatus": schema_k8sio_api_extensions_v1beta1_IngressStatus(ref), - "k8s.io/api/extensions/v1beta1.IngressTLS": schema_k8sio_api_extensions_v1beta1_IngressTLS(ref), - "k8s.io/api/extensions/v1beta1.NetworkPolicy": schema_k8sio_api_extensions_v1beta1_NetworkPolicy(ref), - "k8s.io/api/extensions/v1beta1.NetworkPolicyEgressRule": schema_k8sio_api_extensions_v1beta1_NetworkPolicyEgressRule(ref), - "k8s.io/api/extensions/v1beta1.NetworkPolicyIngressRule": schema_k8sio_api_extensions_v1beta1_NetworkPolicyIngressRule(ref), - "k8s.io/api/extensions/v1beta1.NetworkPolicyList": schema_k8sio_api_extensions_v1beta1_NetworkPolicyList(ref), - "k8s.io/api/extensions/v1beta1.NetworkPolicyPeer": schema_k8sio_api_extensions_v1beta1_NetworkPolicyPeer(ref), - "k8s.io/api/extensions/v1beta1.NetworkPolicyPort": schema_k8sio_api_extensions_v1beta1_NetworkPolicyPort(ref), - "k8s.io/api/extensions/v1beta1.NetworkPolicySpec": schema_k8sio_api_extensions_v1beta1_NetworkPolicySpec(ref), - "k8s.io/api/extensions/v1beta1.ReplicaSet": schema_k8sio_api_extensions_v1beta1_ReplicaSet(ref), - "k8s.io/api/extensions/v1beta1.ReplicaSetCondition": schema_k8sio_api_extensions_v1beta1_ReplicaSetCondition(ref), - "k8s.io/api/extensions/v1beta1.ReplicaSetList": schema_k8sio_api_extensions_v1beta1_ReplicaSetList(ref), - "k8s.io/api/extensions/v1beta1.ReplicaSetSpec": schema_k8sio_api_extensions_v1beta1_ReplicaSetSpec(ref), - "k8s.io/api/extensions/v1beta1.ReplicaSetStatus": schema_k8sio_api_extensions_v1beta1_ReplicaSetStatus(ref), - "k8s.io/api/extensions/v1beta1.RollbackConfig": schema_k8sio_api_extensions_v1beta1_RollbackConfig(ref), - "k8s.io/api/extensions/v1beta1.RollingUpdateDaemonSet": schema_k8sio_api_extensions_v1beta1_RollingUpdateDaemonSet(ref), - "k8s.io/api/extensions/v1beta1.RollingUpdateDeployment": schema_k8sio_api_extensions_v1beta1_RollingUpdateDeployment(ref), - "k8s.io/api/extensions/v1beta1.Scale": schema_k8sio_api_extensions_v1beta1_Scale(ref), - "k8s.io/api/extensions/v1beta1.ScaleSpec": schema_k8sio_api_extensions_v1beta1_ScaleSpec(ref), - "k8s.io/api/extensions/v1beta1.ScaleStatus": schema_k8sio_api_extensions_v1beta1_ScaleStatus(ref), - "k8s.io/api/flowcontrol/v1alpha1.FlowDistinguisherMethod": schema_k8sio_api_flowcontrol_v1alpha1_FlowDistinguisherMethod(ref), - "k8s.io/api/flowcontrol/v1alpha1.FlowSchema": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchema(ref), - "k8s.io/api/flowcontrol/v1alpha1.FlowSchemaCondition": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchemaCondition(ref), - "k8s.io/api/flowcontrol/v1alpha1.FlowSchemaList": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchemaList(ref), - "k8s.io/api/flowcontrol/v1alpha1.FlowSchemaSpec": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchemaSpec(ref), - "k8s.io/api/flowcontrol/v1alpha1.FlowSchemaStatus": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchemaStatus(ref), - "k8s.io/api/flowcontrol/v1alpha1.GroupSubject": schema_k8sio_api_flowcontrol_v1alpha1_GroupSubject(ref), - "k8s.io/api/flowcontrol/v1alpha1.LimitResponse": schema_k8sio_api_flowcontrol_v1alpha1_LimitResponse(ref), - "k8s.io/api/flowcontrol/v1alpha1.LimitedPriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1alpha1_LimitedPriorityLevelConfiguration(ref), - "k8s.io/api/flowcontrol/v1alpha1.NonResourcePolicyRule": schema_k8sio_api_flowcontrol_v1alpha1_NonResourcePolicyRule(ref), - "k8s.io/api/flowcontrol/v1alpha1.PolicyRulesWithSubjects": schema_k8sio_api_flowcontrol_v1alpha1_PolicyRulesWithSubjects(ref), - "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfiguration(ref), - "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationCondition": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationCondition(ref), - "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationList": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationList(ref), - "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationReference": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationReference(ref), - "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationSpec": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationSpec(ref), - "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationStatus": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationStatus(ref), - "k8s.io/api/flowcontrol/v1alpha1.QueuingConfiguration": schema_k8sio_api_flowcontrol_v1alpha1_QueuingConfiguration(ref), - "k8s.io/api/flowcontrol/v1alpha1.ResourcePolicyRule": schema_k8sio_api_flowcontrol_v1alpha1_ResourcePolicyRule(ref), - "k8s.io/api/flowcontrol/v1alpha1.ServiceAccountSubject": schema_k8sio_api_flowcontrol_v1alpha1_ServiceAccountSubject(ref), - "k8s.io/api/flowcontrol/v1alpha1.Subject": schema_k8sio_api_flowcontrol_v1alpha1_Subject(ref), - "k8s.io/api/flowcontrol/v1alpha1.UserSubject": schema_k8sio_api_flowcontrol_v1alpha1_UserSubject(ref), - "k8s.io/api/flowcontrol/v1beta1.FlowDistinguisherMethod": schema_k8sio_api_flowcontrol_v1beta1_FlowDistinguisherMethod(ref), - "k8s.io/api/flowcontrol/v1beta1.FlowSchema": schema_k8sio_api_flowcontrol_v1beta1_FlowSchema(ref), - "k8s.io/api/flowcontrol/v1beta1.FlowSchemaCondition": schema_k8sio_api_flowcontrol_v1beta1_FlowSchemaCondition(ref), - "k8s.io/api/flowcontrol/v1beta1.FlowSchemaList": schema_k8sio_api_flowcontrol_v1beta1_FlowSchemaList(ref), - "k8s.io/api/flowcontrol/v1beta1.FlowSchemaSpec": schema_k8sio_api_flowcontrol_v1beta1_FlowSchemaSpec(ref), - "k8s.io/api/flowcontrol/v1beta1.FlowSchemaStatus": schema_k8sio_api_flowcontrol_v1beta1_FlowSchemaStatus(ref), - "k8s.io/api/flowcontrol/v1beta1.GroupSubject": schema_k8sio_api_flowcontrol_v1beta1_GroupSubject(ref), - "k8s.io/api/flowcontrol/v1beta1.LimitResponse": schema_k8sio_api_flowcontrol_v1beta1_LimitResponse(ref), - "k8s.io/api/flowcontrol/v1beta1.LimitedPriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta1_LimitedPriorityLevelConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta1.NonResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta1_NonResourcePolicyRule(ref), - "k8s.io/api/flowcontrol/v1beta1.PolicyRulesWithSubjects": schema_k8sio_api_flowcontrol_v1beta1_PolicyRulesWithSubjects(ref), - "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationCondition": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationCondition(ref), - "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationList": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationList(ref), - "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationReference": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationReference(ref), - "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationSpec": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationSpec(ref), - "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationStatus": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationStatus(ref), - "k8s.io/api/flowcontrol/v1beta1.QueuingConfiguration": schema_k8sio_api_flowcontrol_v1beta1_QueuingConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta1.ResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta1_ResourcePolicyRule(ref), - "k8s.io/api/flowcontrol/v1beta1.ServiceAccountSubject": schema_k8sio_api_flowcontrol_v1beta1_ServiceAccountSubject(ref), - "k8s.io/api/flowcontrol/v1beta1.Subject": schema_k8sio_api_flowcontrol_v1beta1_Subject(ref), - "k8s.io/api/flowcontrol/v1beta1.UserSubject": schema_k8sio_api_flowcontrol_v1beta1_UserSubject(ref), - "k8s.io/api/flowcontrol/v1beta2.FlowDistinguisherMethod": schema_k8sio_api_flowcontrol_v1beta2_FlowDistinguisherMethod(ref), - "k8s.io/api/flowcontrol/v1beta2.FlowSchema": schema_k8sio_api_flowcontrol_v1beta2_FlowSchema(ref), - "k8s.io/api/flowcontrol/v1beta2.FlowSchemaCondition": schema_k8sio_api_flowcontrol_v1beta2_FlowSchemaCondition(ref), - "k8s.io/api/flowcontrol/v1beta2.FlowSchemaList": schema_k8sio_api_flowcontrol_v1beta2_FlowSchemaList(ref), - "k8s.io/api/flowcontrol/v1beta2.FlowSchemaSpec": schema_k8sio_api_flowcontrol_v1beta2_FlowSchemaSpec(ref), - "k8s.io/api/flowcontrol/v1beta2.FlowSchemaStatus": schema_k8sio_api_flowcontrol_v1beta2_FlowSchemaStatus(ref), - "k8s.io/api/flowcontrol/v1beta2.GroupSubject": schema_k8sio_api_flowcontrol_v1beta2_GroupSubject(ref), - "k8s.io/api/flowcontrol/v1beta2.LimitResponse": schema_k8sio_api_flowcontrol_v1beta2_LimitResponse(ref), - "k8s.io/api/flowcontrol/v1beta2.LimitedPriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta2_LimitedPriorityLevelConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta2.NonResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta2_NonResourcePolicyRule(ref), - "k8s.io/api/flowcontrol/v1beta2.PolicyRulesWithSubjects": schema_k8sio_api_flowcontrol_v1beta2_PolicyRulesWithSubjects(ref), - "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationCondition": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationCondition(ref), - "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationList": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationList(ref), - "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationReference": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationReference(ref), - "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationSpec": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationSpec(ref), - "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationStatus": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationStatus(ref), - "k8s.io/api/flowcontrol/v1beta2.QueuingConfiguration": schema_k8sio_api_flowcontrol_v1beta2_QueuingConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta2.ResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta2_ResourcePolicyRule(ref), - "k8s.io/api/flowcontrol/v1beta2.ServiceAccountSubject": schema_k8sio_api_flowcontrol_v1beta2_ServiceAccountSubject(ref), - "k8s.io/api/flowcontrol/v1beta2.Subject": schema_k8sio_api_flowcontrol_v1beta2_Subject(ref), - "k8s.io/api/flowcontrol/v1beta2.UserSubject": schema_k8sio_api_flowcontrol_v1beta2_UserSubject(ref), - "k8s.io/api/flowcontrol/v1beta3.FlowDistinguisherMethod": schema_k8sio_api_flowcontrol_v1beta3_FlowDistinguisherMethod(ref), - "k8s.io/api/flowcontrol/v1beta3.FlowSchema": schema_k8sio_api_flowcontrol_v1beta3_FlowSchema(ref), - "k8s.io/api/flowcontrol/v1beta3.FlowSchemaCondition": schema_k8sio_api_flowcontrol_v1beta3_FlowSchemaCondition(ref), - "k8s.io/api/flowcontrol/v1beta3.FlowSchemaList": schema_k8sio_api_flowcontrol_v1beta3_FlowSchemaList(ref), - "k8s.io/api/flowcontrol/v1beta3.FlowSchemaSpec": schema_k8sio_api_flowcontrol_v1beta3_FlowSchemaSpec(ref), - "k8s.io/api/flowcontrol/v1beta3.FlowSchemaStatus": schema_k8sio_api_flowcontrol_v1beta3_FlowSchemaStatus(ref), - "k8s.io/api/flowcontrol/v1beta3.GroupSubject": schema_k8sio_api_flowcontrol_v1beta3_GroupSubject(ref), - "k8s.io/api/flowcontrol/v1beta3.LimitResponse": schema_k8sio_api_flowcontrol_v1beta3_LimitResponse(ref), - "k8s.io/api/flowcontrol/v1beta3.LimitedPriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta3_LimitedPriorityLevelConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta3.NonResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta3_NonResourcePolicyRule(ref), - "k8s.io/api/flowcontrol/v1beta3.PolicyRulesWithSubjects": schema_k8sio_api_flowcontrol_v1beta3_PolicyRulesWithSubjects(ref), - "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationCondition": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationCondition(ref), - "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationList": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationList(ref), - "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationReference": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationReference(ref), - "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationSpec": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationSpec(ref), - "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationStatus": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationStatus(ref), - "k8s.io/api/flowcontrol/v1beta3.QueuingConfiguration": schema_k8sio_api_flowcontrol_v1beta3_QueuingConfiguration(ref), - "k8s.io/api/flowcontrol/v1beta3.ResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta3_ResourcePolicyRule(ref), - "k8s.io/api/flowcontrol/v1beta3.ServiceAccountSubject": schema_k8sio_api_flowcontrol_v1beta3_ServiceAccountSubject(ref), - "k8s.io/api/flowcontrol/v1beta3.Subject": schema_k8sio_api_flowcontrol_v1beta3_Subject(ref), - "k8s.io/api/flowcontrol/v1beta3.UserSubject": schema_k8sio_api_flowcontrol_v1beta3_UserSubject(ref), - "k8s.io/api/imagepolicy/v1alpha1.ImageReview": schema_k8sio_api_imagepolicy_v1alpha1_ImageReview(ref), - "k8s.io/api/imagepolicy/v1alpha1.ImageReviewContainerSpec": schema_k8sio_api_imagepolicy_v1alpha1_ImageReviewContainerSpec(ref), - "k8s.io/api/imagepolicy/v1alpha1.ImageReviewSpec": schema_k8sio_api_imagepolicy_v1alpha1_ImageReviewSpec(ref), - "k8s.io/api/imagepolicy/v1alpha1.ImageReviewStatus": schema_k8sio_api_imagepolicy_v1alpha1_ImageReviewStatus(ref), - "k8s.io/api/networking/v1.HTTPIngressPath": schema_k8sio_api_networking_v1_HTTPIngressPath(ref), - "k8s.io/api/networking/v1.HTTPIngressRuleValue": schema_k8sio_api_networking_v1_HTTPIngressRuleValue(ref), - "k8s.io/api/networking/v1.IPBlock": schema_k8sio_api_networking_v1_IPBlock(ref), - "k8s.io/api/networking/v1.Ingress": schema_k8sio_api_networking_v1_Ingress(ref), - "k8s.io/api/networking/v1.IngressBackend": schema_k8sio_api_networking_v1_IngressBackend(ref), - "k8s.io/api/networking/v1.IngressClass": schema_k8sio_api_networking_v1_IngressClass(ref), - "k8s.io/api/networking/v1.IngressClassList": schema_k8sio_api_networking_v1_IngressClassList(ref), - "k8s.io/api/networking/v1.IngressClassParametersReference": schema_k8sio_api_networking_v1_IngressClassParametersReference(ref), - "k8s.io/api/networking/v1.IngressClassSpec": schema_k8sio_api_networking_v1_IngressClassSpec(ref), - "k8s.io/api/networking/v1.IngressList": schema_k8sio_api_networking_v1_IngressList(ref), - "k8s.io/api/networking/v1.IngressLoadBalancerIngress": schema_k8sio_api_networking_v1_IngressLoadBalancerIngress(ref), - "k8s.io/api/networking/v1.IngressLoadBalancerStatus": schema_k8sio_api_networking_v1_IngressLoadBalancerStatus(ref), - "k8s.io/api/networking/v1.IngressPortStatus": schema_k8sio_api_networking_v1_IngressPortStatus(ref), - "k8s.io/api/networking/v1.IngressRule": schema_k8sio_api_networking_v1_IngressRule(ref), - "k8s.io/api/networking/v1.IngressRuleValue": schema_k8sio_api_networking_v1_IngressRuleValue(ref), - "k8s.io/api/networking/v1.IngressServiceBackend": schema_k8sio_api_networking_v1_IngressServiceBackend(ref), - "k8s.io/api/networking/v1.IngressSpec": schema_k8sio_api_networking_v1_IngressSpec(ref), - "k8s.io/api/networking/v1.IngressStatus": schema_k8sio_api_networking_v1_IngressStatus(ref), - "k8s.io/api/networking/v1.IngressTLS": schema_k8sio_api_networking_v1_IngressTLS(ref), - "k8s.io/api/networking/v1.NetworkPolicy": schema_k8sio_api_networking_v1_NetworkPolicy(ref), - "k8s.io/api/networking/v1.NetworkPolicyEgressRule": schema_k8sio_api_networking_v1_NetworkPolicyEgressRule(ref), - "k8s.io/api/networking/v1.NetworkPolicyIngressRule": schema_k8sio_api_networking_v1_NetworkPolicyIngressRule(ref), - "k8s.io/api/networking/v1.NetworkPolicyList": schema_k8sio_api_networking_v1_NetworkPolicyList(ref), - "k8s.io/api/networking/v1.NetworkPolicyPeer": schema_k8sio_api_networking_v1_NetworkPolicyPeer(ref), - "k8s.io/api/networking/v1.NetworkPolicyPort": schema_k8sio_api_networking_v1_NetworkPolicyPort(ref), - "k8s.io/api/networking/v1.NetworkPolicySpec": schema_k8sio_api_networking_v1_NetworkPolicySpec(ref), - "k8s.io/api/networking/v1.ServiceBackendPort": schema_k8sio_api_networking_v1_ServiceBackendPort(ref), - "k8s.io/api/networking/v1alpha1.ClusterCIDR": schema_k8sio_api_networking_v1alpha1_ClusterCIDR(ref), - "k8s.io/api/networking/v1alpha1.ClusterCIDRList": schema_k8sio_api_networking_v1alpha1_ClusterCIDRList(ref), - "k8s.io/api/networking/v1alpha1.ClusterCIDRSpec": schema_k8sio_api_networking_v1alpha1_ClusterCIDRSpec(ref), - "k8s.io/api/networking/v1alpha1.IPAddress": schema_k8sio_api_networking_v1alpha1_IPAddress(ref), - "k8s.io/api/networking/v1alpha1.IPAddressList": schema_k8sio_api_networking_v1alpha1_IPAddressList(ref), - "k8s.io/api/networking/v1alpha1.IPAddressSpec": schema_k8sio_api_networking_v1alpha1_IPAddressSpec(ref), - "k8s.io/api/networking/v1alpha1.ParentReference": schema_k8sio_api_networking_v1alpha1_ParentReference(ref), - "k8s.io/api/networking/v1beta1.HTTPIngressPath": schema_k8sio_api_networking_v1beta1_HTTPIngressPath(ref), - "k8s.io/api/networking/v1beta1.HTTPIngressRuleValue": schema_k8sio_api_networking_v1beta1_HTTPIngressRuleValue(ref), - "k8s.io/api/networking/v1beta1.Ingress": schema_k8sio_api_networking_v1beta1_Ingress(ref), - "k8s.io/api/networking/v1beta1.IngressBackend": schema_k8sio_api_networking_v1beta1_IngressBackend(ref), - "k8s.io/api/networking/v1beta1.IngressClass": schema_k8sio_api_networking_v1beta1_IngressClass(ref), - "k8s.io/api/networking/v1beta1.IngressClassList": schema_k8sio_api_networking_v1beta1_IngressClassList(ref), - "k8s.io/api/networking/v1beta1.IngressClassParametersReference": schema_k8sio_api_networking_v1beta1_IngressClassParametersReference(ref), - "k8s.io/api/networking/v1beta1.IngressClassSpec": schema_k8sio_api_networking_v1beta1_IngressClassSpec(ref), - "k8s.io/api/networking/v1beta1.IngressList": schema_k8sio_api_networking_v1beta1_IngressList(ref), - "k8s.io/api/networking/v1beta1.IngressLoadBalancerIngress": schema_k8sio_api_networking_v1beta1_IngressLoadBalancerIngress(ref), - "k8s.io/api/networking/v1beta1.IngressLoadBalancerStatus": schema_k8sio_api_networking_v1beta1_IngressLoadBalancerStatus(ref), - "k8s.io/api/networking/v1beta1.IngressPortStatus": schema_k8sio_api_networking_v1beta1_IngressPortStatus(ref), - "k8s.io/api/networking/v1beta1.IngressRule": schema_k8sio_api_networking_v1beta1_IngressRule(ref), - "k8s.io/api/networking/v1beta1.IngressRuleValue": schema_k8sio_api_networking_v1beta1_IngressRuleValue(ref), - "k8s.io/api/networking/v1beta1.IngressSpec": schema_k8sio_api_networking_v1beta1_IngressSpec(ref), - "k8s.io/api/networking/v1beta1.IngressStatus": schema_k8sio_api_networking_v1beta1_IngressStatus(ref), - "k8s.io/api/networking/v1beta1.IngressTLS": schema_k8sio_api_networking_v1beta1_IngressTLS(ref), - "k8s.io/api/node/v1.Overhead": schema_k8sio_api_node_v1_Overhead(ref), - "k8s.io/api/node/v1.RuntimeClass": schema_k8sio_api_node_v1_RuntimeClass(ref), - "k8s.io/api/node/v1.RuntimeClassList": schema_k8sio_api_node_v1_RuntimeClassList(ref), - "k8s.io/api/node/v1.Scheduling": schema_k8sio_api_node_v1_Scheduling(ref), - "k8s.io/api/node/v1alpha1.Overhead": schema_k8sio_api_node_v1alpha1_Overhead(ref), - "k8s.io/api/node/v1alpha1.RuntimeClass": schema_k8sio_api_node_v1alpha1_RuntimeClass(ref), - "k8s.io/api/node/v1alpha1.RuntimeClassList": schema_k8sio_api_node_v1alpha1_RuntimeClassList(ref), - "k8s.io/api/node/v1alpha1.RuntimeClassSpec": schema_k8sio_api_node_v1alpha1_RuntimeClassSpec(ref), - "k8s.io/api/node/v1alpha1.Scheduling": schema_k8sio_api_node_v1alpha1_Scheduling(ref), - "k8s.io/api/node/v1beta1.Overhead": schema_k8sio_api_node_v1beta1_Overhead(ref), - "k8s.io/api/node/v1beta1.RuntimeClass": schema_k8sio_api_node_v1beta1_RuntimeClass(ref), - "k8s.io/api/node/v1beta1.RuntimeClassList": schema_k8sio_api_node_v1beta1_RuntimeClassList(ref), - "k8s.io/api/node/v1beta1.Scheduling": schema_k8sio_api_node_v1beta1_Scheduling(ref), - "k8s.io/api/policy/v1.Eviction": schema_k8sio_api_policy_v1_Eviction(ref), - "k8s.io/api/policy/v1.PodDisruptionBudget": schema_k8sio_api_policy_v1_PodDisruptionBudget(ref), - "k8s.io/api/policy/v1.PodDisruptionBudgetList": schema_k8sio_api_policy_v1_PodDisruptionBudgetList(ref), - "k8s.io/api/policy/v1.PodDisruptionBudgetSpec": schema_k8sio_api_policy_v1_PodDisruptionBudgetSpec(ref), - "k8s.io/api/policy/v1.PodDisruptionBudgetStatus": schema_k8sio_api_policy_v1_PodDisruptionBudgetStatus(ref), - "k8s.io/api/policy/v1beta1.AllowedCSIDriver": schema_k8sio_api_policy_v1beta1_AllowedCSIDriver(ref), - "k8s.io/api/policy/v1beta1.AllowedFlexVolume": schema_k8sio_api_policy_v1beta1_AllowedFlexVolume(ref), - "k8s.io/api/policy/v1beta1.AllowedHostPath": schema_k8sio_api_policy_v1beta1_AllowedHostPath(ref), - "k8s.io/api/policy/v1beta1.Eviction": schema_k8sio_api_policy_v1beta1_Eviction(ref), - "k8s.io/api/policy/v1beta1.FSGroupStrategyOptions": schema_k8sio_api_policy_v1beta1_FSGroupStrategyOptions(ref), - "k8s.io/api/policy/v1beta1.HostPortRange": schema_k8sio_api_policy_v1beta1_HostPortRange(ref), - "k8s.io/api/policy/v1beta1.IDRange": schema_k8sio_api_policy_v1beta1_IDRange(ref), - "k8s.io/api/policy/v1beta1.PodDisruptionBudget": schema_k8sio_api_policy_v1beta1_PodDisruptionBudget(ref), - "k8s.io/api/policy/v1beta1.PodDisruptionBudgetList": schema_k8sio_api_policy_v1beta1_PodDisruptionBudgetList(ref), - "k8s.io/api/policy/v1beta1.PodDisruptionBudgetSpec": schema_k8sio_api_policy_v1beta1_PodDisruptionBudgetSpec(ref), - "k8s.io/api/policy/v1beta1.PodDisruptionBudgetStatus": schema_k8sio_api_policy_v1beta1_PodDisruptionBudgetStatus(ref), - "k8s.io/api/policy/v1beta1.PodSecurityPolicy": schema_k8sio_api_policy_v1beta1_PodSecurityPolicy(ref), - "k8s.io/api/policy/v1beta1.PodSecurityPolicyList": schema_k8sio_api_policy_v1beta1_PodSecurityPolicyList(ref), - "k8s.io/api/policy/v1beta1.PodSecurityPolicySpec": schema_k8sio_api_policy_v1beta1_PodSecurityPolicySpec(ref), - "k8s.io/api/policy/v1beta1.RunAsGroupStrategyOptions": schema_k8sio_api_policy_v1beta1_RunAsGroupStrategyOptions(ref), - "k8s.io/api/policy/v1beta1.RunAsUserStrategyOptions": schema_k8sio_api_policy_v1beta1_RunAsUserStrategyOptions(ref), - "k8s.io/api/policy/v1beta1.RuntimeClassStrategyOptions": schema_k8sio_api_policy_v1beta1_RuntimeClassStrategyOptions(ref), - "k8s.io/api/policy/v1beta1.SELinuxStrategyOptions": schema_k8sio_api_policy_v1beta1_SELinuxStrategyOptions(ref), - "k8s.io/api/policy/v1beta1.SupplementalGroupsStrategyOptions": schema_k8sio_api_policy_v1beta1_SupplementalGroupsStrategyOptions(ref), - "k8s.io/api/rbac/v1.AggregationRule": schema_k8sio_api_rbac_v1_AggregationRule(ref), - "k8s.io/api/rbac/v1.ClusterRole": schema_k8sio_api_rbac_v1_ClusterRole(ref), - "k8s.io/api/rbac/v1.ClusterRoleBinding": schema_k8sio_api_rbac_v1_ClusterRoleBinding(ref), - "k8s.io/api/rbac/v1.ClusterRoleBindingList": schema_k8sio_api_rbac_v1_ClusterRoleBindingList(ref), - "k8s.io/api/rbac/v1.ClusterRoleList": schema_k8sio_api_rbac_v1_ClusterRoleList(ref), - "k8s.io/api/rbac/v1.PolicyRule": schema_k8sio_api_rbac_v1_PolicyRule(ref), - "k8s.io/api/rbac/v1.Role": schema_k8sio_api_rbac_v1_Role(ref), - "k8s.io/api/rbac/v1.RoleBinding": schema_k8sio_api_rbac_v1_RoleBinding(ref), - "k8s.io/api/rbac/v1.RoleBindingList": schema_k8sio_api_rbac_v1_RoleBindingList(ref), - "k8s.io/api/rbac/v1.RoleList": schema_k8sio_api_rbac_v1_RoleList(ref), - "k8s.io/api/rbac/v1.RoleRef": schema_k8sio_api_rbac_v1_RoleRef(ref), - "k8s.io/api/rbac/v1.Subject": schema_k8sio_api_rbac_v1_Subject(ref), - "k8s.io/api/rbac/v1alpha1.AggregationRule": schema_k8sio_api_rbac_v1alpha1_AggregationRule(ref), - "k8s.io/api/rbac/v1alpha1.ClusterRole": schema_k8sio_api_rbac_v1alpha1_ClusterRole(ref), - "k8s.io/api/rbac/v1alpha1.ClusterRoleBinding": schema_k8sio_api_rbac_v1alpha1_ClusterRoleBinding(ref), - "k8s.io/api/rbac/v1alpha1.ClusterRoleBindingList": schema_k8sio_api_rbac_v1alpha1_ClusterRoleBindingList(ref), - "k8s.io/api/rbac/v1alpha1.ClusterRoleList": schema_k8sio_api_rbac_v1alpha1_ClusterRoleList(ref), - "k8s.io/api/rbac/v1alpha1.PolicyRule": schema_k8sio_api_rbac_v1alpha1_PolicyRule(ref), - "k8s.io/api/rbac/v1alpha1.Role": schema_k8sio_api_rbac_v1alpha1_Role(ref), - "k8s.io/api/rbac/v1alpha1.RoleBinding": schema_k8sio_api_rbac_v1alpha1_RoleBinding(ref), - "k8s.io/api/rbac/v1alpha1.RoleBindingList": schema_k8sio_api_rbac_v1alpha1_RoleBindingList(ref), - "k8s.io/api/rbac/v1alpha1.RoleList": schema_k8sio_api_rbac_v1alpha1_RoleList(ref), - "k8s.io/api/rbac/v1alpha1.RoleRef": schema_k8sio_api_rbac_v1alpha1_RoleRef(ref), - "k8s.io/api/rbac/v1alpha1.Subject": schema_k8sio_api_rbac_v1alpha1_Subject(ref), - "k8s.io/api/rbac/v1beta1.AggregationRule": schema_k8sio_api_rbac_v1beta1_AggregationRule(ref), - "k8s.io/api/rbac/v1beta1.ClusterRole": schema_k8sio_api_rbac_v1beta1_ClusterRole(ref), - "k8s.io/api/rbac/v1beta1.ClusterRoleBinding": schema_k8sio_api_rbac_v1beta1_ClusterRoleBinding(ref), - "k8s.io/api/rbac/v1beta1.ClusterRoleBindingList": schema_k8sio_api_rbac_v1beta1_ClusterRoleBindingList(ref), - "k8s.io/api/rbac/v1beta1.ClusterRoleList": schema_k8sio_api_rbac_v1beta1_ClusterRoleList(ref), - "k8s.io/api/rbac/v1beta1.PolicyRule": schema_k8sio_api_rbac_v1beta1_PolicyRule(ref), - "k8s.io/api/rbac/v1beta1.Role": schema_k8sio_api_rbac_v1beta1_Role(ref), - "k8s.io/api/rbac/v1beta1.RoleBinding": schema_k8sio_api_rbac_v1beta1_RoleBinding(ref), - "k8s.io/api/rbac/v1beta1.RoleBindingList": schema_k8sio_api_rbac_v1beta1_RoleBindingList(ref), - "k8s.io/api/rbac/v1beta1.RoleList": schema_k8sio_api_rbac_v1beta1_RoleList(ref), - "k8s.io/api/rbac/v1beta1.RoleRef": schema_k8sio_api_rbac_v1beta1_RoleRef(ref), - "k8s.io/api/rbac/v1beta1.Subject": schema_k8sio_api_rbac_v1beta1_Subject(ref), - "k8s.io/api/resource/v1alpha2.AllocationResult": schema_k8sio_api_resource_v1alpha2_AllocationResult(ref), - "k8s.io/api/resource/v1alpha2.PodSchedulingContext": schema_k8sio_api_resource_v1alpha2_PodSchedulingContext(ref), - "k8s.io/api/resource/v1alpha2.PodSchedulingContextList": schema_k8sio_api_resource_v1alpha2_PodSchedulingContextList(ref), - "k8s.io/api/resource/v1alpha2.PodSchedulingContextSpec": schema_k8sio_api_resource_v1alpha2_PodSchedulingContextSpec(ref), - "k8s.io/api/resource/v1alpha2.PodSchedulingContextStatus": schema_k8sio_api_resource_v1alpha2_PodSchedulingContextStatus(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaim": schema_k8sio_api_resource_v1alpha2_ResourceClaim(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimConsumerReference": schema_k8sio_api_resource_v1alpha2_ResourceClaimConsumerReference(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimList": schema_k8sio_api_resource_v1alpha2_ResourceClaimList(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimParametersReference": schema_k8sio_api_resource_v1alpha2_ResourceClaimParametersReference(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimSchedulingStatus": schema_k8sio_api_resource_v1alpha2_ResourceClaimSchedulingStatus(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimSpec": schema_k8sio_api_resource_v1alpha2_ResourceClaimSpec(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimStatus": schema_k8sio_api_resource_v1alpha2_ResourceClaimStatus(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimTemplate": schema_k8sio_api_resource_v1alpha2_ResourceClaimTemplate(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimTemplateList": schema_k8sio_api_resource_v1alpha2_ResourceClaimTemplateList(ref), - "k8s.io/api/resource/v1alpha2.ResourceClaimTemplateSpec": schema_k8sio_api_resource_v1alpha2_ResourceClaimTemplateSpec(ref), - "k8s.io/api/resource/v1alpha2.ResourceClass": schema_k8sio_api_resource_v1alpha2_ResourceClass(ref), - "k8s.io/api/resource/v1alpha2.ResourceClassList": schema_k8sio_api_resource_v1alpha2_ResourceClassList(ref), - "k8s.io/api/resource/v1alpha2.ResourceClassParametersReference": schema_k8sio_api_resource_v1alpha2_ResourceClassParametersReference(ref), - "k8s.io/api/resource/v1alpha2.ResourceHandle": schema_k8sio_api_resource_v1alpha2_ResourceHandle(ref), - "k8s.io/api/scheduling/v1.PriorityClass": schema_k8sio_api_scheduling_v1_PriorityClass(ref), - "k8s.io/api/scheduling/v1.PriorityClassList": schema_k8sio_api_scheduling_v1_PriorityClassList(ref), - "k8s.io/api/scheduling/v1alpha1.PriorityClass": schema_k8sio_api_scheduling_v1alpha1_PriorityClass(ref), - "k8s.io/api/scheduling/v1alpha1.PriorityClassList": schema_k8sio_api_scheduling_v1alpha1_PriorityClassList(ref), - "k8s.io/api/scheduling/v1beta1.PriorityClass": schema_k8sio_api_scheduling_v1beta1_PriorityClass(ref), - "k8s.io/api/scheduling/v1beta1.PriorityClassList": schema_k8sio_api_scheduling_v1beta1_PriorityClassList(ref), - "k8s.io/api/storage/v1.CSIDriver": schema_k8sio_api_storage_v1_CSIDriver(ref), - "k8s.io/api/storage/v1.CSIDriverList": schema_k8sio_api_storage_v1_CSIDriverList(ref), - "k8s.io/api/storage/v1.CSIDriverSpec": schema_k8sio_api_storage_v1_CSIDriverSpec(ref), - "k8s.io/api/storage/v1.CSINode": schema_k8sio_api_storage_v1_CSINode(ref), - "k8s.io/api/storage/v1.CSINodeDriver": schema_k8sio_api_storage_v1_CSINodeDriver(ref), - "k8s.io/api/storage/v1.CSINodeList": schema_k8sio_api_storage_v1_CSINodeList(ref), - "k8s.io/api/storage/v1.CSINodeSpec": schema_k8sio_api_storage_v1_CSINodeSpec(ref), - "k8s.io/api/storage/v1.CSIStorageCapacity": schema_k8sio_api_storage_v1_CSIStorageCapacity(ref), - "k8s.io/api/storage/v1.CSIStorageCapacityList": schema_k8sio_api_storage_v1_CSIStorageCapacityList(ref), - "k8s.io/api/storage/v1.StorageClass": schema_k8sio_api_storage_v1_StorageClass(ref), - "k8s.io/api/storage/v1.StorageClassList": schema_k8sio_api_storage_v1_StorageClassList(ref), - "k8s.io/api/storage/v1.TokenRequest": schema_k8sio_api_storage_v1_TokenRequest(ref), - "k8s.io/api/storage/v1.VolumeAttachment": schema_k8sio_api_storage_v1_VolumeAttachment(ref), - "k8s.io/api/storage/v1.VolumeAttachmentList": schema_k8sio_api_storage_v1_VolumeAttachmentList(ref), - "k8s.io/api/storage/v1.VolumeAttachmentSource": schema_k8sio_api_storage_v1_VolumeAttachmentSource(ref), - "k8s.io/api/storage/v1.VolumeAttachmentSpec": schema_k8sio_api_storage_v1_VolumeAttachmentSpec(ref), - "k8s.io/api/storage/v1.VolumeAttachmentStatus": schema_k8sio_api_storage_v1_VolumeAttachmentStatus(ref), - "k8s.io/api/storage/v1.VolumeError": schema_k8sio_api_storage_v1_VolumeError(ref), - "k8s.io/api/storage/v1.VolumeNodeResources": schema_k8sio_api_storage_v1_VolumeNodeResources(ref), - "k8s.io/api/storage/v1alpha1.CSIStorageCapacity": schema_k8sio_api_storage_v1alpha1_CSIStorageCapacity(ref), - "k8s.io/api/storage/v1alpha1.CSIStorageCapacityList": schema_k8sio_api_storage_v1alpha1_CSIStorageCapacityList(ref), - "k8s.io/api/storage/v1alpha1.VolumeAttachment": schema_k8sio_api_storage_v1alpha1_VolumeAttachment(ref), - "k8s.io/api/storage/v1alpha1.VolumeAttachmentList": schema_k8sio_api_storage_v1alpha1_VolumeAttachmentList(ref), - "k8s.io/api/storage/v1alpha1.VolumeAttachmentSource": schema_k8sio_api_storage_v1alpha1_VolumeAttachmentSource(ref), - "k8s.io/api/storage/v1alpha1.VolumeAttachmentSpec": schema_k8sio_api_storage_v1alpha1_VolumeAttachmentSpec(ref), - "k8s.io/api/storage/v1alpha1.VolumeAttachmentStatus": schema_k8sio_api_storage_v1alpha1_VolumeAttachmentStatus(ref), - "k8s.io/api/storage/v1alpha1.VolumeError": schema_k8sio_api_storage_v1alpha1_VolumeError(ref), - "k8s.io/api/storage/v1beta1.CSIDriver": schema_k8sio_api_storage_v1beta1_CSIDriver(ref), - "k8s.io/api/storage/v1beta1.CSIDriverList": schema_k8sio_api_storage_v1beta1_CSIDriverList(ref), - "k8s.io/api/storage/v1beta1.CSIDriverSpec": schema_k8sio_api_storage_v1beta1_CSIDriverSpec(ref), - "k8s.io/api/storage/v1beta1.CSINode": schema_k8sio_api_storage_v1beta1_CSINode(ref), - "k8s.io/api/storage/v1beta1.CSINodeDriver": schema_k8sio_api_storage_v1beta1_CSINodeDriver(ref), - "k8s.io/api/storage/v1beta1.CSINodeList": schema_k8sio_api_storage_v1beta1_CSINodeList(ref), - "k8s.io/api/storage/v1beta1.CSINodeSpec": schema_k8sio_api_storage_v1beta1_CSINodeSpec(ref), - "k8s.io/api/storage/v1beta1.CSIStorageCapacity": schema_k8sio_api_storage_v1beta1_CSIStorageCapacity(ref), - "k8s.io/api/storage/v1beta1.CSIStorageCapacityList": schema_k8sio_api_storage_v1beta1_CSIStorageCapacityList(ref), - "k8s.io/api/storage/v1beta1.StorageClass": schema_k8sio_api_storage_v1beta1_StorageClass(ref), - "k8s.io/api/storage/v1beta1.StorageClassList": schema_k8sio_api_storage_v1beta1_StorageClassList(ref), - "k8s.io/api/storage/v1beta1.TokenRequest": schema_k8sio_api_storage_v1beta1_TokenRequest(ref), - "k8s.io/api/storage/v1beta1.VolumeAttachment": schema_k8sio_api_storage_v1beta1_VolumeAttachment(ref), - "k8s.io/api/storage/v1beta1.VolumeAttachmentList": schema_k8sio_api_storage_v1beta1_VolumeAttachmentList(ref), - "k8s.io/api/storage/v1beta1.VolumeAttachmentSource": schema_k8sio_api_storage_v1beta1_VolumeAttachmentSource(ref), - "k8s.io/api/storage/v1beta1.VolumeAttachmentSpec": schema_k8sio_api_storage_v1beta1_VolumeAttachmentSpec(ref), - "k8s.io/api/storage/v1beta1.VolumeAttachmentStatus": schema_k8sio_api_storage_v1beta1_VolumeAttachmentStatus(ref), - "k8s.io/api/storage/v1beta1.VolumeError": schema_k8sio_api_storage_v1beta1_VolumeError(ref), - "k8s.io/api/storage/v1beta1.VolumeNodeResources": schema_k8sio_api_storage_v1beta1_VolumeNodeResources(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ConversionRequest": schema_pkg_apis_apiextensions_v1_ConversionRequest(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ConversionResponse": schema_pkg_apis_apiextensions_v1_ConversionResponse(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ConversionReview": schema_pkg_apis_apiextensions_v1_ConversionReview(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceColumnDefinition": schema_pkg_apis_apiextensions_v1_CustomResourceColumnDefinition(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceConversion": schema_pkg_apis_apiextensions_v1_CustomResourceConversion(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinition": schema_pkg_apis_apiextensions_v1_CustomResourceDefinition(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionCondition": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionCondition(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionList": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionList(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionNames": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionNames(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionSpec": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionSpec(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionStatus": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionStatus(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionVersion": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionVersion(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceSubresourceScale": schema_pkg_apis_apiextensions_v1_CustomResourceSubresourceScale(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceSubresourceStatus": schema_pkg_apis_apiextensions_v1_CustomResourceSubresourceStatus(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceSubresources": schema_pkg_apis_apiextensions_v1_CustomResourceSubresources(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceValidation": schema_pkg_apis_apiextensions_v1_CustomResourceValidation(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ExternalDocumentation": schema_pkg_apis_apiextensions_v1_ExternalDocumentation(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON": schema_pkg_apis_apiextensions_v1_JSON(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSONSchemaProps": schema_pkg_apis_apiextensions_v1_JSONSchemaProps(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSONSchemaPropsOrArray": schema_pkg_apis_apiextensions_v1_JSONSchemaPropsOrArray(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSONSchemaPropsOrBool": schema_pkg_apis_apiextensions_v1_JSONSchemaPropsOrBool(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSONSchemaPropsOrStringArray": schema_pkg_apis_apiextensions_v1_JSONSchemaPropsOrStringArray(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ServiceReference": schema_pkg_apis_apiextensions_v1_ServiceReference(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ValidationRule": schema_pkg_apis_apiextensions_v1_ValidationRule(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.WebhookClientConfig": schema_pkg_apis_apiextensions_v1_WebhookClientConfig(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.WebhookConversion": schema_pkg_apis_apiextensions_v1_WebhookConversion(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ConversionRequest": schema_pkg_apis_apiextensions_v1beta1_ConversionRequest(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ConversionResponse": schema_pkg_apis_apiextensions_v1beta1_ConversionResponse(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ConversionReview": schema_pkg_apis_apiextensions_v1beta1_ConversionReview(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceColumnDefinition": schema_pkg_apis_apiextensions_v1beta1_CustomResourceColumnDefinition(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceConversion": schema_pkg_apis_apiextensions_v1beta1_CustomResourceConversion(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinition": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinition(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionCondition": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionCondition(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionList": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionList(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionNames": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionNames(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionSpec": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionSpec(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionStatus": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionStatus(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionVersion": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionVersion(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceSubresourceScale": schema_pkg_apis_apiextensions_v1beta1_CustomResourceSubresourceScale(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceSubresourceStatus": schema_pkg_apis_apiextensions_v1beta1_CustomResourceSubresourceStatus(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceSubresources": schema_pkg_apis_apiextensions_v1beta1_CustomResourceSubresources(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceValidation": schema_pkg_apis_apiextensions_v1beta1_CustomResourceValidation(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ExternalDocumentation": schema_pkg_apis_apiextensions_v1beta1_ExternalDocumentation(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSON": schema_pkg_apis_apiextensions_v1beta1_JSON(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSONSchemaProps": schema_pkg_apis_apiextensions_v1beta1_JSONSchemaProps(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSONSchemaPropsOrArray": schema_pkg_apis_apiextensions_v1beta1_JSONSchemaPropsOrArray(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSONSchemaPropsOrBool": schema_pkg_apis_apiextensions_v1beta1_JSONSchemaPropsOrBool(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSONSchemaPropsOrStringArray": schema_pkg_apis_apiextensions_v1beta1_JSONSchemaPropsOrStringArray(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ServiceReference": schema_pkg_apis_apiextensions_v1beta1_ServiceReference(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ValidationRule": schema_pkg_apis_apiextensions_v1beta1_ValidationRule(ref), - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.WebhookClientConfig": schema_pkg_apis_apiextensions_v1beta1_WebhookClientConfig(ref), - "k8s.io/apimachinery/pkg/api/resource.Quantity": schema_apimachinery_pkg_api_resource_Quantity(ref), - "k8s.io/apimachinery/pkg/api/resource.int64Amount": schema_apimachinery_pkg_api_resource_int64Amount(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.APIGroup": schema_pkg_apis_meta_v1_APIGroup(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.APIGroupList": schema_pkg_apis_meta_v1_APIGroupList(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.APIResource": schema_pkg_apis_meta_v1_APIResource(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.APIResourceList": schema_pkg_apis_meta_v1_APIResourceList(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.APIVersions": schema_pkg_apis_meta_v1_APIVersions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.ApplyOptions": schema_pkg_apis_meta_v1_ApplyOptions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.Condition": schema_pkg_apis_meta_v1_Condition(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.CreateOptions": schema_pkg_apis_meta_v1_CreateOptions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.DeleteOptions": schema_pkg_apis_meta_v1_DeleteOptions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.Duration": schema_pkg_apis_meta_v1_Duration(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.FieldsV1": schema_pkg_apis_meta_v1_FieldsV1(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.GetOptions": schema_pkg_apis_meta_v1_GetOptions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.GroupKind": schema_pkg_apis_meta_v1_GroupKind(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.GroupResource": schema_pkg_apis_meta_v1_GroupResource(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.GroupVersion": schema_pkg_apis_meta_v1_GroupVersion(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.GroupVersionForDiscovery": schema_pkg_apis_meta_v1_GroupVersionForDiscovery(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.GroupVersionKind": schema_pkg_apis_meta_v1_GroupVersionKind(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.GroupVersionResource": schema_pkg_apis_meta_v1_GroupVersionResource(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.InternalEvent": schema_pkg_apis_meta_v1_InternalEvent(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector": schema_pkg_apis_meta_v1_LabelSelector(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelectorRequirement": schema_pkg_apis_meta_v1_LabelSelectorRequirement(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.List": schema_pkg_apis_meta_v1_List(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta": schema_pkg_apis_meta_v1_ListMeta(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.ListOptions": schema_pkg_apis_meta_v1_ListOptions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.ManagedFieldsEntry": schema_pkg_apis_meta_v1_ManagedFieldsEntry(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.MicroTime": schema_pkg_apis_meta_v1_MicroTime(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta": schema_pkg_apis_meta_v1_ObjectMeta(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.OwnerReference": schema_pkg_apis_meta_v1_OwnerReference(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.PartialObjectMetadata": schema_pkg_apis_meta_v1_PartialObjectMetadata(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.PartialObjectMetadataList": schema_pkg_apis_meta_v1_PartialObjectMetadataList(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.Patch": schema_pkg_apis_meta_v1_Patch(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.PatchOptions": schema_pkg_apis_meta_v1_PatchOptions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.Preconditions": schema_pkg_apis_meta_v1_Preconditions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.RootPaths": schema_pkg_apis_meta_v1_RootPaths(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.ServerAddressByClientCIDR": schema_pkg_apis_meta_v1_ServerAddressByClientCIDR(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.Status": schema_pkg_apis_meta_v1_Status(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.StatusCause": schema_pkg_apis_meta_v1_StatusCause(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.StatusDetails": schema_pkg_apis_meta_v1_StatusDetails(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.Table": schema_pkg_apis_meta_v1_Table(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.TableColumnDefinition": schema_pkg_apis_meta_v1_TableColumnDefinition(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.TableOptions": schema_pkg_apis_meta_v1_TableOptions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.TableRow": schema_pkg_apis_meta_v1_TableRow(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.TableRowCondition": schema_pkg_apis_meta_v1_TableRowCondition(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.Time": schema_pkg_apis_meta_v1_Time(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.Timestamp": schema_pkg_apis_meta_v1_Timestamp(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta": schema_pkg_apis_meta_v1_TypeMeta(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.UpdateOptions": schema_pkg_apis_meta_v1_UpdateOptions(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1.WatchEvent": schema_pkg_apis_meta_v1_WatchEvent(ref), - "k8s.io/apimachinery/pkg/apis/meta/v1beta1.PartialObjectMetadataList": schema_pkg_apis_meta_v1beta1_PartialObjectMetadataList(ref), - "k8s.io/apimachinery/pkg/runtime.RawExtension": schema_k8sio_apimachinery_pkg_runtime_RawExtension(ref), - "k8s.io/apimachinery/pkg/runtime.TypeMeta": schema_k8sio_apimachinery_pkg_runtime_TypeMeta(ref), - "k8s.io/apimachinery/pkg/runtime.Unknown": schema_k8sio_apimachinery_pkg_runtime_Unknown(ref), - "k8s.io/apimachinery/pkg/util/intstr.IntOrString": schema_apimachinery_pkg_util_intstr_IntOrString(ref), - "k8s.io/apimachinery/pkg/version.Info": schema_k8sio_apimachinery_pkg_version_Info(ref), - "k8s.io/apiserver/pkg/apis/audit/v1.Event": schema_pkg_apis_audit_v1_Event(ref), - "k8s.io/apiserver/pkg/apis/audit/v1.EventList": schema_pkg_apis_audit_v1_EventList(ref), - "k8s.io/apiserver/pkg/apis/audit/v1.GroupResources": schema_pkg_apis_audit_v1_GroupResources(ref), - "k8s.io/apiserver/pkg/apis/audit/v1.ObjectReference": schema_pkg_apis_audit_v1_ObjectReference(ref), - "k8s.io/apiserver/pkg/apis/audit/v1.Policy": schema_pkg_apis_audit_v1_Policy(ref), - "k8s.io/apiserver/pkg/apis/audit/v1.PolicyList": schema_pkg_apis_audit_v1_PolicyList(ref), - "k8s.io/apiserver/pkg/apis/audit/v1.PolicyRule": schema_pkg_apis_audit_v1_PolicyRule(ref), - "k8s.io/client-go/pkg/apis/clientauthentication/v1.Cluster": schema_pkg_apis_clientauthentication_v1_Cluster(ref), - "k8s.io/client-go/pkg/apis/clientauthentication/v1.ExecCredential": schema_pkg_apis_clientauthentication_v1_ExecCredential(ref), - "k8s.io/client-go/pkg/apis/clientauthentication/v1.ExecCredentialSpec": schema_pkg_apis_clientauthentication_v1_ExecCredentialSpec(ref), - "k8s.io/client-go/pkg/apis/clientauthentication/v1.ExecCredentialStatus": schema_pkg_apis_clientauthentication_v1_ExecCredentialStatus(ref), - "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1.Cluster": schema_pkg_apis_clientauthentication_v1beta1_Cluster(ref), - "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1.ExecCredential": schema_pkg_apis_clientauthentication_v1beta1_ExecCredential(ref), - "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1.ExecCredentialSpec": schema_pkg_apis_clientauthentication_v1beta1_ExecCredentialSpec(ref), - "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1.ExecCredentialStatus": schema_pkg_apis_clientauthentication_v1beta1_ExecCredentialStatus(ref), - "k8s.io/cloud-provider/config/v1alpha1.CloudControllerManagerConfiguration": schema_k8sio_cloud_provider_config_v1alpha1_CloudControllerManagerConfiguration(ref), - "k8s.io/cloud-provider/config/v1alpha1.CloudProviderConfiguration": schema_k8sio_cloud_provider_config_v1alpha1_CloudProviderConfiguration(ref), - "k8s.io/cloud-provider/config/v1alpha1.KubeCloudSharedConfiguration": schema_k8sio_cloud_provider_config_v1alpha1_KubeCloudSharedConfiguration(ref), - "k8s.io/cloud-provider/config/v1alpha1.WebhookConfiguration": schema_k8sio_cloud_provider_config_v1alpha1_WebhookConfiguration(ref), - "k8s.io/controller-manager/config/v1alpha1.ControllerLeaderConfiguration": schema_k8sio_controller_manager_config_v1alpha1_ControllerLeaderConfiguration(ref), - "k8s.io/controller-manager/config/v1alpha1.GenericControllerManagerConfiguration": schema_k8sio_controller_manager_config_v1alpha1_GenericControllerManagerConfiguration(ref), - "k8s.io/controller-manager/config/v1alpha1.LeaderMigrationConfiguration": schema_k8sio_controller_manager_config_v1alpha1_LeaderMigrationConfiguration(ref), - "k8s.io/controller-manager/config/v1beta1.ControllerLeaderConfiguration": schema_k8sio_controller_manager_config_v1beta1_ControllerLeaderConfiguration(ref), - "k8s.io/controller-manager/config/v1beta1.LeaderMigrationConfiguration": schema_k8sio_controller_manager_config_v1beta1_LeaderMigrationConfiguration(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIService": schema_pkg_apis_apiregistration_v1_APIService(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIServiceCondition": schema_pkg_apis_apiregistration_v1_APIServiceCondition(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIServiceList": schema_pkg_apis_apiregistration_v1_APIServiceList(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIServiceSpec": schema_pkg_apis_apiregistration_v1_APIServiceSpec(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIServiceStatus": schema_pkg_apis_apiregistration_v1_APIServiceStatus(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.ServiceReference": schema_pkg_apis_apiregistration_v1_ServiceReference(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIService": schema_pkg_apis_apiregistration_v1beta1_APIService(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIServiceCondition": schema_pkg_apis_apiregistration_v1beta1_APIServiceCondition(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIServiceList": schema_pkg_apis_apiregistration_v1beta1_APIServiceList(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIServiceSpec": schema_pkg_apis_apiregistration_v1beta1_APIServiceSpec(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIServiceStatus": schema_pkg_apis_apiregistration_v1beta1_APIServiceStatus(ref), - "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.ServiceReference": schema_pkg_apis_apiregistration_v1beta1_ServiceReference(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.AttachDetachControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_AttachDetachControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.CSRSigningConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_CSRSigningConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.CSRSigningControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_CSRSigningControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.CronJobControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_CronJobControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.DaemonSetControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_DaemonSetControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.DeploymentControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_DeploymentControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.DeprecatedControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_DeprecatedControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.EndpointControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_EndpointControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.EndpointSliceControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_EndpointSliceControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.EndpointSliceMirroringControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_EndpointSliceMirroringControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.EphemeralVolumeControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_EphemeralVolumeControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.GarbageCollectorControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_GarbageCollectorControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.GroupResource": schema_k8sio_kube_controller_manager_config_v1alpha1_GroupResource(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.HPAControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_HPAControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.JobControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_JobControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.KubeControllerManagerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_KubeControllerManagerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.LegacySATokenCleanerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_LegacySATokenCleanerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.NamespaceControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_NamespaceControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.NodeIPAMControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_NodeIPAMControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.NodeLifecycleControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_NodeLifecycleControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.PersistentVolumeBinderControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_PersistentVolumeBinderControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.PersistentVolumeRecyclerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_PersistentVolumeRecyclerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.PodGCControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_PodGCControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.ReplicaSetControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_ReplicaSetControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.ReplicationControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_ReplicationControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.ResourceQuotaControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_ResourceQuotaControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.SAControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_SAControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.StatefulSetControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_StatefulSetControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.TTLAfterFinishedControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_TTLAfterFinishedControllerConfiguration(ref), - "k8s.io/kube-controller-manager/config/v1alpha1.VolumeConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_VolumeConfiguration(ref), - "k8s.io/kube-proxy/config/v1alpha1.DetectLocalConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_DetectLocalConfiguration(ref), - "k8s.io/kube-proxy/config/v1alpha1.KubeProxyConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyConfiguration(ref), - "k8s.io/kube-proxy/config/v1alpha1.KubeProxyConntrackConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyConntrackConfiguration(ref), - "k8s.io/kube-proxy/config/v1alpha1.KubeProxyIPTablesConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyIPTablesConfiguration(ref), - "k8s.io/kube-proxy/config/v1alpha1.KubeProxyIPVSConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyIPVSConfiguration(ref), - "k8s.io/kube-proxy/config/v1alpha1.KubeProxyWinkernelConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyWinkernelConfiguration(ref), - "k8s.io/kube-scheduler/config/v1.DefaultPreemptionArgs": schema_k8sio_kube_scheduler_config_v1_DefaultPreemptionArgs(ref), - "k8s.io/kube-scheduler/config/v1.Extender": schema_k8sio_kube_scheduler_config_v1_Extender(ref), - "k8s.io/kube-scheduler/config/v1.ExtenderManagedResource": schema_k8sio_kube_scheduler_config_v1_ExtenderManagedResource(ref), - "k8s.io/kube-scheduler/config/v1.ExtenderTLSConfig": schema_k8sio_kube_scheduler_config_v1_ExtenderTLSConfig(ref), - "k8s.io/kube-scheduler/config/v1.InterPodAffinityArgs": schema_k8sio_kube_scheduler_config_v1_InterPodAffinityArgs(ref), - "k8s.io/kube-scheduler/config/v1.KubeSchedulerConfiguration": schema_k8sio_kube_scheduler_config_v1_KubeSchedulerConfiguration(ref), - "k8s.io/kube-scheduler/config/v1.KubeSchedulerProfile": schema_k8sio_kube_scheduler_config_v1_KubeSchedulerProfile(ref), - "k8s.io/kube-scheduler/config/v1.NodeAffinityArgs": schema_k8sio_kube_scheduler_config_v1_NodeAffinityArgs(ref), - "k8s.io/kube-scheduler/config/v1.NodeResourcesBalancedAllocationArgs": schema_k8sio_kube_scheduler_config_v1_NodeResourcesBalancedAllocationArgs(ref), - "k8s.io/kube-scheduler/config/v1.NodeResourcesFitArgs": schema_k8sio_kube_scheduler_config_v1_NodeResourcesFitArgs(ref), - "k8s.io/kube-scheduler/config/v1.Plugin": schema_k8sio_kube_scheduler_config_v1_Plugin(ref), - "k8s.io/kube-scheduler/config/v1.PluginConfig": schema_k8sio_kube_scheduler_config_v1_PluginConfig(ref), - "k8s.io/kube-scheduler/config/v1.PluginSet": schema_k8sio_kube_scheduler_config_v1_PluginSet(ref), - "k8s.io/kube-scheduler/config/v1.Plugins": schema_k8sio_kube_scheduler_config_v1_Plugins(ref), - "k8s.io/kube-scheduler/config/v1.PodTopologySpreadArgs": schema_k8sio_kube_scheduler_config_v1_PodTopologySpreadArgs(ref), - "k8s.io/kube-scheduler/config/v1.RequestedToCapacityRatioParam": schema_k8sio_kube_scheduler_config_v1_RequestedToCapacityRatioParam(ref), - "k8s.io/kube-scheduler/config/v1.ResourceSpec": schema_k8sio_kube_scheduler_config_v1_ResourceSpec(ref), - "k8s.io/kube-scheduler/config/v1.ScoringStrategy": schema_k8sio_kube_scheduler_config_v1_ScoringStrategy(ref), - "k8s.io/kube-scheduler/config/v1.UtilizationShapePoint": schema_k8sio_kube_scheduler_config_v1_UtilizationShapePoint(ref), - "k8s.io/kube-scheduler/config/v1.VolumeBindingArgs": schema_k8sio_kube_scheduler_config_v1_VolumeBindingArgs(ref), - "k8s.io/kube-scheduler/config/v1beta3.DefaultPreemptionArgs": schema_k8sio_kube_scheduler_config_v1beta3_DefaultPreemptionArgs(ref), - "k8s.io/kube-scheduler/config/v1beta3.Extender": schema_k8sio_kube_scheduler_config_v1beta3_Extender(ref), - "k8s.io/kube-scheduler/config/v1beta3.ExtenderManagedResource": schema_k8sio_kube_scheduler_config_v1beta3_ExtenderManagedResource(ref), - "k8s.io/kube-scheduler/config/v1beta3.ExtenderTLSConfig": schema_k8sio_kube_scheduler_config_v1beta3_ExtenderTLSConfig(ref), - "k8s.io/kube-scheduler/config/v1beta3.InterPodAffinityArgs": schema_k8sio_kube_scheduler_config_v1beta3_InterPodAffinityArgs(ref), - "k8s.io/kube-scheduler/config/v1beta3.KubeSchedulerConfiguration": schema_k8sio_kube_scheduler_config_v1beta3_KubeSchedulerConfiguration(ref), - "k8s.io/kube-scheduler/config/v1beta3.KubeSchedulerProfile": schema_k8sio_kube_scheduler_config_v1beta3_KubeSchedulerProfile(ref), - "k8s.io/kube-scheduler/config/v1beta3.NodeAffinityArgs": schema_k8sio_kube_scheduler_config_v1beta3_NodeAffinityArgs(ref), - "k8s.io/kube-scheduler/config/v1beta3.NodeResourcesBalancedAllocationArgs": schema_k8sio_kube_scheduler_config_v1beta3_NodeResourcesBalancedAllocationArgs(ref), - "k8s.io/kube-scheduler/config/v1beta3.NodeResourcesFitArgs": schema_k8sio_kube_scheduler_config_v1beta3_NodeResourcesFitArgs(ref), - "k8s.io/kube-scheduler/config/v1beta3.Plugin": schema_k8sio_kube_scheduler_config_v1beta3_Plugin(ref), - "k8s.io/kube-scheduler/config/v1beta3.PluginConfig": schema_k8sio_kube_scheduler_config_v1beta3_PluginConfig(ref), - "k8s.io/kube-scheduler/config/v1beta3.PluginSet": schema_k8sio_kube_scheduler_config_v1beta3_PluginSet(ref), - "k8s.io/kube-scheduler/config/v1beta3.Plugins": schema_k8sio_kube_scheduler_config_v1beta3_Plugins(ref), - "k8s.io/kube-scheduler/config/v1beta3.PodTopologySpreadArgs": schema_k8sio_kube_scheduler_config_v1beta3_PodTopologySpreadArgs(ref), - "k8s.io/kube-scheduler/config/v1beta3.RequestedToCapacityRatioParam": schema_k8sio_kube_scheduler_config_v1beta3_RequestedToCapacityRatioParam(ref), - "k8s.io/kube-scheduler/config/v1beta3.ResourceSpec": schema_k8sio_kube_scheduler_config_v1beta3_ResourceSpec(ref), - "k8s.io/kube-scheduler/config/v1beta3.ScoringStrategy": schema_k8sio_kube_scheduler_config_v1beta3_ScoringStrategy(ref), - "k8s.io/kube-scheduler/config/v1beta3.UtilizationShapePoint": schema_k8sio_kube_scheduler_config_v1beta3_UtilizationShapePoint(ref), - "k8s.io/kube-scheduler/config/v1beta3.VolumeBindingArgs": schema_k8sio_kube_scheduler_config_v1beta3_VolumeBindingArgs(ref), - "k8s.io/kubelet/config/v1.CredentialProvider": schema_k8sio_kubelet_config_v1_CredentialProvider(ref), - "k8s.io/kubelet/config/v1.CredentialProviderConfig": schema_k8sio_kubelet_config_v1_CredentialProviderConfig(ref), - "k8s.io/kubelet/config/v1.ExecEnvVar": schema_k8sio_kubelet_config_v1_ExecEnvVar(ref), - "k8s.io/kubelet/config/v1alpha1.CredentialProvider": schema_k8sio_kubelet_config_v1alpha1_CredentialProvider(ref), - "k8s.io/kubelet/config/v1alpha1.CredentialProviderConfig": schema_k8sio_kubelet_config_v1alpha1_CredentialProviderConfig(ref), - "k8s.io/kubelet/config/v1alpha1.ExecEnvVar": schema_k8sio_kubelet_config_v1alpha1_ExecEnvVar(ref), - "k8s.io/kubelet/config/v1beta1.CredentialProvider": schema_k8sio_kubelet_config_v1beta1_CredentialProvider(ref), - "k8s.io/kubelet/config/v1beta1.CredentialProviderConfig": schema_k8sio_kubelet_config_v1beta1_CredentialProviderConfig(ref), - "k8s.io/kubelet/config/v1beta1.ExecEnvVar": schema_k8sio_kubelet_config_v1beta1_ExecEnvVar(ref), - "k8s.io/kubelet/config/v1beta1.KubeletAnonymousAuthentication": schema_k8sio_kubelet_config_v1beta1_KubeletAnonymousAuthentication(ref), - "k8s.io/kubelet/config/v1beta1.KubeletAuthentication": schema_k8sio_kubelet_config_v1beta1_KubeletAuthentication(ref), - "k8s.io/kubelet/config/v1beta1.KubeletAuthorization": schema_k8sio_kubelet_config_v1beta1_KubeletAuthorization(ref), - "k8s.io/kubelet/config/v1beta1.KubeletConfiguration": schema_k8sio_kubelet_config_v1beta1_KubeletConfiguration(ref), - "k8s.io/kubelet/config/v1beta1.KubeletWebhookAuthentication": schema_k8sio_kubelet_config_v1beta1_KubeletWebhookAuthentication(ref), - "k8s.io/kubelet/config/v1beta1.KubeletWebhookAuthorization": schema_k8sio_kubelet_config_v1beta1_KubeletWebhookAuthorization(ref), - "k8s.io/kubelet/config/v1beta1.KubeletX509Authentication": schema_k8sio_kubelet_config_v1beta1_KubeletX509Authentication(ref), - "k8s.io/kubelet/config/v1beta1.MemoryReservation": schema_k8sio_kubelet_config_v1beta1_MemoryReservation(ref), - "k8s.io/kubelet/config/v1beta1.MemorySwapConfiguration": schema_k8sio_kubelet_config_v1beta1_MemorySwapConfiguration(ref), - "k8s.io/kubelet/config/v1beta1.SerializedNodeConfigSource": schema_k8sio_kubelet_config_v1beta1_SerializedNodeConfigSource(ref), - "k8s.io/kubelet/config/v1beta1.ShutdownGracePeriodByPodPriority": schema_k8sio_kubelet_config_v1beta1_ShutdownGracePeriodByPodPriority(ref), - "k8s.io/kubernetes/pkg/apis/abac/v1beta1.Policy": schema_pkg_apis_abac_v1beta1_Policy(ref), - "k8s.io/kubernetes/pkg/apis/abac/v1beta1.PolicySpec": schema_pkg_apis_abac_v1beta1_PolicySpec(ref), - "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1.MetricListOptions": schema_pkg_apis_custom_metrics_v1beta1_MetricListOptions(ref), - "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1.MetricValue": schema_pkg_apis_custom_metrics_v1beta1_MetricValue(ref), - "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1.MetricValueList": schema_pkg_apis_custom_metrics_v1beta1_MetricValueList(ref), - "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2.MetricIdentifier": schema_pkg_apis_custom_metrics_v1beta2_MetricIdentifier(ref), - "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2.MetricListOptions": schema_pkg_apis_custom_metrics_v1beta2_MetricListOptions(ref), - "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2.MetricValue": schema_pkg_apis_custom_metrics_v1beta2_MetricValue(ref), - "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2.MetricValueList": schema_pkg_apis_custom_metrics_v1beta2_MetricValueList(ref), - "k8s.io/metrics/pkg/apis/external_metrics/v1beta1.ExternalMetricValue": schema_pkg_apis_external_metrics_v1beta1_ExternalMetricValue(ref), - "k8s.io/metrics/pkg/apis/external_metrics/v1beta1.ExternalMetricValueList": schema_pkg_apis_external_metrics_v1beta1_ExternalMetricValueList(ref), - "k8s.io/metrics/pkg/apis/metrics/v1alpha1.ContainerMetrics": schema_pkg_apis_metrics_v1alpha1_ContainerMetrics(ref), - "k8s.io/metrics/pkg/apis/metrics/v1alpha1.NodeMetrics": schema_pkg_apis_metrics_v1alpha1_NodeMetrics(ref), - "k8s.io/metrics/pkg/apis/metrics/v1alpha1.NodeMetricsList": schema_pkg_apis_metrics_v1alpha1_NodeMetricsList(ref), - "k8s.io/metrics/pkg/apis/metrics/v1alpha1.PodMetrics": schema_pkg_apis_metrics_v1alpha1_PodMetrics(ref), - "k8s.io/metrics/pkg/apis/metrics/v1alpha1.PodMetricsList": schema_pkg_apis_metrics_v1alpha1_PodMetricsList(ref), - "k8s.io/metrics/pkg/apis/metrics/v1beta1.ContainerMetrics": schema_pkg_apis_metrics_v1beta1_ContainerMetrics(ref), - "k8s.io/metrics/pkg/apis/metrics/v1beta1.NodeMetrics": schema_pkg_apis_metrics_v1beta1_NodeMetrics(ref), - "k8s.io/metrics/pkg/apis/metrics/v1beta1.NodeMetricsList": schema_pkg_apis_metrics_v1beta1_NodeMetricsList(ref), - "k8s.io/metrics/pkg/apis/metrics/v1beta1.PodMetrics": schema_pkg_apis_metrics_v1beta1_PodMetrics(ref), - "k8s.io/metrics/pkg/apis/metrics/v1beta1.PodMetricsList": schema_pkg_apis_metrics_v1beta1_PodMetricsList(ref), + "k8s.io/api/admissionregistration/v1.MatchCondition": schema_k8sio_api_admissionregistration_v1_MatchCondition(ref), + "k8s.io/api/admissionregistration/v1.MutatingWebhook": schema_k8sio_api_admissionregistration_v1_MutatingWebhook(ref), + "k8s.io/api/admissionregistration/v1.MutatingWebhookConfiguration": schema_k8sio_api_admissionregistration_v1_MutatingWebhookConfiguration(ref), + "k8s.io/api/admissionregistration/v1.MutatingWebhookConfigurationList": schema_k8sio_api_admissionregistration_v1_MutatingWebhookConfigurationList(ref), + "k8s.io/api/admissionregistration/v1.Rule": schema_k8sio_api_admissionregistration_v1_Rule(ref), + "k8s.io/api/admissionregistration/v1.RuleWithOperations": schema_k8sio_api_admissionregistration_v1_RuleWithOperations(ref), + "k8s.io/api/admissionregistration/v1.ServiceReference": schema_k8sio_api_admissionregistration_v1_ServiceReference(ref), + "k8s.io/api/admissionregistration/v1.ValidatingWebhook": schema_k8sio_api_admissionregistration_v1_ValidatingWebhook(ref), + "k8s.io/api/admissionregistration/v1.ValidatingWebhookConfiguration": schema_k8sio_api_admissionregistration_v1_ValidatingWebhookConfiguration(ref), + "k8s.io/api/admissionregistration/v1.ValidatingWebhookConfigurationList": schema_k8sio_api_admissionregistration_v1_ValidatingWebhookConfigurationList(ref), + "k8s.io/api/admissionregistration/v1.WebhookClientConfig": schema_k8sio_api_admissionregistration_v1_WebhookClientConfig(ref), + "k8s.io/api/admissionregistration/v1alpha1.AuditAnnotation": schema_k8sio_api_admissionregistration_v1alpha1_AuditAnnotation(ref), + "k8s.io/api/admissionregistration/v1alpha1.ExpressionWarning": schema_k8sio_api_admissionregistration_v1alpha1_ExpressionWarning(ref), + "k8s.io/api/admissionregistration/v1alpha1.MatchCondition": schema_k8sio_api_admissionregistration_v1alpha1_MatchCondition(ref), + "k8s.io/api/admissionregistration/v1alpha1.MatchResources": schema_k8sio_api_admissionregistration_v1alpha1_MatchResources(ref), + "k8s.io/api/admissionregistration/v1alpha1.NamedRuleWithOperations": schema_k8sio_api_admissionregistration_v1alpha1_NamedRuleWithOperations(ref), + "k8s.io/api/admissionregistration/v1alpha1.ParamKind": schema_k8sio_api_admissionregistration_v1alpha1_ParamKind(ref), + "k8s.io/api/admissionregistration/v1alpha1.ParamRef": schema_k8sio_api_admissionregistration_v1alpha1_ParamRef(ref), + "k8s.io/api/admissionregistration/v1alpha1.TypeChecking": schema_k8sio_api_admissionregistration_v1alpha1_TypeChecking(ref), + "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicy": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicy(ref), + "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyBinding": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyBinding(ref), + "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyBindingList": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyBindingList(ref), + "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyBindingSpec": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyBindingSpec(ref), + "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyList": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyList(ref), + "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicySpec": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicySpec(ref), + "k8s.io/api/admissionregistration/v1alpha1.ValidatingAdmissionPolicyStatus": schema_k8sio_api_admissionregistration_v1alpha1_ValidatingAdmissionPolicyStatus(ref), + "k8s.io/api/admissionregistration/v1alpha1.Validation": schema_k8sio_api_admissionregistration_v1alpha1_Validation(ref), + "k8s.io/api/admissionregistration/v1beta1.MatchCondition": schema_k8sio_api_admissionregistration_v1beta1_MatchCondition(ref), + "k8s.io/api/admissionregistration/v1beta1.MutatingWebhook": schema_k8sio_api_admissionregistration_v1beta1_MutatingWebhook(ref), + "k8s.io/api/admissionregistration/v1beta1.MutatingWebhookConfiguration": schema_k8sio_api_admissionregistration_v1beta1_MutatingWebhookConfiguration(ref), + "k8s.io/api/admissionregistration/v1beta1.MutatingWebhookConfigurationList": schema_k8sio_api_admissionregistration_v1beta1_MutatingWebhookConfigurationList(ref), + "k8s.io/api/admissionregistration/v1beta1.ServiceReference": schema_k8sio_api_admissionregistration_v1beta1_ServiceReference(ref), + "k8s.io/api/admissionregistration/v1beta1.ValidatingWebhook": schema_k8sio_api_admissionregistration_v1beta1_ValidatingWebhook(ref), + "k8s.io/api/admissionregistration/v1beta1.ValidatingWebhookConfiguration": schema_k8sio_api_admissionregistration_v1beta1_ValidatingWebhookConfiguration(ref), + "k8s.io/api/admissionregistration/v1beta1.ValidatingWebhookConfigurationList": schema_k8sio_api_admissionregistration_v1beta1_ValidatingWebhookConfigurationList(ref), + "k8s.io/api/admissionregistration/v1beta1.WebhookClientConfig": schema_k8sio_api_admissionregistration_v1beta1_WebhookClientConfig(ref), + "k8s.io/api/apidiscovery/v2beta1.APIGroupDiscovery": schema_k8sio_api_apidiscovery_v2beta1_APIGroupDiscovery(ref), + "k8s.io/api/apidiscovery/v2beta1.APIGroupDiscoveryList": schema_k8sio_api_apidiscovery_v2beta1_APIGroupDiscoveryList(ref), + "k8s.io/api/apidiscovery/v2beta1.APIResourceDiscovery": schema_k8sio_api_apidiscovery_v2beta1_APIResourceDiscovery(ref), + "k8s.io/api/apidiscovery/v2beta1.APISubresourceDiscovery": schema_k8sio_api_apidiscovery_v2beta1_APISubresourceDiscovery(ref), + "k8s.io/api/apidiscovery/v2beta1.APIVersionDiscovery": schema_k8sio_api_apidiscovery_v2beta1_APIVersionDiscovery(ref), + "k8s.io/api/apiserverinternal/v1alpha1.ServerStorageVersion": schema_k8sio_api_apiserverinternal_v1alpha1_ServerStorageVersion(ref), + "k8s.io/api/apiserverinternal/v1alpha1.StorageVersion": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersion(ref), + "k8s.io/api/apiserverinternal/v1alpha1.StorageVersionCondition": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersionCondition(ref), + "k8s.io/api/apiserverinternal/v1alpha1.StorageVersionList": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersionList(ref), + "k8s.io/api/apiserverinternal/v1alpha1.StorageVersionSpec": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersionSpec(ref), + "k8s.io/api/apiserverinternal/v1alpha1.StorageVersionStatus": schema_k8sio_api_apiserverinternal_v1alpha1_StorageVersionStatus(ref), + "k8s.io/api/apps/v1.ControllerRevision": schema_k8sio_api_apps_v1_ControllerRevision(ref), + "k8s.io/api/apps/v1.ControllerRevisionList": schema_k8sio_api_apps_v1_ControllerRevisionList(ref), + "k8s.io/api/apps/v1.DaemonSet": schema_k8sio_api_apps_v1_DaemonSet(ref), + "k8s.io/api/apps/v1.DaemonSetCondition": schema_k8sio_api_apps_v1_DaemonSetCondition(ref), + "k8s.io/api/apps/v1.DaemonSetList": schema_k8sio_api_apps_v1_DaemonSetList(ref), + "k8s.io/api/apps/v1.DaemonSetSpec": schema_k8sio_api_apps_v1_DaemonSetSpec(ref), + "k8s.io/api/apps/v1.DaemonSetStatus": schema_k8sio_api_apps_v1_DaemonSetStatus(ref), + "k8s.io/api/apps/v1.DaemonSetUpdateStrategy": schema_k8sio_api_apps_v1_DaemonSetUpdateStrategy(ref), + "k8s.io/api/apps/v1.Deployment": schema_k8sio_api_apps_v1_Deployment(ref), + "k8s.io/api/apps/v1.DeploymentCondition": schema_k8sio_api_apps_v1_DeploymentCondition(ref), + "k8s.io/api/apps/v1.DeploymentList": schema_k8sio_api_apps_v1_DeploymentList(ref), + "k8s.io/api/apps/v1.DeploymentSpec": schema_k8sio_api_apps_v1_DeploymentSpec(ref), + "k8s.io/api/apps/v1.DeploymentStatus": schema_k8sio_api_apps_v1_DeploymentStatus(ref), + "k8s.io/api/apps/v1.DeploymentStrategy": schema_k8sio_api_apps_v1_DeploymentStrategy(ref), + "k8s.io/api/apps/v1.ReplicaSet": schema_k8sio_api_apps_v1_ReplicaSet(ref), + "k8s.io/api/apps/v1.ReplicaSetCondition": schema_k8sio_api_apps_v1_ReplicaSetCondition(ref), + "k8s.io/api/apps/v1.ReplicaSetList": schema_k8sio_api_apps_v1_ReplicaSetList(ref), + "k8s.io/api/apps/v1.ReplicaSetSpec": schema_k8sio_api_apps_v1_ReplicaSetSpec(ref), + "k8s.io/api/apps/v1.ReplicaSetStatus": schema_k8sio_api_apps_v1_ReplicaSetStatus(ref), + "k8s.io/api/apps/v1.RollingUpdateDaemonSet": schema_k8sio_api_apps_v1_RollingUpdateDaemonSet(ref), + "k8s.io/api/apps/v1.RollingUpdateDeployment": schema_k8sio_api_apps_v1_RollingUpdateDeployment(ref), + "k8s.io/api/apps/v1.RollingUpdateStatefulSetStrategy": schema_k8sio_api_apps_v1_RollingUpdateStatefulSetStrategy(ref), + "k8s.io/api/apps/v1.StatefulSet": schema_k8sio_api_apps_v1_StatefulSet(ref), + "k8s.io/api/apps/v1.StatefulSetCondition": schema_k8sio_api_apps_v1_StatefulSetCondition(ref), + "k8s.io/api/apps/v1.StatefulSetList": schema_k8sio_api_apps_v1_StatefulSetList(ref), + "k8s.io/api/apps/v1.StatefulSetOrdinals": schema_k8sio_api_apps_v1_StatefulSetOrdinals(ref), + "k8s.io/api/apps/v1.StatefulSetPersistentVolumeClaimRetentionPolicy": schema_k8sio_api_apps_v1_StatefulSetPersistentVolumeClaimRetentionPolicy(ref), + "k8s.io/api/apps/v1.StatefulSetSpec": schema_k8sio_api_apps_v1_StatefulSetSpec(ref), + "k8s.io/api/apps/v1.StatefulSetStatus": schema_k8sio_api_apps_v1_StatefulSetStatus(ref), + "k8s.io/api/apps/v1.StatefulSetUpdateStrategy": schema_k8sio_api_apps_v1_StatefulSetUpdateStrategy(ref), + "k8s.io/api/apps/v1beta1.ControllerRevision": schema_k8sio_api_apps_v1beta1_ControllerRevision(ref), + "k8s.io/api/apps/v1beta1.ControllerRevisionList": schema_k8sio_api_apps_v1beta1_ControllerRevisionList(ref), + "k8s.io/api/apps/v1beta1.Deployment": schema_k8sio_api_apps_v1beta1_Deployment(ref), + "k8s.io/api/apps/v1beta1.DeploymentCondition": schema_k8sio_api_apps_v1beta1_DeploymentCondition(ref), + "k8s.io/api/apps/v1beta1.DeploymentList": schema_k8sio_api_apps_v1beta1_DeploymentList(ref), + "k8s.io/api/apps/v1beta1.DeploymentRollback": schema_k8sio_api_apps_v1beta1_DeploymentRollback(ref), + "k8s.io/api/apps/v1beta1.DeploymentSpec": schema_k8sio_api_apps_v1beta1_DeploymentSpec(ref), + "k8s.io/api/apps/v1beta1.DeploymentStatus": schema_k8sio_api_apps_v1beta1_DeploymentStatus(ref), + "k8s.io/api/apps/v1beta1.DeploymentStrategy": schema_k8sio_api_apps_v1beta1_DeploymentStrategy(ref), + "k8s.io/api/apps/v1beta1.RollbackConfig": schema_k8sio_api_apps_v1beta1_RollbackConfig(ref), + "k8s.io/api/apps/v1beta1.RollingUpdateDeployment": schema_k8sio_api_apps_v1beta1_RollingUpdateDeployment(ref), + "k8s.io/api/apps/v1beta1.RollingUpdateStatefulSetStrategy": schema_k8sio_api_apps_v1beta1_RollingUpdateStatefulSetStrategy(ref), + "k8s.io/api/apps/v1beta1.Scale": schema_k8sio_api_apps_v1beta1_Scale(ref), + "k8s.io/api/apps/v1beta1.ScaleSpec": schema_k8sio_api_apps_v1beta1_ScaleSpec(ref), + "k8s.io/api/apps/v1beta1.ScaleStatus": schema_k8sio_api_apps_v1beta1_ScaleStatus(ref), + "k8s.io/api/apps/v1beta1.StatefulSet": schema_k8sio_api_apps_v1beta1_StatefulSet(ref), + "k8s.io/api/apps/v1beta1.StatefulSetCondition": schema_k8sio_api_apps_v1beta1_StatefulSetCondition(ref), + "k8s.io/api/apps/v1beta1.StatefulSetList": schema_k8sio_api_apps_v1beta1_StatefulSetList(ref), + "k8s.io/api/apps/v1beta1.StatefulSetOrdinals": schema_k8sio_api_apps_v1beta1_StatefulSetOrdinals(ref), + "k8s.io/api/apps/v1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy": schema_k8sio_api_apps_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy(ref), + "k8s.io/api/apps/v1beta1.StatefulSetSpec": schema_k8sio_api_apps_v1beta1_StatefulSetSpec(ref), + "k8s.io/api/apps/v1beta1.StatefulSetStatus": schema_k8sio_api_apps_v1beta1_StatefulSetStatus(ref), + "k8s.io/api/apps/v1beta1.StatefulSetUpdateStrategy": schema_k8sio_api_apps_v1beta1_StatefulSetUpdateStrategy(ref), + "k8s.io/api/apps/v1beta2.ControllerRevision": schema_k8sio_api_apps_v1beta2_ControllerRevision(ref), + "k8s.io/api/apps/v1beta2.ControllerRevisionList": schema_k8sio_api_apps_v1beta2_ControllerRevisionList(ref), + "k8s.io/api/apps/v1beta2.DaemonSet": schema_k8sio_api_apps_v1beta2_DaemonSet(ref), + "k8s.io/api/apps/v1beta2.DaemonSetCondition": schema_k8sio_api_apps_v1beta2_DaemonSetCondition(ref), + "k8s.io/api/apps/v1beta2.DaemonSetList": schema_k8sio_api_apps_v1beta2_DaemonSetList(ref), + "k8s.io/api/apps/v1beta2.DaemonSetSpec": schema_k8sio_api_apps_v1beta2_DaemonSetSpec(ref), + "k8s.io/api/apps/v1beta2.DaemonSetStatus": schema_k8sio_api_apps_v1beta2_DaemonSetStatus(ref), + "k8s.io/api/apps/v1beta2.DaemonSetUpdateStrategy": schema_k8sio_api_apps_v1beta2_DaemonSetUpdateStrategy(ref), + "k8s.io/api/apps/v1beta2.Deployment": schema_k8sio_api_apps_v1beta2_Deployment(ref), + "k8s.io/api/apps/v1beta2.DeploymentCondition": schema_k8sio_api_apps_v1beta2_DeploymentCondition(ref), + "k8s.io/api/apps/v1beta2.DeploymentList": schema_k8sio_api_apps_v1beta2_DeploymentList(ref), + "k8s.io/api/apps/v1beta2.DeploymentSpec": schema_k8sio_api_apps_v1beta2_DeploymentSpec(ref), + "k8s.io/api/apps/v1beta2.DeploymentStatus": schema_k8sio_api_apps_v1beta2_DeploymentStatus(ref), + "k8s.io/api/apps/v1beta2.DeploymentStrategy": schema_k8sio_api_apps_v1beta2_DeploymentStrategy(ref), + "k8s.io/api/apps/v1beta2.ReplicaSet": schema_k8sio_api_apps_v1beta2_ReplicaSet(ref), + "k8s.io/api/apps/v1beta2.ReplicaSetCondition": schema_k8sio_api_apps_v1beta2_ReplicaSetCondition(ref), + "k8s.io/api/apps/v1beta2.ReplicaSetList": schema_k8sio_api_apps_v1beta2_ReplicaSetList(ref), + "k8s.io/api/apps/v1beta2.ReplicaSetSpec": schema_k8sio_api_apps_v1beta2_ReplicaSetSpec(ref), + "k8s.io/api/apps/v1beta2.ReplicaSetStatus": schema_k8sio_api_apps_v1beta2_ReplicaSetStatus(ref), + "k8s.io/api/apps/v1beta2.RollingUpdateDaemonSet": schema_k8sio_api_apps_v1beta2_RollingUpdateDaemonSet(ref), + "k8s.io/api/apps/v1beta2.RollingUpdateDeployment": schema_k8sio_api_apps_v1beta2_RollingUpdateDeployment(ref), + "k8s.io/api/apps/v1beta2.RollingUpdateStatefulSetStrategy": schema_k8sio_api_apps_v1beta2_RollingUpdateStatefulSetStrategy(ref), + "k8s.io/api/apps/v1beta2.Scale": schema_k8sio_api_apps_v1beta2_Scale(ref), + "k8s.io/api/apps/v1beta2.ScaleSpec": schema_k8sio_api_apps_v1beta2_ScaleSpec(ref), + "k8s.io/api/apps/v1beta2.ScaleStatus": schema_k8sio_api_apps_v1beta2_ScaleStatus(ref), + "k8s.io/api/apps/v1beta2.StatefulSet": schema_k8sio_api_apps_v1beta2_StatefulSet(ref), + "k8s.io/api/apps/v1beta2.StatefulSetCondition": schema_k8sio_api_apps_v1beta2_StatefulSetCondition(ref), + "k8s.io/api/apps/v1beta2.StatefulSetList": schema_k8sio_api_apps_v1beta2_StatefulSetList(ref), + "k8s.io/api/apps/v1beta2.StatefulSetOrdinals": schema_k8sio_api_apps_v1beta2_StatefulSetOrdinals(ref), + "k8s.io/api/apps/v1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy": schema_k8sio_api_apps_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy(ref), + "k8s.io/api/apps/v1beta2.StatefulSetSpec": schema_k8sio_api_apps_v1beta2_StatefulSetSpec(ref), + "k8s.io/api/apps/v1beta2.StatefulSetStatus": schema_k8sio_api_apps_v1beta2_StatefulSetStatus(ref), + "k8s.io/api/apps/v1beta2.StatefulSetUpdateStrategy": schema_k8sio_api_apps_v1beta2_StatefulSetUpdateStrategy(ref), + "k8s.io/api/authentication/v1.BoundObjectReference": schema_k8sio_api_authentication_v1_BoundObjectReference(ref), + "k8s.io/api/authentication/v1.SelfSubjectReview": schema_k8sio_api_authentication_v1_SelfSubjectReview(ref), + "k8s.io/api/authentication/v1.SelfSubjectReviewStatus": schema_k8sio_api_authentication_v1_SelfSubjectReviewStatus(ref), + "k8s.io/api/authentication/v1.TokenRequest": schema_k8sio_api_authentication_v1_TokenRequest(ref), + "k8s.io/api/authentication/v1.TokenRequestSpec": schema_k8sio_api_authentication_v1_TokenRequestSpec(ref), + "k8s.io/api/authentication/v1.TokenRequestStatus": schema_k8sio_api_authentication_v1_TokenRequestStatus(ref), + "k8s.io/api/authentication/v1.TokenReview": schema_k8sio_api_authentication_v1_TokenReview(ref), + "k8s.io/api/authentication/v1.TokenReviewSpec": schema_k8sio_api_authentication_v1_TokenReviewSpec(ref), + "k8s.io/api/authentication/v1.TokenReviewStatus": schema_k8sio_api_authentication_v1_TokenReviewStatus(ref), + "k8s.io/api/authentication/v1.UserInfo": schema_k8sio_api_authentication_v1_UserInfo(ref), + "k8s.io/api/authentication/v1alpha1.SelfSubjectReview": schema_k8sio_api_authentication_v1alpha1_SelfSubjectReview(ref), + "k8s.io/api/authentication/v1alpha1.SelfSubjectReviewStatus": schema_k8sio_api_authentication_v1alpha1_SelfSubjectReviewStatus(ref), + "k8s.io/api/authentication/v1beta1.SelfSubjectReview": schema_k8sio_api_authentication_v1beta1_SelfSubjectReview(ref), + "k8s.io/api/authentication/v1beta1.SelfSubjectReviewStatus": schema_k8sio_api_authentication_v1beta1_SelfSubjectReviewStatus(ref), + "k8s.io/api/authentication/v1beta1.TokenReview": schema_k8sio_api_authentication_v1beta1_TokenReview(ref), + "k8s.io/api/authentication/v1beta1.TokenReviewSpec": schema_k8sio_api_authentication_v1beta1_TokenReviewSpec(ref), + "k8s.io/api/authentication/v1beta1.TokenReviewStatus": schema_k8sio_api_authentication_v1beta1_TokenReviewStatus(ref), + "k8s.io/api/authentication/v1beta1.UserInfo": schema_k8sio_api_authentication_v1beta1_UserInfo(ref), + "k8s.io/api/authorization/v1.LocalSubjectAccessReview": schema_k8sio_api_authorization_v1_LocalSubjectAccessReview(ref), + "k8s.io/api/authorization/v1.NonResourceAttributes": schema_k8sio_api_authorization_v1_NonResourceAttributes(ref), + "k8s.io/api/authorization/v1.NonResourceRule": schema_k8sio_api_authorization_v1_NonResourceRule(ref), + "k8s.io/api/authorization/v1.ResourceAttributes": schema_k8sio_api_authorization_v1_ResourceAttributes(ref), + "k8s.io/api/authorization/v1.ResourceRule": schema_k8sio_api_authorization_v1_ResourceRule(ref), + "k8s.io/api/authorization/v1.SelfSubjectAccessReview": schema_k8sio_api_authorization_v1_SelfSubjectAccessReview(ref), + "k8s.io/api/authorization/v1.SelfSubjectAccessReviewSpec": schema_k8sio_api_authorization_v1_SelfSubjectAccessReviewSpec(ref), + "k8s.io/api/authorization/v1.SelfSubjectRulesReview": schema_k8sio_api_authorization_v1_SelfSubjectRulesReview(ref), + "k8s.io/api/authorization/v1.SelfSubjectRulesReviewSpec": schema_k8sio_api_authorization_v1_SelfSubjectRulesReviewSpec(ref), + "k8s.io/api/authorization/v1.SubjectAccessReview": schema_k8sio_api_authorization_v1_SubjectAccessReview(ref), + "k8s.io/api/authorization/v1.SubjectAccessReviewSpec": schema_k8sio_api_authorization_v1_SubjectAccessReviewSpec(ref), + "k8s.io/api/authorization/v1.SubjectAccessReviewStatus": schema_k8sio_api_authorization_v1_SubjectAccessReviewStatus(ref), + "k8s.io/api/authorization/v1.SubjectRulesReviewStatus": schema_k8sio_api_authorization_v1_SubjectRulesReviewStatus(ref), + "k8s.io/api/authorization/v1beta1.LocalSubjectAccessReview": schema_k8sio_api_authorization_v1beta1_LocalSubjectAccessReview(ref), + "k8s.io/api/authorization/v1beta1.NonResourceAttributes": schema_k8sio_api_authorization_v1beta1_NonResourceAttributes(ref), + "k8s.io/api/authorization/v1beta1.NonResourceRule": schema_k8sio_api_authorization_v1beta1_NonResourceRule(ref), + "k8s.io/api/authorization/v1beta1.ResourceAttributes": schema_k8sio_api_authorization_v1beta1_ResourceAttributes(ref), + "k8s.io/api/authorization/v1beta1.ResourceRule": schema_k8sio_api_authorization_v1beta1_ResourceRule(ref), + "k8s.io/api/authorization/v1beta1.SelfSubjectAccessReview": schema_k8sio_api_authorization_v1beta1_SelfSubjectAccessReview(ref), + "k8s.io/api/authorization/v1beta1.SelfSubjectAccessReviewSpec": schema_k8sio_api_authorization_v1beta1_SelfSubjectAccessReviewSpec(ref), + "k8s.io/api/authorization/v1beta1.SelfSubjectRulesReview": schema_k8sio_api_authorization_v1beta1_SelfSubjectRulesReview(ref), + "k8s.io/api/authorization/v1beta1.SelfSubjectRulesReviewSpec": schema_k8sio_api_authorization_v1beta1_SelfSubjectRulesReviewSpec(ref), + "k8s.io/api/authorization/v1beta1.SubjectAccessReview": schema_k8sio_api_authorization_v1beta1_SubjectAccessReview(ref), + "k8s.io/api/authorization/v1beta1.SubjectAccessReviewSpec": schema_k8sio_api_authorization_v1beta1_SubjectAccessReviewSpec(ref), + "k8s.io/api/authorization/v1beta1.SubjectAccessReviewStatus": schema_k8sio_api_authorization_v1beta1_SubjectAccessReviewStatus(ref), + "k8s.io/api/authorization/v1beta1.SubjectRulesReviewStatus": schema_k8sio_api_authorization_v1beta1_SubjectRulesReviewStatus(ref), + "k8s.io/api/autoscaling/v1.ContainerResourceMetricSource": schema_k8sio_api_autoscaling_v1_ContainerResourceMetricSource(ref), + "k8s.io/api/autoscaling/v1.ContainerResourceMetricStatus": schema_k8sio_api_autoscaling_v1_ContainerResourceMetricStatus(ref), + "k8s.io/api/autoscaling/v1.CrossVersionObjectReference": schema_k8sio_api_autoscaling_v1_CrossVersionObjectReference(ref), + "k8s.io/api/autoscaling/v1.ExternalMetricSource": schema_k8sio_api_autoscaling_v1_ExternalMetricSource(ref), + "k8s.io/api/autoscaling/v1.ExternalMetricStatus": schema_k8sio_api_autoscaling_v1_ExternalMetricStatus(ref), + "k8s.io/api/autoscaling/v1.HorizontalPodAutoscaler": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscaler(ref), + "k8s.io/api/autoscaling/v1.HorizontalPodAutoscalerCondition": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscalerCondition(ref), + "k8s.io/api/autoscaling/v1.HorizontalPodAutoscalerList": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscalerList(ref), + "k8s.io/api/autoscaling/v1.HorizontalPodAutoscalerSpec": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscalerSpec(ref), + "k8s.io/api/autoscaling/v1.HorizontalPodAutoscalerStatus": schema_k8sio_api_autoscaling_v1_HorizontalPodAutoscalerStatus(ref), + "k8s.io/api/autoscaling/v1.MetricSpec": schema_k8sio_api_autoscaling_v1_MetricSpec(ref), + "k8s.io/api/autoscaling/v1.MetricStatus": schema_k8sio_api_autoscaling_v1_MetricStatus(ref), + "k8s.io/api/autoscaling/v1.ObjectMetricSource": schema_k8sio_api_autoscaling_v1_ObjectMetricSource(ref), + "k8s.io/api/autoscaling/v1.ObjectMetricStatus": schema_k8sio_api_autoscaling_v1_ObjectMetricStatus(ref), + "k8s.io/api/autoscaling/v1.PodsMetricSource": schema_k8sio_api_autoscaling_v1_PodsMetricSource(ref), + "k8s.io/api/autoscaling/v1.PodsMetricStatus": schema_k8sio_api_autoscaling_v1_PodsMetricStatus(ref), + "k8s.io/api/autoscaling/v1.ResourceMetricSource": schema_k8sio_api_autoscaling_v1_ResourceMetricSource(ref), + "k8s.io/api/autoscaling/v1.ResourceMetricStatus": schema_k8sio_api_autoscaling_v1_ResourceMetricStatus(ref), + "k8s.io/api/autoscaling/v1.Scale": schema_k8sio_api_autoscaling_v1_Scale(ref), + "k8s.io/api/autoscaling/v1.ScaleSpec": schema_k8sio_api_autoscaling_v1_ScaleSpec(ref), + "k8s.io/api/autoscaling/v1.ScaleStatus": schema_k8sio_api_autoscaling_v1_ScaleStatus(ref), + "k8s.io/api/autoscaling/v2.ContainerResourceMetricSource": schema_k8sio_api_autoscaling_v2_ContainerResourceMetricSource(ref), + "k8s.io/api/autoscaling/v2.ContainerResourceMetricStatus": schema_k8sio_api_autoscaling_v2_ContainerResourceMetricStatus(ref), + "k8s.io/api/autoscaling/v2.CrossVersionObjectReference": schema_k8sio_api_autoscaling_v2_CrossVersionObjectReference(ref), + "k8s.io/api/autoscaling/v2.ExternalMetricSource": schema_k8sio_api_autoscaling_v2_ExternalMetricSource(ref), + "k8s.io/api/autoscaling/v2.ExternalMetricStatus": schema_k8sio_api_autoscaling_v2_ExternalMetricStatus(ref), + "k8s.io/api/autoscaling/v2.HPAScalingPolicy": schema_k8sio_api_autoscaling_v2_HPAScalingPolicy(ref), + "k8s.io/api/autoscaling/v2.HPAScalingRules": schema_k8sio_api_autoscaling_v2_HPAScalingRules(ref), + "k8s.io/api/autoscaling/v2.HorizontalPodAutoscaler": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscaler(ref), + "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerBehavior": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerBehavior(ref), + "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerCondition": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerCondition(ref), + "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerList": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerList(ref), + "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerSpec": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerSpec(ref), + "k8s.io/api/autoscaling/v2.HorizontalPodAutoscalerStatus": schema_k8sio_api_autoscaling_v2_HorizontalPodAutoscalerStatus(ref), + "k8s.io/api/autoscaling/v2.MetricIdentifier": schema_k8sio_api_autoscaling_v2_MetricIdentifier(ref), + "k8s.io/api/autoscaling/v2.MetricSpec": schema_k8sio_api_autoscaling_v2_MetricSpec(ref), + "k8s.io/api/autoscaling/v2.MetricStatus": schema_k8sio_api_autoscaling_v2_MetricStatus(ref), + "k8s.io/api/autoscaling/v2.MetricTarget": schema_k8sio_api_autoscaling_v2_MetricTarget(ref), + "k8s.io/api/autoscaling/v2.MetricValueStatus": schema_k8sio_api_autoscaling_v2_MetricValueStatus(ref), + "k8s.io/api/autoscaling/v2.ObjectMetricSource": schema_k8sio_api_autoscaling_v2_ObjectMetricSource(ref), + "k8s.io/api/autoscaling/v2.ObjectMetricStatus": schema_k8sio_api_autoscaling_v2_ObjectMetricStatus(ref), + "k8s.io/api/autoscaling/v2.PodsMetricSource": schema_k8sio_api_autoscaling_v2_PodsMetricSource(ref), + "k8s.io/api/autoscaling/v2.PodsMetricStatus": schema_k8sio_api_autoscaling_v2_PodsMetricStatus(ref), + "k8s.io/api/autoscaling/v2.ResourceMetricSource": schema_k8sio_api_autoscaling_v2_ResourceMetricSource(ref), + "k8s.io/api/autoscaling/v2.ResourceMetricStatus": schema_k8sio_api_autoscaling_v2_ResourceMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta1.ContainerResourceMetricSource": schema_k8sio_api_autoscaling_v2beta1_ContainerResourceMetricSource(ref), + "k8s.io/api/autoscaling/v2beta1.ContainerResourceMetricStatus": schema_k8sio_api_autoscaling_v2beta1_ContainerResourceMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta1.CrossVersionObjectReference": schema_k8sio_api_autoscaling_v2beta1_CrossVersionObjectReference(ref), + "k8s.io/api/autoscaling/v2beta1.ExternalMetricSource": schema_k8sio_api_autoscaling_v2beta1_ExternalMetricSource(ref), + "k8s.io/api/autoscaling/v2beta1.ExternalMetricStatus": schema_k8sio_api_autoscaling_v2beta1_ExternalMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscaler": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscaler(ref), + "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscalerCondition": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscalerCondition(ref), + "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscalerList": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscalerList(ref), + "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscalerSpec": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscalerSpec(ref), + "k8s.io/api/autoscaling/v2beta1.HorizontalPodAutoscalerStatus": schema_k8sio_api_autoscaling_v2beta1_HorizontalPodAutoscalerStatus(ref), + "k8s.io/api/autoscaling/v2beta1.MetricSpec": schema_k8sio_api_autoscaling_v2beta1_MetricSpec(ref), + "k8s.io/api/autoscaling/v2beta1.MetricStatus": schema_k8sio_api_autoscaling_v2beta1_MetricStatus(ref), + "k8s.io/api/autoscaling/v2beta1.ObjectMetricSource": schema_k8sio_api_autoscaling_v2beta1_ObjectMetricSource(ref), + "k8s.io/api/autoscaling/v2beta1.ObjectMetricStatus": schema_k8sio_api_autoscaling_v2beta1_ObjectMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta1.PodsMetricSource": schema_k8sio_api_autoscaling_v2beta1_PodsMetricSource(ref), + "k8s.io/api/autoscaling/v2beta1.PodsMetricStatus": schema_k8sio_api_autoscaling_v2beta1_PodsMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta1.ResourceMetricSource": schema_k8sio_api_autoscaling_v2beta1_ResourceMetricSource(ref), + "k8s.io/api/autoscaling/v2beta1.ResourceMetricStatus": schema_k8sio_api_autoscaling_v2beta1_ResourceMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta2.ContainerResourceMetricSource": schema_k8sio_api_autoscaling_v2beta2_ContainerResourceMetricSource(ref), + "k8s.io/api/autoscaling/v2beta2.ContainerResourceMetricStatus": schema_k8sio_api_autoscaling_v2beta2_ContainerResourceMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta2.CrossVersionObjectReference": schema_k8sio_api_autoscaling_v2beta2_CrossVersionObjectReference(ref), + "k8s.io/api/autoscaling/v2beta2.ExternalMetricSource": schema_k8sio_api_autoscaling_v2beta2_ExternalMetricSource(ref), + "k8s.io/api/autoscaling/v2beta2.ExternalMetricStatus": schema_k8sio_api_autoscaling_v2beta2_ExternalMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta2.HPAScalingPolicy": schema_k8sio_api_autoscaling_v2beta2_HPAScalingPolicy(ref), + "k8s.io/api/autoscaling/v2beta2.HPAScalingRules": schema_k8sio_api_autoscaling_v2beta2_HPAScalingRules(ref), + "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscaler": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscaler(ref), + "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerBehavior": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerBehavior(ref), + "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerCondition": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerCondition(ref), + "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerList": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerList(ref), + "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerSpec": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerSpec(ref), + "k8s.io/api/autoscaling/v2beta2.HorizontalPodAutoscalerStatus": schema_k8sio_api_autoscaling_v2beta2_HorizontalPodAutoscalerStatus(ref), + "k8s.io/api/autoscaling/v2beta2.MetricIdentifier": schema_k8sio_api_autoscaling_v2beta2_MetricIdentifier(ref), + "k8s.io/api/autoscaling/v2beta2.MetricSpec": schema_k8sio_api_autoscaling_v2beta2_MetricSpec(ref), + "k8s.io/api/autoscaling/v2beta2.MetricStatus": schema_k8sio_api_autoscaling_v2beta2_MetricStatus(ref), + "k8s.io/api/autoscaling/v2beta2.MetricTarget": schema_k8sio_api_autoscaling_v2beta2_MetricTarget(ref), + "k8s.io/api/autoscaling/v2beta2.MetricValueStatus": schema_k8sio_api_autoscaling_v2beta2_MetricValueStatus(ref), + "k8s.io/api/autoscaling/v2beta2.ObjectMetricSource": schema_k8sio_api_autoscaling_v2beta2_ObjectMetricSource(ref), + "k8s.io/api/autoscaling/v2beta2.ObjectMetricStatus": schema_k8sio_api_autoscaling_v2beta2_ObjectMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta2.PodsMetricSource": schema_k8sio_api_autoscaling_v2beta2_PodsMetricSource(ref), + "k8s.io/api/autoscaling/v2beta2.PodsMetricStatus": schema_k8sio_api_autoscaling_v2beta2_PodsMetricStatus(ref), + "k8s.io/api/autoscaling/v2beta2.ResourceMetricSource": schema_k8sio_api_autoscaling_v2beta2_ResourceMetricSource(ref), + "k8s.io/api/autoscaling/v2beta2.ResourceMetricStatus": schema_k8sio_api_autoscaling_v2beta2_ResourceMetricStatus(ref), + "k8s.io/api/batch/v1.CronJob": schema_k8sio_api_batch_v1_CronJob(ref), + "k8s.io/api/batch/v1.CronJobList": schema_k8sio_api_batch_v1_CronJobList(ref), + "k8s.io/api/batch/v1.CronJobSpec": schema_k8sio_api_batch_v1_CronJobSpec(ref), + "k8s.io/api/batch/v1.CronJobStatus": schema_k8sio_api_batch_v1_CronJobStatus(ref), + "k8s.io/api/batch/v1.Job": schema_k8sio_api_batch_v1_Job(ref), + "k8s.io/api/batch/v1.JobCondition": schema_k8sio_api_batch_v1_JobCondition(ref), + "k8s.io/api/batch/v1.JobList": schema_k8sio_api_batch_v1_JobList(ref), + "k8s.io/api/batch/v1.JobSpec": schema_k8sio_api_batch_v1_JobSpec(ref), + "k8s.io/api/batch/v1.JobStatus": schema_k8sio_api_batch_v1_JobStatus(ref), + "k8s.io/api/batch/v1.JobTemplateSpec": schema_k8sio_api_batch_v1_JobTemplateSpec(ref), + "k8s.io/api/batch/v1.PodFailurePolicy": schema_k8sio_api_batch_v1_PodFailurePolicy(ref), + "k8s.io/api/batch/v1.PodFailurePolicyOnExitCodesRequirement": schema_k8sio_api_batch_v1_PodFailurePolicyOnExitCodesRequirement(ref), + "k8s.io/api/batch/v1.PodFailurePolicyOnPodConditionsPattern": schema_k8sio_api_batch_v1_PodFailurePolicyOnPodConditionsPattern(ref), + "k8s.io/api/batch/v1.PodFailurePolicyRule": schema_k8sio_api_batch_v1_PodFailurePolicyRule(ref), + "k8s.io/api/batch/v1.UncountedTerminatedPods": schema_k8sio_api_batch_v1_UncountedTerminatedPods(ref), + "k8s.io/api/batch/v1beta1.CronJob": schema_k8sio_api_batch_v1beta1_CronJob(ref), + "k8s.io/api/batch/v1beta1.CronJobList": schema_k8sio_api_batch_v1beta1_CronJobList(ref), + "k8s.io/api/batch/v1beta1.CronJobSpec": schema_k8sio_api_batch_v1beta1_CronJobSpec(ref), + "k8s.io/api/batch/v1beta1.CronJobStatus": schema_k8sio_api_batch_v1beta1_CronJobStatus(ref), + "k8s.io/api/batch/v1beta1.JobTemplateSpec": schema_k8sio_api_batch_v1beta1_JobTemplateSpec(ref), + "k8s.io/api/certificates/v1.CertificateSigningRequest": schema_k8sio_api_certificates_v1_CertificateSigningRequest(ref), + "k8s.io/api/certificates/v1.CertificateSigningRequestCondition": schema_k8sio_api_certificates_v1_CertificateSigningRequestCondition(ref), + "k8s.io/api/certificates/v1.CertificateSigningRequestList": schema_k8sio_api_certificates_v1_CertificateSigningRequestList(ref), + "k8s.io/api/certificates/v1.CertificateSigningRequestSpec": schema_k8sio_api_certificates_v1_CertificateSigningRequestSpec(ref), + "k8s.io/api/certificates/v1.CertificateSigningRequestStatus": schema_k8sio_api_certificates_v1_CertificateSigningRequestStatus(ref), + "k8s.io/api/certificates/v1alpha1.ClusterTrustBundle": schema_k8sio_api_certificates_v1alpha1_ClusterTrustBundle(ref), + "k8s.io/api/certificates/v1alpha1.ClusterTrustBundleList": schema_k8sio_api_certificates_v1alpha1_ClusterTrustBundleList(ref), + "k8s.io/api/certificates/v1alpha1.ClusterTrustBundleSpec": schema_k8sio_api_certificates_v1alpha1_ClusterTrustBundleSpec(ref), + "k8s.io/api/certificates/v1beta1.CertificateSigningRequest": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequest(ref), + "k8s.io/api/certificates/v1beta1.CertificateSigningRequestCondition": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequestCondition(ref), + "k8s.io/api/certificates/v1beta1.CertificateSigningRequestList": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequestList(ref), + "k8s.io/api/certificates/v1beta1.CertificateSigningRequestSpec": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequestSpec(ref), + "k8s.io/api/certificates/v1beta1.CertificateSigningRequestStatus": schema_k8sio_api_certificates_v1beta1_CertificateSigningRequestStatus(ref), + "k8s.io/api/coordination/v1.Lease": schema_k8sio_api_coordination_v1_Lease(ref), + "k8s.io/api/coordination/v1.LeaseList": schema_k8sio_api_coordination_v1_LeaseList(ref), + "k8s.io/api/coordination/v1.LeaseSpec": schema_k8sio_api_coordination_v1_LeaseSpec(ref), + "k8s.io/api/coordination/v1beta1.Lease": schema_k8sio_api_coordination_v1beta1_Lease(ref), + "k8s.io/api/coordination/v1beta1.LeaseList": schema_k8sio_api_coordination_v1beta1_LeaseList(ref), + "k8s.io/api/coordination/v1beta1.LeaseSpec": schema_k8sio_api_coordination_v1beta1_LeaseSpec(ref), + "k8s.io/api/core/v1.AWSElasticBlockStoreVolumeSource": schema_k8sio_api_core_v1_AWSElasticBlockStoreVolumeSource(ref), + "k8s.io/api/core/v1.Affinity": schema_k8sio_api_core_v1_Affinity(ref), + "k8s.io/api/core/v1.AttachedVolume": schema_k8sio_api_core_v1_AttachedVolume(ref), + "k8s.io/api/core/v1.AvoidPods": schema_k8sio_api_core_v1_AvoidPods(ref), + "k8s.io/api/core/v1.AzureDiskVolumeSource": schema_k8sio_api_core_v1_AzureDiskVolumeSource(ref), + "k8s.io/api/core/v1.AzureFilePersistentVolumeSource": schema_k8sio_api_core_v1_AzureFilePersistentVolumeSource(ref), + "k8s.io/api/core/v1.AzureFileVolumeSource": schema_k8sio_api_core_v1_AzureFileVolumeSource(ref), + "k8s.io/api/core/v1.Binding": schema_k8sio_api_core_v1_Binding(ref), + "k8s.io/api/core/v1.CSIPersistentVolumeSource": schema_k8sio_api_core_v1_CSIPersistentVolumeSource(ref), + "k8s.io/api/core/v1.CSIVolumeSource": schema_k8sio_api_core_v1_CSIVolumeSource(ref), + "k8s.io/api/core/v1.Capabilities": schema_k8sio_api_core_v1_Capabilities(ref), + "k8s.io/api/core/v1.CephFSPersistentVolumeSource": schema_k8sio_api_core_v1_CephFSPersistentVolumeSource(ref), + "k8s.io/api/core/v1.CephFSVolumeSource": schema_k8sio_api_core_v1_CephFSVolumeSource(ref), + "k8s.io/api/core/v1.CinderPersistentVolumeSource": schema_k8sio_api_core_v1_CinderPersistentVolumeSource(ref), + "k8s.io/api/core/v1.CinderVolumeSource": schema_k8sio_api_core_v1_CinderVolumeSource(ref), + "k8s.io/api/core/v1.ClaimSource": schema_k8sio_api_core_v1_ClaimSource(ref), + "k8s.io/api/core/v1.ClientIPConfig": schema_k8sio_api_core_v1_ClientIPConfig(ref), + "k8s.io/api/core/v1.ComponentCondition": schema_k8sio_api_core_v1_ComponentCondition(ref), + "k8s.io/api/core/v1.ComponentStatus": schema_k8sio_api_core_v1_ComponentStatus(ref), + "k8s.io/api/core/v1.ComponentStatusList": schema_k8sio_api_core_v1_ComponentStatusList(ref), + "k8s.io/api/core/v1.ConfigMap": schema_k8sio_api_core_v1_ConfigMap(ref), + "k8s.io/api/core/v1.ConfigMapEnvSource": schema_k8sio_api_core_v1_ConfigMapEnvSource(ref), + "k8s.io/api/core/v1.ConfigMapKeySelector": schema_k8sio_api_core_v1_ConfigMapKeySelector(ref), + "k8s.io/api/core/v1.ConfigMapList": schema_k8sio_api_core_v1_ConfigMapList(ref), + "k8s.io/api/core/v1.ConfigMapNodeConfigSource": schema_k8sio_api_core_v1_ConfigMapNodeConfigSource(ref), + "k8s.io/api/core/v1.ConfigMapProjection": schema_k8sio_api_core_v1_ConfigMapProjection(ref), + "k8s.io/api/core/v1.ConfigMapVolumeSource": schema_k8sio_api_core_v1_ConfigMapVolumeSource(ref), + "k8s.io/api/core/v1.Container": schema_k8sio_api_core_v1_Container(ref), + "k8s.io/api/core/v1.ContainerImage": schema_k8sio_api_core_v1_ContainerImage(ref), + "k8s.io/api/core/v1.ContainerPort": schema_k8sio_api_core_v1_ContainerPort(ref), + "k8s.io/api/core/v1.ContainerResizePolicy": schema_k8sio_api_core_v1_ContainerResizePolicy(ref), + "k8s.io/api/core/v1.ContainerState": schema_k8sio_api_core_v1_ContainerState(ref), + "k8s.io/api/core/v1.ContainerStateRunning": schema_k8sio_api_core_v1_ContainerStateRunning(ref), + "k8s.io/api/core/v1.ContainerStateTerminated": schema_k8sio_api_core_v1_ContainerStateTerminated(ref), + "k8s.io/api/core/v1.ContainerStateWaiting": schema_k8sio_api_core_v1_ContainerStateWaiting(ref), + "k8s.io/api/core/v1.ContainerStatus": schema_k8sio_api_core_v1_ContainerStatus(ref), + "k8s.io/api/core/v1.DaemonEndpoint": schema_k8sio_api_core_v1_DaemonEndpoint(ref), + "k8s.io/api/core/v1.DownwardAPIProjection": schema_k8sio_api_core_v1_DownwardAPIProjection(ref), + "k8s.io/api/core/v1.DownwardAPIVolumeFile": schema_k8sio_api_core_v1_DownwardAPIVolumeFile(ref), + "k8s.io/api/core/v1.DownwardAPIVolumeSource": schema_k8sio_api_core_v1_DownwardAPIVolumeSource(ref), + "k8s.io/api/core/v1.EmptyDirVolumeSource": schema_k8sio_api_core_v1_EmptyDirVolumeSource(ref), + "k8s.io/api/core/v1.EndpointAddress": schema_k8sio_api_core_v1_EndpointAddress(ref), + "k8s.io/api/core/v1.EndpointPort": schema_k8sio_api_core_v1_EndpointPort(ref), + "k8s.io/api/core/v1.EndpointSubset": schema_k8sio_api_core_v1_EndpointSubset(ref), + "k8s.io/api/core/v1.Endpoints": schema_k8sio_api_core_v1_Endpoints(ref), + "k8s.io/api/core/v1.EndpointsList": schema_k8sio_api_core_v1_EndpointsList(ref), + "k8s.io/api/core/v1.EnvFromSource": schema_k8sio_api_core_v1_EnvFromSource(ref), + "k8s.io/api/core/v1.EnvVar": schema_k8sio_api_core_v1_EnvVar(ref), + "k8s.io/api/core/v1.EnvVarSource": schema_k8sio_api_core_v1_EnvVarSource(ref), + "k8s.io/api/core/v1.EphemeralContainer": schema_k8sio_api_core_v1_EphemeralContainer(ref), + "k8s.io/api/core/v1.EphemeralContainerCommon": schema_k8sio_api_core_v1_EphemeralContainerCommon(ref), + "k8s.io/api/core/v1.EphemeralVolumeSource": schema_k8sio_api_core_v1_EphemeralVolumeSource(ref), + "k8s.io/api/core/v1.Event": schema_k8sio_api_core_v1_Event(ref), + "k8s.io/api/core/v1.EventList": schema_k8sio_api_core_v1_EventList(ref), + "k8s.io/api/core/v1.EventSeries": schema_k8sio_api_core_v1_EventSeries(ref), + "k8s.io/api/core/v1.EventSource": schema_k8sio_api_core_v1_EventSource(ref), + "k8s.io/api/core/v1.ExecAction": schema_k8sio_api_core_v1_ExecAction(ref), + "k8s.io/api/core/v1.FCVolumeSource": schema_k8sio_api_core_v1_FCVolumeSource(ref), + "k8s.io/api/core/v1.FlexPersistentVolumeSource": schema_k8sio_api_core_v1_FlexPersistentVolumeSource(ref), + "k8s.io/api/core/v1.FlexVolumeSource": schema_k8sio_api_core_v1_FlexVolumeSource(ref), + "k8s.io/api/core/v1.FlockerVolumeSource": schema_k8sio_api_core_v1_FlockerVolumeSource(ref), + "k8s.io/api/core/v1.GCEPersistentDiskVolumeSource": schema_k8sio_api_core_v1_GCEPersistentDiskVolumeSource(ref), + "k8s.io/api/core/v1.GRPCAction": schema_k8sio_api_core_v1_GRPCAction(ref), + "k8s.io/api/core/v1.GitRepoVolumeSource": schema_k8sio_api_core_v1_GitRepoVolumeSource(ref), + "k8s.io/api/core/v1.GlusterfsPersistentVolumeSource": schema_k8sio_api_core_v1_GlusterfsPersistentVolumeSource(ref), + "k8s.io/api/core/v1.GlusterfsVolumeSource": schema_k8sio_api_core_v1_GlusterfsVolumeSource(ref), + "k8s.io/api/core/v1.HTTPGetAction": schema_k8sio_api_core_v1_HTTPGetAction(ref), + "k8s.io/api/core/v1.HTTPHeader": schema_k8sio_api_core_v1_HTTPHeader(ref), + "k8s.io/api/core/v1.HostAlias": schema_k8sio_api_core_v1_HostAlias(ref), + "k8s.io/api/core/v1.HostPathVolumeSource": schema_k8sio_api_core_v1_HostPathVolumeSource(ref), + "k8s.io/api/core/v1.ISCSIPersistentVolumeSource": schema_k8sio_api_core_v1_ISCSIPersistentVolumeSource(ref), + "k8s.io/api/core/v1.ISCSIVolumeSource": schema_k8sio_api_core_v1_ISCSIVolumeSource(ref), + "k8s.io/api/core/v1.KeyToPath": schema_k8sio_api_core_v1_KeyToPath(ref), + "k8s.io/api/core/v1.Lifecycle": schema_k8sio_api_core_v1_Lifecycle(ref), + "k8s.io/api/core/v1.LifecycleHandler": schema_k8sio_api_core_v1_LifecycleHandler(ref), + "k8s.io/api/core/v1.LimitRange": schema_k8sio_api_core_v1_LimitRange(ref), + "k8s.io/api/core/v1.LimitRangeItem": schema_k8sio_api_core_v1_LimitRangeItem(ref), + "k8s.io/api/core/v1.LimitRangeList": schema_k8sio_api_core_v1_LimitRangeList(ref), + "k8s.io/api/core/v1.LimitRangeSpec": schema_k8sio_api_core_v1_LimitRangeSpec(ref), + "k8s.io/api/core/v1.List": schema_k8sio_api_core_v1_List(ref), + "k8s.io/api/core/v1.LoadBalancerIngress": schema_k8sio_api_core_v1_LoadBalancerIngress(ref), + "k8s.io/api/core/v1.LoadBalancerStatus": schema_k8sio_api_core_v1_LoadBalancerStatus(ref), + "k8s.io/api/core/v1.LocalObjectReference": schema_k8sio_api_core_v1_LocalObjectReference(ref), + "k8s.io/api/core/v1.LocalVolumeSource": schema_k8sio_api_core_v1_LocalVolumeSource(ref), + "k8s.io/api/core/v1.NFSVolumeSource": schema_k8sio_api_core_v1_NFSVolumeSource(ref), + "k8s.io/api/core/v1.Namespace": schema_k8sio_api_core_v1_Namespace(ref), + "k8s.io/api/core/v1.NamespaceCondition": schema_k8sio_api_core_v1_NamespaceCondition(ref), + "k8s.io/api/core/v1.NamespaceList": schema_k8sio_api_core_v1_NamespaceList(ref), + "k8s.io/api/core/v1.NamespaceSpec": schema_k8sio_api_core_v1_NamespaceSpec(ref), + "k8s.io/api/core/v1.NamespaceStatus": schema_k8sio_api_core_v1_NamespaceStatus(ref), + "k8s.io/api/core/v1.Node": schema_k8sio_api_core_v1_Node(ref), + "k8s.io/api/core/v1.NodeAddress": schema_k8sio_api_core_v1_NodeAddress(ref), + "k8s.io/api/core/v1.NodeAffinity": schema_k8sio_api_core_v1_NodeAffinity(ref), + "k8s.io/api/core/v1.NodeCondition": schema_k8sio_api_core_v1_NodeCondition(ref), + "k8s.io/api/core/v1.NodeConfigSource": schema_k8sio_api_core_v1_NodeConfigSource(ref), + "k8s.io/api/core/v1.NodeConfigStatus": schema_k8sio_api_core_v1_NodeConfigStatus(ref), + "k8s.io/api/core/v1.NodeDaemonEndpoints": schema_k8sio_api_core_v1_NodeDaemonEndpoints(ref), + "k8s.io/api/core/v1.NodeList": schema_k8sio_api_core_v1_NodeList(ref), + "k8s.io/api/core/v1.NodeProxyOptions": schema_k8sio_api_core_v1_NodeProxyOptions(ref), + "k8s.io/api/core/v1.NodeResources": schema_k8sio_api_core_v1_NodeResources(ref), + "k8s.io/api/core/v1.NodeSelector": schema_k8sio_api_core_v1_NodeSelector(ref), + "k8s.io/api/core/v1.NodeSelectorRequirement": schema_k8sio_api_core_v1_NodeSelectorRequirement(ref), + "k8s.io/api/core/v1.NodeSelectorTerm": schema_k8sio_api_core_v1_NodeSelectorTerm(ref), + "k8s.io/api/core/v1.NodeSpec": schema_k8sio_api_core_v1_NodeSpec(ref), + "k8s.io/api/core/v1.NodeStatus": schema_k8sio_api_core_v1_NodeStatus(ref), + "k8s.io/api/core/v1.NodeSystemInfo": schema_k8sio_api_core_v1_NodeSystemInfo(ref), + "k8s.io/api/core/v1.ObjectFieldSelector": schema_k8sio_api_core_v1_ObjectFieldSelector(ref), + "k8s.io/api/core/v1.ObjectReference": schema_k8sio_api_core_v1_ObjectReference(ref), + "k8s.io/api/core/v1.PersistentVolume": schema_k8sio_api_core_v1_PersistentVolume(ref), + "k8s.io/api/core/v1.PersistentVolumeClaim": schema_k8sio_api_core_v1_PersistentVolumeClaim(ref), + "k8s.io/api/core/v1.PersistentVolumeClaimCondition": schema_k8sio_api_core_v1_PersistentVolumeClaimCondition(ref), + "k8s.io/api/core/v1.PersistentVolumeClaimList": schema_k8sio_api_core_v1_PersistentVolumeClaimList(ref), + "k8s.io/api/core/v1.PersistentVolumeClaimSpec": schema_k8sio_api_core_v1_PersistentVolumeClaimSpec(ref), + "k8s.io/api/core/v1.PersistentVolumeClaimStatus": schema_k8sio_api_core_v1_PersistentVolumeClaimStatus(ref), + "k8s.io/api/core/v1.PersistentVolumeClaimTemplate": schema_k8sio_api_core_v1_PersistentVolumeClaimTemplate(ref), + "k8s.io/api/core/v1.PersistentVolumeClaimVolumeSource": schema_k8sio_api_core_v1_PersistentVolumeClaimVolumeSource(ref), + "k8s.io/api/core/v1.PersistentVolumeList": schema_k8sio_api_core_v1_PersistentVolumeList(ref), + "k8s.io/api/core/v1.PersistentVolumeSource": schema_k8sio_api_core_v1_PersistentVolumeSource(ref), + "k8s.io/api/core/v1.PersistentVolumeSpec": schema_k8sio_api_core_v1_PersistentVolumeSpec(ref), + "k8s.io/api/core/v1.PersistentVolumeStatus": schema_k8sio_api_core_v1_PersistentVolumeStatus(ref), + "k8s.io/api/core/v1.PhotonPersistentDiskVolumeSource": schema_k8sio_api_core_v1_PhotonPersistentDiskVolumeSource(ref), + "k8s.io/api/core/v1.Pod": schema_k8sio_api_core_v1_Pod(ref), + "k8s.io/api/core/v1.PodAffinity": schema_k8sio_api_core_v1_PodAffinity(ref), + "k8s.io/api/core/v1.PodAffinityTerm": schema_k8sio_api_core_v1_PodAffinityTerm(ref), + "k8s.io/api/core/v1.PodAntiAffinity": schema_k8sio_api_core_v1_PodAntiAffinity(ref), + "k8s.io/api/core/v1.PodAttachOptions": schema_k8sio_api_core_v1_PodAttachOptions(ref), + "k8s.io/api/core/v1.PodCondition": schema_k8sio_api_core_v1_PodCondition(ref), + "k8s.io/api/core/v1.PodDNSConfig": schema_k8sio_api_core_v1_PodDNSConfig(ref), + "k8s.io/api/core/v1.PodDNSConfigOption": schema_k8sio_api_core_v1_PodDNSConfigOption(ref), + "k8s.io/api/core/v1.PodExecOptions": schema_k8sio_api_core_v1_PodExecOptions(ref), + "k8s.io/api/core/v1.PodIP": schema_k8sio_api_core_v1_PodIP(ref), + "k8s.io/api/core/v1.PodList": schema_k8sio_api_core_v1_PodList(ref), + "k8s.io/api/core/v1.PodLogOptions": schema_k8sio_api_core_v1_PodLogOptions(ref), + "k8s.io/api/core/v1.PodOS": schema_k8sio_api_core_v1_PodOS(ref), + "k8s.io/api/core/v1.PodPortForwardOptions": schema_k8sio_api_core_v1_PodPortForwardOptions(ref), + "k8s.io/api/core/v1.PodProxyOptions": schema_k8sio_api_core_v1_PodProxyOptions(ref), + "k8s.io/api/core/v1.PodReadinessGate": schema_k8sio_api_core_v1_PodReadinessGate(ref), + "k8s.io/api/core/v1.PodResourceClaim": schema_k8sio_api_core_v1_PodResourceClaim(ref), + "k8s.io/api/core/v1.PodResourceClaimStatus": schema_k8sio_api_core_v1_PodResourceClaimStatus(ref), + "k8s.io/api/core/v1.PodSchedulingGate": schema_k8sio_api_core_v1_PodSchedulingGate(ref), + "k8s.io/api/core/v1.PodSecurityContext": schema_k8sio_api_core_v1_PodSecurityContext(ref), + "k8s.io/api/core/v1.PodSignature": schema_k8sio_api_core_v1_PodSignature(ref), + "k8s.io/api/core/v1.PodSpec": schema_k8sio_api_core_v1_PodSpec(ref), + "k8s.io/api/core/v1.PodStatus": schema_k8sio_api_core_v1_PodStatus(ref), + "k8s.io/api/core/v1.PodStatusResult": schema_k8sio_api_core_v1_PodStatusResult(ref), + "k8s.io/api/core/v1.PodTemplate": schema_k8sio_api_core_v1_PodTemplate(ref), + "k8s.io/api/core/v1.PodTemplateList": schema_k8sio_api_core_v1_PodTemplateList(ref), + "k8s.io/api/core/v1.PodTemplateSpec": schema_k8sio_api_core_v1_PodTemplateSpec(ref), + "k8s.io/api/core/v1.PortStatus": schema_k8sio_api_core_v1_PortStatus(ref), + "k8s.io/api/core/v1.PortworxVolumeSource": schema_k8sio_api_core_v1_PortworxVolumeSource(ref), + "k8s.io/api/core/v1.PreferAvoidPodsEntry": schema_k8sio_api_core_v1_PreferAvoidPodsEntry(ref), + "k8s.io/api/core/v1.PreferredSchedulingTerm": schema_k8sio_api_core_v1_PreferredSchedulingTerm(ref), + "k8s.io/api/core/v1.Probe": schema_k8sio_api_core_v1_Probe(ref), + "k8s.io/api/core/v1.ProbeHandler": schema_k8sio_api_core_v1_ProbeHandler(ref), + "k8s.io/api/core/v1.ProjectedVolumeSource": schema_k8sio_api_core_v1_ProjectedVolumeSource(ref), + "k8s.io/api/core/v1.QuobyteVolumeSource": schema_k8sio_api_core_v1_QuobyteVolumeSource(ref), + "k8s.io/api/core/v1.RBDPersistentVolumeSource": schema_k8sio_api_core_v1_RBDPersistentVolumeSource(ref), + "k8s.io/api/core/v1.RBDVolumeSource": schema_k8sio_api_core_v1_RBDVolumeSource(ref), + "k8s.io/api/core/v1.RangeAllocation": schema_k8sio_api_core_v1_RangeAllocation(ref), + "k8s.io/api/core/v1.ReplicationController": schema_k8sio_api_core_v1_ReplicationController(ref), + "k8s.io/api/core/v1.ReplicationControllerCondition": schema_k8sio_api_core_v1_ReplicationControllerCondition(ref), + "k8s.io/api/core/v1.ReplicationControllerList": schema_k8sio_api_core_v1_ReplicationControllerList(ref), + "k8s.io/api/core/v1.ReplicationControllerSpec": schema_k8sio_api_core_v1_ReplicationControllerSpec(ref), + "k8s.io/api/core/v1.ReplicationControllerStatus": schema_k8sio_api_core_v1_ReplicationControllerStatus(ref), + "k8s.io/api/core/v1.ResourceClaim": schema_k8sio_api_core_v1_ResourceClaim(ref), + "k8s.io/api/core/v1.ResourceFieldSelector": schema_k8sio_api_core_v1_ResourceFieldSelector(ref), + "k8s.io/api/core/v1.ResourceQuota": schema_k8sio_api_core_v1_ResourceQuota(ref), + "k8s.io/api/core/v1.ResourceQuotaList": schema_k8sio_api_core_v1_ResourceQuotaList(ref), + "k8s.io/api/core/v1.ResourceQuotaSpec": schema_k8sio_api_core_v1_ResourceQuotaSpec(ref), + "k8s.io/api/core/v1.ResourceQuotaStatus": schema_k8sio_api_core_v1_ResourceQuotaStatus(ref), + "k8s.io/api/core/v1.ResourceRequirements": schema_k8sio_api_core_v1_ResourceRequirements(ref), + "k8s.io/api/core/v1.SELinuxOptions": schema_k8sio_api_core_v1_SELinuxOptions(ref), + "k8s.io/api/core/v1.ScaleIOPersistentVolumeSource": schema_k8sio_api_core_v1_ScaleIOPersistentVolumeSource(ref), + "k8s.io/api/core/v1.ScaleIOVolumeSource": schema_k8sio_api_core_v1_ScaleIOVolumeSource(ref), + "k8s.io/api/core/v1.ScopeSelector": schema_k8sio_api_core_v1_ScopeSelector(ref), + "k8s.io/api/core/v1.ScopedResourceSelectorRequirement": schema_k8sio_api_core_v1_ScopedResourceSelectorRequirement(ref), + "k8s.io/api/core/v1.SeccompProfile": schema_k8sio_api_core_v1_SeccompProfile(ref), + "k8s.io/api/core/v1.Secret": schema_k8sio_api_core_v1_Secret(ref), + "k8s.io/api/core/v1.SecretEnvSource": schema_k8sio_api_core_v1_SecretEnvSource(ref), + "k8s.io/api/core/v1.SecretKeySelector": schema_k8sio_api_core_v1_SecretKeySelector(ref), + "k8s.io/api/core/v1.SecretList": schema_k8sio_api_core_v1_SecretList(ref), + "k8s.io/api/core/v1.SecretProjection": schema_k8sio_api_core_v1_SecretProjection(ref), + "k8s.io/api/core/v1.SecretReference": schema_k8sio_api_core_v1_SecretReference(ref), + "k8s.io/api/core/v1.SecretVolumeSource": schema_k8sio_api_core_v1_SecretVolumeSource(ref), + "k8s.io/api/core/v1.SecurityContext": schema_k8sio_api_core_v1_SecurityContext(ref), + "k8s.io/api/core/v1.SerializedReference": schema_k8sio_api_core_v1_SerializedReference(ref), + "k8s.io/api/core/v1.Service": schema_k8sio_api_core_v1_Service(ref), + "k8s.io/api/core/v1.ServiceAccount": schema_k8sio_api_core_v1_ServiceAccount(ref), + "k8s.io/api/core/v1.ServiceAccountList": schema_k8sio_api_core_v1_ServiceAccountList(ref), + "k8s.io/api/core/v1.ServiceAccountTokenProjection": schema_k8sio_api_core_v1_ServiceAccountTokenProjection(ref), + "k8s.io/api/core/v1.ServiceList": schema_k8sio_api_core_v1_ServiceList(ref), + "k8s.io/api/core/v1.ServicePort": schema_k8sio_api_core_v1_ServicePort(ref), + "k8s.io/api/core/v1.ServiceProxyOptions": schema_k8sio_api_core_v1_ServiceProxyOptions(ref), + "k8s.io/api/core/v1.ServiceSpec": schema_k8sio_api_core_v1_ServiceSpec(ref), + "k8s.io/api/core/v1.ServiceStatus": schema_k8sio_api_core_v1_ServiceStatus(ref), + "k8s.io/api/core/v1.SessionAffinityConfig": schema_k8sio_api_core_v1_SessionAffinityConfig(ref), + "k8s.io/api/core/v1.StorageOSPersistentVolumeSource": schema_k8sio_api_core_v1_StorageOSPersistentVolumeSource(ref), + "k8s.io/api/core/v1.StorageOSVolumeSource": schema_k8sio_api_core_v1_StorageOSVolumeSource(ref), + "k8s.io/api/core/v1.Sysctl": schema_k8sio_api_core_v1_Sysctl(ref), + "k8s.io/api/core/v1.TCPSocketAction": schema_k8sio_api_core_v1_TCPSocketAction(ref), + "k8s.io/api/core/v1.Taint": schema_k8sio_api_core_v1_Taint(ref), + "k8s.io/api/core/v1.Toleration": schema_k8sio_api_core_v1_Toleration(ref), + "k8s.io/api/core/v1.TopologySelectorLabelRequirement": schema_k8sio_api_core_v1_TopologySelectorLabelRequirement(ref), + "k8s.io/api/core/v1.TopologySelectorTerm": schema_k8sio_api_core_v1_TopologySelectorTerm(ref), + "k8s.io/api/core/v1.TopologySpreadConstraint": schema_k8sio_api_core_v1_TopologySpreadConstraint(ref), + "k8s.io/api/core/v1.TypedLocalObjectReference": schema_k8sio_api_core_v1_TypedLocalObjectReference(ref), + "k8s.io/api/core/v1.TypedObjectReference": schema_k8sio_api_core_v1_TypedObjectReference(ref), + "k8s.io/api/core/v1.Volume": schema_k8sio_api_core_v1_Volume(ref), + "k8s.io/api/core/v1.VolumeDevice": schema_k8sio_api_core_v1_VolumeDevice(ref), + "k8s.io/api/core/v1.VolumeMount": schema_k8sio_api_core_v1_VolumeMount(ref), + "k8s.io/api/core/v1.VolumeNodeAffinity": schema_k8sio_api_core_v1_VolumeNodeAffinity(ref), + "k8s.io/api/core/v1.VolumeProjection": schema_k8sio_api_core_v1_VolumeProjection(ref), + "k8s.io/api/core/v1.VolumeSource": schema_k8sio_api_core_v1_VolumeSource(ref), + "k8s.io/api/core/v1.VsphereVirtualDiskVolumeSource": schema_k8sio_api_core_v1_VsphereVirtualDiskVolumeSource(ref), + "k8s.io/api/core/v1.WeightedPodAffinityTerm": schema_k8sio_api_core_v1_WeightedPodAffinityTerm(ref), + "k8s.io/api/core/v1.WindowsSecurityContextOptions": schema_k8sio_api_core_v1_WindowsSecurityContextOptions(ref), + "k8s.io/api/discovery/v1.Endpoint": schema_k8sio_api_discovery_v1_Endpoint(ref), + "k8s.io/api/discovery/v1.EndpointConditions": schema_k8sio_api_discovery_v1_EndpointConditions(ref), + "k8s.io/api/discovery/v1.EndpointHints": schema_k8sio_api_discovery_v1_EndpointHints(ref), + "k8s.io/api/discovery/v1.EndpointPort": schema_k8sio_api_discovery_v1_EndpointPort(ref), + "k8s.io/api/discovery/v1.EndpointSlice": schema_k8sio_api_discovery_v1_EndpointSlice(ref), + "k8s.io/api/discovery/v1.EndpointSliceList": schema_k8sio_api_discovery_v1_EndpointSliceList(ref), + "k8s.io/api/discovery/v1.ForZone": schema_k8sio_api_discovery_v1_ForZone(ref), + "k8s.io/api/discovery/v1beta1.Endpoint": schema_k8sio_api_discovery_v1beta1_Endpoint(ref), + "k8s.io/api/discovery/v1beta1.EndpointConditions": schema_k8sio_api_discovery_v1beta1_EndpointConditions(ref), + "k8s.io/api/discovery/v1beta1.EndpointHints": schema_k8sio_api_discovery_v1beta1_EndpointHints(ref), + "k8s.io/api/discovery/v1beta1.EndpointPort": schema_k8sio_api_discovery_v1beta1_EndpointPort(ref), + "k8s.io/api/discovery/v1beta1.EndpointSlice": schema_k8sio_api_discovery_v1beta1_EndpointSlice(ref), + "k8s.io/api/discovery/v1beta1.EndpointSliceList": schema_k8sio_api_discovery_v1beta1_EndpointSliceList(ref), + "k8s.io/api/discovery/v1beta1.ForZone": schema_k8sio_api_discovery_v1beta1_ForZone(ref), + "k8s.io/api/events/v1.Event": schema_k8sio_api_events_v1_Event(ref), + "k8s.io/api/events/v1.EventList": schema_k8sio_api_events_v1_EventList(ref), + "k8s.io/api/events/v1.EventSeries": schema_k8sio_api_events_v1_EventSeries(ref), + "k8s.io/api/events/v1beta1.Event": schema_k8sio_api_events_v1beta1_Event(ref), + "k8s.io/api/events/v1beta1.EventList": schema_k8sio_api_events_v1beta1_EventList(ref), + "k8s.io/api/events/v1beta1.EventSeries": schema_k8sio_api_events_v1beta1_EventSeries(ref), + "k8s.io/api/extensions/v1beta1.DaemonSet": schema_k8sio_api_extensions_v1beta1_DaemonSet(ref), + "k8s.io/api/extensions/v1beta1.DaemonSetCondition": schema_k8sio_api_extensions_v1beta1_DaemonSetCondition(ref), + "k8s.io/api/extensions/v1beta1.DaemonSetList": schema_k8sio_api_extensions_v1beta1_DaemonSetList(ref), + "k8s.io/api/extensions/v1beta1.DaemonSetSpec": schema_k8sio_api_extensions_v1beta1_DaemonSetSpec(ref), + "k8s.io/api/extensions/v1beta1.DaemonSetStatus": schema_k8sio_api_extensions_v1beta1_DaemonSetStatus(ref), + "k8s.io/api/extensions/v1beta1.DaemonSetUpdateStrategy": schema_k8sio_api_extensions_v1beta1_DaemonSetUpdateStrategy(ref), + "k8s.io/api/extensions/v1beta1.Deployment": schema_k8sio_api_extensions_v1beta1_Deployment(ref), + "k8s.io/api/extensions/v1beta1.DeploymentCondition": schema_k8sio_api_extensions_v1beta1_DeploymentCondition(ref), + "k8s.io/api/extensions/v1beta1.DeploymentList": schema_k8sio_api_extensions_v1beta1_DeploymentList(ref), + "k8s.io/api/extensions/v1beta1.DeploymentRollback": schema_k8sio_api_extensions_v1beta1_DeploymentRollback(ref), + "k8s.io/api/extensions/v1beta1.DeploymentSpec": schema_k8sio_api_extensions_v1beta1_DeploymentSpec(ref), + "k8s.io/api/extensions/v1beta1.DeploymentStatus": schema_k8sio_api_extensions_v1beta1_DeploymentStatus(ref), + "k8s.io/api/extensions/v1beta1.DeploymentStrategy": schema_k8sio_api_extensions_v1beta1_DeploymentStrategy(ref), + "k8s.io/api/extensions/v1beta1.HTTPIngressPath": schema_k8sio_api_extensions_v1beta1_HTTPIngressPath(ref), + "k8s.io/api/extensions/v1beta1.HTTPIngressRuleValue": schema_k8sio_api_extensions_v1beta1_HTTPIngressRuleValue(ref), + "k8s.io/api/extensions/v1beta1.IPBlock": schema_k8sio_api_extensions_v1beta1_IPBlock(ref), + "k8s.io/api/extensions/v1beta1.Ingress": schema_k8sio_api_extensions_v1beta1_Ingress(ref), + "k8s.io/api/extensions/v1beta1.IngressBackend": schema_k8sio_api_extensions_v1beta1_IngressBackend(ref), + "k8s.io/api/extensions/v1beta1.IngressList": schema_k8sio_api_extensions_v1beta1_IngressList(ref), + "k8s.io/api/extensions/v1beta1.IngressLoadBalancerIngress": schema_k8sio_api_extensions_v1beta1_IngressLoadBalancerIngress(ref), + "k8s.io/api/extensions/v1beta1.IngressLoadBalancerStatus": schema_k8sio_api_extensions_v1beta1_IngressLoadBalancerStatus(ref), + "k8s.io/api/extensions/v1beta1.IngressPortStatus": schema_k8sio_api_extensions_v1beta1_IngressPortStatus(ref), + "k8s.io/api/extensions/v1beta1.IngressRule": schema_k8sio_api_extensions_v1beta1_IngressRule(ref), + "k8s.io/api/extensions/v1beta1.IngressRuleValue": schema_k8sio_api_extensions_v1beta1_IngressRuleValue(ref), + "k8s.io/api/extensions/v1beta1.IngressSpec": schema_k8sio_api_extensions_v1beta1_IngressSpec(ref), + "k8s.io/api/extensions/v1beta1.IngressStatus": schema_k8sio_api_extensions_v1beta1_IngressStatus(ref), + "k8s.io/api/extensions/v1beta1.IngressTLS": schema_k8sio_api_extensions_v1beta1_IngressTLS(ref), + "k8s.io/api/extensions/v1beta1.NetworkPolicy": schema_k8sio_api_extensions_v1beta1_NetworkPolicy(ref), + "k8s.io/api/extensions/v1beta1.NetworkPolicyEgressRule": schema_k8sio_api_extensions_v1beta1_NetworkPolicyEgressRule(ref), + "k8s.io/api/extensions/v1beta1.NetworkPolicyIngressRule": schema_k8sio_api_extensions_v1beta1_NetworkPolicyIngressRule(ref), + "k8s.io/api/extensions/v1beta1.NetworkPolicyList": schema_k8sio_api_extensions_v1beta1_NetworkPolicyList(ref), + "k8s.io/api/extensions/v1beta1.NetworkPolicyPeer": schema_k8sio_api_extensions_v1beta1_NetworkPolicyPeer(ref), + "k8s.io/api/extensions/v1beta1.NetworkPolicyPort": schema_k8sio_api_extensions_v1beta1_NetworkPolicyPort(ref), + "k8s.io/api/extensions/v1beta1.NetworkPolicySpec": schema_k8sio_api_extensions_v1beta1_NetworkPolicySpec(ref), + "k8s.io/api/extensions/v1beta1.ReplicaSet": schema_k8sio_api_extensions_v1beta1_ReplicaSet(ref), + "k8s.io/api/extensions/v1beta1.ReplicaSetCondition": schema_k8sio_api_extensions_v1beta1_ReplicaSetCondition(ref), + "k8s.io/api/extensions/v1beta1.ReplicaSetList": schema_k8sio_api_extensions_v1beta1_ReplicaSetList(ref), + "k8s.io/api/extensions/v1beta1.ReplicaSetSpec": schema_k8sio_api_extensions_v1beta1_ReplicaSetSpec(ref), + "k8s.io/api/extensions/v1beta1.ReplicaSetStatus": schema_k8sio_api_extensions_v1beta1_ReplicaSetStatus(ref), + "k8s.io/api/extensions/v1beta1.RollbackConfig": schema_k8sio_api_extensions_v1beta1_RollbackConfig(ref), + "k8s.io/api/extensions/v1beta1.RollingUpdateDaemonSet": schema_k8sio_api_extensions_v1beta1_RollingUpdateDaemonSet(ref), + "k8s.io/api/extensions/v1beta1.RollingUpdateDeployment": schema_k8sio_api_extensions_v1beta1_RollingUpdateDeployment(ref), + "k8s.io/api/extensions/v1beta1.Scale": schema_k8sio_api_extensions_v1beta1_Scale(ref), + "k8s.io/api/extensions/v1beta1.ScaleSpec": schema_k8sio_api_extensions_v1beta1_ScaleSpec(ref), + "k8s.io/api/extensions/v1beta1.ScaleStatus": schema_k8sio_api_extensions_v1beta1_ScaleStatus(ref), + "k8s.io/api/flowcontrol/v1alpha1.FlowDistinguisherMethod": schema_k8sio_api_flowcontrol_v1alpha1_FlowDistinguisherMethod(ref), + "k8s.io/api/flowcontrol/v1alpha1.FlowSchema": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchema(ref), + "k8s.io/api/flowcontrol/v1alpha1.FlowSchemaCondition": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchemaCondition(ref), + "k8s.io/api/flowcontrol/v1alpha1.FlowSchemaList": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchemaList(ref), + "k8s.io/api/flowcontrol/v1alpha1.FlowSchemaSpec": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchemaSpec(ref), + "k8s.io/api/flowcontrol/v1alpha1.FlowSchemaStatus": schema_k8sio_api_flowcontrol_v1alpha1_FlowSchemaStatus(ref), + "k8s.io/api/flowcontrol/v1alpha1.GroupSubject": schema_k8sio_api_flowcontrol_v1alpha1_GroupSubject(ref), + "k8s.io/api/flowcontrol/v1alpha1.LimitResponse": schema_k8sio_api_flowcontrol_v1alpha1_LimitResponse(ref), + "k8s.io/api/flowcontrol/v1alpha1.LimitedPriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1alpha1_LimitedPriorityLevelConfiguration(ref), + "k8s.io/api/flowcontrol/v1alpha1.NonResourcePolicyRule": schema_k8sio_api_flowcontrol_v1alpha1_NonResourcePolicyRule(ref), + "k8s.io/api/flowcontrol/v1alpha1.PolicyRulesWithSubjects": schema_k8sio_api_flowcontrol_v1alpha1_PolicyRulesWithSubjects(ref), + "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfiguration(ref), + "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationCondition": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationCondition(ref), + "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationList": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationList(ref), + "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationReference": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationReference(ref), + "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationSpec": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationSpec(ref), + "k8s.io/api/flowcontrol/v1alpha1.PriorityLevelConfigurationStatus": schema_k8sio_api_flowcontrol_v1alpha1_PriorityLevelConfigurationStatus(ref), + "k8s.io/api/flowcontrol/v1alpha1.QueuingConfiguration": schema_k8sio_api_flowcontrol_v1alpha1_QueuingConfiguration(ref), + "k8s.io/api/flowcontrol/v1alpha1.ResourcePolicyRule": schema_k8sio_api_flowcontrol_v1alpha1_ResourcePolicyRule(ref), + "k8s.io/api/flowcontrol/v1alpha1.ServiceAccountSubject": schema_k8sio_api_flowcontrol_v1alpha1_ServiceAccountSubject(ref), + "k8s.io/api/flowcontrol/v1alpha1.Subject": schema_k8sio_api_flowcontrol_v1alpha1_Subject(ref), + "k8s.io/api/flowcontrol/v1alpha1.UserSubject": schema_k8sio_api_flowcontrol_v1alpha1_UserSubject(ref), + "k8s.io/api/flowcontrol/v1beta1.FlowDistinguisherMethod": schema_k8sio_api_flowcontrol_v1beta1_FlowDistinguisherMethod(ref), + "k8s.io/api/flowcontrol/v1beta1.FlowSchema": schema_k8sio_api_flowcontrol_v1beta1_FlowSchema(ref), + "k8s.io/api/flowcontrol/v1beta1.FlowSchemaCondition": schema_k8sio_api_flowcontrol_v1beta1_FlowSchemaCondition(ref), + "k8s.io/api/flowcontrol/v1beta1.FlowSchemaList": schema_k8sio_api_flowcontrol_v1beta1_FlowSchemaList(ref), + "k8s.io/api/flowcontrol/v1beta1.FlowSchemaSpec": schema_k8sio_api_flowcontrol_v1beta1_FlowSchemaSpec(ref), + "k8s.io/api/flowcontrol/v1beta1.FlowSchemaStatus": schema_k8sio_api_flowcontrol_v1beta1_FlowSchemaStatus(ref), + "k8s.io/api/flowcontrol/v1beta1.GroupSubject": schema_k8sio_api_flowcontrol_v1beta1_GroupSubject(ref), + "k8s.io/api/flowcontrol/v1beta1.LimitResponse": schema_k8sio_api_flowcontrol_v1beta1_LimitResponse(ref), + "k8s.io/api/flowcontrol/v1beta1.LimitedPriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta1_LimitedPriorityLevelConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta1.NonResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta1_NonResourcePolicyRule(ref), + "k8s.io/api/flowcontrol/v1beta1.PolicyRulesWithSubjects": schema_k8sio_api_flowcontrol_v1beta1_PolicyRulesWithSubjects(ref), + "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationCondition": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationCondition(ref), + "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationList": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationList(ref), + "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationReference": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationReference(ref), + "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationSpec": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationSpec(ref), + "k8s.io/api/flowcontrol/v1beta1.PriorityLevelConfigurationStatus": schema_k8sio_api_flowcontrol_v1beta1_PriorityLevelConfigurationStatus(ref), + "k8s.io/api/flowcontrol/v1beta1.QueuingConfiguration": schema_k8sio_api_flowcontrol_v1beta1_QueuingConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta1.ResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta1_ResourcePolicyRule(ref), + "k8s.io/api/flowcontrol/v1beta1.ServiceAccountSubject": schema_k8sio_api_flowcontrol_v1beta1_ServiceAccountSubject(ref), + "k8s.io/api/flowcontrol/v1beta1.Subject": schema_k8sio_api_flowcontrol_v1beta1_Subject(ref), + "k8s.io/api/flowcontrol/v1beta1.UserSubject": schema_k8sio_api_flowcontrol_v1beta1_UserSubject(ref), + "k8s.io/api/flowcontrol/v1beta2.FlowDistinguisherMethod": schema_k8sio_api_flowcontrol_v1beta2_FlowDistinguisherMethod(ref), + "k8s.io/api/flowcontrol/v1beta2.FlowSchema": schema_k8sio_api_flowcontrol_v1beta2_FlowSchema(ref), + "k8s.io/api/flowcontrol/v1beta2.FlowSchemaCondition": schema_k8sio_api_flowcontrol_v1beta2_FlowSchemaCondition(ref), + "k8s.io/api/flowcontrol/v1beta2.FlowSchemaList": schema_k8sio_api_flowcontrol_v1beta2_FlowSchemaList(ref), + "k8s.io/api/flowcontrol/v1beta2.FlowSchemaSpec": schema_k8sio_api_flowcontrol_v1beta2_FlowSchemaSpec(ref), + "k8s.io/api/flowcontrol/v1beta2.FlowSchemaStatus": schema_k8sio_api_flowcontrol_v1beta2_FlowSchemaStatus(ref), + "k8s.io/api/flowcontrol/v1beta2.GroupSubject": schema_k8sio_api_flowcontrol_v1beta2_GroupSubject(ref), + "k8s.io/api/flowcontrol/v1beta2.LimitResponse": schema_k8sio_api_flowcontrol_v1beta2_LimitResponse(ref), + "k8s.io/api/flowcontrol/v1beta2.LimitedPriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta2_LimitedPriorityLevelConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta2.NonResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta2_NonResourcePolicyRule(ref), + "k8s.io/api/flowcontrol/v1beta2.PolicyRulesWithSubjects": schema_k8sio_api_flowcontrol_v1beta2_PolicyRulesWithSubjects(ref), + "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationCondition": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationCondition(ref), + "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationList": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationList(ref), + "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationReference": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationReference(ref), + "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationSpec": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationSpec(ref), + "k8s.io/api/flowcontrol/v1beta2.PriorityLevelConfigurationStatus": schema_k8sio_api_flowcontrol_v1beta2_PriorityLevelConfigurationStatus(ref), + "k8s.io/api/flowcontrol/v1beta2.QueuingConfiguration": schema_k8sio_api_flowcontrol_v1beta2_QueuingConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta2.ResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta2_ResourcePolicyRule(ref), + "k8s.io/api/flowcontrol/v1beta2.ServiceAccountSubject": schema_k8sio_api_flowcontrol_v1beta2_ServiceAccountSubject(ref), + "k8s.io/api/flowcontrol/v1beta2.Subject": schema_k8sio_api_flowcontrol_v1beta2_Subject(ref), + "k8s.io/api/flowcontrol/v1beta2.UserSubject": schema_k8sio_api_flowcontrol_v1beta2_UserSubject(ref), + "k8s.io/api/flowcontrol/v1beta3.FlowDistinguisherMethod": schema_k8sio_api_flowcontrol_v1beta3_FlowDistinguisherMethod(ref), + "k8s.io/api/flowcontrol/v1beta3.FlowSchema": schema_k8sio_api_flowcontrol_v1beta3_FlowSchema(ref), + "k8s.io/api/flowcontrol/v1beta3.FlowSchemaCondition": schema_k8sio_api_flowcontrol_v1beta3_FlowSchemaCondition(ref), + "k8s.io/api/flowcontrol/v1beta3.FlowSchemaList": schema_k8sio_api_flowcontrol_v1beta3_FlowSchemaList(ref), + "k8s.io/api/flowcontrol/v1beta3.FlowSchemaSpec": schema_k8sio_api_flowcontrol_v1beta3_FlowSchemaSpec(ref), + "k8s.io/api/flowcontrol/v1beta3.FlowSchemaStatus": schema_k8sio_api_flowcontrol_v1beta3_FlowSchemaStatus(ref), + "k8s.io/api/flowcontrol/v1beta3.GroupSubject": schema_k8sio_api_flowcontrol_v1beta3_GroupSubject(ref), + "k8s.io/api/flowcontrol/v1beta3.LimitResponse": schema_k8sio_api_flowcontrol_v1beta3_LimitResponse(ref), + "k8s.io/api/flowcontrol/v1beta3.LimitedPriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta3_LimitedPriorityLevelConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta3.NonResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta3_NonResourcePolicyRule(ref), + "k8s.io/api/flowcontrol/v1beta3.PolicyRulesWithSubjects": schema_k8sio_api_flowcontrol_v1beta3_PolicyRulesWithSubjects(ref), + "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfiguration": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationCondition": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationCondition(ref), + "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationList": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationList(ref), + "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationReference": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationReference(ref), + "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationSpec": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationSpec(ref), + "k8s.io/api/flowcontrol/v1beta3.PriorityLevelConfigurationStatus": schema_k8sio_api_flowcontrol_v1beta3_PriorityLevelConfigurationStatus(ref), + "k8s.io/api/flowcontrol/v1beta3.QueuingConfiguration": schema_k8sio_api_flowcontrol_v1beta3_QueuingConfiguration(ref), + "k8s.io/api/flowcontrol/v1beta3.ResourcePolicyRule": schema_k8sio_api_flowcontrol_v1beta3_ResourcePolicyRule(ref), + "k8s.io/api/flowcontrol/v1beta3.ServiceAccountSubject": schema_k8sio_api_flowcontrol_v1beta3_ServiceAccountSubject(ref), + "k8s.io/api/flowcontrol/v1beta3.Subject": schema_k8sio_api_flowcontrol_v1beta3_Subject(ref), + "k8s.io/api/flowcontrol/v1beta3.UserSubject": schema_k8sio_api_flowcontrol_v1beta3_UserSubject(ref), + "k8s.io/api/imagepolicy/v1alpha1.ImageReview": schema_k8sio_api_imagepolicy_v1alpha1_ImageReview(ref), + "k8s.io/api/imagepolicy/v1alpha1.ImageReviewContainerSpec": schema_k8sio_api_imagepolicy_v1alpha1_ImageReviewContainerSpec(ref), + "k8s.io/api/imagepolicy/v1alpha1.ImageReviewSpec": schema_k8sio_api_imagepolicy_v1alpha1_ImageReviewSpec(ref), + "k8s.io/api/imagepolicy/v1alpha1.ImageReviewStatus": schema_k8sio_api_imagepolicy_v1alpha1_ImageReviewStatus(ref), + "k8s.io/api/networking/v1.HTTPIngressPath": schema_k8sio_api_networking_v1_HTTPIngressPath(ref), + "k8s.io/api/networking/v1.HTTPIngressRuleValue": schema_k8sio_api_networking_v1_HTTPIngressRuleValue(ref), + "k8s.io/api/networking/v1.IPBlock": schema_k8sio_api_networking_v1_IPBlock(ref), + "k8s.io/api/networking/v1.Ingress": schema_k8sio_api_networking_v1_Ingress(ref), + "k8s.io/api/networking/v1.IngressBackend": schema_k8sio_api_networking_v1_IngressBackend(ref), + "k8s.io/api/networking/v1.IngressClass": schema_k8sio_api_networking_v1_IngressClass(ref), + "k8s.io/api/networking/v1.IngressClassList": schema_k8sio_api_networking_v1_IngressClassList(ref), + "k8s.io/api/networking/v1.IngressClassParametersReference": schema_k8sio_api_networking_v1_IngressClassParametersReference(ref), + "k8s.io/api/networking/v1.IngressClassSpec": schema_k8sio_api_networking_v1_IngressClassSpec(ref), + "k8s.io/api/networking/v1.IngressList": schema_k8sio_api_networking_v1_IngressList(ref), + "k8s.io/api/networking/v1.IngressLoadBalancerIngress": schema_k8sio_api_networking_v1_IngressLoadBalancerIngress(ref), + "k8s.io/api/networking/v1.IngressLoadBalancerStatus": schema_k8sio_api_networking_v1_IngressLoadBalancerStatus(ref), + "k8s.io/api/networking/v1.IngressPortStatus": schema_k8sio_api_networking_v1_IngressPortStatus(ref), + "k8s.io/api/networking/v1.IngressRule": schema_k8sio_api_networking_v1_IngressRule(ref), + "k8s.io/api/networking/v1.IngressRuleValue": schema_k8sio_api_networking_v1_IngressRuleValue(ref), + "k8s.io/api/networking/v1.IngressServiceBackend": schema_k8sio_api_networking_v1_IngressServiceBackend(ref), + "k8s.io/api/networking/v1.IngressSpec": schema_k8sio_api_networking_v1_IngressSpec(ref), + "k8s.io/api/networking/v1.IngressStatus": schema_k8sio_api_networking_v1_IngressStatus(ref), + "k8s.io/api/networking/v1.IngressTLS": schema_k8sio_api_networking_v1_IngressTLS(ref), + "k8s.io/api/networking/v1.NetworkPolicy": schema_k8sio_api_networking_v1_NetworkPolicy(ref), + "k8s.io/api/networking/v1.NetworkPolicyEgressRule": schema_k8sio_api_networking_v1_NetworkPolicyEgressRule(ref), + "k8s.io/api/networking/v1.NetworkPolicyIngressRule": schema_k8sio_api_networking_v1_NetworkPolicyIngressRule(ref), + "k8s.io/api/networking/v1.NetworkPolicyList": schema_k8sio_api_networking_v1_NetworkPolicyList(ref), + "k8s.io/api/networking/v1.NetworkPolicyPeer": schema_k8sio_api_networking_v1_NetworkPolicyPeer(ref), + "k8s.io/api/networking/v1.NetworkPolicyPort": schema_k8sio_api_networking_v1_NetworkPolicyPort(ref), + "k8s.io/api/networking/v1.NetworkPolicySpec": schema_k8sio_api_networking_v1_NetworkPolicySpec(ref), + "k8s.io/api/networking/v1.ServiceBackendPort": schema_k8sio_api_networking_v1_ServiceBackendPort(ref), + "k8s.io/api/networking/v1alpha1.ClusterCIDR": schema_k8sio_api_networking_v1alpha1_ClusterCIDR(ref), + "k8s.io/api/networking/v1alpha1.ClusterCIDRList": schema_k8sio_api_networking_v1alpha1_ClusterCIDRList(ref), + "k8s.io/api/networking/v1alpha1.ClusterCIDRSpec": schema_k8sio_api_networking_v1alpha1_ClusterCIDRSpec(ref), + "k8s.io/api/networking/v1alpha1.IPAddress": schema_k8sio_api_networking_v1alpha1_IPAddress(ref), + "k8s.io/api/networking/v1alpha1.IPAddressList": schema_k8sio_api_networking_v1alpha1_IPAddressList(ref), + "k8s.io/api/networking/v1alpha1.IPAddressSpec": schema_k8sio_api_networking_v1alpha1_IPAddressSpec(ref), + "k8s.io/api/networking/v1alpha1.ParentReference": schema_k8sio_api_networking_v1alpha1_ParentReference(ref), + "k8s.io/api/networking/v1beta1.HTTPIngressPath": schema_k8sio_api_networking_v1beta1_HTTPIngressPath(ref), + "k8s.io/api/networking/v1beta1.HTTPIngressRuleValue": schema_k8sio_api_networking_v1beta1_HTTPIngressRuleValue(ref), + "k8s.io/api/networking/v1beta1.Ingress": schema_k8sio_api_networking_v1beta1_Ingress(ref), + "k8s.io/api/networking/v1beta1.IngressBackend": schema_k8sio_api_networking_v1beta1_IngressBackend(ref), + "k8s.io/api/networking/v1beta1.IngressClass": schema_k8sio_api_networking_v1beta1_IngressClass(ref), + "k8s.io/api/networking/v1beta1.IngressClassList": schema_k8sio_api_networking_v1beta1_IngressClassList(ref), + "k8s.io/api/networking/v1beta1.IngressClassParametersReference": schema_k8sio_api_networking_v1beta1_IngressClassParametersReference(ref), + "k8s.io/api/networking/v1beta1.IngressClassSpec": schema_k8sio_api_networking_v1beta1_IngressClassSpec(ref), + "k8s.io/api/networking/v1beta1.IngressList": schema_k8sio_api_networking_v1beta1_IngressList(ref), + "k8s.io/api/networking/v1beta1.IngressLoadBalancerIngress": schema_k8sio_api_networking_v1beta1_IngressLoadBalancerIngress(ref), + "k8s.io/api/networking/v1beta1.IngressLoadBalancerStatus": schema_k8sio_api_networking_v1beta1_IngressLoadBalancerStatus(ref), + "k8s.io/api/networking/v1beta1.IngressPortStatus": schema_k8sio_api_networking_v1beta1_IngressPortStatus(ref), + "k8s.io/api/networking/v1beta1.IngressRule": schema_k8sio_api_networking_v1beta1_IngressRule(ref), + "k8s.io/api/networking/v1beta1.IngressRuleValue": schema_k8sio_api_networking_v1beta1_IngressRuleValue(ref), + "k8s.io/api/networking/v1beta1.IngressSpec": schema_k8sio_api_networking_v1beta1_IngressSpec(ref), + "k8s.io/api/networking/v1beta1.IngressStatus": schema_k8sio_api_networking_v1beta1_IngressStatus(ref), + "k8s.io/api/networking/v1beta1.IngressTLS": schema_k8sio_api_networking_v1beta1_IngressTLS(ref), + "k8s.io/api/node/v1.Overhead": schema_k8sio_api_node_v1_Overhead(ref), + "k8s.io/api/node/v1.RuntimeClass": schema_k8sio_api_node_v1_RuntimeClass(ref), + "k8s.io/api/node/v1.RuntimeClassList": schema_k8sio_api_node_v1_RuntimeClassList(ref), + "k8s.io/api/node/v1.Scheduling": schema_k8sio_api_node_v1_Scheduling(ref), + "k8s.io/api/node/v1alpha1.Overhead": schema_k8sio_api_node_v1alpha1_Overhead(ref), + "k8s.io/api/node/v1alpha1.RuntimeClass": schema_k8sio_api_node_v1alpha1_RuntimeClass(ref), + "k8s.io/api/node/v1alpha1.RuntimeClassList": schema_k8sio_api_node_v1alpha1_RuntimeClassList(ref), + "k8s.io/api/node/v1alpha1.RuntimeClassSpec": schema_k8sio_api_node_v1alpha1_RuntimeClassSpec(ref), + "k8s.io/api/node/v1alpha1.Scheduling": schema_k8sio_api_node_v1alpha1_Scheduling(ref), + "k8s.io/api/node/v1beta1.Overhead": schema_k8sio_api_node_v1beta1_Overhead(ref), + "k8s.io/api/node/v1beta1.RuntimeClass": schema_k8sio_api_node_v1beta1_RuntimeClass(ref), + "k8s.io/api/node/v1beta1.RuntimeClassList": schema_k8sio_api_node_v1beta1_RuntimeClassList(ref), + "k8s.io/api/node/v1beta1.Scheduling": schema_k8sio_api_node_v1beta1_Scheduling(ref), + "k8s.io/api/policy/v1.Eviction": schema_k8sio_api_policy_v1_Eviction(ref), + "k8s.io/api/policy/v1.PodDisruptionBudget": schema_k8sio_api_policy_v1_PodDisruptionBudget(ref), + "k8s.io/api/policy/v1.PodDisruptionBudgetList": schema_k8sio_api_policy_v1_PodDisruptionBudgetList(ref), + "k8s.io/api/policy/v1.PodDisruptionBudgetSpec": schema_k8sio_api_policy_v1_PodDisruptionBudgetSpec(ref), + "k8s.io/api/policy/v1.PodDisruptionBudgetStatus": schema_k8sio_api_policy_v1_PodDisruptionBudgetStatus(ref), + "k8s.io/api/policy/v1beta1.AllowedCSIDriver": schema_k8sio_api_policy_v1beta1_AllowedCSIDriver(ref), + "k8s.io/api/policy/v1beta1.AllowedFlexVolume": schema_k8sio_api_policy_v1beta1_AllowedFlexVolume(ref), + "k8s.io/api/policy/v1beta1.AllowedHostPath": schema_k8sio_api_policy_v1beta1_AllowedHostPath(ref), + "k8s.io/api/policy/v1beta1.Eviction": schema_k8sio_api_policy_v1beta1_Eviction(ref), + "k8s.io/api/policy/v1beta1.FSGroupStrategyOptions": schema_k8sio_api_policy_v1beta1_FSGroupStrategyOptions(ref), + "k8s.io/api/policy/v1beta1.HostPortRange": schema_k8sio_api_policy_v1beta1_HostPortRange(ref), + "k8s.io/api/policy/v1beta1.IDRange": schema_k8sio_api_policy_v1beta1_IDRange(ref), + "k8s.io/api/policy/v1beta1.PodDisruptionBudget": schema_k8sio_api_policy_v1beta1_PodDisruptionBudget(ref), + "k8s.io/api/policy/v1beta1.PodDisruptionBudgetList": schema_k8sio_api_policy_v1beta1_PodDisruptionBudgetList(ref), + "k8s.io/api/policy/v1beta1.PodDisruptionBudgetSpec": schema_k8sio_api_policy_v1beta1_PodDisruptionBudgetSpec(ref), + "k8s.io/api/policy/v1beta1.PodDisruptionBudgetStatus": schema_k8sio_api_policy_v1beta1_PodDisruptionBudgetStatus(ref), + "k8s.io/api/policy/v1beta1.PodSecurityPolicy": schema_k8sio_api_policy_v1beta1_PodSecurityPolicy(ref), + "k8s.io/api/policy/v1beta1.PodSecurityPolicyList": schema_k8sio_api_policy_v1beta1_PodSecurityPolicyList(ref), + "k8s.io/api/policy/v1beta1.PodSecurityPolicySpec": schema_k8sio_api_policy_v1beta1_PodSecurityPolicySpec(ref), + "k8s.io/api/policy/v1beta1.RunAsGroupStrategyOptions": schema_k8sio_api_policy_v1beta1_RunAsGroupStrategyOptions(ref), + "k8s.io/api/policy/v1beta1.RunAsUserStrategyOptions": schema_k8sio_api_policy_v1beta1_RunAsUserStrategyOptions(ref), + "k8s.io/api/policy/v1beta1.RuntimeClassStrategyOptions": schema_k8sio_api_policy_v1beta1_RuntimeClassStrategyOptions(ref), + "k8s.io/api/policy/v1beta1.SELinuxStrategyOptions": schema_k8sio_api_policy_v1beta1_SELinuxStrategyOptions(ref), + "k8s.io/api/policy/v1beta1.SupplementalGroupsStrategyOptions": schema_k8sio_api_policy_v1beta1_SupplementalGroupsStrategyOptions(ref), + "k8s.io/api/rbac/v1.AggregationRule": schema_k8sio_api_rbac_v1_AggregationRule(ref), + "k8s.io/api/rbac/v1.ClusterRole": schema_k8sio_api_rbac_v1_ClusterRole(ref), + "k8s.io/api/rbac/v1.ClusterRoleBinding": schema_k8sio_api_rbac_v1_ClusterRoleBinding(ref), + "k8s.io/api/rbac/v1.ClusterRoleBindingList": schema_k8sio_api_rbac_v1_ClusterRoleBindingList(ref), + "k8s.io/api/rbac/v1.ClusterRoleList": schema_k8sio_api_rbac_v1_ClusterRoleList(ref), + "k8s.io/api/rbac/v1.PolicyRule": schema_k8sio_api_rbac_v1_PolicyRule(ref), + "k8s.io/api/rbac/v1.Role": schema_k8sio_api_rbac_v1_Role(ref), + "k8s.io/api/rbac/v1.RoleBinding": schema_k8sio_api_rbac_v1_RoleBinding(ref), + "k8s.io/api/rbac/v1.RoleBindingList": schema_k8sio_api_rbac_v1_RoleBindingList(ref), + "k8s.io/api/rbac/v1.RoleList": schema_k8sio_api_rbac_v1_RoleList(ref), + "k8s.io/api/rbac/v1.RoleRef": schema_k8sio_api_rbac_v1_RoleRef(ref), + "k8s.io/api/rbac/v1.Subject": schema_k8sio_api_rbac_v1_Subject(ref), + "k8s.io/api/rbac/v1alpha1.AggregationRule": schema_k8sio_api_rbac_v1alpha1_AggregationRule(ref), + "k8s.io/api/rbac/v1alpha1.ClusterRole": schema_k8sio_api_rbac_v1alpha1_ClusterRole(ref), + "k8s.io/api/rbac/v1alpha1.ClusterRoleBinding": schema_k8sio_api_rbac_v1alpha1_ClusterRoleBinding(ref), + "k8s.io/api/rbac/v1alpha1.ClusterRoleBindingList": schema_k8sio_api_rbac_v1alpha1_ClusterRoleBindingList(ref), + "k8s.io/api/rbac/v1alpha1.ClusterRoleList": schema_k8sio_api_rbac_v1alpha1_ClusterRoleList(ref), + "k8s.io/api/rbac/v1alpha1.PolicyRule": schema_k8sio_api_rbac_v1alpha1_PolicyRule(ref), + "k8s.io/api/rbac/v1alpha1.Role": schema_k8sio_api_rbac_v1alpha1_Role(ref), + "k8s.io/api/rbac/v1alpha1.RoleBinding": schema_k8sio_api_rbac_v1alpha1_RoleBinding(ref), + "k8s.io/api/rbac/v1alpha1.RoleBindingList": schema_k8sio_api_rbac_v1alpha1_RoleBindingList(ref), + "k8s.io/api/rbac/v1alpha1.RoleList": schema_k8sio_api_rbac_v1alpha1_RoleList(ref), + "k8s.io/api/rbac/v1alpha1.RoleRef": schema_k8sio_api_rbac_v1alpha1_RoleRef(ref), + "k8s.io/api/rbac/v1alpha1.Subject": schema_k8sio_api_rbac_v1alpha1_Subject(ref), + "k8s.io/api/rbac/v1beta1.AggregationRule": schema_k8sio_api_rbac_v1beta1_AggregationRule(ref), + "k8s.io/api/rbac/v1beta1.ClusterRole": schema_k8sio_api_rbac_v1beta1_ClusterRole(ref), + "k8s.io/api/rbac/v1beta1.ClusterRoleBinding": schema_k8sio_api_rbac_v1beta1_ClusterRoleBinding(ref), + "k8s.io/api/rbac/v1beta1.ClusterRoleBindingList": schema_k8sio_api_rbac_v1beta1_ClusterRoleBindingList(ref), + "k8s.io/api/rbac/v1beta1.ClusterRoleList": schema_k8sio_api_rbac_v1beta1_ClusterRoleList(ref), + "k8s.io/api/rbac/v1beta1.PolicyRule": schema_k8sio_api_rbac_v1beta1_PolicyRule(ref), + "k8s.io/api/rbac/v1beta1.Role": schema_k8sio_api_rbac_v1beta1_Role(ref), + "k8s.io/api/rbac/v1beta1.RoleBinding": schema_k8sio_api_rbac_v1beta1_RoleBinding(ref), + "k8s.io/api/rbac/v1beta1.RoleBindingList": schema_k8sio_api_rbac_v1beta1_RoleBindingList(ref), + "k8s.io/api/rbac/v1beta1.RoleList": schema_k8sio_api_rbac_v1beta1_RoleList(ref), + "k8s.io/api/rbac/v1beta1.RoleRef": schema_k8sio_api_rbac_v1beta1_RoleRef(ref), + "k8s.io/api/rbac/v1beta1.Subject": schema_k8sio_api_rbac_v1beta1_Subject(ref), + "k8s.io/api/resource/v1alpha2.AllocationResult": schema_k8sio_api_resource_v1alpha2_AllocationResult(ref), + "k8s.io/api/resource/v1alpha2.PodSchedulingContext": schema_k8sio_api_resource_v1alpha2_PodSchedulingContext(ref), + "k8s.io/api/resource/v1alpha2.PodSchedulingContextList": schema_k8sio_api_resource_v1alpha2_PodSchedulingContextList(ref), + "k8s.io/api/resource/v1alpha2.PodSchedulingContextSpec": schema_k8sio_api_resource_v1alpha2_PodSchedulingContextSpec(ref), + "k8s.io/api/resource/v1alpha2.PodSchedulingContextStatus": schema_k8sio_api_resource_v1alpha2_PodSchedulingContextStatus(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaim": schema_k8sio_api_resource_v1alpha2_ResourceClaim(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimConsumerReference": schema_k8sio_api_resource_v1alpha2_ResourceClaimConsumerReference(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimList": schema_k8sio_api_resource_v1alpha2_ResourceClaimList(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimParametersReference": schema_k8sio_api_resource_v1alpha2_ResourceClaimParametersReference(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimSchedulingStatus": schema_k8sio_api_resource_v1alpha2_ResourceClaimSchedulingStatus(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimSpec": schema_k8sio_api_resource_v1alpha2_ResourceClaimSpec(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimStatus": schema_k8sio_api_resource_v1alpha2_ResourceClaimStatus(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimTemplate": schema_k8sio_api_resource_v1alpha2_ResourceClaimTemplate(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimTemplateList": schema_k8sio_api_resource_v1alpha2_ResourceClaimTemplateList(ref), + "k8s.io/api/resource/v1alpha2.ResourceClaimTemplateSpec": schema_k8sio_api_resource_v1alpha2_ResourceClaimTemplateSpec(ref), + "k8s.io/api/resource/v1alpha2.ResourceClass": schema_k8sio_api_resource_v1alpha2_ResourceClass(ref), + "k8s.io/api/resource/v1alpha2.ResourceClassList": schema_k8sio_api_resource_v1alpha2_ResourceClassList(ref), + "k8s.io/api/resource/v1alpha2.ResourceClassParametersReference": schema_k8sio_api_resource_v1alpha2_ResourceClassParametersReference(ref), + "k8s.io/api/resource/v1alpha2.ResourceHandle": schema_k8sio_api_resource_v1alpha2_ResourceHandle(ref), + "k8s.io/api/scheduling/v1.PriorityClass": schema_k8sio_api_scheduling_v1_PriorityClass(ref), + "k8s.io/api/scheduling/v1.PriorityClassList": schema_k8sio_api_scheduling_v1_PriorityClassList(ref), + "k8s.io/api/scheduling/v1alpha1.PriorityClass": schema_k8sio_api_scheduling_v1alpha1_PriorityClass(ref), + "k8s.io/api/scheduling/v1alpha1.PriorityClassList": schema_k8sio_api_scheduling_v1alpha1_PriorityClassList(ref), + "k8s.io/api/scheduling/v1beta1.PriorityClass": schema_k8sio_api_scheduling_v1beta1_PriorityClass(ref), + "k8s.io/api/scheduling/v1beta1.PriorityClassList": schema_k8sio_api_scheduling_v1beta1_PriorityClassList(ref), + "k8s.io/api/storage/v1.CSIDriver": schema_k8sio_api_storage_v1_CSIDriver(ref), + "k8s.io/api/storage/v1.CSIDriverList": schema_k8sio_api_storage_v1_CSIDriverList(ref), + "k8s.io/api/storage/v1.CSIDriverSpec": schema_k8sio_api_storage_v1_CSIDriverSpec(ref), + "k8s.io/api/storage/v1.CSINode": schema_k8sio_api_storage_v1_CSINode(ref), + "k8s.io/api/storage/v1.CSINodeDriver": schema_k8sio_api_storage_v1_CSINodeDriver(ref), + "k8s.io/api/storage/v1.CSINodeList": schema_k8sio_api_storage_v1_CSINodeList(ref), + "k8s.io/api/storage/v1.CSINodeSpec": schema_k8sio_api_storage_v1_CSINodeSpec(ref), + "k8s.io/api/storage/v1.CSIStorageCapacity": schema_k8sio_api_storage_v1_CSIStorageCapacity(ref), + "k8s.io/api/storage/v1.CSIStorageCapacityList": schema_k8sio_api_storage_v1_CSIStorageCapacityList(ref), + "k8s.io/api/storage/v1.StorageClass": schema_k8sio_api_storage_v1_StorageClass(ref), + "k8s.io/api/storage/v1.StorageClassList": schema_k8sio_api_storage_v1_StorageClassList(ref), + "k8s.io/api/storage/v1.TokenRequest": schema_k8sio_api_storage_v1_TokenRequest(ref), + "k8s.io/api/storage/v1.VolumeAttachment": schema_k8sio_api_storage_v1_VolumeAttachment(ref), + "k8s.io/api/storage/v1.VolumeAttachmentList": schema_k8sio_api_storage_v1_VolumeAttachmentList(ref), + "k8s.io/api/storage/v1.VolumeAttachmentSource": schema_k8sio_api_storage_v1_VolumeAttachmentSource(ref), + "k8s.io/api/storage/v1.VolumeAttachmentSpec": schema_k8sio_api_storage_v1_VolumeAttachmentSpec(ref), + "k8s.io/api/storage/v1.VolumeAttachmentStatus": schema_k8sio_api_storage_v1_VolumeAttachmentStatus(ref), + "k8s.io/api/storage/v1.VolumeError": schema_k8sio_api_storage_v1_VolumeError(ref), + "k8s.io/api/storage/v1.VolumeNodeResources": schema_k8sio_api_storage_v1_VolumeNodeResources(ref), + "k8s.io/api/storage/v1alpha1.CSIStorageCapacity": schema_k8sio_api_storage_v1alpha1_CSIStorageCapacity(ref), + "k8s.io/api/storage/v1alpha1.CSIStorageCapacityList": schema_k8sio_api_storage_v1alpha1_CSIStorageCapacityList(ref), + "k8s.io/api/storage/v1alpha1.VolumeAttachment": schema_k8sio_api_storage_v1alpha1_VolumeAttachment(ref), + "k8s.io/api/storage/v1alpha1.VolumeAttachmentList": schema_k8sio_api_storage_v1alpha1_VolumeAttachmentList(ref), + "k8s.io/api/storage/v1alpha1.VolumeAttachmentSource": schema_k8sio_api_storage_v1alpha1_VolumeAttachmentSource(ref), + "k8s.io/api/storage/v1alpha1.VolumeAttachmentSpec": schema_k8sio_api_storage_v1alpha1_VolumeAttachmentSpec(ref), + "k8s.io/api/storage/v1alpha1.VolumeAttachmentStatus": schema_k8sio_api_storage_v1alpha1_VolumeAttachmentStatus(ref), + "k8s.io/api/storage/v1alpha1.VolumeError": schema_k8sio_api_storage_v1alpha1_VolumeError(ref), + "k8s.io/api/storage/v1beta1.CSIDriver": schema_k8sio_api_storage_v1beta1_CSIDriver(ref), + "k8s.io/api/storage/v1beta1.CSIDriverList": schema_k8sio_api_storage_v1beta1_CSIDriverList(ref), + "k8s.io/api/storage/v1beta1.CSIDriverSpec": schema_k8sio_api_storage_v1beta1_CSIDriverSpec(ref), + "k8s.io/api/storage/v1beta1.CSINode": schema_k8sio_api_storage_v1beta1_CSINode(ref), + "k8s.io/api/storage/v1beta1.CSINodeDriver": schema_k8sio_api_storage_v1beta1_CSINodeDriver(ref), + "k8s.io/api/storage/v1beta1.CSINodeList": schema_k8sio_api_storage_v1beta1_CSINodeList(ref), + "k8s.io/api/storage/v1beta1.CSINodeSpec": schema_k8sio_api_storage_v1beta1_CSINodeSpec(ref), + "k8s.io/api/storage/v1beta1.CSIStorageCapacity": schema_k8sio_api_storage_v1beta1_CSIStorageCapacity(ref), + "k8s.io/api/storage/v1beta1.CSIStorageCapacityList": schema_k8sio_api_storage_v1beta1_CSIStorageCapacityList(ref), + "k8s.io/api/storage/v1beta1.StorageClass": schema_k8sio_api_storage_v1beta1_StorageClass(ref), + "k8s.io/api/storage/v1beta1.StorageClassList": schema_k8sio_api_storage_v1beta1_StorageClassList(ref), + "k8s.io/api/storage/v1beta1.TokenRequest": schema_k8sio_api_storage_v1beta1_TokenRequest(ref), + "k8s.io/api/storage/v1beta1.VolumeAttachment": schema_k8sio_api_storage_v1beta1_VolumeAttachment(ref), + "k8s.io/api/storage/v1beta1.VolumeAttachmentList": schema_k8sio_api_storage_v1beta1_VolumeAttachmentList(ref), + "k8s.io/api/storage/v1beta1.VolumeAttachmentSource": schema_k8sio_api_storage_v1beta1_VolumeAttachmentSource(ref), + "k8s.io/api/storage/v1beta1.VolumeAttachmentSpec": schema_k8sio_api_storage_v1beta1_VolumeAttachmentSpec(ref), + "k8s.io/api/storage/v1beta1.VolumeAttachmentStatus": schema_k8sio_api_storage_v1beta1_VolumeAttachmentStatus(ref), + "k8s.io/api/storage/v1beta1.VolumeError": schema_k8sio_api_storage_v1beta1_VolumeError(ref), + "k8s.io/api/storage/v1beta1.VolumeNodeResources": schema_k8sio_api_storage_v1beta1_VolumeNodeResources(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ConversionRequest": schema_pkg_apis_apiextensions_v1_ConversionRequest(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ConversionResponse": schema_pkg_apis_apiextensions_v1_ConversionResponse(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ConversionReview": schema_pkg_apis_apiextensions_v1_ConversionReview(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceColumnDefinition": schema_pkg_apis_apiextensions_v1_CustomResourceColumnDefinition(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceConversion": schema_pkg_apis_apiextensions_v1_CustomResourceConversion(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinition": schema_pkg_apis_apiextensions_v1_CustomResourceDefinition(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionCondition": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionCondition(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionList": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionList(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionNames": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionNames(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionSpec": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionSpec(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionStatus": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionStatus(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceDefinitionVersion": schema_pkg_apis_apiextensions_v1_CustomResourceDefinitionVersion(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceSubresourceScale": schema_pkg_apis_apiextensions_v1_CustomResourceSubresourceScale(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceSubresourceStatus": schema_pkg_apis_apiextensions_v1_CustomResourceSubresourceStatus(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceSubresources": schema_pkg_apis_apiextensions_v1_CustomResourceSubresources(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.CustomResourceValidation": schema_pkg_apis_apiextensions_v1_CustomResourceValidation(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ExternalDocumentation": schema_pkg_apis_apiextensions_v1_ExternalDocumentation(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON": schema_pkg_apis_apiextensions_v1_JSON(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSONSchemaProps": schema_pkg_apis_apiextensions_v1_JSONSchemaProps(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSONSchemaPropsOrArray": schema_pkg_apis_apiextensions_v1_JSONSchemaPropsOrArray(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSONSchemaPropsOrBool": schema_pkg_apis_apiextensions_v1_JSONSchemaPropsOrBool(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSONSchemaPropsOrStringArray": schema_pkg_apis_apiextensions_v1_JSONSchemaPropsOrStringArray(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ServiceReference": schema_pkg_apis_apiextensions_v1_ServiceReference(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.ValidationRule": schema_pkg_apis_apiextensions_v1_ValidationRule(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.WebhookClientConfig": schema_pkg_apis_apiextensions_v1_WebhookClientConfig(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.WebhookConversion": schema_pkg_apis_apiextensions_v1_WebhookConversion(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ConversionRequest": schema_pkg_apis_apiextensions_v1beta1_ConversionRequest(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ConversionResponse": schema_pkg_apis_apiextensions_v1beta1_ConversionResponse(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ConversionReview": schema_pkg_apis_apiextensions_v1beta1_ConversionReview(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceColumnDefinition": schema_pkg_apis_apiextensions_v1beta1_CustomResourceColumnDefinition(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceConversion": schema_pkg_apis_apiextensions_v1beta1_CustomResourceConversion(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinition": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinition(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionCondition": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionCondition(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionList": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionList(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionNames": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionNames(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionSpec": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionSpec(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionStatus": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionStatus(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceDefinitionVersion": schema_pkg_apis_apiextensions_v1beta1_CustomResourceDefinitionVersion(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceSubresourceScale": schema_pkg_apis_apiextensions_v1beta1_CustomResourceSubresourceScale(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceSubresourceStatus": schema_pkg_apis_apiextensions_v1beta1_CustomResourceSubresourceStatus(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceSubresources": schema_pkg_apis_apiextensions_v1beta1_CustomResourceSubresources(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.CustomResourceValidation": schema_pkg_apis_apiextensions_v1beta1_CustomResourceValidation(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ExternalDocumentation": schema_pkg_apis_apiextensions_v1beta1_ExternalDocumentation(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSON": schema_pkg_apis_apiextensions_v1beta1_JSON(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSONSchemaProps": schema_pkg_apis_apiextensions_v1beta1_JSONSchemaProps(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSONSchemaPropsOrArray": schema_pkg_apis_apiextensions_v1beta1_JSONSchemaPropsOrArray(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSONSchemaPropsOrBool": schema_pkg_apis_apiextensions_v1beta1_JSONSchemaPropsOrBool(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.JSONSchemaPropsOrStringArray": schema_pkg_apis_apiextensions_v1beta1_JSONSchemaPropsOrStringArray(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ServiceReference": schema_pkg_apis_apiextensions_v1beta1_ServiceReference(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.ValidationRule": schema_pkg_apis_apiextensions_v1beta1_ValidationRule(ref), + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1.WebhookClientConfig": schema_pkg_apis_apiextensions_v1beta1_WebhookClientConfig(ref), + "k8s.io/apimachinery/pkg/api/resource.Quantity": schema_apimachinery_pkg_api_resource_Quantity(ref), + "k8s.io/apimachinery/pkg/api/resource.int64Amount": schema_apimachinery_pkg_api_resource_int64Amount(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.APIGroup": schema_pkg_apis_meta_v1_APIGroup(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.APIGroupList": schema_pkg_apis_meta_v1_APIGroupList(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.APIResource": schema_pkg_apis_meta_v1_APIResource(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.APIResourceList": schema_pkg_apis_meta_v1_APIResourceList(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.APIVersions": schema_pkg_apis_meta_v1_APIVersions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.ApplyOptions": schema_pkg_apis_meta_v1_ApplyOptions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.Condition": schema_pkg_apis_meta_v1_Condition(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.CreateOptions": schema_pkg_apis_meta_v1_CreateOptions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.DeleteOptions": schema_pkg_apis_meta_v1_DeleteOptions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.Duration": schema_pkg_apis_meta_v1_Duration(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.FieldsV1": schema_pkg_apis_meta_v1_FieldsV1(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.GetOptions": schema_pkg_apis_meta_v1_GetOptions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.GroupKind": schema_pkg_apis_meta_v1_GroupKind(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.GroupResource": schema_pkg_apis_meta_v1_GroupResource(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.GroupVersion": schema_pkg_apis_meta_v1_GroupVersion(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.GroupVersionForDiscovery": schema_pkg_apis_meta_v1_GroupVersionForDiscovery(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.GroupVersionKind": schema_pkg_apis_meta_v1_GroupVersionKind(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.GroupVersionResource": schema_pkg_apis_meta_v1_GroupVersionResource(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.InternalEvent": schema_pkg_apis_meta_v1_InternalEvent(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector": schema_pkg_apis_meta_v1_LabelSelector(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelectorRequirement": schema_pkg_apis_meta_v1_LabelSelectorRequirement(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.List": schema_pkg_apis_meta_v1_List(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta": schema_pkg_apis_meta_v1_ListMeta(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.ListOptions": schema_pkg_apis_meta_v1_ListOptions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.ManagedFieldsEntry": schema_pkg_apis_meta_v1_ManagedFieldsEntry(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.MicroTime": schema_pkg_apis_meta_v1_MicroTime(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta": schema_pkg_apis_meta_v1_ObjectMeta(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.OwnerReference": schema_pkg_apis_meta_v1_OwnerReference(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.PartialObjectMetadata": schema_pkg_apis_meta_v1_PartialObjectMetadata(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.PartialObjectMetadataList": schema_pkg_apis_meta_v1_PartialObjectMetadataList(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.Patch": schema_pkg_apis_meta_v1_Patch(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.PatchOptions": schema_pkg_apis_meta_v1_PatchOptions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.Preconditions": schema_pkg_apis_meta_v1_Preconditions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.RootPaths": schema_pkg_apis_meta_v1_RootPaths(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.ServerAddressByClientCIDR": schema_pkg_apis_meta_v1_ServerAddressByClientCIDR(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.Status": schema_pkg_apis_meta_v1_Status(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.StatusCause": schema_pkg_apis_meta_v1_StatusCause(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.StatusDetails": schema_pkg_apis_meta_v1_StatusDetails(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.Table": schema_pkg_apis_meta_v1_Table(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.TableColumnDefinition": schema_pkg_apis_meta_v1_TableColumnDefinition(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.TableOptions": schema_pkg_apis_meta_v1_TableOptions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.TableRow": schema_pkg_apis_meta_v1_TableRow(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.TableRowCondition": schema_pkg_apis_meta_v1_TableRowCondition(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.Time": schema_pkg_apis_meta_v1_Time(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.Timestamp": schema_pkg_apis_meta_v1_Timestamp(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta": schema_pkg_apis_meta_v1_TypeMeta(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.UpdateOptions": schema_pkg_apis_meta_v1_UpdateOptions(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1.WatchEvent": schema_pkg_apis_meta_v1_WatchEvent(ref), + "k8s.io/apimachinery/pkg/apis/meta/v1beta1.PartialObjectMetadataList": schema_pkg_apis_meta_v1beta1_PartialObjectMetadataList(ref), + "k8s.io/apimachinery/pkg/runtime.RawExtension": schema_k8sio_apimachinery_pkg_runtime_RawExtension(ref), + "k8s.io/apimachinery/pkg/runtime.TypeMeta": schema_k8sio_apimachinery_pkg_runtime_TypeMeta(ref), + "k8s.io/apimachinery/pkg/runtime.Unknown": schema_k8sio_apimachinery_pkg_runtime_Unknown(ref), + "k8s.io/apimachinery/pkg/util/intstr.IntOrString": schema_apimachinery_pkg_util_intstr_IntOrString(ref), + "k8s.io/apimachinery/pkg/version.Info": schema_k8sio_apimachinery_pkg_version_Info(ref), + "k8s.io/apiserver/pkg/apis/audit/v1.Event": schema_pkg_apis_audit_v1_Event(ref), + "k8s.io/apiserver/pkg/apis/audit/v1.EventList": schema_pkg_apis_audit_v1_EventList(ref), + "k8s.io/apiserver/pkg/apis/audit/v1.GroupResources": schema_pkg_apis_audit_v1_GroupResources(ref), + "k8s.io/apiserver/pkg/apis/audit/v1.ObjectReference": schema_pkg_apis_audit_v1_ObjectReference(ref), + "k8s.io/apiserver/pkg/apis/audit/v1.Policy": schema_pkg_apis_audit_v1_Policy(ref), + "k8s.io/apiserver/pkg/apis/audit/v1.PolicyList": schema_pkg_apis_audit_v1_PolicyList(ref), + "k8s.io/apiserver/pkg/apis/audit/v1.PolicyRule": schema_pkg_apis_audit_v1_PolicyRule(ref), + "k8s.io/client-go/pkg/apis/clientauthentication/v1.Cluster": schema_pkg_apis_clientauthentication_v1_Cluster(ref), + "k8s.io/client-go/pkg/apis/clientauthentication/v1.ExecCredential": schema_pkg_apis_clientauthentication_v1_ExecCredential(ref), + "k8s.io/client-go/pkg/apis/clientauthentication/v1.ExecCredentialSpec": schema_pkg_apis_clientauthentication_v1_ExecCredentialSpec(ref), + "k8s.io/client-go/pkg/apis/clientauthentication/v1.ExecCredentialStatus": schema_pkg_apis_clientauthentication_v1_ExecCredentialStatus(ref), + "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1.Cluster": schema_pkg_apis_clientauthentication_v1beta1_Cluster(ref), + "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1.ExecCredential": schema_pkg_apis_clientauthentication_v1beta1_ExecCredential(ref), + "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1.ExecCredentialSpec": schema_pkg_apis_clientauthentication_v1beta1_ExecCredentialSpec(ref), + "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1.ExecCredentialStatus": schema_pkg_apis_clientauthentication_v1beta1_ExecCredentialStatus(ref), + "k8s.io/cloud-provider/config/v1alpha1.CloudControllerManagerConfiguration": schema_k8sio_cloud_provider_config_v1alpha1_CloudControllerManagerConfiguration(ref), + "k8s.io/cloud-provider/config/v1alpha1.CloudProviderConfiguration": schema_k8sio_cloud_provider_config_v1alpha1_CloudProviderConfiguration(ref), + "k8s.io/cloud-provider/config/v1alpha1.KubeCloudSharedConfiguration": schema_k8sio_cloud_provider_config_v1alpha1_KubeCloudSharedConfiguration(ref), + "k8s.io/cloud-provider/config/v1alpha1.WebhookConfiguration": schema_k8sio_cloud_provider_config_v1alpha1_WebhookConfiguration(ref), + "k8s.io/controller-manager/config/v1alpha1.ControllerLeaderConfiguration": schema_k8sio_controller_manager_config_v1alpha1_ControllerLeaderConfiguration(ref), + "k8s.io/controller-manager/config/v1alpha1.GenericControllerManagerConfiguration": schema_k8sio_controller_manager_config_v1alpha1_GenericControllerManagerConfiguration(ref), + "k8s.io/controller-manager/config/v1alpha1.LeaderMigrationConfiguration": schema_k8sio_controller_manager_config_v1alpha1_LeaderMigrationConfiguration(ref), + "k8s.io/controller-manager/config/v1beta1.ControllerLeaderConfiguration": schema_k8sio_controller_manager_config_v1beta1_ControllerLeaderConfiguration(ref), + "k8s.io/controller-manager/config/v1beta1.LeaderMigrationConfiguration": schema_k8sio_controller_manager_config_v1beta1_LeaderMigrationConfiguration(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIService": schema_pkg_apis_apiregistration_v1_APIService(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIServiceCondition": schema_pkg_apis_apiregistration_v1_APIServiceCondition(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIServiceList": schema_pkg_apis_apiregistration_v1_APIServiceList(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIServiceSpec": schema_pkg_apis_apiregistration_v1_APIServiceSpec(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.APIServiceStatus": schema_pkg_apis_apiregistration_v1_APIServiceStatus(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1.ServiceReference": schema_pkg_apis_apiregistration_v1_ServiceReference(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIService": schema_pkg_apis_apiregistration_v1beta1_APIService(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIServiceCondition": schema_pkg_apis_apiregistration_v1beta1_APIServiceCondition(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIServiceList": schema_pkg_apis_apiregistration_v1beta1_APIServiceList(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIServiceSpec": schema_pkg_apis_apiregistration_v1beta1_APIServiceSpec(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.APIServiceStatus": schema_pkg_apis_apiregistration_v1beta1_APIServiceStatus(ref), + "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1.ServiceReference": schema_pkg_apis_apiregistration_v1beta1_ServiceReference(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.AttachDetachControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_AttachDetachControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.CSRSigningConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_CSRSigningConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.CSRSigningControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_CSRSigningControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.CronJobControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_CronJobControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.DaemonSetControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_DaemonSetControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.DeploymentControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_DeploymentControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.DeprecatedControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_DeprecatedControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.EndpointControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_EndpointControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.EndpointSliceControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_EndpointSliceControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.EndpointSliceMirroringControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_EndpointSliceMirroringControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.EphemeralVolumeControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_EphemeralVolumeControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.GarbageCollectorControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_GarbageCollectorControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.GroupResource": schema_k8sio_kube_controller_manager_config_v1alpha1_GroupResource(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.HPAControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_HPAControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.JobControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_JobControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.KubeControllerManagerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_KubeControllerManagerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.LegacySATokenCleanerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_LegacySATokenCleanerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.NamespaceControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_NamespaceControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.NodeIPAMControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_NodeIPAMControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.NodeLifecycleControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_NodeLifecycleControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.PersistentVolumeBinderControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_PersistentVolumeBinderControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.PersistentVolumeRecyclerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_PersistentVolumeRecyclerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.PodGCControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_PodGCControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.ReplicaSetControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_ReplicaSetControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.ReplicationControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_ReplicationControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.ResourceQuotaControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_ResourceQuotaControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.SAControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_SAControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.StatefulSetControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_StatefulSetControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.TTLAfterFinishedControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_TTLAfterFinishedControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration(ref), + "k8s.io/kube-controller-manager/config/v1alpha1.VolumeConfiguration": schema_k8sio_kube_controller_manager_config_v1alpha1_VolumeConfiguration(ref), + "k8s.io/kube-proxy/config/v1alpha1.DetectLocalConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_DetectLocalConfiguration(ref), + "k8s.io/kube-proxy/config/v1alpha1.KubeProxyConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyConfiguration(ref), + "k8s.io/kube-proxy/config/v1alpha1.KubeProxyConntrackConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyConntrackConfiguration(ref), + "k8s.io/kube-proxy/config/v1alpha1.KubeProxyIPTablesConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyIPTablesConfiguration(ref), + "k8s.io/kube-proxy/config/v1alpha1.KubeProxyIPVSConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyIPVSConfiguration(ref), + "k8s.io/kube-proxy/config/v1alpha1.KubeProxyWinkernelConfiguration": schema_k8sio_kube_proxy_config_v1alpha1_KubeProxyWinkernelConfiguration(ref), + "k8s.io/kube-scheduler/config/v1.DefaultPreemptionArgs": schema_k8sio_kube_scheduler_config_v1_DefaultPreemptionArgs(ref), + "k8s.io/kube-scheduler/config/v1.Extender": schema_k8sio_kube_scheduler_config_v1_Extender(ref), + "k8s.io/kube-scheduler/config/v1.ExtenderManagedResource": schema_k8sio_kube_scheduler_config_v1_ExtenderManagedResource(ref), + "k8s.io/kube-scheduler/config/v1.ExtenderTLSConfig": schema_k8sio_kube_scheduler_config_v1_ExtenderTLSConfig(ref), + "k8s.io/kube-scheduler/config/v1.InterPodAffinityArgs": schema_k8sio_kube_scheduler_config_v1_InterPodAffinityArgs(ref), + "k8s.io/kube-scheduler/config/v1.KubeSchedulerConfiguration": schema_k8sio_kube_scheduler_config_v1_KubeSchedulerConfiguration(ref), + "k8s.io/kube-scheduler/config/v1.KubeSchedulerProfile": schema_k8sio_kube_scheduler_config_v1_KubeSchedulerProfile(ref), + "k8s.io/kube-scheduler/config/v1.NodeAffinityArgs": schema_k8sio_kube_scheduler_config_v1_NodeAffinityArgs(ref), + "k8s.io/kube-scheduler/config/v1.NodeResourcesBalancedAllocationArgs": schema_k8sio_kube_scheduler_config_v1_NodeResourcesBalancedAllocationArgs(ref), + "k8s.io/kube-scheduler/config/v1.NodeResourcesFitArgs": schema_k8sio_kube_scheduler_config_v1_NodeResourcesFitArgs(ref), + "k8s.io/kube-scheduler/config/v1.Plugin": schema_k8sio_kube_scheduler_config_v1_Plugin(ref), + "k8s.io/kube-scheduler/config/v1.PluginConfig": schema_k8sio_kube_scheduler_config_v1_PluginConfig(ref), + "k8s.io/kube-scheduler/config/v1.PluginSet": schema_k8sio_kube_scheduler_config_v1_PluginSet(ref), + "k8s.io/kube-scheduler/config/v1.Plugins": schema_k8sio_kube_scheduler_config_v1_Plugins(ref), + "k8s.io/kube-scheduler/config/v1.PodTopologySpreadArgs": schema_k8sio_kube_scheduler_config_v1_PodTopologySpreadArgs(ref), + "k8s.io/kube-scheduler/config/v1.RequestedToCapacityRatioParam": schema_k8sio_kube_scheduler_config_v1_RequestedToCapacityRatioParam(ref), + "k8s.io/kube-scheduler/config/v1.ResourceSpec": schema_k8sio_kube_scheduler_config_v1_ResourceSpec(ref), + "k8s.io/kube-scheduler/config/v1.ScoringStrategy": schema_k8sio_kube_scheduler_config_v1_ScoringStrategy(ref), + "k8s.io/kube-scheduler/config/v1.UtilizationShapePoint": schema_k8sio_kube_scheduler_config_v1_UtilizationShapePoint(ref), + "k8s.io/kube-scheduler/config/v1.VolumeBindingArgs": schema_k8sio_kube_scheduler_config_v1_VolumeBindingArgs(ref), + "k8s.io/kube-scheduler/config/v1beta3.DefaultPreemptionArgs": schema_k8sio_kube_scheduler_config_v1beta3_DefaultPreemptionArgs(ref), + "k8s.io/kube-scheduler/config/v1beta3.Extender": schema_k8sio_kube_scheduler_config_v1beta3_Extender(ref), + "k8s.io/kube-scheduler/config/v1beta3.ExtenderManagedResource": schema_k8sio_kube_scheduler_config_v1beta3_ExtenderManagedResource(ref), + "k8s.io/kube-scheduler/config/v1beta3.ExtenderTLSConfig": schema_k8sio_kube_scheduler_config_v1beta3_ExtenderTLSConfig(ref), + "k8s.io/kube-scheduler/config/v1beta3.InterPodAffinityArgs": schema_k8sio_kube_scheduler_config_v1beta3_InterPodAffinityArgs(ref), + "k8s.io/kube-scheduler/config/v1beta3.KubeSchedulerConfiguration": schema_k8sio_kube_scheduler_config_v1beta3_KubeSchedulerConfiguration(ref), + "k8s.io/kube-scheduler/config/v1beta3.KubeSchedulerProfile": schema_k8sio_kube_scheduler_config_v1beta3_KubeSchedulerProfile(ref), + "k8s.io/kube-scheduler/config/v1beta3.NodeAffinityArgs": schema_k8sio_kube_scheduler_config_v1beta3_NodeAffinityArgs(ref), + "k8s.io/kube-scheduler/config/v1beta3.NodeResourcesBalancedAllocationArgs": schema_k8sio_kube_scheduler_config_v1beta3_NodeResourcesBalancedAllocationArgs(ref), + "k8s.io/kube-scheduler/config/v1beta3.NodeResourcesFitArgs": schema_k8sio_kube_scheduler_config_v1beta3_NodeResourcesFitArgs(ref), + "k8s.io/kube-scheduler/config/v1beta3.Plugin": schema_k8sio_kube_scheduler_config_v1beta3_Plugin(ref), + "k8s.io/kube-scheduler/config/v1beta3.PluginConfig": schema_k8sio_kube_scheduler_config_v1beta3_PluginConfig(ref), + "k8s.io/kube-scheduler/config/v1beta3.PluginSet": schema_k8sio_kube_scheduler_config_v1beta3_PluginSet(ref), + "k8s.io/kube-scheduler/config/v1beta3.Plugins": schema_k8sio_kube_scheduler_config_v1beta3_Plugins(ref), + "k8s.io/kube-scheduler/config/v1beta3.PodTopologySpreadArgs": schema_k8sio_kube_scheduler_config_v1beta3_PodTopologySpreadArgs(ref), + "k8s.io/kube-scheduler/config/v1beta3.RequestedToCapacityRatioParam": schema_k8sio_kube_scheduler_config_v1beta3_RequestedToCapacityRatioParam(ref), + "k8s.io/kube-scheduler/config/v1beta3.ResourceSpec": schema_k8sio_kube_scheduler_config_v1beta3_ResourceSpec(ref), + "k8s.io/kube-scheduler/config/v1beta3.ScoringStrategy": schema_k8sio_kube_scheduler_config_v1beta3_ScoringStrategy(ref), + "k8s.io/kube-scheduler/config/v1beta3.UtilizationShapePoint": schema_k8sio_kube_scheduler_config_v1beta3_UtilizationShapePoint(ref), + "k8s.io/kube-scheduler/config/v1beta3.VolumeBindingArgs": schema_k8sio_kube_scheduler_config_v1beta3_VolumeBindingArgs(ref), + "k8s.io/kubelet/config/v1.CredentialProvider": schema_k8sio_kubelet_config_v1_CredentialProvider(ref), + "k8s.io/kubelet/config/v1.CredentialProviderConfig": schema_k8sio_kubelet_config_v1_CredentialProviderConfig(ref), + "k8s.io/kubelet/config/v1.ExecEnvVar": schema_k8sio_kubelet_config_v1_ExecEnvVar(ref), + "k8s.io/kubelet/config/v1alpha1.CredentialProvider": schema_k8sio_kubelet_config_v1alpha1_CredentialProvider(ref), + "k8s.io/kubelet/config/v1alpha1.CredentialProviderConfig": schema_k8sio_kubelet_config_v1alpha1_CredentialProviderConfig(ref), + "k8s.io/kubelet/config/v1alpha1.ExecEnvVar": schema_k8sio_kubelet_config_v1alpha1_ExecEnvVar(ref), + "k8s.io/kubelet/config/v1beta1.CredentialProvider": schema_k8sio_kubelet_config_v1beta1_CredentialProvider(ref), + "k8s.io/kubelet/config/v1beta1.CredentialProviderConfig": schema_k8sio_kubelet_config_v1beta1_CredentialProviderConfig(ref), + "k8s.io/kubelet/config/v1beta1.ExecEnvVar": schema_k8sio_kubelet_config_v1beta1_ExecEnvVar(ref), + "k8s.io/kubelet/config/v1beta1.KubeletAnonymousAuthentication": schema_k8sio_kubelet_config_v1beta1_KubeletAnonymousAuthentication(ref), + "k8s.io/kubelet/config/v1beta1.KubeletAuthentication": schema_k8sio_kubelet_config_v1beta1_KubeletAuthentication(ref), + "k8s.io/kubelet/config/v1beta1.KubeletAuthorization": schema_k8sio_kubelet_config_v1beta1_KubeletAuthorization(ref), + "k8s.io/kubelet/config/v1beta1.KubeletConfiguration": schema_k8sio_kubelet_config_v1beta1_KubeletConfiguration(ref), + "k8s.io/kubelet/config/v1beta1.KubeletWebhookAuthentication": schema_k8sio_kubelet_config_v1beta1_KubeletWebhookAuthentication(ref), + "k8s.io/kubelet/config/v1beta1.KubeletWebhookAuthorization": schema_k8sio_kubelet_config_v1beta1_KubeletWebhookAuthorization(ref), + "k8s.io/kubelet/config/v1beta1.KubeletX509Authentication": schema_k8sio_kubelet_config_v1beta1_KubeletX509Authentication(ref), + "k8s.io/kubelet/config/v1beta1.MemoryReservation": schema_k8sio_kubelet_config_v1beta1_MemoryReservation(ref), + "k8s.io/kubelet/config/v1beta1.MemorySwapConfiguration": schema_k8sio_kubelet_config_v1beta1_MemorySwapConfiguration(ref), + "k8s.io/kubelet/config/v1beta1.SerializedNodeConfigSource": schema_k8sio_kubelet_config_v1beta1_SerializedNodeConfigSource(ref), + "k8s.io/kubelet/config/v1beta1.ShutdownGracePeriodByPodPriority": schema_k8sio_kubelet_config_v1beta1_ShutdownGracePeriodByPodPriority(ref), + "k8s.io/kubernetes/pkg/apis/abac/v1beta1.Policy": schema_pkg_apis_abac_v1beta1_Policy(ref), + "k8s.io/kubernetes/pkg/apis/abac/v1beta1.PolicySpec": schema_pkg_apis_abac_v1beta1_PolicySpec(ref), + "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1.MetricListOptions": schema_pkg_apis_custom_metrics_v1beta1_MetricListOptions(ref), + "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1.MetricValue": schema_pkg_apis_custom_metrics_v1beta1_MetricValue(ref), + "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1.MetricValueList": schema_pkg_apis_custom_metrics_v1beta1_MetricValueList(ref), + "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2.MetricIdentifier": schema_pkg_apis_custom_metrics_v1beta2_MetricIdentifier(ref), + "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2.MetricListOptions": schema_pkg_apis_custom_metrics_v1beta2_MetricListOptions(ref), + "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2.MetricValue": schema_pkg_apis_custom_metrics_v1beta2_MetricValue(ref), + "k8s.io/metrics/pkg/apis/custom_metrics/v1beta2.MetricValueList": schema_pkg_apis_custom_metrics_v1beta2_MetricValueList(ref), + "k8s.io/metrics/pkg/apis/external_metrics/v1beta1.ExternalMetricValue": schema_pkg_apis_external_metrics_v1beta1_ExternalMetricValue(ref), + "k8s.io/metrics/pkg/apis/external_metrics/v1beta1.ExternalMetricValueList": schema_pkg_apis_external_metrics_v1beta1_ExternalMetricValueList(ref), + "k8s.io/metrics/pkg/apis/metrics/v1alpha1.ContainerMetrics": schema_pkg_apis_metrics_v1alpha1_ContainerMetrics(ref), + "k8s.io/metrics/pkg/apis/metrics/v1alpha1.NodeMetrics": schema_pkg_apis_metrics_v1alpha1_NodeMetrics(ref), + "k8s.io/metrics/pkg/apis/metrics/v1alpha1.NodeMetricsList": schema_pkg_apis_metrics_v1alpha1_NodeMetricsList(ref), + "k8s.io/metrics/pkg/apis/metrics/v1alpha1.PodMetrics": schema_pkg_apis_metrics_v1alpha1_PodMetrics(ref), + "k8s.io/metrics/pkg/apis/metrics/v1alpha1.PodMetricsList": schema_pkg_apis_metrics_v1alpha1_PodMetricsList(ref), + "k8s.io/metrics/pkg/apis/metrics/v1beta1.ContainerMetrics": schema_pkg_apis_metrics_v1beta1_ContainerMetrics(ref), + "k8s.io/metrics/pkg/apis/metrics/v1beta1.NodeMetrics": schema_pkg_apis_metrics_v1beta1_NodeMetrics(ref), + "k8s.io/metrics/pkg/apis/metrics/v1beta1.NodeMetricsList": schema_pkg_apis_metrics_v1beta1_NodeMetricsList(ref), + "k8s.io/metrics/pkg/apis/metrics/v1beta1.PodMetrics": schema_pkg_apis_metrics_v1beta1_PodMetrics(ref), + "k8s.io/metrics/pkg/apis/metrics/v1beta1.PodMetricsList": schema_pkg_apis_metrics_v1beta1_PodMetricsList(ref), } } @@ -53218,12 +53219,19 @@ func schema_k8sio_kube_controller_manager_config_v1alpha1_KubeControllerManagerC Ref: ref("k8s.io/kube-controller-manager/config/v1alpha1.TTLAfterFinishedControllerConfiguration"), }, }, + "ValidatingAdmissionPolicyStatusController": { + SchemaProps: spec.SchemaProps{ + Description: "ValidatingAdmissionPolicyStatusControllerConfiguration holds configuration for ValidatingAdmissionPolicyStatusController related features.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/kube-controller-manager/config/v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration"), + }, + }, }, - Required: []string{"Generic", "KubeCloudShared", "AttachDetachController", "CSRSigningController", "DaemonSetController", "DeploymentController", "StatefulSetController", "DeprecatedController", "EndpointController", "EndpointSliceController", "EndpointSliceMirroringController", "EphemeralVolumeController", "GarbageCollectorController", "HPAController", "JobController", "CronJobController", "LegacySATokenCleaner", "NamespaceController", "NodeIPAMController", "NodeLifecycleController", "PersistentVolumeBinderController", "PodGCController", "ReplicaSetController", "ReplicationController", "ResourceQuotaController", "SAController", "ServiceController", "TTLAfterFinishedController"}, + Required: []string{"Generic", "KubeCloudShared", "AttachDetachController", "CSRSigningController", "DaemonSetController", "DeploymentController", "StatefulSetController", "DeprecatedController", "EndpointController", "EndpointSliceController", "EndpointSliceMirroringController", "EphemeralVolumeController", "GarbageCollectorController", "HPAController", "JobController", "CronJobController", "LegacySATokenCleaner", "NamespaceController", "NodeIPAMController", "NodeLifecycleController", "PersistentVolumeBinderController", "PodGCController", "ReplicaSetController", "ReplicationController", "ResourceQuotaController", "SAController", "ServiceController", "TTLAfterFinishedController", "ValidatingAdmissionPolicyStatusController"}, }, }, Dependencies: []string{ - "k8s.io/cloud-provider/config/v1alpha1.KubeCloudSharedConfiguration", "k8s.io/cloud-provider/controllers/service/config/v1alpha1.ServiceControllerConfiguration", "k8s.io/controller-manager/config/v1alpha1.GenericControllerManagerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.AttachDetachControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.CSRSigningControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.CronJobControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.DaemonSetControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.DeploymentControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.DeprecatedControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.EndpointControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.EndpointSliceControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.EndpointSliceMirroringControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.EphemeralVolumeControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.GarbageCollectorControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.HPAControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.JobControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.LegacySATokenCleanerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.NamespaceControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.NodeIPAMControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.NodeLifecycleControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.PersistentVolumeBinderControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.PodGCControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.ReplicaSetControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.ReplicationControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.ResourceQuotaControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.SAControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.StatefulSetControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.TTLAfterFinishedControllerConfiguration"}, + "k8s.io/cloud-provider/config/v1alpha1.KubeCloudSharedConfiguration", "k8s.io/cloud-provider/controllers/service/config/v1alpha1.ServiceControllerConfiguration", "k8s.io/controller-manager/config/v1alpha1.GenericControllerManagerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.AttachDetachControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.CSRSigningControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.CronJobControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.DaemonSetControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.DeploymentControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.DeprecatedControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.EndpointControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.EndpointSliceControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.EndpointSliceMirroringControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.EphemeralVolumeControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.GarbageCollectorControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.HPAControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.JobControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.LegacySATokenCleanerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.NamespaceControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.NodeIPAMControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.NodeLifecycleControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.PersistentVolumeBinderControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.PodGCControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.ReplicaSetControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.ReplicationControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.ResourceQuotaControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.SAControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.StatefulSetControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.TTLAfterFinishedControllerConfiguration", "k8s.io/kube-controller-manager/config/v1alpha1.ValidatingAdmissionPolicyStatusControllerConfiguration"}, } } @@ -53705,6 +53713,28 @@ func schema_k8sio_kube_controller_manager_config_v1alpha1_TTLAfterFinishedContro } } +func schema_k8sio_kube_controller_manager_config_v1alpha1_ValidatingAdmissionPolicyStatusControllerConfiguration(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ValidatingAdmissionPolicyStatusControllerConfiguration contains elements describing ValidatingAdmissionPolicyStatusController.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "ConcurrentPolicySyncs": { + SchemaProps: spec.SchemaProps{ + Description: "ConcurrentPolicySyncs is the number of policy objects that are allowed to sync concurrently. Larger number = quicker type checking, but more CPU (and network) load. The default value is 5.", + Default: 0, + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + Required: []string{"ConcurrentPolicySyncs"}, + }, + }, + } +} + func schema_k8sio_kube_controller_manager_config_v1alpha1_VolumeConfiguration(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ diff --git a/pkg/kubeapiserver/admission/config.go b/pkg/kubeapiserver/admission/config.go index 81712b49cbd..751d29f3c86 100644 --- a/pkg/kubeapiserver/admission/config.go +++ b/pkg/kubeapiserver/admission/config.go @@ -28,7 +28,6 @@ import ( utilwait "k8s.io/apimachinery/pkg/util/wait" "k8s.io/apiserver/pkg/admission" webhookinit "k8s.io/apiserver/pkg/admission/plugin/webhook/initializer" - "k8s.io/apiserver/pkg/cel/openapi/resolver" genericapiserver "k8s.io/apiserver/pkg/server" egressselector "k8s.io/apiserver/pkg/server/egressselector" "k8s.io/apiserver/pkg/util/webhook" @@ -48,7 +47,7 @@ type Config struct { } // New sets up the plugins and admission start hooks needed for admission -func (c *Config) New(proxyTransport *http.Transport, egressSelector *egressselector.EgressSelector, serviceResolver webhook.ServiceResolver, tp trace.TracerProvider, schemaResolver resolver.SchemaResolver) ([]admission.PluginInitializer, genericapiserver.PostStartHookFunc, error) { +func (c *Config) New(proxyTransport *http.Transport, egressSelector *egressselector.EgressSelector, serviceResolver webhook.ServiceResolver, tp trace.TracerProvider) ([]admission.PluginInitializer, genericapiserver.PostStartHookFunc, error) { webhookAuthResolverWrapper := webhook.NewDefaultAuthenticationInfoResolverWrapper(proxyTransport, egressSelector, c.LoopbackClientConfig, tp) webhookPluginInitializer := webhookinit.NewPluginInitializer(webhookAuthResolverWrapper, serviceResolver) @@ -70,7 +69,6 @@ func (c *Config) New(proxyTransport *http.Transport, egressSelector *egressselec cloudConfig, discoveryRESTMapper, quotainstall.NewQuotaConfigurationForAdmission(), - schemaResolver, ) admissionPostStartHook := func(context genericapiserver.PostStartHookContext) error { diff --git a/pkg/kubeapiserver/admission/initializer.go b/pkg/kubeapiserver/admission/initializer.go index 40feff35c35..0ba97b5427b 100644 --- a/pkg/kubeapiserver/admission/initializer.go +++ b/pkg/kubeapiserver/admission/initializer.go @@ -20,7 +20,6 @@ import ( "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apiserver/pkg/admission" "k8s.io/apiserver/pkg/admission/initializer" - "k8s.io/apiserver/pkg/cel/openapi/resolver" quota "k8s.io/apiserver/pkg/quota/v1" ) @@ -36,7 +35,6 @@ type PluginInitializer struct { cloudConfig []byte restMapper meta.RESTMapper quotaConfiguration quota.Configuration - schemaResolver resolver.SchemaResolver } var _ admission.PluginInitializer = &PluginInitializer{} @@ -48,13 +46,11 @@ func NewPluginInitializer( cloudConfig []byte, restMapper meta.RESTMapper, quotaConfiguration quota.Configuration, - schemaResolver resolver.SchemaResolver, ) *PluginInitializer { return &PluginInitializer{ cloudConfig: cloudConfig, restMapper: restMapper, quotaConfiguration: quotaConfiguration, - schemaResolver: schemaResolver, } } @@ -72,8 +68,4 @@ func (i *PluginInitializer) Initialize(plugin admission.Interface) { if wants, ok := plugin.(initializer.WantsQuotaConfiguration); ok { wants.SetQuotaConfiguration(i.quotaConfiguration) } - - if wants, ok := plugin.(initializer.WantsSchemaResolver); ok { - wants.SetSchemaResolver(i.schemaResolver) - } } diff --git a/pkg/kubeapiserver/admission/initializer_test.go b/pkg/kubeapiserver/admission/initializer_test.go index f4fa85e812c..a9fdd5fcece 100644 --- a/pkg/kubeapiserver/admission/initializer_test.go +++ b/pkg/kubeapiserver/admission/initializer_test.go @@ -49,7 +49,7 @@ func (p *WantsCloudConfigAdmissionPlugin) SetCloudConfig(cloudConfig []byte) { func TestCloudConfigAdmissionPlugin(t *testing.T) { cloudConfig := []byte("cloud-configuration") - initializer := NewPluginInitializer(cloudConfig, nil, nil, nil) + initializer := NewPluginInitializer(cloudConfig, nil, nil) wantsCloudConfigAdmission := &WantsCloudConfigAdmissionPlugin{} initializer.Initialize(wantsCloudConfigAdmission) @@ -94,7 +94,7 @@ func (p *WantsRESTMapperAdmissionPlugin) SetRESTMapper(mapper meta.RESTMapper) { func TestRESTMapperAdmissionPlugin(t *testing.T) { mapper := doNothingRESTMapper{} - initializer := NewPluginInitializer(nil, mapper, nil, nil) + initializer := NewPluginInitializer(nil, mapper, nil) wantsRESTMapperAdmission := &WantsRESTMapperAdmissionPlugin{} initializer.Initialize(wantsRESTMapperAdmission) @@ -121,7 +121,7 @@ func (p *WantsQuotaConfigurationAdmissionPlugin) SetQuotaConfiguration(config qu func TestQuotaConfigurationAdmissionPlugin(t *testing.T) { config := doNothingQuotaConfiguration{} - initializer := NewPluginInitializer(nil, nil, config, nil) + initializer := NewPluginInitializer(nil, nil, config) wantsQuotaConfigurationAdmission := &WantsQuotaConfigurationAdmissionPlugin{} initializer.Initialize(wantsQuotaConfigurationAdmission) diff --git a/plugin/pkg/admission/gc/gc_admission_test.go b/plugin/pkg/admission/gc/gc_admission_test.go index 889162e29f0..d32c7cd2504 100644 --- a/plugin/pkg/admission/gc/gc_admission_test.go +++ b/plugin/pkg/admission/gc/gc_admission_test.go @@ -139,7 +139,7 @@ func newGCPermissionsEnforcement() (*gcPermissionsEnforcement, error) { return nil, fmt.Errorf("unexpected error while constructing resource list from fake discovery client: %v", err) } restMapper := restmapper.NewDiscoveryRESTMapper(restMapperRes) - pluginInitializer := kubeadmission.NewPluginInitializer(nil, restMapper, nil, nil) + pluginInitializer := kubeadmission.NewPluginInitializer(nil, restMapper, nil) initializersChain := admission.PluginInitializers{} initializersChain = append(initializersChain, genericPluginInitializer) initializersChain = append(initializersChain, pluginInitializer) diff --git a/plugin/pkg/admission/resourcequota/admission_test.go b/plugin/pkg/admission/resourcequota/admission_test.go index f98f1cd5c60..a1114331e3c 100644 --- a/plugin/pkg/admission/resourcequota/admission_test.go +++ b/plugin/pkg/admission/resourcequota/admission_test.go @@ -111,7 +111,7 @@ func createHandlerWithConfig(kubeClient kubernetes.Interface, informerFactory in initializers := admission.PluginInitializers{ genericadmissioninitializer.New(kubeClient, nil, informerFactory, nil, nil, stopCh), - kubeapiserveradmission.NewPluginInitializer(nil, nil, quotaConfiguration, nil), + kubeapiserveradmission.NewPluginInitializer(nil, nil, quotaConfiguration), } initializers.Initialize(handler) diff --git a/plugin/pkg/auth/authorizer/rbac/bootstrappolicy/controller_policy.go b/plugin/pkg/auth/authorizer/rbac/bootstrappolicy/controller_policy.go index b1eb24a9c3e..3b3f6ed98d8 100644 --- a/plugin/pkg/auth/authorizer/rbac/bootstrappolicy/controller_policy.go +++ b/plugin/pkg/auth/authorizer/rbac/bootstrappolicy/controller_policy.go @@ -441,6 +441,18 @@ func buildControllerRoles() ([]rbacv1.ClusterRole, []rbacv1.ClusterRoleBinding) eventsRule(), }, }) + if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.ValidatingAdmissionPolicy) { + addControllerRole(&controllerRoles, &controllerRoleBindings, rbacv1.ClusterRole{ + ObjectMeta: metav1.ObjectMeta{Name: saRolePrefix + "validatingadmissionpolicy-status-controller"}, + Rules: []rbacv1.PolicyRule{ + rbacv1helpers.NewRule("get", "list", "watch").Groups(admissionRegistrationGroup). + Resources("validatingadmissionpolicies").RuleOrDie(), + rbacv1helpers.NewRule("get", "patch", "update").Groups(admissionRegistrationGroup). + Resources("validatingadmissionpolicies/status").RuleOrDie(), + eventsRule(), + }, + }) + } if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.StorageVersionAPI) && utilfeature.DefaultFeatureGate.Enabled(genericfeatures.APIServerIdentity) { addControllerRole(&controllerRoles, &controllerRoleBindings, rbacv1.ClusterRole{ diff --git a/plugin/pkg/auth/authorizer/rbac/bootstrappolicy/policy.go b/plugin/pkg/auth/authorizer/rbac/bootstrappolicy/policy.go index 2e49905210d..5b1b7cb6a60 100644 --- a/plugin/pkg/auth/authorizer/rbac/bootstrappolicy/policy.go +++ b/plugin/pkg/auth/authorizer/rbac/bootstrappolicy/policy.go @@ -42,26 +42,27 @@ var ( ) const ( - legacyGroup = "" - appsGroup = "apps" - authenticationGroup = "authentication.k8s.io" - authorizationGroup = "authorization.k8s.io" - autoscalingGroup = "autoscaling" - batchGroup = "batch" - certificatesGroup = "certificates.k8s.io" - coordinationGroup = "coordination.k8s.io" - discoveryGroup = "discovery.k8s.io" - extensionsGroup = "extensions" - policyGroup = "policy" - rbacGroup = "rbac.authorization.k8s.io" - resourceGroup = "resource.k8s.io" - storageGroup = "storage.k8s.io" - resMetricsGroup = "metrics.k8s.io" - customMetricsGroup = "custom.metrics.k8s.io" - externalMetricsGroup = "external.metrics.k8s.io" - networkingGroup = "networking.k8s.io" - eventsGroup = "events.k8s.io" - internalAPIServerGroup = "internal.apiserver.k8s.io" + legacyGroup = "" + appsGroup = "apps" + authenticationGroup = "authentication.k8s.io" + authorizationGroup = "authorization.k8s.io" + autoscalingGroup = "autoscaling" + batchGroup = "batch" + certificatesGroup = "certificates.k8s.io" + coordinationGroup = "coordination.k8s.io" + discoveryGroup = "discovery.k8s.io" + extensionsGroup = "extensions" + policyGroup = "policy" + rbacGroup = "rbac.authorization.k8s.io" + resourceGroup = "resource.k8s.io" + storageGroup = "storage.k8s.io" + resMetricsGroup = "metrics.k8s.io" + customMetricsGroup = "custom.metrics.k8s.io" + externalMetricsGroup = "external.metrics.k8s.io" + networkingGroup = "networking.k8s.io" + eventsGroup = "events.k8s.io" + internalAPIServerGroup = "internal.apiserver.k8s.io" + admissionRegistrationGroup = "admissionregistration.k8s.io" ) func addDefaultMetadata(obj runtime.Object) { diff --git a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/admission.go b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/admission.go index 9a514b46319..e51bc6e7379 100644 --- a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/admission.go +++ b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/admission.go @@ -24,7 +24,6 @@ import ( "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apiserver/pkg/authorization/authorizer" - "k8s.io/apiserver/pkg/cel/openapi/resolver" "k8s.io/apiserver/pkg/features" "k8s.io/client-go/dynamic" "k8s.io/component-base/featuregate" @@ -74,7 +73,6 @@ type celAdmissionPlugin struct { dynamicClient dynamic.Interface stopCh <-chan struct{} authorizer authorizer.Authorizer - schemaResolver resolver.SchemaResolver } var _ initializer.WantsExternalKubeInformerFactory = &celAdmissionPlugin{} @@ -83,7 +81,6 @@ var _ initializer.WantsRESTMapper = &celAdmissionPlugin{} var _ initializer.WantsDynamicClient = &celAdmissionPlugin{} var _ initializer.WantsDrainedNotification = &celAdmissionPlugin{} var _ initializer.WantsAuthorizer = &celAdmissionPlugin{} -var _ initializer.WantsSchemaResolver = &celAdmissionPlugin{} var _ admission.InitializationValidator = &celAdmissionPlugin{} var _ admission.ValidationInterface = &celAdmissionPlugin{} @@ -116,11 +113,6 @@ func (c *celAdmissionPlugin) SetDrainedNotification(stopCh <-chan struct{}) { func (c *celAdmissionPlugin) SetAuthorizer(authorizer authorizer.Authorizer) { c.authorizer = authorizer } - -func (c *celAdmissionPlugin) SetSchemaResolver(resolver resolver.SchemaResolver) { - c.schemaResolver = resolver -} - func (c *celAdmissionPlugin) InspectFeatureGates(featureGates featuregate.FeatureGate) { if featureGates.Enabled(features.ValidatingAdmissionPolicy) { c.enabled = true @@ -154,7 +146,7 @@ func (c *celAdmissionPlugin) ValidateInitialization() error { if c.authorizer == nil { return errors.New("missing authorizer") } - c.evaluator = NewAdmissionController(c.informerFactory, c.client, c.restMapper, c.schemaResolver /* (optional) */, c.dynamicClient, c.authorizer) + c.evaluator = NewAdmissionController(c.informerFactory, c.client, c.restMapper, c.dynamicClient, c.authorizer) if err := c.evaluator.ValidateInitialization(); err != nil { return err } diff --git a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/controller.go b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/controller.go index ab5cd9434ca..506167f9752 100644 --- a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/controller.go +++ b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/controller.go @@ -25,8 +25,6 @@ import ( "sync/atomic" "time" - "k8s.io/klog/v2" - "k8s.io/api/admissionregistration/v1alpha1" k8serrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" @@ -44,12 +42,12 @@ import ( celconfig "k8s.io/apiserver/pkg/apis/cel" "k8s.io/apiserver/pkg/authorization/authorizer" "k8s.io/apiserver/pkg/cel/environment" - "k8s.io/apiserver/pkg/cel/openapi/resolver" "k8s.io/apiserver/pkg/warning" "k8s.io/client-go/dynamic" "k8s.io/client-go/informers" "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/cache" + "k8s.io/klog/v2" ) var _ CELPolicyEvaluator = &celAdmissionController{} @@ -128,21 +126,15 @@ func NewAdmissionController( informerFactory informers.SharedInformerFactory, client kubernetes.Interface, restMapper meta.RESTMapper, - schemaResolver resolver.SchemaResolver, dynamicClient dynamic.Interface, authz authorizer.Authorizer, ) CELPolicyEvaluator { - var typeChecker *TypeChecker - if schemaResolver != nil { - typeChecker = &TypeChecker{schemaResolver: schemaResolver, restMapper: restMapper} - } return &celAdmissionController{ definitions: atomic.Value{}, policyController: newPolicyController( restMapper, client, dynamicClient, - typeChecker, cel.NewFilterCompiler(environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion())), NewMatcher(matching.NewMatcher(informerFactory.Core().V1().Namespaces().Lister(), client)), generic.NewInformer[*v1alpha1.ValidatingAdmissionPolicy]( diff --git a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/controller_reconcile.go b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/controller_reconcile.go index 21bbbd54064..77d9670fad0 100644 --- a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/controller_reconcile.go +++ b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/controller_reconcile.go @@ -27,10 +27,8 @@ import ( corev1 "k8s.io/api/core/v1" apiequality "k8s.io/apimachinery/pkg/api/equality" "k8s.io/apimachinery/pkg/api/meta" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" - utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/sets" celmetrics "k8s.io/apiserver/pkg/admission/cel" "k8s.io/apiserver/pkg/admission/plugin/cel" @@ -61,11 +59,6 @@ type policyController struct { newValidator - // The TypeCheck checks the policy's expressions for type errors. - // Type of params is defined in policy.Spec.ParamsKind - // Types of object are calculated from policy.Spec.MatchingConstraints - typeChecker *TypeChecker - // Lock which protects: // - cachedPolicies // - paramCRDControllers @@ -103,7 +96,6 @@ func newPolicyController( restMapper meta.RESTMapper, client kubernetes.Interface, dynamicClient dynamic.Interface, - typeChecker *TypeChecker, filterCompiler cel.FilterCompiler, matcher Matcher, policiesInformer generic.Informer[*v1alpha1.ValidatingAdmissionPolicy], @@ -112,7 +104,6 @@ func newPolicyController( res := &policyController{} *res = policyController{ filterCompiler: filterCompiler, - typeChecker: typeChecker, definitionInfo: make(map[namespacedName]*definitionInfo), bindingInfos: make(map[namespacedName]*bindingInfo), paramsCRDControllers: make(map[v1alpha1.ParamKind]*paramInfo), @@ -174,12 +165,6 @@ func (c *policyController) reconcilePolicyDefinition(namespace, name string, def c.mutex.Lock() defer c.mutex.Unlock() err := c.reconcilePolicyDefinitionSpec(namespace, name, definition) - if err != nil { - return err - } - if c.typeChecker != nil { - err = c.reconcilePolicyStatus(namespace, name, definition) - } return err } @@ -438,30 +423,6 @@ func (c *policyController) reconcilePolicyBinding(namespace, name string, bindin return nil } -func (c *policyController) reconcilePolicyStatus(namespace, name string, definition *v1alpha1.ValidatingAdmissionPolicy) error { - if definition != nil && definition.Status.ObservedGeneration < definition.Generation { - st := c.calculatePolicyStatus(definition) - newDefinition := definition.DeepCopy() - newDefinition.Status = *st - _, err := c.client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().UpdateStatus(c.context, newDefinition, metav1.UpdateOptions{}) - if err != nil { - // ignore error when the controller is not able to - // mutate the definition, and to avoid infinite requeue. - utilruntime.HandleError(err) - } - } - return nil -} - -func (c *policyController) calculatePolicyStatus(definition *v1alpha1.ValidatingAdmissionPolicy) *v1alpha1.ValidatingAdmissionPolicyStatus { - expressionWarnings := c.typeChecker.Check(definition) - // modifying a deepcopy of the original status, preserving unrelated existing data - status := definition.Status.DeepCopy() - status.ObservedGeneration = definition.Generation - status.TypeChecking = &v1alpha1.TypeChecking{ExpressionWarnings: expressionWarnings} - return status -} - func (c *policyController) reconcileParams(namespace, name string, params runtime.Object) error { // Do nothing. // When we add informational type checking we will need to compile in the diff --git a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/typechecking.go b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/typechecking.go index 2ecd5a4410f..21c454cebd6 100644 --- a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/typechecking.go +++ b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/typechecking.go @@ -44,8 +44,8 @@ import ( const maxTypesToCheck = 10 type TypeChecker struct { - schemaResolver resolver.SchemaResolver - restMapper meta.RESTMapper + SchemaResolver resolver.SchemaResolver + RestMapper meta.RESTMapper } // TypeCheckingContext holds information about the policy being type-checked. @@ -196,7 +196,7 @@ func (c *TypeChecker) declType(gvk schema.GroupVersionKind) (*apiservercel.DeclT if gvk.Empty() { return nil, nil } - s, err := c.schemaResolver.ResolveSchema(gvk) + s, err := c.SchemaResolver.ResolveSchema(gvk) if err != nil { return nil, err } @@ -266,7 +266,7 @@ func (c *TypeChecker) typesToCheck(p *v1alpha1.ValidatingAdmissionPolicy) []sche Version: version, Resource: resource, } - resolved, err := c.restMapper.KindsFor(gvr) + resolved, err := c.RestMapper.KindsFor(gvr) if err != nil { continue } diff --git a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/typechecking_test.go b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/typechecking_test.go index 66892c6041f..7a4fe293544 100644 --- a/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/typechecking_test.go +++ b/staging/src/k8s.io/apiserver/pkg/admission/plugin/validatingadmissionpolicy/typechecking_test.go @@ -435,8 +435,8 @@ func buildTypeChecker(schemaToReturn *spec.Schema) *TypeChecker { restMapper.Add(must3(scheme.ObjectKinds(&appsv1.Deployment{}))[0], meta.RESTScopeRoot) return &TypeChecker{ - schemaResolver: &fakeSchemaResolver{schemaToReturn: schemaToReturn}, - restMapper: restMapper, + SchemaResolver: &fakeSchemaResolver{schemaToReturn: schemaToReturn}, + RestMapper: restMapper, } } diff --git a/staging/src/k8s.io/kube-controller-manager/config/v1alpha1/types.go b/staging/src/k8s.io/kube-controller-manager/config/v1alpha1/types.go index 952b2c2fc79..6aaa3e1978b 100644 --- a/staging/src/k8s.io/kube-controller-manager/config/v1alpha1/types.go +++ b/staging/src/k8s.io/kube-controller-manager/config/v1alpha1/types.go @@ -165,6 +165,9 @@ type KubeControllerManagerConfiguration struct { // TTLAfterFinishedControllerConfiguration holds configuration for // TTLAfterFinishedController related features. TTLAfterFinishedController TTLAfterFinishedControllerConfiguration + // ValidatingAdmissionPolicyStatusControllerConfiguration holds configuration for + // ValidatingAdmissionPolicyStatusController related features. + ValidatingAdmissionPolicyStatusController ValidatingAdmissionPolicyStatusControllerConfiguration } // AttachDetachControllerConfiguration contains elements describing AttachDetachController. @@ -481,3 +484,12 @@ type TTLAfterFinishedControllerConfiguration struct { // allowed to sync concurrently. ConcurrentTTLSyncs int32 } + +// ValidatingAdmissionPolicyStatusControllerConfiguration contains elements describing ValidatingAdmissionPolicyStatusController. +type ValidatingAdmissionPolicyStatusControllerConfiguration struct { + // ConcurrentPolicySyncs is the number of policy objects that are + // allowed to sync concurrently. Larger number = quicker type checking, + // but more CPU (and network) load. + // The default value is 5. + ConcurrentPolicySyncs int32 +} diff --git a/staging/src/k8s.io/kube-controller-manager/config/v1alpha1/zz_generated.deepcopy.go b/staging/src/k8s.io/kube-controller-manager/config/v1alpha1/zz_generated.deepcopy.go index 7a457692277..1f8b5984b7c 100644 --- a/staging/src/k8s.io/kube-controller-manager/config/v1alpha1/zz_generated.deepcopy.go +++ b/staging/src/k8s.io/kube-controller-manager/config/v1alpha1/zz_generated.deepcopy.go @@ -322,6 +322,7 @@ func (in *KubeControllerManagerConfiguration) DeepCopyInto(out *KubeControllerMa out.SAController = in.SAController out.ServiceController = in.ServiceController out.TTLAfterFinishedController = in.TTLAfterFinishedController + out.ValidatingAdmissionPolicyStatusController = in.ValidatingAdmissionPolicyStatusController return } @@ -569,6 +570,22 @@ func (in *TTLAfterFinishedControllerConfiguration) DeepCopy() *TTLAfterFinishedC return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ValidatingAdmissionPolicyStatusControllerConfiguration) DeepCopyInto(out *ValidatingAdmissionPolicyStatusControllerConfiguration) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicyStatusControllerConfiguration. +func (in *ValidatingAdmissionPolicyStatusControllerConfiguration) DeepCopy() *ValidatingAdmissionPolicyStatusControllerConfiguration { + if in == nil { + return nil + } + out := new(ValidatingAdmissionPolicyStatusControllerConfiguration) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *VolumeConfiguration) DeepCopyInto(out *VolumeConfiguration) { *out = *in diff --git a/test/e2e/apimachinery/validatingadmissionpolicy.go b/test/e2e/apimachinery/validatingadmissionpolicy.go index 1edf8936572..aff69b944f6 100644 --- a/test/e2e/apimachinery/validatingadmissionpolicy.go +++ b/test/e2e/apimachinery/validatingadmissionpolicy.go @@ -22,6 +22,7 @@ import ( "time" "github.com/onsi/ginkgo/v2" + "github.com/onsi/gomega" admissionregistrationv1 "k8s.io/api/admissionregistration/v1" admissionregistrationv1alpha1 "k8s.io/api/admissionregistration/v1alpha1" @@ -112,6 +113,81 @@ var _ = SIGDescribe("ValidatingAdmissionPolicy [Privileged:ClusterAdmin][Alpha][ framework.ExpectNoError(err, "create non-replicated ReplicaSet") }) }) + + ginkgo.It("should type check validation expressions", func(ctx context.Context) { + var policy *admissionregistrationv1alpha1.ValidatingAdmissionPolicy + ginkgo.By("creating the policy with correct types", func() { + policy = newValidatingAdmissionPolicyBuilder(f.UniqueName+".correct-policy.example.com"). + MatchUniqueNamespace(f.UniqueName). + StartResourceRule(). + MatchResource([]string{"apps"}, []string{"v1"}, []string{"deployments"}). + EndResourceRule(). + WithValidation(admissionregistrationv1alpha1.Validation{ + Expression: "object.spec.replicas > 1", + }). + Build() + var err error + policy, err = client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Create(ctx, policy, metav1.CreateOptions{}) + framework.ExpectNoError(err, "create policy") + ginkgo.DeferCleanup(func(ctx context.Context, name string) error { + return client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Delete(ctx, name, metav1.DeleteOptions{}) + }, policy.Name) + }) + ginkgo.By("waiting for the type check to finish without any warnings", func() { + err := wait.PollUntilContextCancel(ctx, 100*time.Millisecond, true, func(ctx context.Context) (done bool, err error) { + policy, err = client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Get(ctx, policy.Name, metav1.GetOptions{}) + if err != nil { + return false, err + } + if policy.Status.TypeChecking != nil { // non-nil TypeChecking indicates its completion + return true, nil + } + return false, nil + }) + framework.ExpectNoError(err, "wait for type checking") + gomega.Expect(policy.Status.TypeChecking.ExpressionWarnings).To(gomega.BeEmpty()) + }) + ginkgo.By("creating the policy with type confusion", func() { + policy = newValidatingAdmissionPolicyBuilder(f.UniqueName+".confused-policy.example.com"). + MatchUniqueNamespace(f.UniqueName). + StartResourceRule(). + MatchResource([]string{"apps"}, []string{"v1"}, []string{"deployments"}). + EndResourceRule(). + WithValidation(admissionregistrationv1alpha1.Validation{ + Expression: "object.spec.replicas > '1'", // confusion: int > string + MessageExpression: "'wants replicas > 1, got ' + object.spec.replicas", // confusion: string + int + }). + Build() + var err error + policy, err = client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Create(ctx, policy, metav1.CreateOptions{}) + framework.ExpectNoError(err, "create policy") + ginkgo.DeferCleanup(func(ctx context.Context, name string) error { + return client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Delete(ctx, name, metav1.DeleteOptions{}) + }, policy.Name) + }) + ginkgo.By("waiting for the type check to finish with warnings", func() { + err := wait.PollUntilContextCancel(ctx, 100*time.Millisecond, true, func(ctx context.Context) (done bool, err error) { + policy, err = client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Get(ctx, policy.Name, metav1.GetOptions{}) + if err != nil { + return false, err + } + if policy.Status.TypeChecking != nil { // non-nil TypeChecking indicates its completion + return true, nil + } + return false, nil + }) + framework.ExpectNoError(err, "wait for type checking") + + // assert it to contain 2 warnings, first for expression and second for messageExpression + gomega.Expect(policy.Status.TypeChecking.ExpressionWarnings).To(gomega.HaveLen(2)) + warning := policy.Status.TypeChecking.ExpressionWarnings[0] + gomega.Expect(warning.FieldRef).To(gomega.Equal("spec.validations[0].expression")) + gomega.Expect(warning.Warning).To(gomega.ContainSubstring("found no matching overload for '_>_' applied to '(int, string)'")) + warning = policy.Status.TypeChecking.ExpressionWarnings[1] + gomega.Expect(warning.FieldRef).To(gomega.Equal("spec.validations[0].messageExpression")) + gomega.Expect(warning.Warning).To(gomega.ContainSubstring("found no matching overload for '_+_' applied to '(string, int)'")) + }) + }) }) func createBinding(bindingName string, uniqueLabel string, policyName string) *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding { diff --git a/test/integration/apiserver/cel/validatingadmissionpolicy_test.go b/test/integration/apiserver/cel/validatingadmissionpolicy_test.go index 83948704d69..9e5dfdd6084 100644 --- a/test/integration/apiserver/cel/validatingadmissionpolicy_test.go +++ b/test/integration/apiserver/cel/validatingadmissionpolicy_test.go @@ -2622,26 +2622,6 @@ func withPolicyExistsLabels(labels []string, policy *admissionregistrationv1alph return policy } -func withGVRMatch(groups []string, versions []string, resources []string, policy *admissionregistrationv1alpha1.ValidatingAdmissionPolicy) *admissionregistrationv1alpha1.ValidatingAdmissionPolicy { - policy.Spec.MatchConstraints = &admissionregistrationv1alpha1.MatchResources{ - ResourceRules: []admissionregistrationv1alpha1.NamedRuleWithOperations{ - { - RuleWithOperations: admissionregistrationv1alpha1.RuleWithOperations{ - Operations: []admissionregistrationv1.OperationType{ - "*", - }, - Rule: admissionregistrationv1.Rule{ - APIGroups: groups, - APIVersions: versions, - Resources: resources, - }, - }, - }, - }, - } - return policy -} - func withValidations(validations []admissionregistrationv1alpha1.Validation, policy *admissionregistrationv1alpha1.ValidatingAdmissionPolicy) *admissionregistrationv1alpha1.ValidatingAdmissionPolicy { policy.Spec.Validations = validations return policy @@ -2917,117 +2897,6 @@ rules: ` ) -func TestValidatingAdmissionPolicyTypeChecking(t *testing.T) { - defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, genericfeatures.ValidatingAdmissionPolicy, true)() - server, err := apiservertesting.StartTestServer(t, nil, []string{ - "--enable-admission-plugins", "ValidatingAdmissionPolicy", - }, framework.SharedEtcd()) - if err != nil { - t.Fatal(err) - } - defer server.TearDownFn() - - config := server.ClientConfig - - client, err := clientset.NewForConfig(config) - if err != nil { - t.Fatal(err) - } - for _, tc := range []struct { - name string - policy *admissionregistrationv1alpha1.ValidatingAdmissionPolicy - assertFieldRef func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) // warning.fieldRef - assertWarnings func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) // warning.warning - }{ - { - name: "deployment with correct expression", - policy: withGVRMatch([]string{"apps"}, []string{"v1"}, []string{"deployments"}, withValidations([]admissionregistrationv1alpha1.Validation{ - { - Expression: "object.spec.replicas > 1", - }, - }, makePolicy("replicated-deployment"))), - assertFieldRef: toHasLengthOf(0), - assertWarnings: toHasLengthOf(0), - }, - { - name: "deployment with type confusion", - policy: withGVRMatch([]string{"apps"}, []string{"v1"}, []string{"deployments"}, withValidations([]admissionregistrationv1alpha1.Validation{ - { - Expression: "object.spec.replicas < 100", // this one passes - }, - { - Expression: "object.spec.replicas > '1'", // '1' should be int - }, - }, makePolicy("confused-deployment"))), - assertFieldRef: toBe("spec.validations[1].expression"), - assertWarnings: toHasSubstring(`found no matching overload for '_>_' applied to '(int, string)'`), - }, - } { - t.Run(tc.name, func(t *testing.T) { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - policy, err := client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Create(ctx, tc.policy, metav1.CreateOptions{}) - if err != nil { - t.Fatal(err) - } - defer client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Delete(context.Background(), policy.Name, metav1.DeleteOptions{}) - err = wait.PollImmediateWithContext(ctx, time.Second, time.Minute, func(ctx context.Context) (done bool, err error) { - name := policy.Name - // wait until the typeChecking is set, which means the type checking - // is complete. - updated, err := client.AdmissionregistrationV1alpha1().ValidatingAdmissionPolicies().Get(ctx, name, metav1.GetOptions{}) - if err != nil { - return false, err - } - if updated.Status.TypeChecking != nil { - policy = updated - return true, nil - } - return false, nil - }) - if err != nil { - t.Fatal(err) - } - tc.assertFieldRef(policy.Status.TypeChecking.ExpressionWarnings, t) - tc.assertWarnings(policy.Status.TypeChecking.ExpressionWarnings, t) - }) - } -} - -func toBe(expected ...string) func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { - return func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { - if len(expected) != len(warnings) { - t.Fatalf("mismatched length, expect %d, got %d", len(expected), len(warnings)) - } - for i := range expected { - if expected[i] != warnings[i].FieldRef { - t.Errorf("expected %q but got %q", expected[i], warnings[i].FieldRef) - } - } - } -} - -func toHasSubstring(substrings ...string) func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { - return func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { - if len(substrings) != len(warnings) { - t.Fatalf("mismatched length, expect %d, got %d", len(substrings), len(warnings)) - } - for i := range substrings { - if !strings.Contains(warnings[i].Warning, substrings[i]) { - t.Errorf("missing expected substring %q in %v", substrings[i], warnings[i]) - } - } - } -} - -func toHasLengthOf(n int) func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { - return func(warnings []admissionregistrationv1alpha1.ExpressionWarning, t *testing.T) { - if n != len(warnings) { - t.Fatalf("mismatched length, expect %d, got %d", n, len(warnings)) - } - } -} - func TestAuthorizationDecisionCaching(t *testing.T) { for _, tc := range []struct { name string