github/client-go
1
0
Fork 0
mirror of https://github.com/kubernetes/client-go.git synced 2025-09-25 22:48:22 +00:00
Code Issues Projects Releases Wiki Activity

DRA API: s/v1beta2/v1/ and generated files

Browse Source 
Kubernetes-commit: 4e592f6c145bb322786aa77ff2d25d8fe370b893
This commit is contained in:
Patrick Ohly
2025-07-03 13:29:02 +02:00
committed by Kubernetes Publisher
parent dce90c45af
commit 14fa3d1f20
66 changed files with 1145 additions and 450 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
kubernetes/clientset.go
View File

@@ -67,6 +67,7 @@ import (
rbacv1 "k8s.io/client-go/kubernetes/typed/rbac/v1"
rbacv1alpha1 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
rbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
resourcev1 "k8s.io/client-go/kubernetes/typed/resource/v1"
resourcev1alpha3 "k8s.io/client-go/kubernetes/typed/resource/v1alpha3"
resourcev1beta1 "k8s.io/client-go/kubernetes/typed/resource/v1beta1"
resourcev1beta2 "k8s.io/client-go/kubernetes/typed/resource/v1beta2"
@@ -127,6 +128,7 @@ type Interface interface {
RbacV1() rbacv1.RbacV1Interface
RbacV1beta1() rbacv1beta1.RbacV1beta1Interface
RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface
ResourceV1() resourcev1.ResourceV1Interface
ResourceV1beta2() resourcev1beta2.ResourceV1beta2Interface
ResourceV1beta1() resourcev1beta1.ResourceV1beta1Interface
ResourceV1alpha3() resourcev1alpha3.ResourceV1alpha3Interface
@@ -186,6 +188,7 @@ type Clientset struct {
rbacV1 *rbacv1.RbacV1Client
rbacV1beta1 *rbacv1beta1.RbacV1beta1Client
rbacV1alpha1 *rbacv1alpha1.RbacV1alpha1Client
resourceV1 *resourcev1.ResourceV1Client
resourceV1beta2 *resourcev1beta2.ResourceV1beta2Client
resourceV1beta1 *resourcev1beta1.ResourceV1beta1Client
resourceV1alpha3 *resourcev1alpha3.ResourceV1alpha3Client
@@ -418,6 +421,11 @@ func (c *Clientset) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface {
return c.rbacV1alpha1
}
// ResourceV1 retrieves the ResourceV1Client
func (c *Clientset) ResourceV1() resourcev1.ResourceV1Interface {
return c.resourceV1
}
// ResourceV1beta2 retrieves the ResourceV1beta2Client
func (c *Clientset) ResourceV1beta2() resourcev1beta2.ResourceV1beta2Interface {
return c.resourceV1beta2
@@ -688,6 +696,10 @@ func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset,
if err != nil {
return nil, err
}
cs.resourceV1, err = resourcev1.NewForConfigAndClient(&configShallowCopy, httpClient)
if err != nil {
return nil, err
}
cs.resourceV1beta2, err = resourcev1beta2.NewForConfigAndClient(&configShallowCopy, httpClient)
if err != nil {
return nil, err
@@ -793,6 +805,7 @@ func New(c rest.Interface) *Clientset {
cs.rbacV1 = rbacv1.New(c)
cs.rbacV1beta1 = rbacv1beta1.New(c)
cs.rbacV1alpha1 = rbacv1alpha1.New(c)
cs.resourceV1 = resourcev1.New(c)
cs.resourceV1beta2 = resourcev1beta2.New(c)
cs.resourceV1beta1 = resourcev1beta1.New(c)
cs.resourceV1alpha3 = resourcev1alpha3.New(c)

7
kubernetes/fake/clientset_generated.go
View File

@@ -114,6 +114,8 @@ import (
fakerbacv1alpha1 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1/fake"
rbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
fakerbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1/fake"
resourcev1 "k8s.io/client-go/kubernetes/typed/resource/v1"
fakeresourcev1 "k8s.io/client-go/kubernetes/typed/resource/v1/fake"
resourcev1alpha3 "k8s.io/client-go/kubernetes/typed/resource/v1alpha3"
fakeresourcev1alpha3 "k8s.io/client-go/kubernetes/typed/resource/v1alpha3/fake"
resourcev1beta1 "k8s.io/client-go/kubernetes/typed/resource/v1beta1"
@@ -451,6 +453,11 @@ func (c *Clientset) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface {
return &fakerbacv1alpha1.FakeRbacV1alpha1{Fake: &c.Fake}
}
// ResourceV1 retrieves the ResourceV1Client
func (c *Clientset) ResourceV1() resourcev1.ResourceV1Interface {
return &fakeresourcev1.FakeResourceV1{Fake: &c.Fake}
}
// ResourceV1beta2 retrieves the ResourceV1beta2Client
func (c *Clientset) ResourceV1beta2() resourcev1beta2.ResourceV1beta2Interface {
return &fakeresourcev1beta2.FakeResourceV1beta2{Fake: &c.Fake}

2
kubernetes/fake/register.go
View File

@@ -63,6 +63,7 @@ import (
rbacv1 "k8s.io/api/rbac/v1"
rbacv1alpha1 "k8s.io/api/rbac/v1alpha1"
rbacv1beta1 "k8s.io/api/rbac/v1beta1"
resourcev1 "k8s.io/api/resource/v1"
resourcev1alpha3 "k8s.io/api/resource/v1alpha3"
resourcev1beta1 "k8s.io/api/resource/v1beta1"
resourcev1beta2 "k8s.io/api/resource/v1beta2"
@@ -128,6 +129,7 @@ var localSchemeBuilder = runtime.SchemeBuilder{
rbacv1.AddToScheme,
rbacv1beta1.AddToScheme,
rbacv1alpha1.AddToScheme,
resourcev1.AddToScheme,
resourcev1beta2.AddToScheme,
resourcev1beta1.AddToScheme,
resourcev1alpha3.AddToScheme,

2
kubernetes/scheme/register.go
View File

@@ -63,6 +63,7 @@ import (
rbacv1 "k8s.io/api/rbac/v1"
rbacv1alpha1 "k8s.io/api/rbac/v1alpha1"
rbacv1beta1 "k8s.io/api/rbac/v1beta1"
resourcev1 "k8s.io/api/resource/v1"
resourcev1alpha3 "k8s.io/api/resource/v1alpha3"
resourcev1beta1 "k8s.io/api/resource/v1beta1"
resourcev1beta2 "k8s.io/api/resource/v1beta2"
@@ -128,6 +129,7 @@ var localSchemeBuilder = runtime.SchemeBuilder{
rbacv1.AddToScheme,
rbacv1beta1.AddToScheme,
rbacv1alpha1.AddToScheme,
resourcev1.AddToScheme,
resourcev1beta2.AddToScheme,
resourcev1beta1.AddToScheme,
resourcev1alpha3.AddToScheme,

38
kubernetes/typed/resource/v1/deviceclass.go
View File

@@ -16,16 +16,16 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta2
package v1
import (
context "context"
resourcev1beta2 "k8s.io/api/resource/v1beta2"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
resourcev1 "k8s.io/api/resource/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
applyconfigurationsresourcev1beta2 "k8s.io/client-go/applyconfigurations/resource/v1beta2"
applyconfigurationsresourcev1 "k8s.io/client-go/applyconfigurations/resource/v1"
gentype "k8s.io/client-go/gentype"
scheme "k8s.io/client-go/kubernetes/scheme"
)
@@ -38,34 +38,34 @@ type DeviceClassesGetter interface {
// DeviceClassInterface has methods to work with DeviceClass resources.
type DeviceClassInterface interface {
Create(ctx context.Context, deviceClass *resourcev1beta2.DeviceClass, opts v1.CreateOptions) (*resourcev1beta2.DeviceClass, error)
Update(ctx context.Context, deviceClass *resourcev1beta2.DeviceClass, opts v1.UpdateOptions) (*resourcev1beta2.DeviceClass, error)
Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
Get(ctx context.Context, name string, opts v1.GetOptions) (*resourcev1beta2.DeviceClass, error)
List(ctx context.Context, opts v1.ListOptions) (*resourcev1beta2.DeviceClassList, error)
Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *resourcev1beta2.DeviceClass, err error)
Apply(ctx context.Context, deviceClass *applyconfigurationsresourcev1beta2.DeviceClassApplyConfiguration, opts v1.ApplyOptions) (result *resourcev1beta2.DeviceClass, err error)
Create(ctx context.Context, deviceClass *resourcev1.DeviceClass, opts metav1.CreateOptions) (*resourcev1.DeviceClass, error)
Update(ctx context.Context, deviceClass *resourcev1.DeviceClass, opts metav1.UpdateOptions) (*resourcev1.DeviceClass, error)
Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error
Get(ctx context.Context, name string, opts metav1.GetOptions) (*resourcev1.DeviceClass, error)
List(ctx context.Context, opts metav1.ListOptions) (*resourcev1.DeviceClassList, error)
Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *resourcev1.DeviceClass, err error)
Apply(ctx context.Context, deviceClass *applyconfigurationsresourcev1.DeviceClassApplyConfiguration, opts metav1.ApplyOptions) (result *resourcev1.DeviceClass, err error)
DeviceClassExpansion
}
// deviceClasses implements DeviceClassInterface
type deviceClasses struct {
*gentype.ClientWithListAndApply[*resourcev1beta2.DeviceClass, *resourcev1beta2.DeviceClassList, *applyconfigurationsresourcev1beta2.DeviceClassApplyConfiguration]
*gentype.ClientWithListAndApply[*resourcev1.DeviceClass, *resourcev1.DeviceClassList, *applyconfigurationsresourcev1.DeviceClassApplyConfiguration]
}
// newDeviceClasses returns a DeviceClasses
func newDeviceClasses(c *ResourceV1beta2Client) *deviceClasses {
func newDeviceClasses(c *ResourceV1Client) *deviceClasses {
return &deviceClasses{
gentype.NewClientWithListAndApply[*resourcev1beta2.DeviceClass, *resourcev1beta2.DeviceClassList, *applyconfigurationsresourcev1beta2.DeviceClassApplyConfiguration](
gentype.NewClientWithListAndApply[*resourcev1.DeviceClass, *resourcev1.DeviceClassList, *applyconfigurationsresourcev1.DeviceClassApplyConfiguration](
"deviceclasses",
c.RESTClient(),
scheme.ParameterCodec,
"",
func() *resourcev1beta2.DeviceClass { return &resourcev1beta2.DeviceClass{} },
func() *resourcev1beta2.DeviceClassList { return &resourcev1beta2.DeviceClassList{} },
gentype.PrefersProtobuf[*resourcev1beta2.DeviceClass](),
func() *resourcev1.DeviceClass { return &resourcev1.DeviceClass{} },
func() *resourcev1.DeviceClassList { return &resourcev1.DeviceClassList{} },
gentype.PrefersProtobuf[*resourcev1.DeviceClass](),
),
}
}

2
kubernetes/typed/resource/v1/doc.go
View File

@@ -17,4 +17,4 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
// This package has the automatically generated typed clients.
package v1beta2
package v1

30
kubernetes/typed/resource/v1/fake/fake_deviceclass.go
View File

@@ -19,32 +19,30 @@ limitations under the License.
package fake
import (
v1beta2 "k8s.io/api/resource/v1beta2"
resourcev1beta2 "k8s.io/client-go/applyconfigurations/resource/v1beta2"
v1 "k8s.io/api/resource/v1"
resourcev1 "k8s.io/client-go/applyconfigurations/resource/v1"
gentype "k8s.io/client-go/gentype"
typedresourcev1beta2 "k8s.io/client-go/kubernetes/typed/resource/v1beta2"
typedresourcev1 "k8s.io/client-go/kubernetes/typed/resource/v1"
)
// fakeDeviceClasses implements DeviceClassInterface
type fakeDeviceClasses struct {
*gentype.FakeClientWithListAndApply[*v1beta2.DeviceClass, *v1beta2.DeviceClassList, *resourcev1beta2.DeviceClassApplyConfiguration]
Fake *FakeResourceV1beta2
*gentype.FakeClientWithListAndApply[*v1.DeviceClass, *v1.DeviceClassList, *resourcev1.DeviceClassApplyConfiguration]
Fake *FakeResourceV1
}
func newFakeDeviceClasses(fake *FakeResourceV1beta2) typedresourcev1beta2.DeviceClassInterface {
func newFakeDeviceClasses(fake *FakeResourceV1) typedresourcev1.DeviceClassInterface {
return &fakeDeviceClasses{
gentype.NewFakeClientWithListAndApply[*v1beta2.DeviceClass, *v1beta2.DeviceClassList, *resourcev1beta2.DeviceClassApplyConfiguration](
gentype.NewFakeClientWithListAndApply[*v1.DeviceClass, *v1.DeviceClassList, *resourcev1.DeviceClassApplyConfiguration](
fake.Fake,
"",
v1beta2.SchemeGroupVersion.WithResource("deviceclasses"),
v1beta2.SchemeGroupVersion.WithKind("DeviceClass"),
func() *v1beta2.DeviceClass { return &v1beta2.DeviceClass{} },
func() *v1beta2.DeviceClassList { return &v1beta2.DeviceClassList{} },
func(dst, src *v1beta2.DeviceClassList) { dst.ListMeta = src.ListMeta },
func(list *v1beta2.DeviceClassList) []*v1beta2.DeviceClass { return gentype.ToPointerSlice(list.Items) },
func(list *v1beta2.DeviceClassList, items []*v1beta2.DeviceClass) {
list.Items = gentype.FromPointerSlice(items)
},
v1.SchemeGroupVersion.WithResource("deviceclasses"),
v1.SchemeGroupVersion.WithKind("DeviceClass"),
func() *v1.DeviceClass { return &v1.DeviceClass{} },
func() *v1.DeviceClassList { return &v1.DeviceClassList{} },
func(dst, src *v1.DeviceClassList) { dst.ListMeta = src.ListMeta },
func(list *v1.DeviceClassList) []*v1.DeviceClass { return gentype.ToPointerSlice(list.Items) },
func(list *v1.DeviceClassList, items []*v1.DeviceClass) { list.Items = gentype.FromPointerSlice(items) },
),
fake,
}

14
kubernetes/typed/resource/v1/fake/fake_resource_client.go
View File

@@ -19,34 +19,34 @@ limitations under the License.
package fake
import (
v1beta2 "k8s.io/client-go/kubernetes/typed/resource/v1beta2"
v1 "k8s.io/client-go/kubernetes/typed/resource/v1"
rest "k8s.io/client-go/rest"
testing "k8s.io/client-go/testing"
)
type FakeResourceV1beta2 struct {
type FakeResourceV1 struct {
*testing.Fake
}
func (c *FakeResourceV1beta2) DeviceClasses() v1beta2.DeviceClassInterface {
func (c *FakeResourceV1) DeviceClasses() v1.DeviceClassInterface {
return newFakeDeviceClasses(c)
}
func (c *FakeResourceV1beta2) ResourceClaims(namespace string) v1beta2.ResourceClaimInterface {
func (c *FakeResourceV1) ResourceClaims(namespace string) v1.ResourceClaimInterface {
return newFakeResourceClaims(c, namespace)
}
func (c *FakeResourceV1beta2) ResourceClaimTemplates(namespace string) v1beta2.ResourceClaimTemplateInterface {
func (c *FakeResourceV1) ResourceClaimTemplates(namespace string) v1.ResourceClaimTemplateInterface {
return newFakeResourceClaimTemplates(c, namespace)
}
func (c *FakeResourceV1beta2) ResourceSlices() v1beta2.ResourceSliceInterface {
func (c *FakeResourceV1) ResourceSlices() v1.ResourceSliceInterface {
return newFakeResourceSlices(c)
}
// RESTClient returns a RESTClient that is used to communicate
// with API server by this client implementation.
func (c *FakeResourceV1beta2) RESTClient() rest.Interface {
func (c *FakeResourceV1) RESTClient() rest.Interface {
var ret *rest.RESTClient
return ret
}

30
kubernetes/typed/resource/v1/fake/fake_resourceclaim.go
View File

@@ -19,32 +19,30 @@ limitations under the License.
package fake
import (
v1beta2 "k8s.io/api/resource/v1beta2"
resourcev1beta2 "k8s.io/client-go/applyconfigurations/resource/v1beta2"
v1 "k8s.io/api/resource/v1"
resourcev1 "k8s.io/client-go/applyconfigurations/resource/v1"
gentype "k8s.io/client-go/gentype"
typedresourcev1beta2 "k8s.io/client-go/kubernetes/typed/resource/v1beta2"
typedresourcev1 "k8s.io/client-go/kubernetes/typed/resource/v1"
)
// fakeResourceClaims implements ResourceClaimInterface
type fakeResourceClaims struct {
*gentype.FakeClientWithListAndApply[*v1beta2.ResourceClaim, *v1beta2.ResourceClaimList, *resourcev1beta2.ResourceClaimApplyConfiguration]
Fake *FakeResourceV1beta2
*gentype.FakeClientWithListAndApply[*v1.ResourceClaim, *v1.ResourceClaimList, *resourcev1.ResourceClaimApplyConfiguration]
Fake *FakeResourceV1
}
func newFakeResourceClaims(fake *FakeResourceV1beta2, namespace string) typedresourcev1beta2.ResourceClaimInterface {
func newFakeResourceClaims(fake *FakeResourceV1, namespace string) typedresourcev1.ResourceClaimInterface {
return &fakeResourceClaims{
gentype.NewFakeClientWithListAndApply[*v1beta2.ResourceClaim, *v1beta2.ResourceClaimList, *resourcev1beta2.ResourceClaimApplyConfiguration](
gentype.NewFakeClientWithListAndApply[*v1.ResourceClaim, *v1.ResourceClaimList, *resourcev1.ResourceClaimApplyConfiguration](
fake.Fake,
namespace,
v1beta2.SchemeGroupVersion.WithResource("resourceclaims"),
v1beta2.SchemeGroupVersion.WithKind("ResourceClaim"),
func() *v1beta2.ResourceClaim { return &v1beta2.ResourceClaim{} },
func() *v1beta2.ResourceClaimList { return &v1beta2.ResourceClaimList{} },
func(dst, src *v1beta2.ResourceClaimList) { dst.ListMeta = src.ListMeta },
func(list *v1beta2.ResourceClaimList) []*v1beta2.ResourceClaim {
return gentype.ToPointerSlice(list.Items)
},
func(list *v1beta2.ResourceClaimList, items []*v1beta2.ResourceClaim) {
v1.SchemeGroupVersion.WithResource("resourceclaims"),
v1.SchemeGroupVersion.WithKind("ResourceClaim"),
func() *v1.ResourceClaim { return &v1.ResourceClaim{} },
func() *v1.ResourceClaimList { return &v1.ResourceClaimList{} },
func(dst, src *v1.ResourceClaimList) { dst.ListMeta = src.ListMeta },
func(list *v1.ResourceClaimList) []*v1.ResourceClaim { return gentype.ToPointerSlice(list.Items) },
func(list *v1.ResourceClaimList, items []*v1.ResourceClaim) {
list.Items = gentype.FromPointerSlice(items)
},
),

28
kubernetes/typed/resource/v1/fake/fake_resourceclaimtemplate.go
View File

@@ -19,32 +19,32 @@ limitations under the License.
package fake
import (
v1beta2 "k8s.io/api/resource/v1beta2"
resourcev1beta2 "k8s.io/client-go/applyconfigurations/resource/v1beta2"
v1 "k8s.io/api/resource/v1"
resourcev1 "k8s.io/client-go/applyconfigurations/resource/v1"
gentype "k8s.io/client-go/gentype"
typedresourcev1beta2 "k8s.io/client-go/kubernetes/typed/resource/v1beta2"
typedresourcev1 "k8s.io/client-go/kubernetes/typed/resource/v1"
)
// fakeResourceClaimTemplates implements ResourceClaimTemplateInterface
type fakeResourceClaimTemplates struct {
*gentype.FakeClientWithListAndApply[*v1beta2.ResourceClaimTemplate, *v1beta2.ResourceClaimTemplateList, *resourcev1beta2.ResourceClaimTemplateApplyConfiguration]
Fake *FakeResourceV1beta2
*gentype.FakeClientWithListAndApply[*v1.ResourceClaimTemplate, *v1.ResourceClaimTemplateList, *resourcev1.ResourceClaimTemplateApplyConfiguration]
Fake *FakeResourceV1
}
func newFakeResourceClaimTemplates(fake *FakeResourceV1beta2, namespace string) typedresourcev1beta2.ResourceClaimTemplateInterface {
func newFakeResourceClaimTemplates(fake *FakeResourceV1, namespace string) typedresourcev1.ResourceClaimTemplateInterface {
return &fakeResourceClaimTemplates{
gentype.NewFakeClientWithListAndApply[*v1beta2.ResourceClaimTemplate, *v1beta2.ResourceClaimTemplateList, *resourcev1beta2.ResourceClaimTemplateApplyConfiguration](
gentype.NewFakeClientWithListAndApply[*v1.ResourceClaimTemplate, *v1.ResourceClaimTemplateList, *resourcev1.ResourceClaimTemplateApplyConfiguration](
fake.Fake,
namespace,
v1beta2.SchemeGroupVersion.WithResource("resourceclaimtemplates"),
v1beta2.SchemeGroupVersion.WithKind("ResourceClaimTemplate"),
func() *v1beta2.ResourceClaimTemplate { return &v1beta2.ResourceClaimTemplate{} },
func() *v1beta2.ResourceClaimTemplateList { return &v1beta2.ResourceClaimTemplateList{} },
func(dst, src *v1beta2.ResourceClaimTemplateList) { dst.ListMeta = src.ListMeta },
func(list *v1beta2.ResourceClaimTemplateList) []*v1beta2.ResourceClaimTemplate {
v1.SchemeGroupVersion.WithResource("resourceclaimtemplates"),
v1.SchemeGroupVersion.WithKind("ResourceClaimTemplate"),
func() *v1.ResourceClaimTemplate { return &v1.ResourceClaimTemplate{} },
func() *v1.ResourceClaimTemplateList { return &v1.ResourceClaimTemplateList{} },
func(dst, src *v1.ResourceClaimTemplateList) { dst.ListMeta = src.ListMeta },
func(list *v1.ResourceClaimTemplateList) []*v1.ResourceClaimTemplate {
return gentype.ToPointerSlice(list.Items)
},
func(list *v1beta2.ResourceClaimTemplateList, items []*v1beta2.ResourceClaimTemplate) {
func(list *v1.ResourceClaimTemplateList, items []*v1.ResourceClaimTemplate) {
list.Items = gentype.FromPointerSlice(items)
},
),

30
kubernetes/typed/resource/v1/fake/fake_resourceslice.go
View File

@@ -19,32 +19,30 @@ limitations under the License.
package fake
import (
v1beta2 "k8s.io/api/resource/v1beta2"
resourcev1beta2 "k8s.io/client-go/applyconfigurations/resource/v1beta2"
v1 "k8s.io/api/resource/v1"
resourcev1 "k8s.io/client-go/applyconfigurations/resource/v1"
gentype "k8s.io/client-go/gentype"
typedresourcev1beta2 "k8s.io/client-go/kubernetes/typed/resource/v1beta2"
typedresourcev1 "k8s.io/client-go/kubernetes/typed/resource/v1"
)
// fakeResourceSlices implements ResourceSliceInterface
type fakeResourceSlices struct {
*gentype.FakeClientWithListAndApply[*v1beta2.ResourceSlice, *v1beta2.ResourceSliceList, *resourcev1beta2.ResourceSliceApplyConfiguration]
Fake *FakeResourceV1beta2
*gentype.FakeClientWithListAndApply[*v1.ResourceSlice, *v1.ResourceSliceList, *resourcev1.ResourceSliceApplyConfiguration]
Fake *FakeResourceV1
}
func newFakeResourceSlices(fake *FakeResourceV1beta2) typedresourcev1beta2.ResourceSliceInterface {
func newFakeResourceSlices(fake *FakeResourceV1) typedresourcev1.ResourceSliceInterface {
return &fakeResourceSlices{
gentype.NewFakeClientWithListAndApply[*v1beta2.ResourceSlice, *v1beta2.ResourceSliceList, *resourcev1beta2.ResourceSliceApplyConfiguration](
gentype.NewFakeClientWithListAndApply[*v1.ResourceSlice, *v1.ResourceSliceList, *resourcev1.ResourceSliceApplyConfiguration](
fake.Fake,
"",
v1beta2.SchemeGroupVersion.WithResource("resourceslices"),
v1beta2.SchemeGroupVersion.WithKind("ResourceSlice"),
func() *v1beta2.ResourceSlice { return &v1beta2.ResourceSlice{} },
func() *v1beta2.ResourceSliceList { return &v1beta2.ResourceSliceList{} },
func(dst, src *v1beta2.ResourceSliceList) { dst.ListMeta = src.ListMeta },
func(list *v1beta2.ResourceSliceList) []*v1beta2.ResourceSlice {
return gentype.ToPointerSlice(list.Items)
},
func(list *v1beta2.ResourceSliceList, items []*v1beta2.ResourceSlice) {
v1.SchemeGroupVersion.WithResource("resourceslices"),
v1.SchemeGroupVersion.WithKind("ResourceSlice"),
func() *v1.ResourceSlice { return &v1.ResourceSlice{} },
func() *v1.ResourceSliceList { return &v1.ResourceSliceList{} },
func(dst, src *v1.ResourceSliceList) { dst.ListMeta = src.ListMeta },
func(list *v1.ResourceSliceList) []*v1.ResourceSlice { return gentype.ToPointerSlice(list.Items) },
func(list *v1.ResourceSliceList, items []*v1.ResourceSlice) {
list.Items = gentype.FromPointerSlice(items)
},
),

2
kubernetes/typed/resource/v1/generated_expansion.go
View File

@@ -16,7 +16,7 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta2
package v1
type DeviceClassExpansion interface{}

42
kubernetes/typed/resource/v1/resource_client.go
View File

@@ -16,17 +16,17 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta2
package v1
import (
http "net/http"
resourcev1beta2 "k8s.io/api/resource/v1beta2"
resourcev1 "k8s.io/api/resource/v1"
scheme "k8s.io/client-go/kubernetes/scheme"
rest "k8s.io/client-go/rest"
)
type ResourceV1beta2Interface interface {
type ResourceV1Interface interface {
RESTClient() rest.Interface
DeviceClassesGetter
ResourceClaimsGetter
@@ -34,31 +34,31 @@ type ResourceV1beta2Interface interface {
ResourceSlicesGetter
}
// ResourceV1beta2Client is used to interact with features provided by the resource.k8s.io group.
type ResourceV1beta2Client struct {
// ResourceV1Client is used to interact with features provided by the resource.k8s.io group.
type ResourceV1Client struct {
restClient rest.Interface
}
func (c *ResourceV1beta2Client) DeviceClasses() DeviceClassInterface {
func (c *ResourceV1Client) DeviceClasses() DeviceClassInterface {
return newDeviceClasses(c)
}
func (c *ResourceV1beta2Client) ResourceClaims(namespace string) ResourceClaimInterface {
func (c *ResourceV1Client) ResourceClaims(namespace string) ResourceClaimInterface {
return newResourceClaims(c, namespace)
}
func (c *ResourceV1beta2Client) ResourceClaimTemplates(namespace string) ResourceClaimTemplateInterface {
func (c *ResourceV1Client) ResourceClaimTemplates(namespace string) ResourceClaimTemplateInterface {
return newResourceClaimTemplates(c, namespace)
}
func (c *ResourceV1beta2Client) ResourceSlices() ResourceSliceInterface {
func (c *ResourceV1Client) ResourceSlices() ResourceSliceInterface {
return newResourceSlices(c)
}
// NewForConfig creates a new ResourceV1beta2Client for the given config.
// NewForConfig creates a new ResourceV1Client for the given config.
// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient),
// where httpClient was generated with rest.HTTPClientFor(c).
func NewForConfig(c *rest.Config) (*ResourceV1beta2Client, error) {
func NewForConfig(c *rest.Config) (*ResourceV1Client, error) {
config := *c
setConfigDefaults(&config)
httpClient, err := rest.HTTPClientFor(&config)
@@ -68,21 +68,21 @@ func NewForConfig(c *rest.Config) (*ResourceV1beta2Client, error) {
return NewForConfigAndClient(&config, httpClient)
}
// NewForConfigAndClient creates a new ResourceV1beta2Client for the given config and http client.
// NewForConfigAndClient creates a new ResourceV1Client for the given config and http client.
// Note the http client provided takes precedence over the configured transport values.
func NewForConfigAndClient(c *rest.Config, h *http.Client) (*ResourceV1beta2Client, error) {
func NewForConfigAndClient(c *rest.Config, h *http.Client) (*ResourceV1Client, error) {
config := *c
setConfigDefaults(&config)
client, err := rest.RESTClientForConfigAndClient(&config, h)
if err != nil {
return nil, err
}
return &ResourceV1beta2Client{client}, nil
return &ResourceV1Client{client}, nil
}
// NewForConfigOrDie creates a new ResourceV1beta2Client for the given config and
// NewForConfigOrDie creates a new ResourceV1Client for the given config and
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *ResourceV1beta2Client {
func NewForConfigOrDie(c *rest.Config) *ResourceV1Client {
client, err := NewForConfig(c)
if err != nil {
panic(err)
@@ -90,13 +90,13 @@ func NewForConfigOrDie(c *rest.Config) *ResourceV1beta2Client {
return client
}
// New creates a new ResourceV1beta2Client for the given RESTClient.
func New(c rest.Interface) *ResourceV1beta2Client {
return &ResourceV1beta2Client{c}
// New creates a new ResourceV1Client for the given RESTClient.
func New(c rest.Interface) *ResourceV1Client {
return &ResourceV1Client{c}
}
func setConfigDefaults(config *rest.Config) {
gv := resourcev1beta2.SchemeGroupVersion
gv := resourcev1.SchemeGroupVersion
config.GroupVersion = &gv
config.APIPath = "/apis"
config.NegotiatedSerializer = rest.CodecFactoryForGeneratedClient(scheme.Scheme, scheme.Codecs).WithoutConversion()
@@ -108,7 +108,7 @@ func setConfigDefaults(config *rest.Config) {
// RESTClient returns a RESTClient that is used to communicate
// with API server by this client implementation.
func (c *ResourceV1beta2Client) RESTClient() rest.Interface {
func (c *ResourceV1Client) RESTClient() rest.Interface {
if c == nil {
return nil
}

42
kubernetes/typed/resource/v1/resourceclaim.go
View File

@@ -16,16 +16,16 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta2
package v1
import (
context "context"
resourcev1beta2 "k8s.io/api/resource/v1beta2"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
resourcev1 "k8s.io/api/resource/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
applyconfigurationsresourcev1beta2 "k8s.io/client-go/applyconfigurations/resource/v1beta2"
applyconfigurationsresourcev1 "k8s.io/client-go/applyconfigurations/resource/v1"
gentype "k8s.io/client-go/gentype"
scheme "k8s.io/client-go/kubernetes/scheme"
)
@@ -38,38 +38,38 @@ type ResourceClaimsGetter interface {
// ResourceClaimInterface has methods to work with ResourceClaim resources.
type ResourceClaimInterface interface {
Create(ctx context.Context, resourceClaim *resourcev1beta2.ResourceClaim, opts v1.CreateOptions) (*resourcev1beta2.ResourceClaim, error)
Update(ctx context.Context, resourceClaim *resourcev1beta2.ResourceClaim, opts v1.UpdateOptions) (*resourcev1beta2.ResourceClaim, error)
Create(ctx context.Context, resourceClaim *resourcev1.ResourceClaim, opts metav1.CreateOptions) (*resourcev1.ResourceClaim, error)
Update(ctx context.Context, resourceClaim *resourcev1.ResourceClaim, opts metav1.UpdateOptions) (*resourcev1.ResourceClaim, error)
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
UpdateStatus(ctx context.Context, resourceClaim *resourcev1beta2.ResourceClaim, opts v1.UpdateOptions) (*resourcev1beta2.ResourceClaim, error)
Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
Get(ctx context.Context, name string, opts v1.GetOptions) (*resourcev1beta2.ResourceClaim, error)
List(ctx context.Context, opts v1.ListOptions) (*resourcev1beta2.ResourceClaimList, error)
Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *resourcev1beta2.ResourceClaim, err error)
Apply(ctx context.Context, resourceClaim *applyconfigurationsresourcev1beta2.ResourceClaimApplyConfiguration, opts v1.ApplyOptions) (result *resourcev1beta2.ResourceClaim, err error)
UpdateStatus(ctx context.Context, resourceClaim *resourcev1.ResourceClaim, opts metav1.UpdateOptions) (*resourcev1.ResourceClaim, error)
Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error
Get(ctx context.Context, name string, opts metav1.GetOptions) (*resourcev1.ResourceClaim, error)
List(ctx context.Context, opts metav1.ListOptions) (*resourcev1.ResourceClaimList, error)
Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *resourcev1.ResourceClaim, err error)
Apply(ctx context.Context, resourceClaim *applyconfigurationsresourcev1.ResourceClaimApplyConfiguration, opts metav1.ApplyOptions) (result *resourcev1.ResourceClaim, err error)
// Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus().
ApplyStatus(ctx context.Context, resourceClaim *applyconfigurationsresourcev1beta2.ResourceClaimApplyConfiguration, opts v1.ApplyOptions) (result *resourcev1beta2.ResourceClaim, err error)
ApplyStatus(ctx context.Context, resourceClaim *applyconfigurationsresourcev1.ResourceClaimApplyConfiguration, opts metav1.ApplyOptions) (result *resourcev1.ResourceClaim, err error)
ResourceClaimExpansion
}
// resourceClaims implements ResourceClaimInterface
type resourceClaims struct {
*gentype.ClientWithListAndApply[*resourcev1beta2.ResourceClaim, *resourcev1beta2.ResourceClaimList, *applyconfigurationsresourcev1beta2.ResourceClaimApplyConfiguration]
*gentype.ClientWithListAndApply[*resourcev1.ResourceClaim, *resourcev1.ResourceClaimList, *applyconfigurationsresourcev1.ResourceClaimApplyConfiguration]
}
// newResourceClaims returns a ResourceClaims
func newResourceClaims(c *ResourceV1beta2Client, namespace string) *resourceClaims {
func newResourceClaims(c *ResourceV1Client, namespace string) *resourceClaims {
return &resourceClaims{
gentype.NewClientWithListAndApply[*resourcev1beta2.ResourceClaim, *resourcev1beta2.ResourceClaimList, *applyconfigurationsresourcev1beta2.ResourceClaimApplyConfiguration](
gentype.NewClientWithListAndApply[*resourcev1.ResourceClaim, *resourcev1.ResourceClaimList, *applyconfigurationsresourcev1.ResourceClaimApplyConfiguration](
"resourceclaims",
c.RESTClient(),
scheme.ParameterCodec,
namespace,
func() *resourcev1beta2.ResourceClaim { return &resourcev1beta2.ResourceClaim{} },
func() *resourcev1beta2.ResourceClaimList { return &resourcev1beta2.ResourceClaimList{} },
gentype.PrefersProtobuf[*resourcev1beta2.ResourceClaim](),
func() *resourcev1.ResourceClaim { return &resourcev1.ResourceClaim{} },
func() *resourcev1.ResourceClaimList { return &resourcev1.ResourceClaimList{} },
gentype.PrefersProtobuf[*resourcev1.ResourceClaim](),
),
}
}

38
kubernetes/typed/resource/v1/resourceclaimtemplate.go
View File

@@ -16,16 +16,16 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta2
package v1
import (
context "context"
resourcev1beta2 "k8s.io/api/resource/v1beta2"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
resourcev1 "k8s.io/api/resource/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
applyconfigurationsresourcev1beta2 "k8s.io/client-go/applyconfigurations/resource/v1beta2"
applyconfigurationsresourcev1 "k8s.io/client-go/applyconfigurations/resource/v1"
gentype "k8s.io/client-go/gentype"
scheme "k8s.io/client-go/kubernetes/scheme"
)
@@ -38,34 +38,34 @@ type ResourceClaimTemplatesGetter interface {
// ResourceClaimTemplateInterface has methods to work with ResourceClaimTemplate resources.
type ResourceClaimTemplateInterface interface {
Create(ctx context.Context, resourceClaimTemplate *resourcev1beta2.ResourceClaimTemplate, opts v1.CreateOptions) (*resourcev1beta2.ResourceClaimTemplate, error)
Update(ctx context.Context, resourceClaimTemplate *resourcev1beta2.ResourceClaimTemplate, opts v1.UpdateOptions) (*resourcev1beta2.ResourceClaimTemplate, error)
Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
Get(ctx context.Context, name string, opts v1.GetOptions) (*resourcev1beta2.ResourceClaimTemplate, error)
List(ctx context.Context, opts v1.ListOptions) (*resourcev1beta2.ResourceClaimTemplateList, error)
Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *resourcev1beta2.ResourceClaimTemplate, err error)
Apply(ctx context.Context, resourceClaimTemplate *applyconfigurationsresourcev1beta2.ResourceClaimTemplateApplyConfiguration, opts v1.ApplyOptions) (result *resourcev1beta2.ResourceClaimTemplate, err error)
Create(ctx context.Context, resourceClaimTemplate *resourcev1.ResourceClaimTemplate, opts metav1.CreateOptions) (*resourcev1.ResourceClaimTemplate, error)
Update(ctx context.Context, resourceClaimTemplate *resourcev1.ResourceClaimTemplate, opts metav1.UpdateOptions) (*resourcev1.ResourceClaimTemplate, error)
Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error
Get(ctx context.Context, name string, opts metav1.GetOptions) (*resourcev1.ResourceClaimTemplate, error)
List(ctx context.Context, opts metav1.ListOptions) (*resourcev1.ResourceClaimTemplateList, error)
Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *resourcev1.ResourceClaimTemplate, err error)
Apply(ctx context.Context, resourceClaimTemplate *applyconfigurationsresourcev1.ResourceClaimTemplateApplyConfiguration, opts metav1.ApplyOptions) (result *resourcev1.ResourceClaimTemplate, err error)
ResourceClaimTemplateExpansion
}
// resourceClaimTemplates implements ResourceClaimTemplateInterface
type resourceClaimTemplates struct {
*gentype.ClientWithListAndApply[*resourcev1beta2.ResourceClaimTemplate, *resourcev1beta2.ResourceClaimTemplateList, *applyconfigurationsresourcev1beta2.ResourceClaimTemplateApplyConfiguration]
*gentype.ClientWithListAndApply[*resourcev1.ResourceClaimTemplate, *resourcev1.ResourceClaimTemplateList, *applyconfigurationsresourcev1.ResourceClaimTemplateApplyConfiguration]
}
// newResourceClaimTemplates returns a ResourceClaimTemplates
func newResourceClaimTemplates(c *ResourceV1beta2Client, namespace string) *resourceClaimTemplates {
func newResourceClaimTemplates(c *ResourceV1Client, namespace string) *resourceClaimTemplates {
return &resourceClaimTemplates{
gentype.NewClientWithListAndApply[*resourcev1beta2.ResourceClaimTemplate, *resourcev1beta2.ResourceClaimTemplateList, *applyconfigurationsresourcev1beta2.ResourceClaimTemplateApplyConfiguration](
gentype.NewClientWithListAndApply[*resourcev1.ResourceClaimTemplate, *resourcev1.ResourceClaimTemplateList, *applyconfigurationsresourcev1.ResourceClaimTemplateApplyConfiguration](
"resourceclaimtemplates",
c.RESTClient(),
scheme.ParameterCodec,
namespace,
func() *resourcev1beta2.ResourceClaimTemplate { return &resourcev1beta2.ResourceClaimTemplate{} },
func() *resourcev1beta2.ResourceClaimTemplateList { return &resourcev1beta2.ResourceClaimTemplateList{} },
gentype.PrefersProtobuf[*resourcev1beta2.ResourceClaimTemplate](),
func() *resourcev1.ResourceClaimTemplate { return &resourcev1.ResourceClaimTemplate{} },
func() *resourcev1.ResourceClaimTemplateList { return &resourcev1.ResourceClaimTemplateList{} },
gentype.PrefersProtobuf[*resourcev1.ResourceClaimTemplate](),
),
}
}

38
kubernetes/typed/resource/v1/resourceslice.go
View File

@@ -16,16 +16,16 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta2
package v1
import (
context "context"
resourcev1beta2 "k8s.io/api/resource/v1beta2"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
resourcev1 "k8s.io/api/resource/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
applyconfigurationsresourcev1beta2 "k8s.io/client-go/applyconfigurations/resource/v1beta2"
applyconfigurationsresourcev1 "k8s.io/client-go/applyconfigurations/resource/v1"
gentype "k8s.io/client-go/gentype"
scheme "k8s.io/client-go/kubernetes/scheme"
)
@@ -38,34 +38,34 @@ type ResourceSlicesGetter interface {
// ResourceSliceInterface has methods to work with ResourceSlice resources.
type ResourceSliceInterface interface {
Create(ctx context.Context, resourceSlice *resourcev1beta2.ResourceSlice, opts v1.CreateOptions) (*resourcev1beta2.ResourceSlice, error)
Update(ctx context.Context, resourceSlice *resourcev1beta2.ResourceSlice, opts v1.UpdateOptions) (*resourcev1beta2.ResourceSlice, error)
Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
Get(ctx context.Context, name string, opts v1.GetOptions) (*resourcev1beta2.ResourceSlice, error)
List(ctx context.Context, opts v1.ListOptions) (*resourcev1beta2.ResourceSliceList, error)
Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *resourcev1beta2.ResourceSlice, err error)
Apply(ctx context.Context, resourceSlice *applyconfigurationsresourcev1beta2.ResourceSliceApplyConfiguration, opts v1.ApplyOptions) (result *resourcev1beta2.ResourceSlice, err error)
Create(ctx context.Context, resourceSlice *resourcev1.ResourceSlice, opts metav1.CreateOptions) (*resourcev1.ResourceSlice, error)
Update(ctx context.Context, resourceSlice *resourcev1.ResourceSlice, opts metav1.UpdateOptions) (*resourcev1.ResourceSlice, error)
Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error
Get(ctx context.Context, name string, opts metav1.GetOptions) (*resourcev1.ResourceSlice, error)
List(ctx context.Context, opts metav1.ListOptions) (*resourcev1.ResourceSliceList, error)
Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *resourcev1.ResourceSlice, err error)
Apply(ctx context.Context, resourceSlice *applyconfigurationsresourcev1.ResourceSliceApplyConfiguration, opts metav1.ApplyOptions) (result *resourcev1.ResourceSlice, err error)
ResourceSliceExpansion
}
// resourceSlices implements ResourceSliceInterface
type resourceSlices struct {
*gentype.ClientWithListAndApply[*resourcev1beta2.ResourceSlice, *resourcev1beta2.ResourceSliceList, *applyconfigurationsresourcev1beta2.ResourceSliceApplyConfiguration]
*gentype.ClientWithListAndApply[*resourcev1.ResourceSlice, *resourcev1.ResourceSliceList, *applyconfigurationsresourcev1.ResourceSliceApplyConfiguration]
}
// newResourceSlices returns a ResourceSlices
func newResourceSlices(c *ResourceV1beta2Client) *resourceSlices {
func newResourceSlices(c *ResourceV1Client) *resourceSlices {
return &resourceSlices{
gentype.NewClientWithListAndApply[*resourcev1beta2.ResourceSlice, *resourcev1beta2.ResourceSliceList, *applyconfigurationsresourcev1beta2.ResourceSliceApplyConfiguration](
gentype.NewClientWithListAndApply[*resourcev1.ResourceSlice, *resourcev1.ResourceSliceList, *applyconfigurationsresourcev1.ResourceSliceApplyConfiguration](
"resourceslices",
c.RESTClient(),
scheme.ParameterCodec,
"",
func() *resourcev1beta2.ResourceSlice { return &resourcev1beta2.ResourceSlice{} },
func() *resourcev1beta2.ResourceSliceList { return &resourcev1beta2.ResourceSliceList{} },
gentype.PrefersProtobuf[*resourcev1beta2.ResourceSlice](),
func() *resourcev1.ResourceSlice { return &resourcev1.ResourceSlice{} },
func() *resourcev1.ResourceSliceList { return &resourcev1.ResourceSliceList{} },
gentype.PrefersProtobuf[*resourcev1.ResourceSlice](),
),
}
}