defaultCacheSize  int32 = 1000
	defaultAPIVersion       = "v1"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
	return RegisterDefaults(scheme)
}

// SetDefaults_KMSConfiguration applies defaults to KMSConfiguration.
func SetDefaults_KMSConfiguration(obj *KMSConfiguration) {
	if obj.Timeout == nil {
		obj.Timeout = defaultTimeout
	}

	if obj.APIVersion == "" {
		obj.APIVersion = defaultAPIVersion
	}

		}
		if strategy.RollingUpdate.MaxUnavailable == nil {
			// Set default MaxUnavailable as 25% by default.
			maxUnavailable := intstr.FromString("25%")
			strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
		}
		if strategy.RollingUpdate.MaxSurge == nil {
			// Set default MaxSurge as 25% by default.
			maxSurge := intstr.FromString("25%")
			strategy.RollingUpdate.MaxSurge = &maxSurge
		}
	}

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Denotes that the {@link RuleSource} method rule carrying this annotation initializes the rule subject with default values.
 * <p>
 * Default rules execute first for a given subject, just after the subject has been created but before {@link Model} rules and {@link Mutate} rules.

			continue
		}
		scheme.Default(args)
		args.GetObjectKind().SetGroupVersionKind(gvk)
		prof.PluginConfig = append(prof.PluginConfig, configv1.PluginConfig{
			Name: name,
			Args: runtime.RawExtension{Object: args},
		})
	}
}

// SetDefaults_KubeSchedulerConfiguration sets additional defaults
func SetDefaults_KubeSchedulerConfiguration(obj *configv1.KubeSchedulerConfiguration) {

		}
		if strategy.RollingUpdate.MaxUnavailable == nil {
			// Set default MaxUnavailable as 25% by default.
			maxUnavailable := intstr.FromString("25%")
			strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
		}
		if strategy.RollingUpdate.MaxSurge == nil {
			// Set default MaxSurge as 25% by default.
			maxSurge := intstr.FromString("25%")
			strategy.RollingUpdate.MaxSurge = &maxSurge
		}
	}

			updateStrategy.RollingUpdate = &rollingUpdate
		}
		if updateStrategy.RollingUpdate.MaxUnavailable == nil {
			// Set default MaxUnavailable as 1 by default.
			updateStrategy.RollingUpdate.MaxUnavailable = ptr.To(intstr.FromInt32(1))
		}
		if updateStrategy.RollingUpdate.MaxSurge == nil {
			// Set default MaxSurge as 0 by default.
			updateStrategy.RollingUpdate.MaxSurge = ptr.To(intstr.FromInt32(0))
		}
	}

See the License for the specific language governing permissions and
limitations under the License.
*/

package defaults

import (
	"k8s.io/kubernetes/pkg/scheduler/apis/config"
	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/names"
)

// PluginsV1 is the set of default v1 plugins (before MultiPoint expansion)
var PluginsV1 = &config.Plugins{
	MultiPoint: config.PluginSet{
		Enabled: []config.Plugin{

// limitations under the License.

package log

// These functions enable logging using a global Scope. See scope.go for usage information.

func registerDefaultScopes() (defaults *Scope, grpc *Scope) {
	return registerScope(DefaultScopeName, "Unscoped logging messages.", 1),
		registerScope(GrpcScopeName, "logs from gRPC", 3)
}

var defaultScope, grpcScope = registerDefaultScopes()

}

// SetDefaults_ValidatingAdmissionPolicySpec sets defaults for ValidatingAdmissionPolicySpec
func SetDefaults_ValidatingAdmissionPolicySpec(obj *admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec) {
	if obj.FailurePolicy == nil {
		policy := admissionregistrationv1alpha1.Fail
		obj.FailurePolicy = &policy
	}
}

// SetDefaults_MatchResources sets defaults for MatchResources

limitations under the License.
*/

package v1beta3

import (
	"k8s.io/api/flowcontrol/v1beta3"
	"k8s.io/utils/ptr"
)

// Default settings for flow-schema
const (
	FlowSchemaDefaultMatchingPrecedence int32 = 1000
)

// Default settings for priority-level-configuration
const (
	PriorityLevelConfigurationDefaultHandSize                 int32 = 8