)

// REST implements a RESTStorage for CertificateSigningRequest.
type REST struct {
	*genericregistry.Store
}

// NewREST returns a registry which will store CertificateSigningRequest in the given helper.
func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST, *ApprovalREST, error) {
	store := &genericregistry.Store{

	storage := map[string]rest.Storage{}

	if resource := "runtimeclasses"; apiResourceConfigSource.ResourceEnabled(nodev1.SchemeGroupVersion.WithResource(resource)) {
		s, err := runtimeclassstorage.NewREST(restOptionsGetter)
		if err != nil {
			return storage, err
		}
		storage[resource] = s
	}

	return storage, nil
}

// GroupName is the group name for the storage provider

	storage := map[string]rest.Storage{}

	// events
	if resource := "events"; apiResourceConfigSource.ResourceEnabled(eventsapiv1.SchemeGroupVersion.WithResource(resource)) {
		eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds()))
		if err != nil {
			return storage, err
		}
		storage[resource] = eventsStorage
	}

	return storage, nil
}

func (p RESTStorageProvider) GroupName() string {

	if resource := "poddisruptionbudgets"; apiResourceConfigSource.ResourceEnabled(policyapiv1.SchemeGroupVersion.WithResource(resource)) {
		poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter)
		if err != nil {
			return storage, err
		}
		storage[resource] = poddisruptionbudgetStorage
		storage[resource+"/status"] = poddisruptionbudgetStatusStorage
	}

	return storage, nil
}

		if utilfeature.DefaultFeatureGate.Enabled(features.StorageVersionMigrator) {
			svm, svmStatus, err := storagemigrationstore.NewREST(restOptionsGetter)
			if err != nil {
				return nil, err
			}
			storage[resource] = svm
			storage[resource+"/status"] = svmStatus
		} else {

	"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
)

// rest implements a RESTStorage for API services against etcd
type REST struct {
	*genericregistry.Store
}

// NewREST returns a RESTStorage object that will work against API services.
func NewREST(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) (*REST, error) {
	strategy := NewStrategy(scheme)

	store := &genericregistry.Store{

	authorizationvalidation "k8s.io/kubernetes/pkg/apis/authorization/validation"
	authorizationutil "k8s.io/kubernetes/pkg/registry/authorization/util"
)

type REST struct {
	authorizer authorizer.Authorizer
}

func NewREST(authorizer authorizer.Authorizer) *REST {
	return &REST{authorizer}
}

func (r *REST) NamespaceScoped() bool {
	return false
}

func (r *REST) New() runtime.Object {

	storage := map[string]rest.Storage{}

	if resource := "endpointslices"; apiResourceConfigSource.ResourceEnabled(discoveryv1.SchemeGroupVersion.WithResource(resource)) {
		endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter)
		if err != nil {
			return storage, err
		}
		storage[resource] = endpointSliceStorage
	}

	return storage, nil
}

// GroupName is the group name for the storage provider.

	storage := map[string]rest.Storage{}

	// leases
	if resource := "leases"; apiResourceConfigSource.ResourceEnabled(coordinationv1.SchemeGroupVersion.WithResource(resource)) {
		leaseStorage, err := leasestorage.NewREST(restOptionsGetter)
		if err != nil {
			return storage, err
		}
		storage[resource] = leaseStorage
	}
	return storage, nil
}

func (p RESTStorageProvider) GroupName() string {

	storage := map[string]rest.Storage{}

	if resource := "storageversions"; apiResourceConfigSource.ResourceEnabled(apiserverv1alpha1.SchemeGroupVersion.WithResource(resource)) {
		s, status, err := storageversionstorage.NewREST(restOptionsGetter)
		if err != nil {
			return nil, err
		}
		storage[resource] = s
		storage[resource+"/status"] = status
	}

	return storage, nil
}