if o == nil {
		return nil
	}

	errs := []error{}

	if o.ConcurrentServiceEndpointSyncs < minConcurrentServiceEndpointSyncs {
		errs = append(errs, fmt.Errorf("concurrent-service-endpoint-syncs must not be less than %d, but got %d", minConcurrentServiceEndpointSyncs, o.ConcurrentServiceEndpointSyncs))
	} else if o.ConcurrentServiceEndpointSyncs > maxConcurrentServiceEndpointSyncs {

// its `SetDefaults_` method.
func RecommendedDefaultEndpointSliceControllerConfiguration(obj *kubectrlmgrconfigv1alpha1.EndpointSliceControllerConfiguration) {
	if obj.ConcurrentServiceEndpointSyncs == 0 {
		obj.ConcurrentServiceEndpointSyncs = 5
	}

	if obj.MaxEndpointsPerSlice == 0 {
		obj.MaxEndpointsPerSlice = 100
	}

	out.ConcurrentServiceEndpointSyncs = in.ConcurrentServiceEndpointSyncs
	out.MaxEndpointsPerSlice = in.MaxEndpointsPerSlice
	out.EndpointUpdatesBatchPeriod = in.EndpointUpdatesBatchPeriod
	return nil
}

// EndpointSliceController.
type EndpointSliceControllerConfiguration struct {
	// concurrentServiceEndpointSyncs is the number of service endpoint syncing
	// operations that will be done concurrently. Larger number = faster
	// endpoint slice updating, but more CPU (and network) load.
	ConcurrentServiceEndpointSyncs int32

	// maxEndpointsPerSlice is the maximum number of endpoints that will be

			name:                   "EndpointSliceControllerOptions ConcurrentServiceEndpointSyncs lower than minConcurrentServiceEndpointSyncs (1)",
			expectErrors:           true,
			expectedErrorSubString: "concurrent-service-endpoint-syncs must not be less than 1",
			options: &EndpointSliceControllerOptions{
				&endpointsliceconfig.EndpointSliceControllerConfiguration{
					ConcurrentServiceEndpointSyncs: 0,
					MaxEndpointsPerSlice:           200,
				},

		controllerContext.ComponentConfig.EndpointSliceController.EndpointUpdatesBatchPeriod.Duration,
	).Run(ctx, int(controllerContext.ComponentConfig.EndpointSliceController.ConcurrentServiceEndpointSyncs))
	return nil, true, nil
}

func newEndpointSliceMirroringControllerDescriptor() *ControllerDescriptor {
	return &ControllerDescriptor{
		name:     names.EndpointSliceMirroringController,

API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,EndpointSliceControllerConfiguration,ConcurrentServiceEndpointSyncs
API rule violation: names_match,k8s.io/kube-controller-manager/config/v1alpha1,EndpointSliceControllerConfiguration,EndpointUpdatesBatchPeriod

				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"ConcurrentServiceEndpointSyncs": {
						SchemaProps: spec.SchemaProps{
							Description: "concurrentServiceEndpointSyncs is the number of service endpoint syncing operations that will be done concurrently. Larger number = faster endpoint slice updating, but more CPU (and network) load.",