Repository: knative-sandbox/eventing-kafka-broker
Pull request #2774 (2022-11-08 08:54:17)

Allow running rekt tests in namespace with enforced "restricted" pod security standard
Related to https://github.com/knative/eventing/pull/6584
Pulls in changes from https://github.com/knative-sandbox/reconciler-test/pull/414 and https://github.com/knative/pkg/pull/2625

<!-- Please include the 'why' behind your changes if no issue exists -->

## Proposed Changes

- Update dependencies to pull in the required changes
-
-

<!--
If this change has user-visible impact, follow the instructions below.
Examples include:

- :gift: Add new feature
- :bug: Fix bug
- :broom: Update or clean up current behavior
- :wastebasket: Remove feature or internal logic

Otherwise delete the rest of this template.
-->

**Release Note**

<!--
:page_facing_up: If this change has user-visible impact, write a release note in the block
below. Include the string "action required" if additional action is required of
users switching to the new release, for example in case of a breaking change.

Write as if you are speaking to users, not other Knative contributors. If this
change has no user-visible impact, no release-note is needed.
-->

```release-note

```

**Docs**

<!--
:book: If this change has user-visible impact, link to an issue or PR in
https://github.com/knative/docs.
-->


knative-prow[bot]: [APPROVALNOTIFIER] This PR is **NOT APPROVED**

This pull-request has been approved by: *<a href="https://github.com/knative-sandbox/eventing-kafka-broker/pull/2774#" title="Author self-approved">mgencur</a>*
**Once this PR has been reviewed and has the lgtm label**, please assign psschwei for approval by writing `/assign @psschwei` in a comment. For more information see [the Kubernetes Code Review Process](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process).

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=knative-sandbox%2Feventing-kafka-broker).

<details open>
Needs approval from an approver in each of these files:

- **[OWNERS](https://github.com/knative-sandbox/eventing-kafka-broker/blob/main/OWNERS)**

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":["psschwei"]} -->
codecov[bot]: # [Codecov](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox) Report
> Merging [#2774](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox) (fc2d62c) into [main](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/commit/041a2d3350c7a60b4a05a3f8f259578d83549dfa?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox) (041a2d3) will **decrease** coverage by `6.27%`.
> The diff coverage is `n/a`.

```diff
@@             Coverage Diff              @@
##               main    #2774      +/-   ##
============================================
- Coverage     61.66%   55.38%   -6.28%     
============================================
  Files           152       75      -77     
  Lines         10713     8096    -2617     
  Branches        231        0     -231     
============================================
- Hits           6606     4484    -2122     
+ Misses         3643     3288     -355     
+ Partials        464      324     -140     
```

| Flag | Coverage Δ | |
|---|---|---|
| java-unittests | `?` | |

Flags with carried forward coverage won't be shown. [Click here](https://docs.codecov.io/docs/carryforward-flags?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#carryforward-flags-in-the-pull-request-comment) to find out more.

| [Impacted Files](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox) | Coverage Δ | |
|---|---|---|
| [...spatcher/impl/consumer/CloudEventDeserializer.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9kaXNwYXRjaGVyL3NyYy9tYWluL2phdmEvZGV2L2tuYXRpdmUvZXZlbnRpbmcva2Fma2EvYnJva2VyL2Rpc3BhdGNoZXIvaW1wbC9jb25zdW1lci9DbG91ZEV2ZW50RGVzZXJpYWxpemVyLmphdmE=) | | |
| [.../core/reconciler/impl/ResourcesReconcilerImpl.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9jb3JlL3NyYy9tYWluL2phdmEvZGV2L2tuYXRpdmUvZXZlbnRpbmcva2Fma2EvYnJva2VyL2NvcmUvcmVjb25jaWxlci9pbXBsL1Jlc291cmNlc1JlY29uY2lsZXJJbXBsLmphdmE=) | | |
| [...oker/dispatcher/impl/ResponseFailureException.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9kaXNwYXRjaGVyL3NyYy9tYWluL2phdmEvZGV2L2tuYXRpdmUvZXZlbnRpbmcva2Fma2EvYnJva2VyL2Rpc3BhdGNoZXIvaW1wbC9SZXNwb25zZUZhaWx1cmVFeGNlcHRpb24uamF2YQ==) | | |
| [...fka/broker/core/security/PlaintextCredentials.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9jb3JlL3NyYy9tYWluL2phdmEvZGV2L2tuYXRpdmUvZXZlbnRpbmcva2Fma2EvYnJva2VyL2NvcmUvc2VjdXJpdHkvUGxhaW50ZXh0Q3JlZGVudGlhbHMuamF2YQ==) | | |
| [...enting/kafka/broker/receiver/main/ReceiverEnv.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9yZWNlaXZlci9zcmMvbWFpbi9qYXZhL2Rldi9rbmF0aXZlL2V2ZW50aW5nL2thZmthL2Jyb2tlci9yZWNlaXZlci9tYWluL1JlY2VpdmVyRW52LmphdmE=) | | |
| [.../broker/dispatcher/impl/ConsumerRecordContext.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9kaXNwYXRjaGVyL3NyYy9tYWluL2phdmEvZGV2L2tuYXRpdmUvZXZlbnRpbmcva2Fma2EvYnJva2VyL2Rpc3BhdGNoZXIvaW1wbC9Db25zdW1lclJlY29yZENvbnRleHQuamF2YQ==) | | |
| [...ver/impl/handler/ControlPlaneProbeRequestUtil.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9yZWNlaXZlci9zcmMvbWFpbi9qYXZhL2Rldi9rbmF0aXZlL2V2ZW50aW5nL2thZmthL2Jyb2tlci9yZWNlaXZlci9pbXBsL2hhbmRsZXIvQ29udHJvbFBsYW5lUHJvYmVSZXF1ZXN0VXRpbC5qYXZh) | | |
| [...eceiver/impl/IngressProducerReconcilableStore.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9yZWNlaXZlci9zcmMvbWFpbi9qYXZhL2Rldi9rbmF0aXZlL2V2ZW50aW5nL2thZmthL2Jyb2tlci9yZWNlaXZlci9pbXBsL0luZ3Jlc3NQcm9kdWNlclJlY29uY2lsYWJsZVN0b3JlLmphdmE=) | | |
| [...ve/eventing/kafka/broker/core/metrics/Metrics.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9jb3JlL3NyYy9tYWluL2phdmEvZGV2L2tuYXRpdmUvZXZlbnRpbmcva2Fma2EvYnJva2VyL2NvcmUvbWV0cmljcy9NZXRyaWNzLmphdmE=) | | |
| [...atcher/impl/filter/subscriptionsapi/AnyFilter.java](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox#diff-ZGF0YS1wbGFuZS9kaXNwYXRjaGVyL3NyYy9tYWluL2phdmEvZGV2L2tuYXRpdmUvZXZlbnRpbmcva2Fma2EvYnJva2VyL2Rpc3BhdGNoZXIvaW1wbC9maWx0ZXIvc3Vic2NyaXB0aW9uc2FwaS9BbnlGaWx0ZXIuamF2YQ==) | | |
| ... and [67 more](https://codecov.io/gh/knative-sandbox/eventing-kafka-broker/pull/2774/diff?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox) | |

Help us with your feedback. Take ten seconds to tell us [how you rate us](https://about.codecov.io/nps?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox). Have a feature suggestion? [Share it here.](https://app.codecov.io/gh/feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=knative-sandbox)

knative-prow[bot]: @mgencur: The following test **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
channel-integration-tests-ssl_eventing-kafka-broker_main | fc2d62c6484d6aeb1e3b8364538aa9da47510095 | [link](https://prow.knative.dev/view/gs/knative-prow/pr-logs/pull/knative-sandbox_eventing-kafka-broker/2774/channel-integration-tests-ssl_eventing-kafka-broker_main/1589909370114674688) | true | `/test channel-integration-tests-ssl`

[Your PR dashboard](https://prow.knative.dev/pr).

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
mgencur: /retest

Patch:
diff --git a/control-plane/pkg/reconciler/trigger/v2/triggerv2.go b/control-plane/pkg/reconciler/trigger/v2/triggerv2.go
index 377a88a8f..1afc5960f 100644
--- a/control-plane/pkg/reconciler/trigger/v2/triggerv2.go
+++ b/control-plane/pkg/reconciler/trigger/v2/triggerv2.go
@@ -134,7 +134,12 @@ func (r Reconciler) reconcileConsumerGroup(ctx context.Context, broker *eventing
 		offset = sources.OffsetEarliest
 	}
 
-	secret, err := security.Secret(ctx, &security.AnnotationsSecretLocator{Annotations: broker.Status.Annotations}, security.DefaultSecretProviderFunc(r.SecretLister, r.KubeClient))
+	namespace := broker.GetNamespace()
+	if broker.Spec.Config.Namespace != "" {
+		namespace = broker.Spec.Config.Namespace
+	}
+
+	secret, err := security.Secret(ctx, &security.AnnotationsSecretLocator{Annotations: broker.Status.Annotations, Namespace: namespace}, security.DefaultSecretProviderFunc(r.SecretLister, r.KubeClient))
 	if err != nil {
 		return nil, fmt.Errorf("failed to get secret: %w", err)
 	}
diff --git a/control-plane/pkg/security/config.go b/control-plane/pkg/security/config.go
index 60e58020d..a35902e6a 100644
--- a/control-plane/pkg/security/config.go
+++ b/control-plane/pkg/security/config.go
@@ -140,12 +140,5 @@ func (a *AnnotationsSecretLocator) SecretName() (string, bool) {
 
 func (a *AnnotationsSecretLocator) SecretNamespace() (string, bool) {
 	name, ok := a.SecretName()
-	if a.Namespace != "" {
-		return a.Namespace, len(a.Namespace) > 0 && ok && len(name) > 0
-	}
-	namespace, ok := a.Annotations[AuthSecretNamespaceKey]
-	if ok && namespace != "" {
-		return namespace, ok
-	}
-	return "", false
+	return a.Namespace, len(a.Namespace) > 0 && ok && len(name) > 0
 }
diff --git a/go.mod b/go.mod
index e4ebed6c5..947694351 100644
--- a/go.mod
+++ b/go.mod
@@ -37,11 +37,11 @@ require (
 
 require (
 	github.com/kedacore/keda/v2 v2.8.1
-	knative.dev/eventing v0.35.1-0.20221028065008-ecf7a29708c3
-	knative.dev/eventing-kafka v0.35.0
-	knative.dev/hack v0.0.0-20221024013916-9d2ae47c16b2
-	knative.dev/pkg v0.0.0-20221027173407-198b4637065d
-	knative.dev/reconciler-test v0.0.0-20221028112508-07a0279f6a51
+	knative.dev/eventing v0.35.1-0.20221104013907-6de07e818049
+	knative.dev/eventing-kafka v0.35.1-0.20221102062409-3992a225fc57
+	knative.dev/hack v0.0.0-20221104013908-8f3c7050408b
+	knative.dev/pkg v0.0.0-20221107171117-0243d641354d
+	knative.dev/reconciler-test v0.0.0-20221108073117-5600f5301d87
 	sigs.k8s.io/controller-runtime v0.12.3
 )
 
diff --git a/go.sum b/go.sum
index 88d0c4273..b2d8f7490 100644
--- a/go.sum
+++ b/go.sum
@@ -1514,16 +1514,16 @@ k8s.io/utils v0.0.0-20200912215256-4140de9c8800/go.mod h1:jPW/WVKK9YHAvNhRxK0md/
 k8s.io/utils v0.0.0-20210819203725-bdf08cb9a70a/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
 k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed h1:jAne/RjBTyawwAy0utX5eqigAwz/lQhTmy+Hr/Cpue4=
 k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
-knative.dev/eventing v0.35.1-0.20221028065008-ecf7a29708c3 h1:kD+BRRb+SbloRRv+LrmqBkiCTcukwkEDK3S0PmGx1ZI=
-knative.dev/eventing v0.35.1-0.20221028065008-ecf7a29708c3/go.mod h1:LRcPcuemoX4bKzktYZlmZfV4CMLC6Ef9PH5/eVyOSqE=
-knative.dev/eventing-kafka v0.35.0 h1:N7zkSHyYHay/tS8T6o6S1pLGbbi3ccFslBAeHapaltE=
-knative.dev/eventing-kafka v0.35.0/go.mod h1:L7wLSNKcvrW3vp+jjPadD/HVRrMv24pMoA2sn28E4Ho=
-knative.dev/hack v0.0.0-20221024013916-9d2ae47c16b2 h1:DvWcy2c6wvjDo+rPRWe9Rn5QEH8fiq/j4QWOka0wMvQ=
-knative.dev/hack v0.0.0-20221024013916-9d2ae47c16b2/go.mod h1:yk2OjGDsbEnQjfxdm0/HJKS2WqTLEFg/N6nUs6Rqx3Q=
-knative.dev/pkg v0.0.0-20221027173407-198b4637065d h1:sqnBiIFVRo/TWxMNF+gNgwFM2JVdWQKtrtwidTVi5Zk=
-knative.dev/pkg v0.0.0-20221027173407-198b4637065d/go.mod h1:j5kO7gKmWGj2DJpefCEiPbItToiYf+2bCtI+A6REkQo=
-knative.dev/reconciler-test v0.0.0-20221028112508-07a0279f6a51 h1:N2DgerktZi6cKSUhqYH8xeaunD0qFnACDr3YLO1Q1oM=
-knative.dev/reconciler-test v0.0.0-20221028112508-07a0279f6a51/go.mod h1:AHzFDo9EKSCBirwFTYJz4GmqVFXXOp54QAavVF9e5yY=
+knative.dev/eventing v0.35.1-0.20221104013907-6de07e818049 h1:JAbeKbn+3ZgD2PO+K3wZVJwcAlIkxFRCvKE+t9ui3Jo=
+knative.dev/eventing v0.35.1-0.20221104013907-6de07e818049/go.mod h1:MUVPi3EN46i+13b0azAsZ09oevqd21RZzZPmRpUwwNo=
+knative.dev/eventing-kafka v0.35.1-0.20221102062409-3992a225fc57 h1:JdEB4ZE9nckzxciTS+ea3EBDRkMm1M3vnDrWndfRpk0=
+knative.dev/eventing-kafka v0.35.1-0.20221102062409-3992a225fc57/go.mod h1:FZG6TBdrrXA9oyJNrIVetyM60Yp5zt5NIJvUO/WTCds=
+knative.dev/hack v0.0.0-20221104013908-8f3c7050408b h1:EqqlOqjCy/hVexdmPpUjcplO2eZc12+jTdTpodfLaI4=
+knative.dev/hack v0.0.0-20221104013908-8f3c7050408b/go.mod h1:yk2OjGDsbEnQjfxdm0/HJKS2WqTLEFg/N6nUs6Rqx3Q=
+knative.dev/pkg v0.0.0-20221107171117-0243d641354d h1:ACj/4O74QvoB8zE/mlg1ji680gFW7RaUIjAL1x5IN58=
+knative.dev/pkg v0.0.0-20221107171117-0243d641354d/go.mod h1:JwNkOLWAeuMYlH9WQA83k+afGCanWcvWvdXZsI3xKo4=
+knative.dev/reconciler-test v0.0.0-20221108073117-5600f5301d87 h1:sPnVPVO0SoF71AWNDe8y3cYAB0sTLBHdlOan+E1L5B4=
+knative.dev/reconciler-test v0.0.0-20221108073117-5600f5301d87/go.mod h1:go1LeYtNHRIKLLIaJZYMvtYvn1Tky/gkUXX+311pY6I=
 pgregory.net/rapid v0.3.3 h1:jCjBsY4ln4Atz78QoBWxUEvAHaFyNDQg9+WU62aCn1U=
 pgregory.net/rapid v0.3.3/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
diff --git a/vendor/knative.dev/hack/README.md b/vendor/knative.dev/hack/README.md
index 89cae268a..607bc897a 100644
--- a/vendor/knative.dev/hack/README.md
+++ b/vendor/knative.dev/hack/README.md
@@ -149,9 +149,6 @@ This is a helper script for Knative E2E test scripts. To use it:
 1. By default `knative_teardown()` and `test_teardown()` will be called after
    the tests finish, use `--skip-teardowns` if you don't want them to be called.
 
-1. By default Istio is installed on the cluster via Addon, use
-   `--skip-istio-addon` if you choose not to have it preinstalled.
-
 1. By default Google Kubernetes Engine telemetry to Cloud Logging and Monitoring is disabled.
    This can be enabled by setting `ENABLE_GKE_TELEMETRY` to `true`.
    
diff --git a/vendor/knative.dev/pkg/apis/duck/v1alpha1/legacy_targetable_types.go b/vendor/knative.dev/pkg/apis/duck/v1alpha1/legacy_targetable_types.go
index c8a32a735..09513ff03 100644
--- a/vendor/knative.dev/pkg/apis/duck/v1alpha1/legacy_targetable_types.go
+++ b/vendor/knative.dev/pkg/apis/duck/v1alpha1/legacy_targetable_types.go
@@ -33,7 +33,7 @@ import (
 // under Status rather than strings.
 // This is to support existing resources until they migrate.
 //
-// Do not use this for anything new, use Addressable
+// # Do not use this for anything new, use Addressable
 //
 // LegacyTargetable is the old schema for the addressable portion
 // of the payload
diff --git a/vendor/knative.dev/pkg/apis/duck/verify.go b/vendor/knative.dev/pkg/apis/duck/verify.go
index e3f5abab4..48675f93a 100644
--- a/vendor/knative.dev/pkg/apis/duck/verify.go
+++ b/vendor/knative.dev/pkg/apis/duck/verify.go
@@ -31,10 +31,10 @@ type Populatable = ducktypes.Populatable
 // the provided Implementable duck type.  It is expected that under the resource
 // definition implementing a particular "Fooable" that one would write:
 //
-//   type ConcreteResource struct { ... }
+//	type ConcreteResource struct { ... }
 //
-//   // Check that ConcreteResource properly implement Fooable.
-//   err := duck.VerifyType(&ConcreteResource{}, &something.Fooable{})
+//	// Check that ConcreteResource properly implement Fooable.
+//	err := duck.VerifyType(&ConcreteResource{}, &something.Fooable{})
 //
 // This will return an error if the duck typing is not satisfied.
 func VerifyType(instance interface{}, iface Implementable) error {
diff --git a/vendor/knative.dev/pkg/changeset/commit.go b/vendor/knative.dev/pkg/changeset/commit.go
index da38bd330..90a031f59 100644
--- a/vendor/knative.dev/pkg/changeset/commit.go
+++ b/vendor/knative.dev/pkg/changeset/commit.go
@@ -39,7 +39,10 @@ var (
 // The result will have a '-dirty' suffix if the workspace was not clean
 func Get() string {
 	once.Do(func() {
-		rev = get()
+		if rev == "" {
+			rev = get()
+		}
+		// It has been set through ldflags, do nothing
 	})
 
 	return rev
diff --git a/vendor/knative.dev/pkg/client/injection/kube/client/client.go b/vendor/knative.dev/pkg/client/injection/kube/client/client.go
index 0111485ca..f490241e1 100644
--- a/vendor/knative.dev/pkg/client/injection/kube/client/client.go
+++ b/vendor/knative.dev/pkg/client/injection/kube/client/client.go
@@ -171,6 +171,7 @@ import (
 	injection "knative.dev/pkg/injection"
 	dynamicclient "knative.dev/pkg/injection/clients/dynamicclient"
 	logging "knative.dev/pkg/logging"
+	ptr "knative.dev/pkg/ptr"
 )
 
 func init() {
@@ -260,11 +261,43 @@ type wrapAdmissionregistrationV1MutatingWebhookConfigurationImpl struct {
 var _ typedadmissionregistrationv1.MutatingWebhookConfigurationInterface = (*wrapAdmissionregistrationV1MutatingWebhookConfigurationImpl)(nil)
 
 func (w *wrapAdmissionregistrationV1MutatingWebhookConfigurationImpl) Apply(ctx context.Context, in *v1.MutatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *admissionregistrationv1.MutatingWebhookConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("MutatingWebhookConfiguration")
+
+	in.APIVersion = ptr.String("admissionregistration.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &admissionregistrationv1.MutatingWebhookConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAdmissionregistrationV1MutatingWebhookConfigurationImpl) ApplyStatus(ctx context.Context, in *v1.MutatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *admissionregistrationv1.MutatingWebhookConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("MutatingWebhookConfiguration")
+
+	in.APIVersion = ptr.String("admissionregistration.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &admissionregistrationv1.MutatingWebhookConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAdmissionregistrationV1MutatingWebhookConfigurationImpl) Create(ctx context.Context, in *admissionregistrationv1.MutatingWebhookConfiguration, opts metav1.CreateOptions) (*admissionregistrationv1.MutatingWebhookConfiguration, error) {
@@ -395,11 +428,43 @@ type wrapAdmissionregistrationV1ValidatingWebhookConfigurationImpl struct {
 var _ typedadmissionregistrationv1.ValidatingWebhookConfigurationInterface = (*wrapAdmissionregistrationV1ValidatingWebhookConfigurationImpl)(nil)
 
 func (w *wrapAdmissionregistrationV1ValidatingWebhookConfigurationImpl) Apply(ctx context.Context, in *v1.ValidatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *admissionregistrationv1.ValidatingWebhookConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ValidatingWebhookConfiguration")
+
+	in.APIVersion = ptr.String("admissionregistration.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &admissionregistrationv1.ValidatingWebhookConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAdmissionregistrationV1ValidatingWebhookConfigurationImpl) ApplyStatus(ctx context.Context, in *v1.ValidatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *admissionregistrationv1.ValidatingWebhookConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ValidatingWebhookConfiguration")
+
+	in.APIVersion = ptr.String("admissionregistration.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &admissionregistrationv1.ValidatingWebhookConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAdmissionregistrationV1ValidatingWebhookConfigurationImpl) Create(ctx context.Context, in *admissionregistrationv1.ValidatingWebhookConfiguration, opts metav1.CreateOptions) (*admissionregistrationv1.ValidatingWebhookConfiguration, error) {
@@ -545,11 +610,43 @@ type wrapAdmissionregistrationV1beta1MutatingWebhookConfigurationImpl struct {
 var _ typedadmissionregistrationv1beta1.MutatingWebhookConfigurationInterface = (*wrapAdmissionregistrationV1beta1MutatingWebhookConfigurationImpl)(nil)
 
 func (w *wrapAdmissionregistrationV1beta1MutatingWebhookConfigurationImpl) Apply(ctx context.Context, in *v1beta1.MutatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *admissionregistrationv1beta1.MutatingWebhookConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("MutatingWebhookConfiguration")
+
+	in.APIVersion = ptr.String("admissionregistration.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &admissionregistrationv1beta1.MutatingWebhookConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAdmissionregistrationV1beta1MutatingWebhookConfigurationImpl) ApplyStatus(ctx context.Context, in *v1beta1.MutatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *admissionregistrationv1beta1.MutatingWebhookConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("MutatingWebhookConfiguration")
+
+	in.APIVersion = ptr.String("admissionregistration.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &admissionregistrationv1beta1.MutatingWebhookConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAdmissionregistrationV1beta1MutatingWebhookConfigurationImpl) Create(ctx context.Context, in *admissionregistrationv1beta1.MutatingWebhookConfiguration, opts metav1.CreateOptions) (*admissionregistrationv1beta1.MutatingWebhookConfiguration, error) {
@@ -680,11 +777,43 @@ type wrapAdmissionregistrationV1beta1ValidatingWebhookConfigurationImpl struct {
 var _ typedadmissionregistrationv1beta1.ValidatingWebhookConfigurationInterface = (*wrapAdmissionregistrationV1beta1ValidatingWebhookConfigurationImpl)(nil)
 
 func (w *wrapAdmissionregistrationV1beta1ValidatingWebhookConfigurationImpl) Apply(ctx context.Context, in *v1beta1.ValidatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *admissionregistrationv1beta1.ValidatingWebhookConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ValidatingWebhookConfiguration")
+
+	in.APIVersion = ptr.String("admissionregistration.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &admissionregistrationv1beta1.ValidatingWebhookConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAdmissionregistrationV1beta1ValidatingWebhookConfigurationImpl) ApplyStatus(ctx context.Context, in *v1beta1.ValidatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *admissionregistrationv1beta1.ValidatingWebhookConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ValidatingWebhookConfiguration")
+
+	in.APIVersion = ptr.String("admissionregistration.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &admissionregistrationv1beta1.ValidatingWebhookConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAdmissionregistrationV1beta1ValidatingWebhookConfigurationImpl) Create(ctx context.Context, in *admissionregistrationv1beta1.ValidatingWebhookConfiguration, opts metav1.CreateOptions) (*admissionregistrationv1beta1.ValidatingWebhookConfiguration, error) {
@@ -830,11 +959,43 @@ type wrapInternalV1alpha1StorageVersionImpl struct {
 var _ typedinternalv1alpha1.StorageVersionInterface = (*wrapInternalV1alpha1StorageVersionImpl)(nil)
 
 func (w *wrapInternalV1alpha1StorageVersionImpl) Apply(ctx context.Context, in *v1alpha1.StorageVersionApplyConfiguration, opts metav1.ApplyOptions) (result *apiserverinternalv1alpha1.StorageVersion, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StorageVersion")
+
+	in.APIVersion = ptr.String("internal.apiserver.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiserverinternalv1alpha1.StorageVersion{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapInternalV1alpha1StorageVersionImpl) ApplyStatus(ctx context.Context, in *v1alpha1.StorageVersionApplyConfiguration, opts metav1.ApplyOptions) (result *apiserverinternalv1alpha1.StorageVersion, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StorageVersion")
+
+	in.APIVersion = ptr.String("internal.apiserver.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiserverinternalv1alpha1.StorageVersion{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapInternalV1alpha1StorageVersionImpl) Create(ctx context.Context, in *apiserverinternalv1alpha1.StorageVersion, opts metav1.CreateOptions) (*apiserverinternalv1alpha1.StorageVersion, error) {
@@ -984,11 +1145,43 @@ type wrapAppsV1ControllerRevisionImpl struct {
 var _ typedappsv1.ControllerRevisionInterface = (*wrapAppsV1ControllerRevisionImpl)(nil)
 
 func (w *wrapAppsV1ControllerRevisionImpl) Apply(ctx context.Context, in *appsv1.ControllerRevisionApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.ControllerRevision, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ControllerRevision")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.ControllerRevision{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1ControllerRevisionImpl) ApplyStatus(ctx context.Context, in *appsv1.ControllerRevisionApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.ControllerRevision, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ControllerRevision")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.ControllerRevision{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1ControllerRevisionImpl) Create(ctx context.Context, in *apiappsv1.ControllerRevision, opts metav1.CreateOptions) (*apiappsv1.ControllerRevision, error) {
@@ -1123,11 +1316,43 @@ type wrapAppsV1DaemonSetImpl struct {
 var _ typedappsv1.DaemonSetInterface = (*wrapAppsV1DaemonSetImpl)(nil)
 
 func (w *wrapAppsV1DaemonSetImpl) Apply(ctx context.Context, in *appsv1.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.DaemonSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("DaemonSet")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.DaemonSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1DaemonSetImpl) ApplyStatus(ctx context.Context, in *appsv1.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.DaemonSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("DaemonSet")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.DaemonSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1DaemonSetImpl) Create(ctx context.Context, in *apiappsv1.DaemonSet, opts metav1.CreateOptions) (*apiappsv1.DaemonSet, error) {
@@ -1262,11 +1487,43 @@ type wrapAppsV1DeploymentImpl struct {
 var _ typedappsv1.DeploymentInterface = (*wrapAppsV1DeploymentImpl)(nil)
 
 func (w *wrapAppsV1DeploymentImpl) Apply(ctx context.Context, in *appsv1.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.Deployment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Deployment")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.Deployment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1DeploymentImpl) ApplyStatus(ctx context.Context, in *appsv1.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.Deployment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Deployment")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.Deployment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1DeploymentImpl) Create(ctx context.Context, in *apiappsv1.Deployment, opts metav1.CreateOptions) (*apiappsv1.Deployment, error) {
@@ -1413,24 +1670,15 @@ type wrapAppsV1ReplicaSetImpl struct {
 var _ typedappsv1.ReplicaSetInterface = (*wrapAppsV1ReplicaSetImpl)(nil)
 
 func (w *wrapAppsV1ReplicaSetImpl) Apply(ctx context.Context, in *appsv1.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.ReplicaSet, err error) {
-	panic("NYI")
-}
+	in.Kind = ptr.String("ReplicaSet")
 
-func (w *wrapAppsV1ReplicaSetImpl) ApplyStatus(ctx context.Context, in *appsv1.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.ReplicaSet, err error) {
-	panic("NYI")
-}
+	in.APIVersion = ptr.String("apps/v1")
 
-func (w *wrapAppsV1ReplicaSetImpl) Create(ctx context.Context, in *apiappsv1.ReplicaSet, opts metav1.CreateOptions) (*apiappsv1.ReplicaSet, error) {
-	in.SetGroupVersionKind(schema.GroupVersionKind{
-		Group:   "apps",
-		Version: "v1",
-		Kind:    "ReplicaSet",
-	})
 	uo := &unstructured.Unstructured{}
 	if err := convert(in, uo); err != nil {
 		return nil, err
 	}
-	uo, err := w.dyn.Namespace(w.namespace).Create(ctx, uo, opts)
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
 	if err != nil {
 		return nil, err
 	}
@@ -1441,9 +1689,50 @@ func (w *wrapAppsV1ReplicaSetImpl) Create(ctx context.Context, in *apiappsv1.Rep
 	return out, nil
 }
 
-func (w *wrapAppsV1ReplicaSetImpl) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
-	return w.dyn.Namespace(w.namespace).Delete(ctx, name, opts)
-}
+func (w *wrapAppsV1ReplicaSetImpl) ApplyStatus(ctx context.Context, in *appsv1.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.ReplicaSet, err error) {
+	in.Kind = ptr.String("ReplicaSet")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.ReplicaSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapAppsV1ReplicaSetImpl) Create(ctx context.Context, in *apiappsv1.ReplicaSet, opts metav1.CreateOptions) (*apiappsv1.ReplicaSet, error) {
+	in.SetGroupVersionKind(schema.GroupVersionKind{
+		Group:   "apps",
+		Version: "v1",
+		Kind:    "ReplicaSet",
+	})
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err := w.dyn.Namespace(w.namespace).Create(ctx, uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.ReplicaSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapAppsV1ReplicaSetImpl) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
+	return w.dyn.Namespace(w.namespace).Delete(ctx, name, opts)
+}
 
 func (w *wrapAppsV1ReplicaSetImpl) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error {
 	return w.dyn.Namespace(w.namespace).DeleteCollection(ctx, opts, listOpts)
@@ -1564,11 +1853,43 @@ type wrapAppsV1StatefulSetImpl struct {
 var _ typedappsv1.StatefulSetInterface = (*wrapAppsV1StatefulSetImpl)(nil)
 
 func (w *wrapAppsV1StatefulSetImpl) Apply(ctx context.Context, in *appsv1.StatefulSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.StatefulSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StatefulSet")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.StatefulSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1StatefulSetImpl) ApplyStatus(ctx context.Context, in *appsv1.StatefulSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1.StatefulSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StatefulSet")
+
+	in.APIVersion = ptr.String("apps/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1.StatefulSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1StatefulSetImpl) Create(ctx context.Context, in *apiappsv1.StatefulSet, opts metav1.CreateOptions) (*apiappsv1.StatefulSet, error) {
@@ -1730,11 +2051,43 @@ type wrapAppsV1beta1ControllerRevisionImpl struct {
 var _ typedappsv1beta1.ControllerRevisionInterface = (*wrapAppsV1beta1ControllerRevisionImpl)(nil)
 
 func (w *wrapAppsV1beta1ControllerRevisionImpl) Apply(ctx context.Context, in *appsv1beta1.ControllerRevisionApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1beta1.ControllerRevision, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ControllerRevision")
+
+	in.APIVersion = ptr.String("apps/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1beta1.ControllerRevision{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta1ControllerRevisionImpl) ApplyStatus(ctx context.Context, in *appsv1beta1.ControllerRevisionApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1beta1.ControllerRevision, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ControllerRevision")
+
+	in.APIVersion = ptr.String("apps/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1beta1.ControllerRevision{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta1ControllerRevisionImpl) Create(ctx context.Context, in *apiappsv1beta1.ControllerRevision, opts metav1.CreateOptions) (*apiappsv1beta1.ControllerRevision, error) {
@@ -1869,11 +2222,43 @@ type wrapAppsV1beta1DeploymentImpl struct {
 var _ typedappsv1beta1.DeploymentInterface = (*wrapAppsV1beta1DeploymentImpl)(nil)
 
 func (w *wrapAppsV1beta1DeploymentImpl) Apply(ctx context.Context, in *appsv1beta1.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1beta1.Deployment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Deployment")
+
+	in.APIVersion = ptr.String("apps/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1beta1.Deployment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta1DeploymentImpl) ApplyStatus(ctx context.Context, in *appsv1beta1.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1beta1.Deployment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Deployment")
+
+	in.APIVersion = ptr.String("apps/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1beta1.Deployment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta1DeploymentImpl) Create(ctx context.Context, in *apiappsv1beta1.Deployment, opts metav1.CreateOptions) (*apiappsv1beta1.Deployment, error) {
@@ -2008,11 +2393,43 @@ type wrapAppsV1beta1StatefulSetImpl struct {
 var _ typedappsv1beta1.StatefulSetInterface = (*wrapAppsV1beta1StatefulSetImpl)(nil)
 
 func (w *wrapAppsV1beta1StatefulSetImpl) Apply(ctx context.Context, in *appsv1beta1.StatefulSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1beta1.StatefulSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StatefulSet")
+
+	in.APIVersion = ptr.String("apps/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1beta1.StatefulSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta1StatefulSetImpl) ApplyStatus(ctx context.Context, in *appsv1beta1.StatefulSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiappsv1beta1.StatefulSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StatefulSet")
+
+	in.APIVersion = ptr.String("apps/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiappsv1beta1.StatefulSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta1StatefulSetImpl) Create(ctx context.Context, in *apiappsv1beta1.StatefulSet, opts metav1.CreateOptions) (*apiappsv1beta1.StatefulSet, error) {
@@ -2162,11 +2579,43 @@ type wrapAppsV1beta2ControllerRevisionImpl struct {
 var _ typedappsv1beta2.ControllerRevisionInterface = (*wrapAppsV1beta2ControllerRevisionImpl)(nil)
 
 func (w *wrapAppsV1beta2ControllerRevisionImpl) Apply(ctx context.Context, in *v1beta2.ControllerRevisionApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.ControllerRevision, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ControllerRevision")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.ControllerRevision{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta2ControllerRevisionImpl) ApplyStatus(ctx context.Context, in *v1beta2.ControllerRevisionApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.ControllerRevision, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ControllerRevision")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.ControllerRevision{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta2ControllerRevisionImpl) Create(ctx context.Context, in *appsv1beta2.ControllerRevision, opts metav1.CreateOptions) (*appsv1beta2.ControllerRevision, error) {
@@ -2301,11 +2750,43 @@ type wrapAppsV1beta2DaemonSetImpl struct {
 var _ typedappsv1beta2.DaemonSetInterface = (*wrapAppsV1beta2DaemonSetImpl)(nil)
 
 func (w *wrapAppsV1beta2DaemonSetImpl) Apply(ctx context.Context, in *v1beta2.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.DaemonSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("DaemonSet")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.DaemonSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta2DaemonSetImpl) ApplyStatus(ctx context.Context, in *v1beta2.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.DaemonSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("DaemonSet")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.DaemonSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta2DaemonSetImpl) Create(ctx context.Context, in *appsv1beta2.DaemonSet, opts metav1.CreateOptions) (*appsv1beta2.DaemonSet, error) {
@@ -2440,11 +2921,43 @@ type wrapAppsV1beta2DeploymentImpl struct {
 var _ typedappsv1beta2.DeploymentInterface = (*wrapAppsV1beta2DeploymentImpl)(nil)
 
 func (w *wrapAppsV1beta2DeploymentImpl) Apply(ctx context.Context, in *v1beta2.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.Deployment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Deployment")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.Deployment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta2DeploymentImpl) ApplyStatus(ctx context.Context, in *v1beta2.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.Deployment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Deployment")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.Deployment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta2DeploymentImpl) Create(ctx context.Context, in *appsv1beta2.Deployment, opts metav1.CreateOptions) (*appsv1beta2.Deployment, error) {
@@ -2579,14 +3092,46 @@ type wrapAppsV1beta2ReplicaSetImpl struct {
 var _ typedappsv1beta2.ReplicaSetInterface = (*wrapAppsV1beta2ReplicaSetImpl)(nil)
 
 func (w *wrapAppsV1beta2ReplicaSetImpl) Apply(ctx context.Context, in *v1beta2.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.ReplicaSet, err error) {
-	panic("NYI")
-}
+	in.Kind = ptr.String("ReplicaSet")
 
-func (w *wrapAppsV1beta2ReplicaSetImpl) ApplyStatus(ctx context.Context, in *v1beta2.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.ReplicaSet, err error) {
-	panic("NYI")
-}
+	in.APIVersion = ptr.String("apps/v1beta2")
 
-func (w *wrapAppsV1beta2ReplicaSetImpl) Create(ctx context.Context, in *appsv1beta2.ReplicaSet, opts metav1.CreateOptions) (*appsv1beta2.ReplicaSet, error) {
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.ReplicaSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapAppsV1beta2ReplicaSetImpl) ApplyStatus(ctx context.Context, in *v1beta2.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.ReplicaSet, err error) {
+	in.Kind = ptr.String("ReplicaSet")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.ReplicaSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapAppsV1beta2ReplicaSetImpl) Create(ctx context.Context, in *appsv1beta2.ReplicaSet, opts metav1.CreateOptions) (*appsv1beta2.ReplicaSet, error) {
 	in.SetGroupVersionKind(schema.GroupVersionKind{
 		Group:   "apps",
 		Version: "v1beta2",
@@ -2718,11 +3263,43 @@ type wrapAppsV1beta2StatefulSetImpl struct {
 var _ typedappsv1beta2.StatefulSetInterface = (*wrapAppsV1beta2StatefulSetImpl)(nil)
 
 func (w *wrapAppsV1beta2StatefulSetImpl) Apply(ctx context.Context, in *v1beta2.StatefulSetApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.StatefulSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StatefulSet")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.StatefulSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta2StatefulSetImpl) ApplyStatus(ctx context.Context, in *v1beta2.StatefulSetApplyConfiguration, opts metav1.ApplyOptions) (result *appsv1beta2.StatefulSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StatefulSet")
+
+	in.APIVersion = ptr.String("apps/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &appsv1beta2.StatefulSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAppsV1beta2StatefulSetImpl) Create(ctx context.Context, in *appsv1beta2.StatefulSet, opts metav1.CreateOptions) (*appsv1beta2.StatefulSet, error) {
@@ -3322,11 +3899,43 @@ type wrapAutoscalingV1HorizontalPodAutoscalerImpl struct {
 var _ typedautoscalingv1.HorizontalPodAutoscalerInterface = (*wrapAutoscalingV1HorizontalPodAutoscalerImpl)(nil)
 
 func (w *wrapAutoscalingV1HorizontalPodAutoscalerImpl) Apply(ctx context.Context, in *applyconfigurationsautoscalingv1.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (result *autoscalingv1.HorizontalPodAutoscaler, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("HorizontalPodAutoscaler")
+
+	in.APIVersion = ptr.String("autoscaling/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &autoscalingv1.HorizontalPodAutoscaler{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAutoscalingV1HorizontalPodAutoscalerImpl) ApplyStatus(ctx context.Context, in *applyconfigurationsautoscalingv1.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (result *autoscalingv1.HorizontalPodAutoscaler, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("HorizontalPodAutoscaler")
+
+	in.APIVersion = ptr.String("autoscaling/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &autoscalingv1.HorizontalPodAutoscaler{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAutoscalingV1HorizontalPodAutoscalerImpl) Create(ctx context.Context, in *autoscalingv1.HorizontalPodAutoscaler, opts metav1.CreateOptions) (*autoscalingv1.HorizontalPodAutoscaler, error) {
@@ -3476,11 +4085,43 @@ type wrapAutoscalingV2HorizontalPodAutoscalerImpl struct {
 var _ typedautoscalingv2.HorizontalPodAutoscalerInterface = (*wrapAutoscalingV2HorizontalPodAutoscalerImpl)(nil)
 
 func (w *wrapAutoscalingV2HorizontalPodAutoscalerImpl) Apply(ctx context.Context, in *v2.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (result *autoscalingv2.HorizontalPodAutoscaler, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("HorizontalPodAutoscaler")
+
+	in.APIVersion = ptr.String("autoscaling/v2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &autoscalingv2.HorizontalPodAutoscaler{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAutoscalingV2HorizontalPodAutoscalerImpl) ApplyStatus(ctx context.Context, in *v2.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (result *autoscalingv2.HorizontalPodAutoscaler, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("HorizontalPodAutoscaler")
+
+	in.APIVersion = ptr.String("autoscaling/v2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &autoscalingv2.HorizontalPodAutoscaler{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAutoscalingV2HorizontalPodAutoscalerImpl) Create(ctx context.Context, in *autoscalingv2.HorizontalPodAutoscaler, opts metav1.CreateOptions) (*autoscalingv2.HorizontalPodAutoscaler, error) {
@@ -3630,11 +4271,43 @@ type wrapAutoscalingV2beta1HorizontalPodAutoscalerImpl struct {
 var _ typedautoscalingv2beta1.HorizontalPodAutoscalerInterface = (*wrapAutoscalingV2beta1HorizontalPodAutoscalerImpl)(nil)
 
 func (w *wrapAutoscalingV2beta1HorizontalPodAutoscalerImpl) Apply(ctx context.Context, in *v2beta1.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (result *autoscalingv2beta1.HorizontalPodAutoscaler, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("HorizontalPodAutoscaler")
+
+	in.APIVersion = ptr.String("autoscaling/v2beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &autoscalingv2beta1.HorizontalPodAutoscaler{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAutoscalingV2beta1HorizontalPodAutoscalerImpl) ApplyStatus(ctx context.Context, in *v2beta1.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (result *autoscalingv2beta1.HorizontalPodAutoscaler, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("HorizontalPodAutoscaler")
+
+	in.APIVersion = ptr.String("autoscaling/v2beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &autoscalingv2beta1.HorizontalPodAutoscaler{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAutoscalingV2beta1HorizontalPodAutoscalerImpl) Create(ctx context.Context, in *autoscalingv2beta1.HorizontalPodAutoscaler, opts metav1.CreateOptions) (*autoscalingv2beta1.HorizontalPodAutoscaler, error) {
@@ -3784,11 +4457,43 @@ type wrapAutoscalingV2beta2HorizontalPodAutoscalerImpl struct {
 var _ typedautoscalingv2beta2.HorizontalPodAutoscalerInterface = (*wrapAutoscalingV2beta2HorizontalPodAutoscalerImpl)(nil)
 
 func (w *wrapAutoscalingV2beta2HorizontalPodAutoscalerImpl) Apply(ctx context.Context, in *v2beta2.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (result *autoscalingv2beta2.HorizontalPodAutoscaler, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("HorizontalPodAutoscaler")
+
+	in.APIVersion = ptr.String("autoscaling/v2beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &autoscalingv2beta2.HorizontalPodAutoscaler{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAutoscalingV2beta2HorizontalPodAutoscalerImpl) ApplyStatus(ctx context.Context, in *v2beta2.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (result *autoscalingv2beta2.HorizontalPodAutoscaler, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("HorizontalPodAutoscaler")
+
+	in.APIVersion = ptr.String("autoscaling/v2beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &autoscalingv2beta2.HorizontalPodAutoscaler{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapAutoscalingV2beta2HorizontalPodAutoscalerImpl) Create(ctx context.Context, in *autoscalingv2beta2.HorizontalPodAutoscaler, opts metav1.CreateOptions) (*autoscalingv2beta2.HorizontalPodAutoscaler, error) {
@@ -3938,11 +4643,43 @@ type wrapBatchV1CronJobImpl struct {
 var _ typedbatchv1.CronJobInterface = (*wrapBatchV1CronJobImpl)(nil)
 
 func (w *wrapBatchV1CronJobImpl) Apply(ctx context.Context, in *batchv1.CronJobApplyConfiguration, opts metav1.ApplyOptions) (result *apibatchv1.CronJob, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CronJob")
+
+	in.APIVersion = ptr.String("batch/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apibatchv1.CronJob{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapBatchV1CronJobImpl) ApplyStatus(ctx context.Context, in *batchv1.CronJobApplyConfiguration, opts metav1.ApplyOptions) (result *apibatchv1.CronJob, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CronJob")
+
+	in.APIVersion = ptr.String("batch/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apibatchv1.CronJob{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapBatchV1CronJobImpl) Create(ctx context.Context, in *apibatchv1.CronJob, opts metav1.CreateOptions) (*apibatchv1.CronJob, error) {
@@ -4077,11 +4814,43 @@ type wrapBatchV1JobImpl struct {
 var _ typedbatchv1.JobInterface = (*wrapBatchV1JobImpl)(nil)
 
 func (w *wrapBatchV1JobImpl) Apply(ctx context.Context, in *batchv1.JobApplyConfiguration, opts metav1.ApplyOptions) (result *apibatchv1.Job, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Job")
+
+	in.APIVersion = ptr.String("batch/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apibatchv1.Job{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapBatchV1JobImpl) ApplyStatus(ctx context.Context, in *batchv1.JobApplyConfiguration, opts metav1.ApplyOptions) (result *apibatchv1.Job, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Job")
+
+	in.APIVersion = ptr.String("batch/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apibatchv1.Job{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapBatchV1JobImpl) Create(ctx context.Context, in *apibatchv1.Job, opts metav1.CreateOptions) (*apibatchv1.Job, error) {
@@ -4231,24 +5000,15 @@ type wrapBatchV1beta1CronJobImpl struct {
 var _ typedbatchv1beta1.CronJobInterface = (*wrapBatchV1beta1CronJobImpl)(nil)
 
 func (w *wrapBatchV1beta1CronJobImpl) Apply(ctx context.Context, in *batchv1beta1.CronJobApplyConfiguration, opts metav1.ApplyOptions) (result *apibatchv1beta1.CronJob, err error) {
-	panic("NYI")
-}
+	in.Kind = ptr.String("CronJob")
 
-func (w *wrapBatchV1beta1CronJobImpl) ApplyStatus(ctx context.Context, in *batchv1beta1.CronJobApplyConfiguration, opts metav1.ApplyOptions) (result *apibatchv1beta1.CronJob, err error) {
-	panic("NYI")
-}
+	in.APIVersion = ptr.String("batch/v1beta1")
 
-func (w *wrapBatchV1beta1CronJobImpl) Create(ctx context.Context, in *apibatchv1beta1.CronJob, opts metav1.CreateOptions) (*apibatchv1beta1.CronJob, error) {
-	in.SetGroupVersionKind(schema.GroupVersionKind{
-		Group:   "batch",
-		Version: "v1beta1",
-		Kind:    "CronJob",
-	})
 	uo := &unstructured.Unstructured{}
 	if err := convert(in, uo); err != nil {
 		return nil, err
 	}
-	uo, err := w.dyn.Namespace(w.namespace).Create(ctx, uo, opts)
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
 	if err != nil {
 		return nil, err
 	}
@@ -4259,8 +5019,49 @@ func (w *wrapBatchV1beta1CronJobImpl) Create(ctx context.Context, in *apibatchv1
 	return out, nil
 }
 
-func (w *wrapBatchV1beta1CronJobImpl) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
-	return w.dyn.Namespace(w.namespace).Delete(ctx, name, opts)
+func (w *wrapBatchV1beta1CronJobImpl) ApplyStatus(ctx context.Context, in *batchv1beta1.CronJobApplyConfiguration, opts metav1.ApplyOptions) (result *apibatchv1beta1.CronJob, err error) {
+	in.Kind = ptr.String("CronJob")
+
+	in.APIVersion = ptr.String("batch/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apibatchv1beta1.CronJob{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapBatchV1beta1CronJobImpl) Create(ctx context.Context, in *apibatchv1beta1.CronJob, opts metav1.CreateOptions) (*apibatchv1beta1.CronJob, error) {
+	in.SetGroupVersionKind(schema.GroupVersionKind{
+		Group:   "batch",
+		Version: "v1beta1",
+		Kind:    "CronJob",
+	})
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err := w.dyn.Namespace(w.namespace).Create(ctx, uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apibatchv1beta1.CronJob{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapBatchV1beta1CronJobImpl) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
+	return w.dyn.Namespace(w.namespace).Delete(ctx, name, opts)
 }
 
 func (w *wrapBatchV1beta1CronJobImpl) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error {
@@ -4381,11 +5182,43 @@ type wrapCertificatesV1CertificateSigningRequestImpl struct {
 var _ typedcertificatesv1.CertificateSigningRequestInterface = (*wrapCertificatesV1CertificateSigningRequestImpl)(nil)
 
 func (w *wrapCertificatesV1CertificateSigningRequestImpl) Apply(ctx context.Context, in *certificatesv1.CertificateSigningRequestApplyConfiguration, opts metav1.ApplyOptions) (result *apicertificatesv1.CertificateSigningRequest, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CertificateSigningRequest")
+
+	in.APIVersion = ptr.String("certificates.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicertificatesv1.CertificateSigningRequest{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCertificatesV1CertificateSigningRequestImpl) ApplyStatus(ctx context.Context, in *certificatesv1.CertificateSigningRequestApplyConfiguration, opts metav1.ApplyOptions) (result *apicertificatesv1.CertificateSigningRequest, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CertificateSigningRequest")
+
+	in.APIVersion = ptr.String("certificates.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicertificatesv1.CertificateSigningRequest{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCertificatesV1CertificateSigningRequestImpl) Create(ctx context.Context, in *apicertificatesv1.CertificateSigningRequest, opts metav1.CreateOptions) (*apicertificatesv1.CertificateSigningRequest, error) {
@@ -4535,11 +5368,43 @@ type wrapCertificatesV1beta1CertificateSigningRequestImpl struct {
 var _ typedcertificatesv1beta1.CertificateSigningRequestInterface = (*wrapCertificatesV1beta1CertificateSigningRequestImpl)(nil)
 
 func (w *wrapCertificatesV1beta1CertificateSigningRequestImpl) Apply(ctx context.Context, in *certificatesv1beta1.CertificateSigningRequestApplyConfiguration, opts metav1.ApplyOptions) (result *apicertificatesv1beta1.CertificateSigningRequest, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CertificateSigningRequest")
+
+	in.APIVersion = ptr.String("certificates.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicertificatesv1beta1.CertificateSigningRequest{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCertificatesV1beta1CertificateSigningRequestImpl) ApplyStatus(ctx context.Context, in *certificatesv1beta1.CertificateSigningRequestApplyConfiguration, opts metav1.ApplyOptions) (result *apicertificatesv1beta1.CertificateSigningRequest, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CertificateSigningRequest")
+
+	in.APIVersion = ptr.String("certificates.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicertificatesv1beta1.CertificateSigningRequest{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCertificatesV1beta1CertificateSigningRequestImpl) Create(ctx context.Context, in *apicertificatesv1beta1.CertificateSigningRequest, opts metav1.CreateOptions) (*apicertificatesv1beta1.CertificateSigningRequest, error) {
@@ -4689,11 +5554,43 @@ type wrapCoordinationV1LeaseImpl struct {
 var _ typedcoordinationv1.LeaseInterface = (*wrapCoordinationV1LeaseImpl)(nil)
 
 func (w *wrapCoordinationV1LeaseImpl) Apply(ctx context.Context, in *coordinationv1.LeaseApplyConfiguration, opts metav1.ApplyOptions) (result *apicoordinationv1.Lease, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Lease")
+
+	in.APIVersion = ptr.String("coordination.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicoordinationv1.Lease{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoordinationV1LeaseImpl) ApplyStatus(ctx context.Context, in *coordinationv1.LeaseApplyConfiguration, opts metav1.ApplyOptions) (result *apicoordinationv1.Lease, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Lease")
+
+	in.APIVersion = ptr.String("coordination.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicoordinationv1.Lease{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoordinationV1LeaseImpl) Create(ctx context.Context, in *apicoordinationv1.Lease, opts metav1.CreateOptions) (*apicoordinationv1.Lease, error) {
@@ -4843,11 +5740,43 @@ type wrapCoordinationV1beta1LeaseImpl struct {
 var _ typedcoordinationv1beta1.LeaseInterface = (*wrapCoordinationV1beta1LeaseImpl)(nil)
 
 func (w *wrapCoordinationV1beta1LeaseImpl) Apply(ctx context.Context, in *coordinationv1beta1.LeaseApplyConfiguration, opts metav1.ApplyOptions) (result *apicoordinationv1beta1.Lease, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Lease")
+
+	in.APIVersion = ptr.String("coordination.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicoordinationv1beta1.Lease{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoordinationV1beta1LeaseImpl) ApplyStatus(ctx context.Context, in *coordinationv1beta1.LeaseApplyConfiguration, opts metav1.ApplyOptions) (result *apicoordinationv1beta1.Lease, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Lease")
+
+	in.APIVersion = ptr.String("coordination.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicoordinationv1beta1.Lease{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoordinationV1beta1LeaseImpl) Create(ctx context.Context, in *apicoordinationv1beta1.Lease, opts metav1.CreateOptions) (*apicoordinationv1beta1.Lease, error) {
@@ -4993,11 +5922,43 @@ type wrapCoreV1ComponentStatusImpl struct {
 var _ typedcorev1.ComponentStatusInterface = (*wrapCoreV1ComponentStatusImpl)(nil)
 
 func (w *wrapCoreV1ComponentStatusImpl) Apply(ctx context.Context, in *corev1.ComponentStatusApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ComponentStatus, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ComponentStatus")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ComponentStatus{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ComponentStatusImpl) ApplyStatus(ctx context.Context, in *corev1.ComponentStatusApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ComponentStatus, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ComponentStatus")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ComponentStatus{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ComponentStatusImpl) Create(ctx context.Context, in *apicorev1.ComponentStatus, opts metav1.CreateOptions) (*apicorev1.ComponentStatus, error) {
@@ -5132,11 +6093,43 @@ type wrapCoreV1ConfigMapImpl struct {
 var _ typedcorev1.ConfigMapInterface = (*wrapCoreV1ConfigMapImpl)(nil)
 
 func (w *wrapCoreV1ConfigMapImpl) Apply(ctx context.Context, in *corev1.ConfigMapApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ConfigMap, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ConfigMap")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ConfigMap{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ConfigMapImpl) ApplyStatus(ctx context.Context, in *corev1.ConfigMapApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ConfigMap, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ConfigMap")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ConfigMap{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ConfigMapImpl) Create(ctx context.Context, in *apicorev1.ConfigMap, opts metav1.CreateOptions) (*apicorev1.ConfigMap, error) {
@@ -5271,11 +6264,43 @@ type wrapCoreV1EndpointsImpl struct {
 var _ typedcorev1.EndpointsInterface = (*wrapCoreV1EndpointsImpl)(nil)
 
 func (w *wrapCoreV1EndpointsImpl) Apply(ctx context.Context, in *corev1.EndpointsApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Endpoints, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Endpoints")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Endpoints{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1EndpointsImpl) ApplyStatus(ctx context.Context, in *corev1.EndpointsApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Endpoints, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Endpoints")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Endpoints{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1EndpointsImpl) Create(ctx context.Context, in *apicorev1.Endpoints, opts metav1.CreateOptions) (*apicorev1.Endpoints, error) {
@@ -5410,14 +6435,46 @@ type wrapCoreV1EventImpl struct {
 var _ typedcorev1.EventInterface = (*wrapCoreV1EventImpl)(nil)
 
 func (w *wrapCoreV1EventImpl) Apply(ctx context.Context, in *corev1.EventApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Event, err error) {
-	panic("NYI")
-}
+	in.Kind = ptr.String("Event")
 
-func (w *wrapCoreV1EventImpl) ApplyStatus(ctx context.Context, in *corev1.EventApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Event, err error) {
-	panic("NYI")
-}
+	in.APIVersion = ptr.String("v1")
 
-func (w *wrapCoreV1EventImpl) Create(ctx context.Context, in *apicorev1.Event, opts metav1.CreateOptions) (*apicorev1.Event, error) {
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Event{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapCoreV1EventImpl) ApplyStatus(ctx context.Context, in *corev1.EventApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Event, err error) {
+	in.Kind = ptr.String("Event")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Event{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapCoreV1EventImpl) Create(ctx context.Context, in *apicorev1.Event, opts metav1.CreateOptions) (*apicorev1.Event, error) {
 	in.SetGroupVersionKind(schema.GroupVersionKind{
 		Group:   "",
 		Version: "v1",
@@ -5549,11 +6606,43 @@ type wrapCoreV1LimitRangeImpl struct {
 var _ typedcorev1.LimitRangeInterface = (*wrapCoreV1LimitRangeImpl)(nil)
 
 func (w *wrapCoreV1LimitRangeImpl) Apply(ctx context.Context, in *corev1.LimitRangeApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.LimitRange, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("LimitRange")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.LimitRange{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1LimitRangeImpl) ApplyStatus(ctx context.Context, in *corev1.LimitRangeApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.LimitRange, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("LimitRange")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.LimitRange{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1LimitRangeImpl) Create(ctx context.Context, in *apicorev1.LimitRange, opts metav1.CreateOptions) (*apicorev1.LimitRange, error) {
@@ -5684,11 +6773,43 @@ type wrapCoreV1NamespaceImpl struct {
 var _ typedcorev1.NamespaceInterface = (*wrapCoreV1NamespaceImpl)(nil)
 
 func (w *wrapCoreV1NamespaceImpl) Apply(ctx context.Context, in *corev1.NamespaceApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Namespace, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Namespace")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Namespace{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1NamespaceImpl) ApplyStatus(ctx context.Context, in *corev1.NamespaceApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Namespace, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Namespace")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Namespace{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1NamespaceImpl) Create(ctx context.Context, in *apicorev1.Namespace, opts metav1.CreateOptions) (*apicorev1.Namespace, error) {
@@ -5815,11 +6936,43 @@ type wrapCoreV1NodeImpl struct {
 var _ typedcorev1.NodeInterface = (*wrapCoreV1NodeImpl)(nil)
 
 func (w *wrapCoreV1NodeImpl) Apply(ctx context.Context, in *corev1.NodeApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Node, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Node")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Node{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1NodeImpl) ApplyStatus(ctx context.Context, in *corev1.NodeApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Node, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Node")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Node{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1NodeImpl) Create(ctx context.Context, in *apicorev1.Node, opts metav1.CreateOptions) (*apicorev1.Node, error) {
@@ -5950,11 +7103,43 @@ type wrapCoreV1PersistentVolumeImpl struct {
 var _ typedcorev1.PersistentVolumeInterface = (*wrapCoreV1PersistentVolumeImpl)(nil)
 
 func (w *wrapCoreV1PersistentVolumeImpl) Apply(ctx context.Context, in *corev1.PersistentVolumeApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.PersistentVolume, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PersistentVolume")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.PersistentVolume{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1PersistentVolumeImpl) ApplyStatus(ctx context.Context, in *corev1.PersistentVolumeApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.PersistentVolume, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PersistentVolume")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.PersistentVolume{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1PersistentVolumeImpl) Create(ctx context.Context, in *apicorev1.PersistentVolume, opts metav1.CreateOptions) (*apicorev1.PersistentVolume, error) {
@@ -6089,11 +7274,43 @@ type wrapCoreV1PersistentVolumeClaimImpl struct {
 var _ typedcorev1.PersistentVolumeClaimInterface = (*wrapCoreV1PersistentVolumeClaimImpl)(nil)
 
 func (w *wrapCoreV1PersistentVolumeClaimImpl) Apply(ctx context.Context, in *corev1.PersistentVolumeClaimApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.PersistentVolumeClaim, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PersistentVolumeClaim")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.PersistentVolumeClaim{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1PersistentVolumeClaimImpl) ApplyStatus(ctx context.Context, in *corev1.PersistentVolumeClaimApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.PersistentVolumeClaim, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PersistentVolumeClaim")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.PersistentVolumeClaim{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1PersistentVolumeClaimImpl) Create(ctx context.Context, in *apicorev1.PersistentVolumeClaim, opts metav1.CreateOptions) (*apicorev1.PersistentVolumeClaim, error) {
@@ -6228,11 +7445,43 @@ type wrapCoreV1PodImpl struct {
 var _ typedcorev1.PodInterface = (*wrapCoreV1PodImpl)(nil)
 
 func (w *wrapCoreV1PodImpl) Apply(ctx context.Context, in *corev1.PodApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Pod, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Pod")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Pod{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1PodImpl) ApplyStatus(ctx context.Context, in *corev1.PodApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Pod, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Pod")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Pod{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1PodImpl) Create(ctx context.Context, in *apicorev1.Pod, opts metav1.CreateOptions) (*apicorev1.Pod, error) {
@@ -6371,11 +7620,43 @@ type wrapCoreV1PodTemplateImpl struct {
 var _ typedcorev1.PodTemplateInterface = (*wrapCoreV1PodTemplateImpl)(nil)
 
 func (w *wrapCoreV1PodTemplateImpl) Apply(ctx context.Context, in *corev1.PodTemplateApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.PodTemplate, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodTemplate")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.PodTemplate{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1PodTemplateImpl) ApplyStatus(ctx context.Context, in *corev1.PodTemplateApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.PodTemplate, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodTemplate")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.PodTemplate{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1PodTemplateImpl) Create(ctx context.Context, in *apicorev1.PodTemplate, opts metav1.CreateOptions) (*apicorev1.PodTemplate, error) {
@@ -6510,11 +7791,43 @@ type wrapCoreV1ReplicationControllerImpl struct {
 var _ typedcorev1.ReplicationControllerInterface = (*wrapCoreV1ReplicationControllerImpl)(nil)
 
 func (w *wrapCoreV1ReplicationControllerImpl) Apply(ctx context.Context, in *corev1.ReplicationControllerApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ReplicationController, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ReplicationController")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ReplicationController{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ReplicationControllerImpl) ApplyStatus(ctx context.Context, in *corev1.ReplicationControllerApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ReplicationController, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ReplicationController")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ReplicationController{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ReplicationControllerImpl) Create(ctx context.Context, in *apicorev1.ReplicationController, opts metav1.CreateOptions) (*apicorev1.ReplicationController, error) {
@@ -6654,14 +7967,46 @@ type wrapCoreV1ResourceQuotaImpl struct {
 	namespace string
 }
 
-var _ typedcorev1.ResourceQuotaInterface = (*wrapCoreV1ResourceQuotaImpl)(nil)
+var _ typedcorev1.ResourceQuotaInterface = (*wrapCoreV1ResourceQuotaImpl)(nil)
+
+func (w *wrapCoreV1ResourceQuotaImpl) Apply(ctx context.Context, in *corev1.ResourceQuotaApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ResourceQuota, err error) {
+	in.Kind = ptr.String("ResourceQuota")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ResourceQuota{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapCoreV1ResourceQuotaImpl) ApplyStatus(ctx context.Context, in *corev1.ResourceQuotaApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ResourceQuota, err error) {
+	in.Kind = ptr.String("ResourceQuota")
 
-func (w *wrapCoreV1ResourceQuotaImpl) Apply(ctx context.Context, in *corev1.ResourceQuotaApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ResourceQuota, err error) {
-	panic("NYI")
-}
+	in.APIVersion = ptr.String("v1")
 
-func (w *wrapCoreV1ResourceQuotaImpl) ApplyStatus(ctx context.Context, in *corev1.ResourceQuotaApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ResourceQuota, err error) {
-	panic("NYI")
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ResourceQuota{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ResourceQuotaImpl) Create(ctx context.Context, in *apicorev1.ResourceQuota, opts metav1.CreateOptions) (*apicorev1.ResourceQuota, error) {
@@ -6796,11 +8141,43 @@ type wrapCoreV1SecretImpl struct {
 var _ typedcorev1.SecretInterface = (*wrapCoreV1SecretImpl)(nil)
 
 func (w *wrapCoreV1SecretImpl) Apply(ctx context.Context, in *corev1.SecretApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Secret, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Secret")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Secret{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1SecretImpl) ApplyStatus(ctx context.Context, in *corev1.SecretApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Secret, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Secret")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Secret{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1SecretImpl) Create(ctx context.Context, in *apicorev1.Secret, opts metav1.CreateOptions) (*apicorev1.Secret, error) {
@@ -6935,11 +8312,43 @@ type wrapCoreV1ServiceImpl struct {
 var _ typedcorev1.ServiceInterface = (*wrapCoreV1ServiceImpl)(nil)
 
 func (w *wrapCoreV1ServiceImpl) Apply(ctx context.Context, in *corev1.ServiceApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Service, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Service")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Service{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ServiceImpl) ApplyStatus(ctx context.Context, in *corev1.ServiceApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.Service, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Service")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.Service{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ServiceImpl) Create(ctx context.Context, in *apicorev1.Service, opts metav1.CreateOptions) (*apicorev1.Service, error) {
@@ -7070,11 +8479,43 @@ type wrapCoreV1ServiceAccountImpl struct {
 var _ typedcorev1.ServiceAccountInterface = (*wrapCoreV1ServiceAccountImpl)(nil)
 
 func (w *wrapCoreV1ServiceAccountImpl) Apply(ctx context.Context, in *corev1.ServiceAccountApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ServiceAccount, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ServiceAccount")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ServiceAccount{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ServiceAccountImpl) ApplyStatus(ctx context.Context, in *corev1.ServiceAccountApplyConfiguration, opts metav1.ApplyOptions) (result *apicorev1.ServiceAccount, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ServiceAccount")
+
+	in.APIVersion = ptr.String("v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apicorev1.ServiceAccount{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapCoreV1ServiceAccountImpl) Create(ctx context.Context, in *apicorev1.ServiceAccount, opts metav1.CreateOptions) (*apicorev1.ServiceAccount, error) {
@@ -7228,11 +8669,43 @@ type wrapDiscoveryV1EndpointSliceImpl struct {
 var _ typeddiscoveryv1.EndpointSliceInterface = (*wrapDiscoveryV1EndpointSliceImpl)(nil)
 
 func (w *wrapDiscoveryV1EndpointSliceImpl) Apply(ctx context.Context, in *discoveryv1.EndpointSliceApplyConfiguration, opts metav1.ApplyOptions) (result *apidiscoveryv1.EndpointSlice, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("EndpointSlice")
+
+	in.APIVersion = ptr.String("discovery.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apidiscoveryv1.EndpointSlice{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapDiscoveryV1EndpointSliceImpl) ApplyStatus(ctx context.Context, in *discoveryv1.EndpointSliceApplyConfiguration, opts metav1.ApplyOptions) (result *apidiscoveryv1.EndpointSlice, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("EndpointSlice")
+
+	in.APIVersion = ptr.String("discovery.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apidiscoveryv1.EndpointSlice{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapDiscoveryV1EndpointSliceImpl) Create(ctx context.Context, in *apidiscoveryv1.EndpointSlice, opts metav1.CreateOptions) (*apidiscoveryv1.EndpointSlice, error) {
@@ -7382,11 +8855,43 @@ type wrapDiscoveryV1beta1EndpointSliceImpl struct {
 var _ typeddiscoveryv1beta1.EndpointSliceInterface = (*wrapDiscoveryV1beta1EndpointSliceImpl)(nil)
 
 func (w *wrapDiscoveryV1beta1EndpointSliceImpl) Apply(ctx context.Context, in *discoveryv1beta1.EndpointSliceApplyConfiguration, opts metav1.ApplyOptions) (result *apidiscoveryv1beta1.EndpointSlice, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("EndpointSlice")
+
+	in.APIVersion = ptr.String("discovery.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apidiscoveryv1beta1.EndpointSlice{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapDiscoveryV1beta1EndpointSliceImpl) ApplyStatus(ctx context.Context, in *discoveryv1beta1.EndpointSliceApplyConfiguration, opts metav1.ApplyOptions) (result *apidiscoveryv1beta1.EndpointSlice, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("EndpointSlice")
+
+	in.APIVersion = ptr.String("discovery.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apidiscoveryv1beta1.EndpointSlice{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapDiscoveryV1beta1EndpointSliceImpl) Create(ctx context.Context, in *apidiscoveryv1beta1.EndpointSlice, opts metav1.CreateOptions) (*apidiscoveryv1beta1.EndpointSlice, error) {
@@ -7536,11 +9041,43 @@ type wrapEventsV1EventImpl struct {
 var _ typedeventsv1.EventInterface = (*wrapEventsV1EventImpl)(nil)
 
 func (w *wrapEventsV1EventImpl) Apply(ctx context.Context, in *eventsv1.EventApplyConfiguration, opts metav1.ApplyOptions) (result *apieventsv1.Event, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Event")
+
+	in.APIVersion = ptr.String("events.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apieventsv1.Event{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapEventsV1EventImpl) ApplyStatus(ctx context.Context, in *eventsv1.EventApplyConfiguration, opts metav1.ApplyOptions) (result *apieventsv1.Event, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Event")
+
+	in.APIVersion = ptr.String("events.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apieventsv1.Event{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapEventsV1EventImpl) Create(ctx context.Context, in *apieventsv1.Event, opts metav1.CreateOptions) (*apieventsv1.Event, error) {
@@ -7690,11 +9227,43 @@ type wrapEventsV1beta1EventImpl struct {
 var _ typedeventsv1beta1.EventInterface = (*wrapEventsV1beta1EventImpl)(nil)
 
 func (w *wrapEventsV1beta1EventImpl) Apply(ctx context.Context, in *eventsv1beta1.EventApplyConfiguration, opts metav1.ApplyOptions) (result *apieventsv1beta1.Event, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Event")
+
+	in.APIVersion = ptr.String("events.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apieventsv1beta1.Event{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapEventsV1beta1EventImpl) ApplyStatus(ctx context.Context, in *eventsv1beta1.EventApplyConfiguration, opts metav1.ApplyOptions) (result *apieventsv1beta1.Event, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Event")
+
+	in.APIVersion = ptr.String("events.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apieventsv1beta1.Event{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapEventsV1beta1EventImpl) Create(ctx context.Context, in *apieventsv1beta1.Event, opts metav1.CreateOptions) (*apieventsv1beta1.Event, error) {
@@ -7835,20 +9404,52 @@ func (w *wrapExtensionsV1beta1) DaemonSets(namespace string) typedextensionsv1be
 	}
 }
 
-type wrapExtensionsV1beta1DaemonSetImpl struct {
-	dyn dynamic.NamespaceableResourceInterface
-
-	namespace string
-}
-
-var _ typedextensionsv1beta1.DaemonSetInterface = (*wrapExtensionsV1beta1DaemonSetImpl)(nil)
+type wrapExtensionsV1beta1DaemonSetImpl struct {
+	dyn dynamic.NamespaceableResourceInterface
+
+	namespace string
+}
+
+var _ typedextensionsv1beta1.DaemonSetInterface = (*wrapExtensionsV1beta1DaemonSetImpl)(nil)
+
+func (w *wrapExtensionsV1beta1DaemonSetImpl) Apply(ctx context.Context, in *extensionsv1beta1.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.DaemonSet, err error) {
+	in.Kind = ptr.String("DaemonSet")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.DaemonSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapExtensionsV1beta1DaemonSetImpl) ApplyStatus(ctx context.Context, in *extensionsv1beta1.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.DaemonSet, err error) {
+	in.Kind = ptr.String("DaemonSet")
 
-func (w *wrapExtensionsV1beta1DaemonSetImpl) Apply(ctx context.Context, in *extensionsv1beta1.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.DaemonSet, err error) {
-	panic("NYI")
-}
+	in.APIVersion = ptr.String("extensions/v1beta1")
 
-func (w *wrapExtensionsV1beta1DaemonSetImpl) ApplyStatus(ctx context.Context, in *extensionsv1beta1.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.DaemonSet, err error) {
-	panic("NYI")
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.DaemonSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1DaemonSetImpl) Create(ctx context.Context, in *apiextensionsv1beta1.DaemonSet, opts metav1.CreateOptions) (*apiextensionsv1beta1.DaemonSet, error) {
@@ -7983,11 +9584,43 @@ type wrapExtensionsV1beta1DeploymentImpl struct {
 var _ typedextensionsv1beta1.DeploymentInterface = (*wrapExtensionsV1beta1DeploymentImpl)(nil)
 
 func (w *wrapExtensionsV1beta1DeploymentImpl) Apply(ctx context.Context, in *extensionsv1beta1.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.Deployment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Deployment")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.Deployment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1DeploymentImpl) ApplyStatus(ctx context.Context, in *extensionsv1beta1.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.Deployment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Deployment")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.Deployment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1DeploymentImpl) Create(ctx context.Context, in *apiextensionsv1beta1.Deployment, opts metav1.CreateOptions) (*apiextensionsv1beta1.Deployment, error) {
@@ -8134,11 +9767,43 @@ type wrapExtensionsV1beta1IngressImpl struct {
 var _ typedextensionsv1beta1.IngressInterface = (*wrapExtensionsV1beta1IngressImpl)(nil)
 
 func (w *wrapExtensionsV1beta1IngressImpl) Apply(ctx context.Context, in *extensionsv1beta1.IngressApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.Ingress, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Ingress")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.Ingress{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1IngressImpl) ApplyStatus(ctx context.Context, in *extensionsv1beta1.IngressApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.Ingress, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Ingress")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.Ingress{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1IngressImpl) Create(ctx context.Context, in *apiextensionsv1beta1.Ingress, opts metav1.CreateOptions) (*apiextensionsv1beta1.Ingress, error) {
@@ -8273,11 +9938,43 @@ type wrapExtensionsV1beta1NetworkPolicyImpl struct {
 var _ typedextensionsv1beta1.NetworkPolicyInterface = (*wrapExtensionsV1beta1NetworkPolicyImpl)(nil)
 
 func (w *wrapExtensionsV1beta1NetworkPolicyImpl) Apply(ctx context.Context, in *extensionsv1beta1.NetworkPolicyApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.NetworkPolicy, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("NetworkPolicy")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.NetworkPolicy{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1NetworkPolicyImpl) ApplyStatus(ctx context.Context, in *extensionsv1beta1.NetworkPolicyApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.NetworkPolicy, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("NetworkPolicy")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.NetworkPolicy{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1NetworkPolicyImpl) Create(ctx context.Context, in *apiextensionsv1beta1.NetworkPolicy, opts metav1.CreateOptions) (*apiextensionsv1beta1.NetworkPolicy, error) {
@@ -8408,11 +10105,43 @@ type wrapExtensionsV1beta1PodSecurityPolicyImpl struct {
 var _ typedextensionsv1beta1.PodSecurityPolicyInterface = (*wrapExtensionsV1beta1PodSecurityPolicyImpl)(nil)
 
 func (w *wrapExtensionsV1beta1PodSecurityPolicyImpl) Apply(ctx context.Context, in *extensionsv1beta1.PodSecurityPolicyApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.PodSecurityPolicy, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodSecurityPolicy")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.PodSecurityPolicy{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1PodSecurityPolicyImpl) ApplyStatus(ctx context.Context, in *extensionsv1beta1.PodSecurityPolicyApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.PodSecurityPolicy, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodSecurityPolicy")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.PodSecurityPolicy{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1PodSecurityPolicyImpl) Create(ctx context.Context, in *apiextensionsv1beta1.PodSecurityPolicy, opts metav1.CreateOptions) (*apiextensionsv1beta1.PodSecurityPolicy, error) {
@@ -8547,11 +10276,43 @@ type wrapExtensionsV1beta1ReplicaSetImpl struct {
 var _ typedextensionsv1beta1.ReplicaSetInterface = (*wrapExtensionsV1beta1ReplicaSetImpl)(nil)
 
 func (w *wrapExtensionsV1beta1ReplicaSetImpl) Apply(ctx context.Context, in *extensionsv1beta1.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.ReplicaSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ReplicaSet")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.ReplicaSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1ReplicaSetImpl) ApplyStatus(ctx context.Context, in *extensionsv1beta1.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (result *apiextensionsv1beta1.ReplicaSet, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ReplicaSet")
+
+	in.APIVersion = ptr.String("extensions/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiextensionsv1beta1.ReplicaSet{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapExtensionsV1beta1ReplicaSetImpl) Create(ctx context.Context, in *apiextensionsv1beta1.ReplicaSet, opts metav1.CreateOptions) (*apiextensionsv1beta1.ReplicaSet, error) {
@@ -8709,11 +10470,43 @@ type wrapFlowcontrolV1alpha1FlowSchemaImpl struct {
 var _ typedflowcontrolv1alpha1.FlowSchemaInterface = (*wrapFlowcontrolV1alpha1FlowSchemaImpl)(nil)
 
 func (w *wrapFlowcontrolV1alpha1FlowSchemaImpl) Apply(ctx context.Context, in *flowcontrolv1alpha1.FlowSchemaApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1alpha1.FlowSchema, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("FlowSchema")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1alpha1.FlowSchema{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1alpha1FlowSchemaImpl) ApplyStatus(ctx context.Context, in *flowcontrolv1alpha1.FlowSchemaApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1alpha1.FlowSchema, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("FlowSchema")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1alpha1.FlowSchema{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1alpha1FlowSchemaImpl) Create(ctx context.Context, in *apiflowcontrolv1alpha1.FlowSchema, opts metav1.CreateOptions) (*apiflowcontrolv1alpha1.FlowSchema, error) {
@@ -8844,11 +10637,43 @@ type wrapFlowcontrolV1alpha1PriorityLevelConfigurationImpl struct {
 var _ typedflowcontrolv1alpha1.PriorityLevelConfigurationInterface = (*wrapFlowcontrolV1alpha1PriorityLevelConfigurationImpl)(nil)
 
 func (w *wrapFlowcontrolV1alpha1PriorityLevelConfigurationImpl) Apply(ctx context.Context, in *flowcontrolv1alpha1.PriorityLevelConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1alpha1.PriorityLevelConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityLevelConfiguration")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1alpha1.PriorityLevelConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1alpha1PriorityLevelConfigurationImpl) ApplyStatus(ctx context.Context, in *flowcontrolv1alpha1.PriorityLevelConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1alpha1.PriorityLevelConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityLevelConfiguration")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1alpha1.PriorityLevelConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1alpha1PriorityLevelConfigurationImpl) Create(ctx context.Context, in *apiflowcontrolv1alpha1.PriorityLevelConfiguration, opts metav1.CreateOptions) (*apiflowcontrolv1alpha1.PriorityLevelConfiguration, error) {
@@ -8991,14 +10816,46 @@ type wrapFlowcontrolV1beta1FlowSchemaImpl struct {
 	dyn dynamic.NamespaceableResourceInterface
 }
 
-var _ typedflowcontrolv1beta1.FlowSchemaInterface = (*wrapFlowcontrolV1beta1FlowSchemaImpl)(nil)
+var _ typedflowcontrolv1beta1.FlowSchemaInterface = (*wrapFlowcontrolV1beta1FlowSchemaImpl)(nil)
+
+func (w *wrapFlowcontrolV1beta1FlowSchemaImpl) Apply(ctx context.Context, in *flowcontrolv1beta1.FlowSchemaApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta1.FlowSchema, err error) {
+	in.Kind = ptr.String("FlowSchema")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1beta1.FlowSchema{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (w *wrapFlowcontrolV1beta1FlowSchemaImpl) ApplyStatus(ctx context.Context, in *flowcontrolv1beta1.FlowSchemaApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta1.FlowSchema, err error) {
+	in.Kind = ptr.String("FlowSchema")
 
-func (w *wrapFlowcontrolV1beta1FlowSchemaImpl) Apply(ctx context.Context, in *flowcontrolv1beta1.FlowSchemaApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta1.FlowSchema, err error) {
-	panic("NYI")
-}
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1beta1")
 
-func (w *wrapFlowcontrolV1beta1FlowSchemaImpl) ApplyStatus(ctx context.Context, in *flowcontrolv1beta1.FlowSchemaApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta1.FlowSchema, err error) {
-	panic("NYI")
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1beta1.FlowSchema{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1beta1FlowSchemaImpl) Create(ctx context.Context, in *apiflowcontrolv1beta1.FlowSchema, opts metav1.CreateOptions) (*apiflowcontrolv1beta1.FlowSchema, error) {
@@ -9129,11 +10986,43 @@ type wrapFlowcontrolV1beta1PriorityLevelConfigurationImpl struct {
 var _ typedflowcontrolv1beta1.PriorityLevelConfigurationInterface = (*wrapFlowcontrolV1beta1PriorityLevelConfigurationImpl)(nil)
 
 func (w *wrapFlowcontrolV1beta1PriorityLevelConfigurationImpl) Apply(ctx context.Context, in *flowcontrolv1beta1.PriorityLevelConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta1.PriorityLevelConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityLevelConfiguration")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1beta1.PriorityLevelConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1beta1PriorityLevelConfigurationImpl) ApplyStatus(ctx context.Context, in *flowcontrolv1beta1.PriorityLevelConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta1.PriorityLevelConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityLevelConfiguration")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1beta1.PriorityLevelConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1beta1PriorityLevelConfigurationImpl) Create(ctx context.Context, in *apiflowcontrolv1beta1.PriorityLevelConfiguration, opts metav1.CreateOptions) (*apiflowcontrolv1beta1.PriorityLevelConfiguration, error) {
@@ -9279,11 +11168,43 @@ type wrapFlowcontrolV1beta2FlowSchemaImpl struct {
 var _ typedflowcontrolv1beta2.FlowSchemaInterface = (*wrapFlowcontrolV1beta2FlowSchemaImpl)(nil)
 
 func (w *wrapFlowcontrolV1beta2FlowSchemaImpl) Apply(ctx context.Context, in *flowcontrolv1beta2.FlowSchemaApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta2.FlowSchema, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("FlowSchema")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1beta2.FlowSchema{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1beta2FlowSchemaImpl) ApplyStatus(ctx context.Context, in *flowcontrolv1beta2.FlowSchemaApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta2.FlowSchema, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("FlowSchema")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1beta2.FlowSchema{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1beta2FlowSchemaImpl) Create(ctx context.Context, in *apiflowcontrolv1beta2.FlowSchema, opts metav1.CreateOptions) (*apiflowcontrolv1beta2.FlowSchema, error) {
@@ -9414,11 +11335,43 @@ type wrapFlowcontrolV1beta2PriorityLevelConfigurationImpl struct {
 var _ typedflowcontrolv1beta2.PriorityLevelConfigurationInterface = (*wrapFlowcontrolV1beta2PriorityLevelConfigurationImpl)(nil)
 
 func (w *wrapFlowcontrolV1beta2PriorityLevelConfigurationImpl) Apply(ctx context.Context, in *flowcontrolv1beta2.PriorityLevelConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta2.PriorityLevelConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityLevelConfiguration")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1beta2.PriorityLevelConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1beta2PriorityLevelConfigurationImpl) ApplyStatus(ctx context.Context, in *flowcontrolv1beta2.PriorityLevelConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *apiflowcontrolv1beta2.PriorityLevelConfiguration, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityLevelConfiguration")
+
+	in.APIVersion = ptr.String("flowcontrol.apiserver.k8s.io/v1beta2")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apiflowcontrolv1beta2.PriorityLevelConfiguration{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapFlowcontrolV1beta2PriorityLevelConfigurationImpl) Create(ctx context.Context, in *apiflowcontrolv1beta2.PriorityLevelConfiguration, opts metav1.CreateOptions) (*apiflowcontrolv1beta2.PriorityLevelConfiguration, error) {
@@ -9568,11 +11521,43 @@ type wrapNetworkingV1IngressImpl struct {
 var _ typednetworkingv1.IngressInterface = (*wrapNetworkingV1IngressImpl)(nil)
 
 func (w *wrapNetworkingV1IngressImpl) Apply(ctx context.Context, in *networkingv1.IngressApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1.Ingress, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Ingress")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1.Ingress{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1IngressImpl) ApplyStatus(ctx context.Context, in *networkingv1.IngressApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1.Ingress, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Ingress")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1.Ingress{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1IngressImpl) Create(ctx context.Context, in *apinetworkingv1.Ingress, opts metav1.CreateOptions) (*apinetworkingv1.Ingress, error) {
@@ -9703,11 +11688,43 @@ type wrapNetworkingV1IngressClassImpl struct {
 var _ typednetworkingv1.IngressClassInterface = (*wrapNetworkingV1IngressClassImpl)(nil)
 
 func (w *wrapNetworkingV1IngressClassImpl) Apply(ctx context.Context, in *networkingv1.IngressClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1.IngressClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("IngressClass")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1.IngressClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1IngressClassImpl) ApplyStatus(ctx context.Context, in *networkingv1.IngressClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1.IngressClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("IngressClass")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1.IngressClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1IngressClassImpl) Create(ctx context.Context, in *apinetworkingv1.IngressClass, opts metav1.CreateOptions) (*apinetworkingv1.IngressClass, error) {
@@ -9842,11 +11859,43 @@ type wrapNetworkingV1NetworkPolicyImpl struct {
 var _ typednetworkingv1.NetworkPolicyInterface = (*wrapNetworkingV1NetworkPolicyImpl)(nil)
 
 func (w *wrapNetworkingV1NetworkPolicyImpl) Apply(ctx context.Context, in *networkingv1.NetworkPolicyApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1.NetworkPolicy, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("NetworkPolicy")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1.NetworkPolicy{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1NetworkPolicyImpl) ApplyStatus(ctx context.Context, in *networkingv1.NetworkPolicyApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1.NetworkPolicy, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("NetworkPolicy")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1.NetworkPolicy{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1NetworkPolicyImpl) Create(ctx context.Context, in *apinetworkingv1.NetworkPolicy, opts metav1.CreateOptions) (*apinetworkingv1.NetworkPolicy, error) {
@@ -9992,11 +12041,43 @@ type wrapNetworkingV1alpha1ClusterCIDRImpl struct {
 var _ typednetworkingv1alpha1.ClusterCIDRInterface = (*wrapNetworkingV1alpha1ClusterCIDRImpl)(nil)
 
 func (w *wrapNetworkingV1alpha1ClusterCIDRImpl) Apply(ctx context.Context, in *networkingv1alpha1.ClusterCIDRApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1alpha1.ClusterCIDR, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterCIDR")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1alpha1.ClusterCIDR{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1alpha1ClusterCIDRImpl) ApplyStatus(ctx context.Context, in *networkingv1alpha1.ClusterCIDRApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1alpha1.ClusterCIDR, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterCIDR")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1alpha1.ClusterCIDR{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1alpha1ClusterCIDRImpl) Create(ctx context.Context, in *apinetworkingv1alpha1.ClusterCIDR, opts metav1.CreateOptions) (*apinetworkingv1alpha1.ClusterCIDR, error) {
@@ -10146,11 +12227,43 @@ type wrapNetworkingV1beta1IngressImpl struct {
 var _ typednetworkingv1beta1.IngressInterface = (*wrapNetworkingV1beta1IngressImpl)(nil)
 
 func (w *wrapNetworkingV1beta1IngressImpl) Apply(ctx context.Context, in *networkingv1beta1.IngressApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1beta1.Ingress, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Ingress")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1beta1.Ingress{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1beta1IngressImpl) ApplyStatus(ctx context.Context, in *networkingv1beta1.IngressApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1beta1.Ingress, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Ingress")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1beta1.Ingress{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1beta1IngressImpl) Create(ctx context.Context, in *apinetworkingv1beta1.Ingress, opts metav1.CreateOptions) (*apinetworkingv1beta1.Ingress, error) {
@@ -10281,11 +12394,43 @@ type wrapNetworkingV1beta1IngressClassImpl struct {
 var _ typednetworkingv1beta1.IngressClassInterface = (*wrapNetworkingV1beta1IngressClassImpl)(nil)
 
 func (w *wrapNetworkingV1beta1IngressClassImpl) Apply(ctx context.Context, in *networkingv1beta1.IngressClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1beta1.IngressClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("IngressClass")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1beta1.IngressClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1beta1IngressClassImpl) ApplyStatus(ctx context.Context, in *networkingv1beta1.IngressClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinetworkingv1beta1.IngressClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("IngressClass")
+
+	in.APIVersion = ptr.String("networking.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinetworkingv1beta1.IngressClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNetworkingV1beta1IngressClassImpl) Create(ctx context.Context, in *apinetworkingv1beta1.IngressClass, opts metav1.CreateOptions) (*apinetworkingv1beta1.IngressClass, error) {
@@ -10431,11 +12576,43 @@ type wrapNodeV1RuntimeClassImpl struct {
 var _ typednodev1.RuntimeClassInterface = (*wrapNodeV1RuntimeClassImpl)(nil)
 
 func (w *wrapNodeV1RuntimeClassImpl) Apply(ctx context.Context, in *nodev1.RuntimeClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinodev1.RuntimeClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RuntimeClass")
+
+	in.APIVersion = ptr.String("node.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinodev1.RuntimeClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNodeV1RuntimeClassImpl) ApplyStatus(ctx context.Context, in *nodev1.RuntimeClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinodev1.RuntimeClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RuntimeClass")
+
+	in.APIVersion = ptr.String("node.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinodev1.RuntimeClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNodeV1RuntimeClassImpl) Create(ctx context.Context, in *apinodev1.RuntimeClass, opts metav1.CreateOptions) (*apinodev1.RuntimeClass, error) {
@@ -10581,11 +12758,43 @@ type wrapNodeV1alpha1RuntimeClassImpl struct {
 var _ typednodev1alpha1.RuntimeClassInterface = (*wrapNodeV1alpha1RuntimeClassImpl)(nil)
 
 func (w *wrapNodeV1alpha1RuntimeClassImpl) Apply(ctx context.Context, in *nodev1alpha1.RuntimeClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinodev1alpha1.RuntimeClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RuntimeClass")
+
+	in.APIVersion = ptr.String("node.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinodev1alpha1.RuntimeClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNodeV1alpha1RuntimeClassImpl) ApplyStatus(ctx context.Context, in *nodev1alpha1.RuntimeClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinodev1alpha1.RuntimeClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RuntimeClass")
+
+	in.APIVersion = ptr.String("node.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinodev1alpha1.RuntimeClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNodeV1alpha1RuntimeClassImpl) Create(ctx context.Context, in *apinodev1alpha1.RuntimeClass, opts metav1.CreateOptions) (*apinodev1alpha1.RuntimeClass, error) {
@@ -10731,11 +12940,43 @@ type wrapNodeV1beta1RuntimeClassImpl struct {
 var _ typednodev1beta1.RuntimeClassInterface = (*wrapNodeV1beta1RuntimeClassImpl)(nil)
 
 func (w *wrapNodeV1beta1RuntimeClassImpl) Apply(ctx context.Context, in *nodev1beta1.RuntimeClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinodev1beta1.RuntimeClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RuntimeClass")
+
+	in.APIVersion = ptr.String("node.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinodev1beta1.RuntimeClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNodeV1beta1RuntimeClassImpl) ApplyStatus(ctx context.Context, in *nodev1beta1.RuntimeClassApplyConfiguration, opts metav1.ApplyOptions) (result *apinodev1beta1.RuntimeClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RuntimeClass")
+
+	in.APIVersion = ptr.String("node.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apinodev1beta1.RuntimeClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapNodeV1beta1RuntimeClassImpl) Create(ctx context.Context, in *apinodev1beta1.RuntimeClass, opts metav1.CreateOptions) (*apinodev1beta1.RuntimeClass, error) {
@@ -10905,11 +13146,43 @@ type wrapPolicyV1PodDisruptionBudgetImpl struct {
 var _ typedpolicyv1.PodDisruptionBudgetInterface = (*wrapPolicyV1PodDisruptionBudgetImpl)(nil)
 
 func (w *wrapPolicyV1PodDisruptionBudgetImpl) Apply(ctx context.Context, in *policyv1.PodDisruptionBudgetApplyConfiguration, opts metav1.ApplyOptions) (result *apipolicyv1.PodDisruptionBudget, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodDisruptionBudget")
+
+	in.APIVersion = ptr.String("policy/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apipolicyv1.PodDisruptionBudget{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapPolicyV1PodDisruptionBudgetImpl) ApplyStatus(ctx context.Context, in *policyv1.PodDisruptionBudgetApplyConfiguration, opts metav1.ApplyOptions) (result *apipolicyv1.PodDisruptionBudget, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodDisruptionBudget")
+
+	in.APIVersion = ptr.String("policy/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apipolicyv1.PodDisruptionBudget{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapPolicyV1PodDisruptionBudgetImpl) Create(ctx context.Context, in *apipolicyv1.PodDisruptionBudget, opts metav1.CreateOptions) (*apipolicyv1.PodDisruptionBudget, error) {
@@ -11079,11 +13352,43 @@ type wrapPolicyV1beta1PodDisruptionBudgetImpl struct {
 var _ typedpolicyv1beta1.PodDisruptionBudgetInterface = (*wrapPolicyV1beta1PodDisruptionBudgetImpl)(nil)
 
 func (w *wrapPolicyV1beta1PodDisruptionBudgetImpl) Apply(ctx context.Context, in *policyv1beta1.PodDisruptionBudgetApplyConfiguration, opts metav1.ApplyOptions) (result *apipolicyv1beta1.PodDisruptionBudget, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodDisruptionBudget")
+
+	in.APIVersion = ptr.String("policy/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apipolicyv1beta1.PodDisruptionBudget{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapPolicyV1beta1PodDisruptionBudgetImpl) ApplyStatus(ctx context.Context, in *policyv1beta1.PodDisruptionBudgetApplyConfiguration, opts metav1.ApplyOptions) (result *apipolicyv1beta1.PodDisruptionBudget, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodDisruptionBudget")
+
+	in.APIVersion = ptr.String("policy/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apipolicyv1beta1.PodDisruptionBudget{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapPolicyV1beta1PodDisruptionBudgetImpl) Create(ctx context.Context, in *apipolicyv1beta1.PodDisruptionBudget, opts metav1.CreateOptions) (*apipolicyv1beta1.PodDisruptionBudget, error) {
@@ -11214,11 +13519,43 @@ type wrapPolicyV1beta1PodSecurityPolicyImpl struct {
 var _ typedpolicyv1beta1.PodSecurityPolicyInterface = (*wrapPolicyV1beta1PodSecurityPolicyImpl)(nil)
 
 func (w *wrapPolicyV1beta1PodSecurityPolicyImpl) Apply(ctx context.Context, in *policyv1beta1.PodSecurityPolicyApplyConfiguration, opts metav1.ApplyOptions) (result *apipolicyv1beta1.PodSecurityPolicy, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodSecurityPolicy")
+
+	in.APIVersion = ptr.String("policy/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apipolicyv1beta1.PodSecurityPolicy{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapPolicyV1beta1PodSecurityPolicyImpl) ApplyStatus(ctx context.Context, in *policyv1beta1.PodSecurityPolicyApplyConfiguration, opts metav1.ApplyOptions) (result *apipolicyv1beta1.PodSecurityPolicy, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PodSecurityPolicy")
+
+	in.APIVersion = ptr.String("policy/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apipolicyv1beta1.PodSecurityPolicy{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapPolicyV1beta1PodSecurityPolicyImpl) Create(ctx context.Context, in *apipolicyv1beta1.PodSecurityPolicy, opts metav1.CreateOptions) (*apipolicyv1beta1.PodSecurityPolicy, error) {
@@ -11364,11 +13701,43 @@ type wrapRbacV1ClusterRoleImpl struct {
 var _ typedrbacv1.ClusterRoleInterface = (*wrapRbacV1ClusterRoleImpl)(nil)
 
 func (w *wrapRbacV1ClusterRoleImpl) Apply(ctx context.Context, in *rbacv1.ClusterRoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1.ClusterRole, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRole")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1.ClusterRole{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1ClusterRoleImpl) ApplyStatus(ctx context.Context, in *rbacv1.ClusterRoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1.ClusterRole, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRole")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1.ClusterRole{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1ClusterRoleImpl) Create(ctx context.Context, in *apirbacv1.ClusterRole, opts metav1.CreateOptions) (*apirbacv1.ClusterRole, error) {
@@ -11499,11 +13868,43 @@ type wrapRbacV1ClusterRoleBindingImpl struct {
 var _ typedrbacv1.ClusterRoleBindingInterface = (*wrapRbacV1ClusterRoleBindingImpl)(nil)
 
 func (w *wrapRbacV1ClusterRoleBindingImpl) Apply(ctx context.Context, in *rbacv1.ClusterRoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1.ClusterRoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1.ClusterRoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1ClusterRoleBindingImpl) ApplyStatus(ctx context.Context, in *rbacv1.ClusterRoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1.ClusterRoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1.ClusterRoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1ClusterRoleBindingImpl) Create(ctx context.Context, in *apirbacv1.ClusterRoleBinding, opts metav1.CreateOptions) (*apirbacv1.ClusterRoleBinding, error) {
@@ -11638,11 +14039,43 @@ type wrapRbacV1RoleImpl struct {
 var _ typedrbacv1.RoleInterface = (*wrapRbacV1RoleImpl)(nil)
 
 func (w *wrapRbacV1RoleImpl) Apply(ctx context.Context, in *rbacv1.RoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1.Role, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Role")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1.Role{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1RoleImpl) ApplyStatus(ctx context.Context, in *rbacv1.RoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1.Role, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Role")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1.Role{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1RoleImpl) Create(ctx context.Context, in *apirbacv1.Role, opts metav1.CreateOptions) (*apirbacv1.Role, error) {
@@ -11777,11 +14210,43 @@ type wrapRbacV1RoleBindingImpl struct {
 var _ typedrbacv1.RoleBindingInterface = (*wrapRbacV1RoleBindingImpl)(nil)
 
 func (w *wrapRbacV1RoleBindingImpl) Apply(ctx context.Context, in *rbacv1.RoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1.RoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1.RoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1RoleBindingImpl) ApplyStatus(ctx context.Context, in *rbacv1.RoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1.RoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1.RoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1RoleBindingImpl) Create(ctx context.Context, in *apirbacv1.RoleBinding, opts metav1.CreateOptions) (*apirbacv1.RoleBinding, error) {
@@ -11927,11 +14392,43 @@ type wrapRbacV1alpha1ClusterRoleImpl struct {
 var _ typedrbacv1alpha1.ClusterRoleInterface = (*wrapRbacV1alpha1ClusterRoleImpl)(nil)
 
 func (w *wrapRbacV1alpha1ClusterRoleImpl) Apply(ctx context.Context, in *rbacv1alpha1.ClusterRoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1alpha1.ClusterRole, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRole")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1alpha1.ClusterRole{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1alpha1ClusterRoleImpl) ApplyStatus(ctx context.Context, in *rbacv1alpha1.ClusterRoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1alpha1.ClusterRole, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRole")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1alpha1.ClusterRole{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1alpha1ClusterRoleImpl) Create(ctx context.Context, in *apirbacv1alpha1.ClusterRole, opts metav1.CreateOptions) (*apirbacv1alpha1.ClusterRole, error) {
@@ -12062,11 +14559,43 @@ type wrapRbacV1alpha1ClusterRoleBindingImpl struct {
 var _ typedrbacv1alpha1.ClusterRoleBindingInterface = (*wrapRbacV1alpha1ClusterRoleBindingImpl)(nil)
 
 func (w *wrapRbacV1alpha1ClusterRoleBindingImpl) Apply(ctx context.Context, in *rbacv1alpha1.ClusterRoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1alpha1.ClusterRoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1alpha1.ClusterRoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1alpha1ClusterRoleBindingImpl) ApplyStatus(ctx context.Context, in *rbacv1alpha1.ClusterRoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1alpha1.ClusterRoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1alpha1.ClusterRoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1alpha1ClusterRoleBindingImpl) Create(ctx context.Context, in *apirbacv1alpha1.ClusterRoleBinding, opts metav1.CreateOptions) (*apirbacv1alpha1.ClusterRoleBinding, error) {
@@ -12201,11 +14730,43 @@ type wrapRbacV1alpha1RoleImpl struct {
 var _ typedrbacv1alpha1.RoleInterface = (*wrapRbacV1alpha1RoleImpl)(nil)
 
 func (w *wrapRbacV1alpha1RoleImpl) Apply(ctx context.Context, in *rbacv1alpha1.RoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1alpha1.Role, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Role")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1alpha1.Role{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1alpha1RoleImpl) ApplyStatus(ctx context.Context, in *rbacv1alpha1.RoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1alpha1.Role, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Role")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1alpha1.Role{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1alpha1RoleImpl) Create(ctx context.Context, in *apirbacv1alpha1.Role, opts metav1.CreateOptions) (*apirbacv1alpha1.Role, error) {
@@ -12340,11 +14901,43 @@ type wrapRbacV1alpha1RoleBindingImpl struct {
 var _ typedrbacv1alpha1.RoleBindingInterface = (*wrapRbacV1alpha1RoleBindingImpl)(nil)
 
 func (w *wrapRbacV1alpha1RoleBindingImpl) Apply(ctx context.Context, in *rbacv1alpha1.RoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1alpha1.RoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1alpha1.RoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1alpha1RoleBindingImpl) ApplyStatus(ctx context.Context, in *rbacv1alpha1.RoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1alpha1.RoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1alpha1.RoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1alpha1RoleBindingImpl) Create(ctx context.Context, in *apirbacv1alpha1.RoleBinding, opts metav1.CreateOptions) (*apirbacv1alpha1.RoleBinding, error) {
@@ -12490,11 +15083,43 @@ type wrapRbacV1beta1ClusterRoleImpl struct {
 var _ typedrbacv1beta1.ClusterRoleInterface = (*wrapRbacV1beta1ClusterRoleImpl)(nil)
 
 func (w *wrapRbacV1beta1ClusterRoleImpl) Apply(ctx context.Context, in *rbacv1beta1.ClusterRoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1beta1.ClusterRole, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRole")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1beta1.ClusterRole{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1beta1ClusterRoleImpl) ApplyStatus(ctx context.Context, in *rbacv1beta1.ClusterRoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1beta1.ClusterRole, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRole")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1beta1.ClusterRole{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1beta1ClusterRoleImpl) Create(ctx context.Context, in *apirbacv1beta1.ClusterRole, opts metav1.CreateOptions) (*apirbacv1beta1.ClusterRole, error) {
@@ -12625,11 +15250,43 @@ type wrapRbacV1beta1ClusterRoleBindingImpl struct {
 var _ typedrbacv1beta1.ClusterRoleBindingInterface = (*wrapRbacV1beta1ClusterRoleBindingImpl)(nil)
 
 func (w *wrapRbacV1beta1ClusterRoleBindingImpl) Apply(ctx context.Context, in *rbacv1beta1.ClusterRoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1beta1.ClusterRoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1beta1.ClusterRoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1beta1ClusterRoleBindingImpl) ApplyStatus(ctx context.Context, in *rbacv1beta1.ClusterRoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1beta1.ClusterRoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("ClusterRoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1beta1.ClusterRoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1beta1ClusterRoleBindingImpl) Create(ctx context.Context, in *apirbacv1beta1.ClusterRoleBinding, opts metav1.CreateOptions) (*apirbacv1beta1.ClusterRoleBinding, error) {
@@ -12764,11 +15421,43 @@ type wrapRbacV1beta1RoleImpl struct {
 var _ typedrbacv1beta1.RoleInterface = (*wrapRbacV1beta1RoleImpl)(nil)
 
 func (w *wrapRbacV1beta1RoleImpl) Apply(ctx context.Context, in *rbacv1beta1.RoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1beta1.Role, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Role")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1beta1.Role{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1beta1RoleImpl) ApplyStatus(ctx context.Context, in *rbacv1beta1.RoleApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1beta1.Role, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("Role")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1beta1.Role{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1beta1RoleImpl) Create(ctx context.Context, in *apirbacv1beta1.Role, opts metav1.CreateOptions) (*apirbacv1beta1.Role, error) {
@@ -12903,11 +15592,43 @@ type wrapRbacV1beta1RoleBindingImpl struct {
 var _ typedrbacv1beta1.RoleBindingInterface = (*wrapRbacV1beta1RoleBindingImpl)(nil)
 
 func (w *wrapRbacV1beta1RoleBindingImpl) Apply(ctx context.Context, in *rbacv1beta1.RoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1beta1.RoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1beta1.RoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1beta1RoleBindingImpl) ApplyStatus(ctx context.Context, in *rbacv1beta1.RoleBindingApplyConfiguration, opts metav1.ApplyOptions) (result *apirbacv1beta1.RoleBinding, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("RoleBinding")
+
+	in.APIVersion = ptr.String("rbac.authorization.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apirbacv1beta1.RoleBinding{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapRbacV1beta1RoleBindingImpl) Create(ctx context.Context, in *apirbacv1beta1.RoleBinding, opts metav1.CreateOptions) (*apirbacv1beta1.RoleBinding, error) {
@@ -13053,11 +15774,43 @@ type wrapSchedulingV1PriorityClassImpl struct {
 var _ typedschedulingv1.PriorityClassInterface = (*wrapSchedulingV1PriorityClassImpl)(nil)
 
 func (w *wrapSchedulingV1PriorityClassImpl) Apply(ctx context.Context, in *schedulingv1.PriorityClassApplyConfiguration, opts metav1.ApplyOptions) (result *apischedulingv1.PriorityClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityClass")
+
+	in.APIVersion = ptr.String("scheduling.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apischedulingv1.PriorityClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapSchedulingV1PriorityClassImpl) ApplyStatus(ctx context.Context, in *schedulingv1.PriorityClassApplyConfiguration, opts metav1.ApplyOptions) (result *apischedulingv1.PriorityClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityClass")
+
+	in.APIVersion = ptr.String("scheduling.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apischedulingv1.PriorityClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapSchedulingV1PriorityClassImpl) Create(ctx context.Context, in *apischedulingv1.PriorityClass, opts metav1.CreateOptions) (*apischedulingv1.PriorityClass, error) {
@@ -13203,11 +15956,43 @@ type wrapSchedulingV1alpha1PriorityClassImpl struct {
 var _ typedschedulingv1alpha1.PriorityClassInterface = (*wrapSchedulingV1alpha1PriorityClassImpl)(nil)
 
 func (w *wrapSchedulingV1alpha1PriorityClassImpl) Apply(ctx context.Context, in *schedulingv1alpha1.PriorityClassApplyConfiguration, opts metav1.ApplyOptions) (result *apischedulingv1alpha1.PriorityClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityClass")
+
+	in.APIVersion = ptr.String("scheduling.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apischedulingv1alpha1.PriorityClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapSchedulingV1alpha1PriorityClassImpl) ApplyStatus(ctx context.Context, in *schedulingv1alpha1.PriorityClassApplyConfiguration, opts metav1.ApplyOptions) (result *apischedulingv1alpha1.PriorityClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityClass")
+
+	in.APIVersion = ptr.String("scheduling.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apischedulingv1alpha1.PriorityClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapSchedulingV1alpha1PriorityClassImpl) Create(ctx context.Context, in *apischedulingv1alpha1.PriorityClass, opts metav1.CreateOptions) (*apischedulingv1alpha1.PriorityClass, error) {
@@ -13353,11 +16138,43 @@ type wrapSchedulingV1beta1PriorityClassImpl struct {
 var _ typedschedulingv1beta1.PriorityClassInterface = (*wrapSchedulingV1beta1PriorityClassImpl)(nil)
 
 func (w *wrapSchedulingV1beta1PriorityClassImpl) Apply(ctx context.Context, in *schedulingv1beta1.PriorityClassApplyConfiguration, opts metav1.ApplyOptions) (result *apischedulingv1beta1.PriorityClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityClass")
+
+	in.APIVersion = ptr.String("scheduling.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apischedulingv1beta1.PriorityClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapSchedulingV1beta1PriorityClassImpl) ApplyStatus(ctx context.Context, in *schedulingv1beta1.PriorityClassApplyConfiguration, opts metav1.ApplyOptions) (result *apischedulingv1beta1.PriorityClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("PriorityClass")
+
+	in.APIVersion = ptr.String("scheduling.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apischedulingv1beta1.PriorityClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapSchedulingV1beta1PriorityClassImpl) Create(ctx context.Context, in *apischedulingv1beta1.PriorityClass, opts metav1.CreateOptions) (*apischedulingv1beta1.PriorityClass, error) {
@@ -13503,11 +16320,43 @@ type wrapStorageV1CSIDriverImpl struct {
 var _ typedstoragev1.CSIDriverInterface = (*wrapStorageV1CSIDriverImpl)(nil)
 
 func (w *wrapStorageV1CSIDriverImpl) Apply(ctx context.Context, in *storagev1.CSIDriverApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.CSIDriver, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIDriver")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.CSIDriver{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1CSIDriverImpl) ApplyStatus(ctx context.Context, in *storagev1.CSIDriverApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.CSIDriver, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIDriver")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.CSIDriver{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1CSIDriverImpl) Create(ctx context.Context, in *apistoragev1.CSIDriver, opts metav1.CreateOptions) (*apistoragev1.CSIDriver, error) {
@@ -13638,11 +16487,43 @@ type wrapStorageV1CSINodeImpl struct {
 var _ typedstoragev1.CSINodeInterface = (*wrapStorageV1CSINodeImpl)(nil)
 
 func (w *wrapStorageV1CSINodeImpl) Apply(ctx context.Context, in *storagev1.CSINodeApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.CSINode, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSINode")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.CSINode{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1CSINodeImpl) ApplyStatus(ctx context.Context, in *storagev1.CSINodeApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.CSINode, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSINode")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.CSINode{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1CSINodeImpl) Create(ctx context.Context, in *apistoragev1.CSINode, opts metav1.CreateOptions) (*apistoragev1.CSINode, error) {
@@ -13777,11 +16658,43 @@ type wrapStorageV1CSIStorageCapacityImpl struct {
 var _ typedstoragev1.CSIStorageCapacityInterface = (*wrapStorageV1CSIStorageCapacityImpl)(nil)
 
 func (w *wrapStorageV1CSIStorageCapacityImpl) Apply(ctx context.Context, in *storagev1.CSIStorageCapacityApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.CSIStorageCapacity, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIStorageCapacity")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.CSIStorageCapacity{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1CSIStorageCapacityImpl) ApplyStatus(ctx context.Context, in *storagev1.CSIStorageCapacityApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.CSIStorageCapacity, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIStorageCapacity")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.CSIStorageCapacity{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1CSIStorageCapacityImpl) Create(ctx context.Context, in *apistoragev1.CSIStorageCapacity, opts metav1.CreateOptions) (*apistoragev1.CSIStorageCapacity, error) {
@@ -13912,11 +16825,43 @@ type wrapStorageV1StorageClassImpl struct {
 var _ typedstoragev1.StorageClassInterface = (*wrapStorageV1StorageClassImpl)(nil)
 
 func (w *wrapStorageV1StorageClassImpl) Apply(ctx context.Context, in *storagev1.StorageClassApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.StorageClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StorageClass")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.StorageClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1StorageClassImpl) ApplyStatus(ctx context.Context, in *storagev1.StorageClassApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.StorageClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StorageClass")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.StorageClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1StorageClassImpl) Create(ctx context.Context, in *apistoragev1.StorageClass, opts metav1.CreateOptions) (*apistoragev1.StorageClass, error) {
@@ -14047,11 +16992,43 @@ type wrapStorageV1VolumeAttachmentImpl struct {
 var _ typedstoragev1.VolumeAttachmentInterface = (*wrapStorageV1VolumeAttachmentImpl)(nil)
 
 func (w *wrapStorageV1VolumeAttachmentImpl) Apply(ctx context.Context, in *storagev1.VolumeAttachmentApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.VolumeAttachment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("VolumeAttachment")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.VolumeAttachment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1VolumeAttachmentImpl) ApplyStatus(ctx context.Context, in *storagev1.VolumeAttachmentApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1.VolumeAttachment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("VolumeAttachment")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1.VolumeAttachment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1VolumeAttachmentImpl) Create(ctx context.Context, in *apistoragev1.VolumeAttachment, opts metav1.CreateOptions) (*apistoragev1.VolumeAttachment, error) {
@@ -14201,11 +17178,43 @@ type wrapStorageV1alpha1CSIStorageCapacityImpl struct {
 var _ typedstoragev1alpha1.CSIStorageCapacityInterface = (*wrapStorageV1alpha1CSIStorageCapacityImpl)(nil)
 
 func (w *wrapStorageV1alpha1CSIStorageCapacityImpl) Apply(ctx context.Context, in *storagev1alpha1.CSIStorageCapacityApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1alpha1.CSIStorageCapacity, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIStorageCapacity")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1alpha1.CSIStorageCapacity{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1alpha1CSIStorageCapacityImpl) ApplyStatus(ctx context.Context, in *storagev1alpha1.CSIStorageCapacityApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1alpha1.CSIStorageCapacity, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIStorageCapacity")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1alpha1.CSIStorageCapacity{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1alpha1CSIStorageCapacityImpl) Create(ctx context.Context, in *apistoragev1alpha1.CSIStorageCapacity, opts metav1.CreateOptions) (*apistoragev1alpha1.CSIStorageCapacity, error) {
@@ -14336,11 +17345,43 @@ type wrapStorageV1alpha1VolumeAttachmentImpl struct {
 var _ typedstoragev1alpha1.VolumeAttachmentInterface = (*wrapStorageV1alpha1VolumeAttachmentImpl)(nil)
 
 func (w *wrapStorageV1alpha1VolumeAttachmentImpl) Apply(ctx context.Context, in *storagev1alpha1.VolumeAttachmentApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1alpha1.VolumeAttachment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("VolumeAttachment")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1alpha1.VolumeAttachment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1alpha1VolumeAttachmentImpl) ApplyStatus(ctx context.Context, in *storagev1alpha1.VolumeAttachmentApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1alpha1.VolumeAttachment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("VolumeAttachment")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1alpha1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1alpha1.VolumeAttachment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1alpha1VolumeAttachmentImpl) Create(ctx context.Context, in *apistoragev1alpha1.VolumeAttachment, opts metav1.CreateOptions) (*apistoragev1alpha1.VolumeAttachment, error) {
@@ -14486,11 +17527,43 @@ type wrapStorageV1beta1CSIDriverImpl struct {
 var _ typedstoragev1beta1.CSIDriverInterface = (*wrapStorageV1beta1CSIDriverImpl)(nil)
 
 func (w *wrapStorageV1beta1CSIDriverImpl) Apply(ctx context.Context, in *storagev1beta1.CSIDriverApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.CSIDriver, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIDriver")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.CSIDriver{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1CSIDriverImpl) ApplyStatus(ctx context.Context, in *storagev1beta1.CSIDriverApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.CSIDriver, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIDriver")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.CSIDriver{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1CSIDriverImpl) Create(ctx context.Context, in *apistoragev1beta1.CSIDriver, opts metav1.CreateOptions) (*apistoragev1beta1.CSIDriver, error) {
@@ -14621,11 +17694,43 @@ type wrapStorageV1beta1CSINodeImpl struct {
 var _ typedstoragev1beta1.CSINodeInterface = (*wrapStorageV1beta1CSINodeImpl)(nil)
 
 func (w *wrapStorageV1beta1CSINodeImpl) Apply(ctx context.Context, in *storagev1beta1.CSINodeApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.CSINode, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSINode")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.CSINode{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1CSINodeImpl) ApplyStatus(ctx context.Context, in *storagev1beta1.CSINodeApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.CSINode, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSINode")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.CSINode{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1CSINodeImpl) Create(ctx context.Context, in *apistoragev1beta1.CSINode, opts metav1.CreateOptions) (*apistoragev1beta1.CSINode, error) {
@@ -14760,11 +17865,43 @@ type wrapStorageV1beta1CSIStorageCapacityImpl struct {
 var _ typedstoragev1beta1.CSIStorageCapacityInterface = (*wrapStorageV1beta1CSIStorageCapacityImpl)(nil)
 
 func (w *wrapStorageV1beta1CSIStorageCapacityImpl) Apply(ctx context.Context, in *storagev1beta1.CSIStorageCapacityApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.CSIStorageCapacity, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIStorageCapacity")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.CSIStorageCapacity{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1CSIStorageCapacityImpl) ApplyStatus(ctx context.Context, in *storagev1beta1.CSIStorageCapacityApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.CSIStorageCapacity, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("CSIStorageCapacity")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Namespace(w.namespace).ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.CSIStorageCapacity{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1CSIStorageCapacityImpl) Create(ctx context.Context, in *apistoragev1beta1.CSIStorageCapacity, opts metav1.CreateOptions) (*apistoragev1beta1.CSIStorageCapacity, error) {
@@ -14895,11 +18032,43 @@ type wrapStorageV1beta1StorageClassImpl struct {
 var _ typedstoragev1beta1.StorageClassInterface = (*wrapStorageV1beta1StorageClassImpl)(nil)
 
 func (w *wrapStorageV1beta1StorageClassImpl) Apply(ctx context.Context, in *storagev1beta1.StorageClassApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.StorageClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StorageClass")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.StorageClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1StorageClassImpl) ApplyStatus(ctx context.Context, in *storagev1beta1.StorageClassApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.StorageClass, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("StorageClass")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.StorageClass{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1StorageClassImpl) Create(ctx context.Context, in *apistoragev1beta1.StorageClass, opts metav1.CreateOptions) (*apistoragev1beta1.StorageClass, error) {
@@ -15030,11 +18199,43 @@ type wrapStorageV1beta1VolumeAttachmentImpl struct {
 var _ typedstoragev1beta1.VolumeAttachmentInterface = (*wrapStorageV1beta1VolumeAttachmentImpl)(nil)
 
 func (w *wrapStorageV1beta1VolumeAttachmentImpl) Apply(ctx context.Context, in *storagev1beta1.VolumeAttachmentApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.VolumeAttachment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("VolumeAttachment")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.VolumeAttachment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1VolumeAttachmentImpl) ApplyStatus(ctx context.Context, in *storagev1beta1.VolumeAttachmentApplyConfiguration, opts metav1.ApplyOptions) (result *apistoragev1beta1.VolumeAttachment, err error) {
-	panic("NYI")
+	in.Kind = ptr.String("VolumeAttachment")
+
+	in.APIVersion = ptr.String("storage.k8s.io/v1beta1")
+
+	uo := &unstructured.Unstructured{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &apistoragev1beta1.VolumeAttachment{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
 func (w *wrapStorageV1beta1VolumeAttachmentImpl) Create(ctx context.Context, in *apistoragev1beta1.VolumeAttachment, opts metav1.CreateOptions) (*apistoragev1beta1.VolumeAttachment, error) {
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/client.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/client.go
index 6248db52f..8338ed647 100644
--- a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/client.go
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/client.go
@@ -286,6 +286,11 @@ func (g *clientGenerator) GenerateType(c *generator.Context, t *types.Type, w io
 					"Group":        group,
 					"VersionLower": version,
 					"Kind":         t.Name.Name,
+
+					"ptrString": c.Universe.Function(types.Name{
+						Package: "knative.dev/pkg/ptr",
+						Name:    "String",
+					}),
 				}
 
 				for _, v := range verbs.List() {
@@ -575,13 +580,51 @@ func (w *wrap{{.GroupGoName}}{{.Version}}{{ .Type.Name.Name }}Impl) Patch(ctx {{
 `,
 	"apply": `{{if .generateApply}}
 func (w *wrap{{.GroupGoName}}{{.Version}}{{ .Type.Name.Name }}Impl) Apply(ctx {{ .contextContext|raw }}, in *{{ .ApplyType|raw }}, opts {{ .metav1ApplyOptions|raw }}) (result *{{ .ResultType|raw }}, err error) {
-	panic("NYI")
+	in.Kind = {{ .ptrString|raw }}("{{ .Kind }}")
+	{{ if .Group }}
+	in.APIVersion = {{ .ptrString|raw }}("{{ .Group }}/{{ .VersionLower }}")
+	{{ else }}
+	in.APIVersion = {{ .ptrString|raw }}("{{ .VersionLower }}")
+	{{ end }}
+
+	uo := &{{ .unstructuredUnstructured|raw }}{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn{{if .Namespaced}}.Namespace(w.namespace){{end}}.Apply(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &{{ .ResultType|raw }}{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 {{end}}
 `,
 	"applyStatus": `{{if .generateApply}}
 func (w *wrap{{.GroupGoName}}{{.Version}}{{ .Type.Name.Name }}Impl) ApplyStatus(ctx {{ .contextContext|raw }}, in *{{ .ApplyType|raw }}, opts {{ .metav1ApplyOptions|raw }}) (result *{{ .ResultType|raw }}, err error) {
-	panic("NYI")
+	in.Kind = {{ .ptrString|raw }}("{{ .Kind }}")
+	{{ if .Group }}
+	in.APIVersion = {{ .ptrString|raw }}("{{ .Group }}/{{ .VersionLower }}")
+	{{ else }}
+	in.APIVersion = {{ .ptrString|raw }}("{{ .VersionLower }}")
+	{{ end }}
+
+	uo := &{{ .unstructuredUnstructured|raw }}{}
+	if err := convert(in, uo); err != nil {
+		return nil, err
+	}
+	uo, err = w.dyn{{if .Namespaced}}.Namespace(w.namespace){{end}}.ApplyStatus(ctx, uo.GetName(), uo, opts)
+	if err != nil {
+		return nil, err
+	}
+	out := &{{ .ResultType|raw }}{}
+	if err := convert(uo, out); err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 {{end}}
 `,
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/comment_parser.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/comment_parser.go
index 68ac8b4cb..4051e6a86 100644
--- a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/comment_parser.go
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/comment_parser.go
@@ -5,7 +5,7 @@ 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
+	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,
@@ -27,10 +27,10 @@ type CommentTag map[string][]string
 
 // ExtractCommentTags parses comments for lines of the form:
 //
-//   "marker" + "prefix" + ':' + "key=value,key2=value2".
+//	 "marker" + "prefix" + ':' + "key=value,key2=value2".
 //
-//  In the following example the marker is '+' and the prefix is 'foo':
-//   +foo:key=value1,key2=value2,key=value3
+//	In the following example the marker is '+' and the prefix is 'foo':
+//	 +foo:key=value1,key2=value2,key=value3
 //
 // Values are optional; empty map is the default. A tag can be specified more than
 // one time and all values are returned.  If the resulting map has an entry for
@@ -38,17 +38,19 @@ type CommentTag map[string][]string
 //
 // Example: if you pass "+" for 'marker', and the following lines are in
 // the comments:
-//   +foo:key=value1,key2=value2,key=value3
-//   +bar
+//
+//	+foo:key=value1,key2=value2,key=value3
+//	+bar
 //
 // Then this function will return:
-//   map[string]map[string]string{
-//     "foo":{
-//      "key":  []string{"value1", "value3"},
-//      "key2": []string{"value2"}
-//     },
-//     "bar": {},
-//  }
+//
+//	 map[string]map[string]string{
+//	   "foo":{
+//	    "key":  []string{"value1", "value3"},
+//	    "key2": []string{"value2"}
+//	   },
+//	   "bar": {},
+//	}
 //
 // Users are not expected to repeat values.
 func ExtractCommentTags(marker string, lines []string) CommentTags {
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_informer.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_informer.go
index 53debfb38..b9c5c4ae2 100644
--- a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_informer.go
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_informer.go
@@ -41,6 +41,7 @@ type filteredInjectionGenerator struct {
 	injectionClientSetPackage   string
 	clientSetPackage            string
 	listerPkg                   string
+	listerHasPointerElem        bool
 }
 
 var _ generator.Generator = (*filteredInjectionGenerator)(nil)
@@ -92,6 +93,7 @@ func (g *filteredInjectionGenerator) GenerateType(c *generator.Context, t *types
 		"clientSetInterface":                 c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"}),
 		"resourceLister":                     c.Universe.Type(types.Name{Name: g.typeToGenerate.Name.Name + "Lister", Package: g.listerPkg}),
 		"resourceNamespaceLister":            c.Universe.Type(types.Name{Name: g.typeToGenerate.Name.Name + "NamespaceLister", Package: g.listerPkg}),
+		"listerHasPointerElem":               g.listerHasPointerElem,
 		"groupGoName":                        namer.IC(g.groupGoName),
 		"versionGoName":                      namer.IC(g.groupVersion.Version.String()),
 		"group":                              namer.IC(g.groupGoName),
@@ -246,7 +248,7 @@ func (w *wrapper) List(selector {{ .labelsSelector|raw }}) (ret []*{{ .type|raw
 		return nil, err
 	}
 	for idx := range lo.Items {
-		ret = append(ret, &lo.Items[idx])
+		ret = append(ret, {{if not .listerHasPointerElem}}&{{end}}lo.Items[idx])
 	}
 	return ret, nil
 }
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/packages.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/packages.go
index 72d5ed0d2..8c3fe5240 100644
--- a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/packages.go
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/packages.go
@@ -503,6 +503,7 @@ func versionInformerPackages(basePackage string, groupPkgName string, gv clientg
 					clientSetPackage:            customArgs.VersionedClientSetPackage,
 					injectionClientSetPackage:   filepath.Join(basePackage, "client"),
 					listerPkg:                   listerPackagePath,
+					listerHasPointerElem:        customArgs.ListerHasPointerElem,
 				})
 				return generators
 			},
diff --git a/vendor/knative.dev/pkg/configmap/doc.go b/vendor/knative.dev/pkg/configmap/doc.go
index d861a3801..5e9ab8990 100644
--- a/vendor/knative.dev/pkg/configmap/doc.go
+++ b/vendor/knative.dev/pkg/configmap/doc.go
@@ -16,6 +16,6 @@ limitations under the License.
 
 // Package configmap exists to facilitate consuming Kubernetes ConfigMap
 // resources in various ways, including:
-//  - Watching them for changes over time, and
-//  - Loading them from a VolumeMount.
+//   - Watching them for changes over time, and
+//   - Loading them from a VolumeMount.
 package configmap
diff --git a/vendor/knative.dev/pkg/configmap/store.go b/vendor/knative.dev/pkg/configmap/store.go
index ffe9ad8c6..375a474c2 100644
--- a/vendor/knative.dev/pkg/configmap/store.go
+++ b/vendor/knative.dev/pkg/configmap/store.go
@@ -35,7 +35,7 @@ type Logger interface {
 // Constructors is a map for specifying configmap names to
 // their function constructors
 //
-// The values of this map must be functions with the definition
+// # The values of this map must be functions with the definition
 //
 // func(*k8s.io/api/core/v1.ConfigMap) (... , error)
 //
@@ -60,7 +60,7 @@ type UntypedStore struct {
 // NewUntypedStore creates an UntypedStore with given name,
 // Logger and Constructors
 //
-// The Logger must not be nil
+// # The Logger must not be nil
 //
 // The values in the Constructors map must be functions with
 // the definition
diff --git a/vendor/knative.dev/pkg/hash/doc.go b/vendor/knative.dev/pkg/hash/doc.go
index 8b849cd3e..5595336ad 100644
--- a/vendor/knative.dev/pkg/hash/doc.go
+++ b/vendor/knative.dev/pkg/hash/doc.go
@@ -16,12 +16,12 @@ limitations under the License.
 
 // Package hash contains various Knative specific hashing utilities.
 //
-// - ChooseSubset is a consistent hashing/mapping function providing
-//   a consistent selection of N keys from M (N<=M) keys for a given
-//   target.
-// - BucketSet is a bucketer library which uses ChooseSubset under the
-//   the hood in order to implement consistent mapping between keys and
-//   set of buckets, identified by unique names. Compared to basic bucket
-//   implementation which just does hash%num_buckets, when the number of
-//   buckets change only a small subset of keys are supposed to migrate.
+//   - ChooseSubset is a consistent hashing/mapping function providing
+//     a consistent selection of N keys from M (N<=M) keys for a given
+//     target.
+//   - BucketSet is a bucketer library which uses ChooseSubset under the
+//     the hood in order to implement consistent mapping between keys and
+//     set of buckets, identified by unique names. Compared to basic bucket
+//     implementation which just does hash%num_buckets, when the number of
+//     buckets change only a small subset of keys are supposed to migrate.
 package hash
diff --git a/vendor/knative.dev/pkg/injection/doc.go b/vendor/knative.dev/pkg/injection/doc.go
index db5495d81..960674dea 100644
--- a/vendor/knative.dev/pkg/injection/doc.go
+++ b/vendor/knative.dev/pkg/injection/doc.go
@@ -22,84 +22,84 @@ limitations under the License.
 // interesting.  The first is in the context of implementations of
 // `controller.Reconciler` being wrapped in a `*controller.Impl`:
 //
-//   import (
-//     // Simply linking this triggers the injection of the informer, which links
-//     // the factory triggering its injection, and which links the client,
-//     // triggering its injection.  All you need to know is that it works :)
-//     deployinformer "knative.dev/pkg/injection/informers/kubeinformers/appsv1/deployment"
-//     "knative.dev/pkg/injection"
-//   )
+//	import (
+//	  // Simply linking this triggers the injection of the informer, which links
+//	  // the factory triggering its injection, and which links the client,
+//	  // triggering its injection.  All you need to know is that it works :)
+//	  deployinformer "knative.dev/pkg/injection/informers/kubeinformers/appsv1/deployment"
+//	  "knative.dev/pkg/injection"
+//	)
 //
-//   func NewController(ctx context.Context) *controller.Impl {
-//     deploymentInformer := deployinformer.Get(ctx)
-//     // Pass deploymentInformer.Lister() to Reconciler
-//     ...
-//     // Set up events on deploymentInformer.Informer()
-//     ...
-//   }
+//	func NewController(ctx context.Context) *controller.Impl {
+//	  deploymentInformer := deployinformer.Get(ctx)
+//	  // Pass deploymentInformer.Lister() to Reconciler
+//	  ...
+//	  // Set up events on deploymentInformer.Informer()
+//	  ...
+//	}
 //
 // Then in `package main` the entire controller process can be set up via:
 //
-//   package main
+//	package main
 //
-//   import (
-//   	// The set of controllers this controller process runs.
-//      // Linking these will register their transitive dependencies, after
-//      // which the shared main can set up the rest.
-//   	"github.com/knative/foo/pkg/reconciler/matt"
-//   	"github.com/knative/foo/pkg/reconciler/scott"
-//   	"github.com/knative/foo/pkg/reconciler/ville"
-//   	"github.com/knative/foo/pkg/reconciler/dave"
+//	import (
+//		// The set of controllers this controller process runs.
+//	   // Linking these will register their transitive dependencies, after
+//	   // which the shared main can set up the rest.
+//		"github.com/knative/foo/pkg/reconciler/matt"
+//		"github.com/knative/foo/pkg/reconciler/scott"
+//		"github.com/knative/foo/pkg/reconciler/ville"
+//		"github.com/knative/foo/pkg/reconciler/dave"
 //
-//   	// This defines the shared main for injected controllers.
-//   	"knative.dev/pkg/injection/sharedmain"
-//   )
+//		// This defines the shared main for injected controllers.
+//		"knative.dev/pkg/injection/sharedmain"
+//	)
 //
-//   func main() {
-//   	sharedmain.Main("mycomponent",
-//         // We pass in the list of controllers to construct, and that's it!
-//         // If we forget to add this, go will complain about the unused import.
-//         matt.NewController,
-//         scott.NewController,
-//         ville.NewController,
-//         dave.NewController,
-//      )
-//   }
+//	func main() {
+//		sharedmain.Main("mycomponent",
+//	      // We pass in the list of controllers to construct, and that's it!
+//	      // If we forget to add this, go will complain about the unused import.
+//	      matt.NewController,
+//	      scott.NewController,
+//	      ville.NewController,
+//	      dave.NewController,
+//	   )
+//	}
 //
 // If you want to adapt the above to run the controller within a single
 // namespace, you can instead do something like:
 //
-//   package main
+//	package main
 //
-//   import (
-//   	// The set of controllers this controller process runs.
-//      // Linking these will register their transitive dependencies, after
-//      // which the shared main can set up the rest.
-//   	"github.com/knative/foo/pkg/reconciler/matt"
-//   	"github.com/knative/foo/pkg/reconciler/scott"
-//   	"github.com/knative/foo/pkg/reconciler/ville"
-//   	"github.com/knative/foo/pkg/reconciler/dave"
+//	import (
+//		// The set of controllers this controller process runs.
+//	   // Linking these will register their transitive dependencies, after
+//	   // which the shared main can set up the rest.
+//		"github.com/knative/foo/pkg/reconciler/matt"
+//		"github.com/knative/foo/pkg/reconciler/scott"
+//		"github.com/knative/foo/pkg/reconciler/ville"
+//		"github.com/knative/foo/pkg/reconciler/dave"
 //
-//   	// This defines the shared main for injected controllers.
-//   	"knative.dev/pkg/injection/sharedmain"
+//		// This defines the shared main for injected controllers.
+//		"knative.dev/pkg/injection/sharedmain"
 //
-//      // These are used to set up the context.
-//   	"knative.dev/pkg/injection"
-//   	"knative.dev/pkg/signals"
-//   )
+//	   // These are used to set up the context.
+//		"knative.dev/pkg/injection"
+//		"knative.dev/pkg/signals"
+//	)
 //
-//   func main() {
-//      // Scope the shared informer factories to the provided namespace.
-//      ctx := injection.WithNamespace(signals.NewContext(), "the-namespace")
+//	func main() {
+//	   // Scope the shared informer factories to the provided namespace.
+//	   ctx := injection.WithNamespace(signals.NewContext(), "the-namespace")
 //
-//      // Use our initial context when setting up the controllers.
-//   	sharedmain.MainWithContext(ctx, "mycomponent",
-//         // We pass in the list of controllers to construct, and that's it!
-//         // If we forget to add this, go will complain about the unused import.
-//         matt.NewController,
-//         scott.NewController,
-//         ville.NewController,
-//         dave.NewController,
-//      )
-//   }
+//	   // Use our initial context when setting up the controllers.
+//		sharedmain.MainWithContext(ctx, "mycomponent",
+//	      // We pass in the list of controllers to construct, and that's it!
+//	      // If we forget to add this, go will complain about the unused import.
+//	      matt.NewController,
+//	      scott.NewController,
+//	      ville.NewController,
+//	      dave.NewController,
+//	   )
+//	}
 package injection
diff --git a/vendor/knative.dev/pkg/injection/injection.go b/vendor/knative.dev/pkg/injection/injection.go
index d8cefc9fb..f06e06f17 100644
--- a/vendor/knative.dev/pkg/injection/injection.go
+++ b/vendor/knative.dev/pkg/injection/injection.go
@@ -34,9 +34,11 @@ import (
 //
 // Typical integration:
 // ```go
-//   ctx, startInformers := injection.EnableInjectionOrDie(signals.NewContext(), nil)
-//   ... start watches with informers, if required ...
-//   startInformers()
+//
+//	ctx, startInformers := injection.EnableInjectionOrDie(signals.NewContext(), nil)
+//	... start watches with informers, if required ...
+//	startInformers()
+//
 // ```
 func EnableInjectionOrDie(ctx context.Context, cfg *rest.Config) (context.Context, func()) {
 	if ctx == nil {
diff --git a/vendor/knative.dev/pkg/logging/object_encoders.go b/vendor/knative.dev/pkg/logging/object_encoders.go
index ee14737ce..9a30f8aab 100644
--- a/vendor/knative.dev/pkg/logging/object_encoders.go
+++ b/vendor/knative.dev/pkg/logging/object_encoders.go
@@ -29,9 +29,12 @@ import (
 
 // StringSet returns a marshaler for the set of strings.
 // To use this in sugared logger do:
+//
 //	logger.Infow("Revision State", zap.Object("healthy", logging.StringSet(healthySet)),
 //		zap.Object("unhealthy", logging.StringSet(unhealthySet)))
+//
 // To use with non-sugared logger do:
+//
 //	logger.Info("Revision State", zap.Object("healthy", logging.StringSet(healthySet)),
 //		zap.Object("unhealthy", logging.StringSet(unhealthySet)))
 func StringSet(s sets.String) zapcore.ObjectMarshalerFunc {
diff --git a/vendor/knative.dev/pkg/metrics/prometheus_exporter.go b/vendor/knative.dev/pkg/metrics/prometheus_exporter.go
index b5b39d9fc..aec6c09a0 100644
--- a/vendor/knative.dev/pkg/metrics/prometheus_exporter.go
+++ b/vendor/knative.dev/pkg/metrics/prometheus_exporter.go
@@ -41,7 +41,7 @@ func (emptyPromExporter) ExportView(viewData *view.Data) {
 	// a signal to enrich the internal Meters with Resource information.
 }
 
-//nolint: unparam // False positive of flagging the second result of this function unused.
+// nolint: unparam // False positive of flagging the second result of this function unused.
 func newPrometheusExporter(config *metricsConfig, logger *zap.SugaredLogger) (view.Exporter, ResourceExporterFactory, error) {
 	e, err := prom.NewExporter(prom.Options{Namespace: config.component})
 	if err != nil {
@@ -82,6 +82,7 @@ func startNewPromSrv(e *prom.Exporter, host string, port int) *http.Server {
 	if curPromSrv != nil {
 		curPromSrv.Close()
 	}
+	//nolint:gosec
 	curPromSrv = &http.Server{
 		Addr:    host + ":" + strconv.Itoa(port),
 		Handler: sm,
diff --git a/vendor/knative.dev/pkg/network/h2c.go b/vendor/knative.dev/pkg/network/h2c.go
index 6cc0fa733..4620b084d 100644
--- a/vendor/knative.dev/pkg/network/h2c.go
+++ b/vendor/knative.dev/pkg/network/h2c.go
@@ -28,6 +28,7 @@ import (
 
 // NewServer returns a new HTTP Server with HTTP2 handler.
 func NewServer(addr string, h http.Handler) *http.Server {
+	//nolint:gosec
 	h1s := &http.Server{
 		Addr:    addr,
 		Handler: h2c.NewHandler(h, &http2.Server{}),
diff --git a/vendor/knative.dev/pkg/network/handlers/error.go b/vendor/knative.dev/pkg/network/handlers/error.go
index e45d2fa03..fd3b1c1b2 100644
--- a/vendor/knative.dev/pkg/network/handlers/error.go
+++ b/vendor/knative.dev/pkg/network/handlers/error.go
@@ -20,5 +20,6 @@ import "knative.dev/pkg/network"
 
 // Error sets up a handler suitable for use with the ErrorHandler field on
 // httputil's reverse proxy, which logs /proc/net/sockstat data.
+//
 //nolint:staticcheck // We actually want to mirror this.
 var Error = network.ErrorHandler
diff --git a/vendor/knative.dev/pkg/profiling/server.go b/vendor/knative.dev/pkg/profiling/server.go
index 9d61c0981..8af5bd98d 100644
--- a/vendor/knative.dev/pkg/profiling/server.go
+++ b/vendor/knative.dev/pkg/profiling/server.go
@@ -110,6 +110,7 @@ func NewServer(handler http.Handler) *http.Server {
 		port = strconv.Itoa(ProfilingPort)
 	}
 
+	//nolint:gosec
 	return &http.Server{
 		Addr:    ":" + port,
 		Handler: handler,
diff --git a/vendor/knative.dev/pkg/reconciler/retry.go b/vendor/knative.dev/pkg/reconciler/retry.go
index 1a50406b1..2c6cfd612 100644
--- a/vendor/knative.dev/pkg/reconciler/retry.go
+++ b/vendor/knative.dev/pkg/reconciler/retry.go
@@ -5,7 +5,7 @@ Licensed under the Apache License, Veroute.on 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
+	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,
diff --git a/vendor/knative.dev/pkg/tracing/opencensus.go b/vendor/knative.dev/pkg/tracing/opencensus.go
index 7471c1336..69019d267 100644
--- a/vendor/knative.dev/pkg/tracing/opencensus.go
+++ b/vendor/knative.dev/pkg/tracing/opencensus.go
@@ -147,8 +147,9 @@ func WithExporter(name string, logger *zap.SugaredLogger) ConfigOption {
 // The host arg is used for a value of tag ip="{IP}" so you can use an actual IP. Otherwise,
 // the host name must be able to be resolved.
 // e.g)
-//   "name" is a service name like activator-service.
-//   "host" is a endpoint IP like activator-service's endpoint IP.
+//
+//	"name" is a service name like activator-service.
+//	"host" is a endpoint IP like activator-service's endpoint IP.
 func WithExporterFull(name, host string, logger *zap.SugaredLogger) ConfigOption {
 	return func(cfg *config.Config) error {
 		var (
diff --git a/vendor/knative.dev/pkg/tracing/zipkin.go b/vendor/knative.dev/pkg/tracing/zipkin.go
index ab94386ff..b124a20d1 100644
--- a/vendor/knative.dev/pkg/tracing/zipkin.go
+++ b/vendor/knative.dev/pkg/tracing/zipkin.go
@@ -31,8 +31,8 @@ type ZipkinReporterFactory func(*config.Config) (zipkinreporter.Reporter, error)
 // WithZipkinExporter returns a config with zipkin enabled.
 //
 // Deprecated: This function is the legacy entrypoint and should be replaced with one of:
-//  - WithExporter() in production code
-//  - testing/FakeZipkinExporter() in test code.
+//   - WithExporter() in production code
+//   - testing/FakeZipkinExporter() in test code.
 func WithZipkinExporter(reporterFact ZipkinReporterFactory, endpoint *zipkinmodel.Endpoint) ConfigOption {
 	return func(cfg *config.Config) error {
 		var (
diff --git a/vendor/knative.dev/pkg/webhook/resourcesemantics/validation/validation_admit.go b/vendor/knative.dev/pkg/webhook/resourcesemantics/validation/validation_admit.go
index d30e1e981..002d60791 100644
--- a/vendor/knative.dev/pkg/webhook/resourcesemantics/validation/validation_admit.go
+++ b/vendor/knative.dev/pkg/webhook/resourcesemantics/validation/validation_admit.go
@@ -160,7 +160,7 @@ func (ac *reconciler) decodeRequestAndPrepareContext(
 	return ctx, newObj, nil
 }
 
-func validate(ctx context.Context, resource resourcesemantics.GenericCRD, req *admissionv1.AdmissionRequest) (err error, warn []error) {
+func validate(ctx context.Context, resource resourcesemantics.GenericCRD, req *admissionv1.AdmissionRequest) (err error, warn []error) { //nolint
 	logger := logging.FromContext(ctx)
 
 	// Only run validation for supported create and update validation.
diff --git a/vendor/knative.dev/pkg/webhook/webhook.go b/vendor/knative.dev/pkg/webhook/webhook.go
index ffb806ee0..435dfe38a 100644
--- a/vendor/knative.dev/pkg/webhook/webhook.go
+++ b/vendor/knative.dev/pkg/webhook/webhook.go
@@ -208,6 +208,7 @@ func (wh *Webhook) Run(stop <-chan struct{}) error {
 		QuietPeriod: wh.Options.GracePeriod,
 	}
 
+	//nolint:gosec
 	server := &http.Server{
 		Handler:   drainer,
 		Addr:      fmt.Sprint(":", wh.Options.Port),
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 29eff2014..710d5f9d2 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1221,7 +1221,7 @@ k8s.io/utils/net
 k8s.io/utils/pointer
 k8s.io/utils/strings/slices
 k8s.io/utils/trace
-# knative.dev/eventing v0.35.1-0.20221028065008-ecf7a29708c3
+# knative.dev/eventing v0.35.1-0.20221104013907-6de07e818049
 ## explicit; go 1.18
 knative.dev/eventing/cmd/event_display
 knative.dev/eventing/pkg/apis/config
@@ -1374,7 +1374,7 @@ knative.dev/eventing/test/upgrade/prober/wathola/fetcher
 knative.dev/eventing/test/upgrade/prober/wathola/forwarder
 knative.dev/eventing/test/upgrade/prober/wathola/receiver
 knative.dev/eventing/test/upgrade/prober/wathola/sender
-# knative.dev/eventing-kafka v0.35.0
+# knative.dev/eventing-kafka v0.35.1-0.20221102062409-3992a225fc57
 ## explicit; go 1.18
 knative.dev/eventing-kafka/pkg/apis/bindings
 knative.dev/eventing-kafka/pkg/apis/bindings/v1beta1
@@ -1441,11 +1441,11 @@ knative.dev/eventing-kafka/test/rekt/resources/resetoffset
 knative.dev/eventing-kafka/test/upgrade
 knative.dev/eventing-kafka/test/upgrade/continual
 knative.dev/eventing-kafka/test/upgrade/installation
-# knative.dev/hack v0.0.0-20221024013916-9d2ae47c16b2
+# knative.dev/hack v0.0.0-20221104013908-8f3c7050408b
 ## explicit; go 1.18
 knative.dev/hack
 knative.dev/hack/shell
-# knative.dev/pkg v0.0.0-20221027173407-198b4637065d
+# knative.dev/pkg v0.0.0-20221107171117-0243d641354d
 ## explicit; go 1.18
 knative.dev/pkg/apiextensions/storageversion
 knative.dev/pkg/apiextensions/storageversion/cmd/migrate
@@ -1535,6 +1535,7 @@ knative.dev/pkg/test/mako/alerter/slack
 knative.dev/pkg/test/mako/config
 knative.dev/pkg/test/monitoring
 knative.dev/pkg/test/prow
+knative.dev/pkg/test/security
 knative.dev/pkg/test/slackutil
 knative.dev/pkg/test/spoof
 knative.dev/pkg/test/upgrade
@@ -1552,7 +1553,7 @@ knative.dev/pkg/webhook/json
 knative.dev/pkg/webhook/resourcesemantics
 knative.dev/pkg/webhook/resourcesemantics/defaulting
 knative.dev/pkg/webhook/resourcesemantics/validation
-# knative.dev/reconciler-test v0.0.0-20221028112508-07a0279f6a51
+# knative.dev/reconciler-test v0.0.0-20221108073117-5600f5301d87
 ## explicit; go 1.18
 knative.dev/reconciler-test/cmd/eventshub
 knative.dev/reconciler-test/pkg/environment


Test patch:
diff --git a/control-plane/pkg/reconciler/testing/objects_broker.go b/control-plane/pkg/reconciler/testing/objects_broker.go
index d83fbb92d..8194717e4 100644
--- a/control-plane/pkg/reconciler/testing/objects_broker.go
+++ b/control-plane/pkg/reconciler/testing/objects_broker.go
@@ -194,13 +194,12 @@ func WithBootstrapServerStatusAnnotation(servers string) reconcilertesting.Broke
 	}
 }
 
-func WithSecretStatusAnnotation(name string, namespace string) reconcilertesting.BrokerOption {
+func WithSecretStatusAnnotation(name string) reconcilertesting.BrokerOption {
 	return func(broker *eventing.Broker) {
 		if broker.Status.Annotations == nil {
 			broker.Status.Annotations = make(map[string]string, 10)
 		}
 		broker.Status.Annotations[security.AuthSecretNameKey] = name
-		broker.Status.Annotations[security.AuthSecretNamespaceKey] = namespace
 	}
 }
 
diff --git a/control-plane/pkg/reconciler/trigger/v2/triggerv2_test.go b/control-plane/pkg/reconciler/trigger/v2/triggerv2_test.go
index ec5e968c1..47a7c65e2 100644
--- a/control-plane/pkg/reconciler/trigger/v2/triggerv2_test.go
+++ b/control-plane/pkg/reconciler/trigger/v2/triggerv2_test.go
@@ -496,7 +496,7 @@ func TestReconcileKind(t *testing.T) {
 					BrokerReady,
 					WithTopicStatusAnnotation(BrokerTopic()),
 					WithBootstrapServerStatusAnnotation(bootstrapServers),
-					WithSecretStatusAnnotation("secret-1", SystemNamespace),
+					WithSecretStatusAnnotation("secret-1"),
 				),
 				DataPlaneConfigMap(env.DataPlaneConfigMapNamespace, env.DataPlaneConfigConfigMapName, brokerreconciler.ConsumerConfigKey,
 					DataPlaneConfigInitialOffset(brokerreconciler.ConsumerConfigKey, sources.OffsetLatest),
@@ -520,13 +520,13 @@ func TestReconcileKind(t *testing.T) {
 							SecretSpec: &internalscg.SecretSpec{
 								Ref: &internalscg.SecretReference{
 									Name:      "secret-1",
-									Namespace: SystemNamespace,
+									Namespace: ConfigMapNamespace,
 								},
 							},
 						}),
 					)),
 				),
-				NewLegacySASLSecret(SystemNamespace, "secret-1"),
+				NewLegacySASLSecret(ConfigMapNamespace, "secret-1"),
 			},
 			Key: testKey,
 			WantUpdates: []clientgotesting.UpdateActionImpl{
@@ -550,7 +550,7 @@ func TestReconcileKind(t *testing.T) {
 								SecretSpec: &internalscg.SecretSpec{
 									Ref: &internalscg.SecretReference{
 										Name:      "secret-1",
-										Namespace: SystemNamespace,
+										Namespace: ConfigMapNamespace,
 									},
 								},
 							}),
diff --git a/vendor/knative.dev/hack/e2e-tests.sh b/vendor/knative.dev/hack/e2e-tests.sh
index 12cb6d614..cb186a4e2 100644
--- a/vendor/knative.dev/hack/e2e-tests.sh
+++ b/vendor/knative.dev/hack/e2e-tests.sh
@@ -60,6 +60,7 @@ function setup_test_cluster() {
 
   header "Setting up test cluster"
   kubectl get nodes
+
   # Set the actual project the test cluster resides in
   # It will be a project assigned by Boskos if test is running on Prow,
   # otherwise will be ${E2E_GCP_PROJECT_ID} set up by user.
@@ -90,8 +91,6 @@ function setup_test_cluster() {
   echo "- Cluster is ${k8s_cluster}"
   echo "- Docker is ${KO_DOCKER_REPO}"
 
-  export KO_DATA_PATH="${REPO_ROOT_DIR}/.git"
-
   # Do not run teardowns if we explicitly want to skip them.
   (( ! SKIP_TEARDOWNS )) && add_trap teardown_test_resources EXIT
 
@@ -99,9 +98,6 @@ function setup_test_cluster() {
   set +o errexit
   set +o pipefail
 
-  # Wait for Istio installation to complete, if necessary, before calling knative_setup.
-  # TODO(chizhg): is it really needed?
-  (( ! SKIP_ISTIO_ADDON )) && (wait_until_batch_job_complete istio-system || return 1)
   if function_exists knative_setup; then
     knative_setup || fail_test "Knative setup failed"
   fi
@@ -131,7 +127,6 @@ function fail_test() {
 }
 
 SKIP_TEARDOWNS=0
-SKIP_ISTIO_ADDON=0
 E2E_SCRIPT=""
 CLOUD_PROVIDER="gke"
 
@@ -171,8 +166,8 @@ function initialize() {
     case ${parameter} in
       --run-tests) run_tests=1 ;;
       --skip-teardowns) SKIP_TEARDOWNS=1 ;;
-      # TODO(chizhg): remove this flag once the addons is defined as an env var.
-      --skip-istio-addon) SKIP_ISTIO_ADDON=1 ;;
+      --skip-istio-addon) echo "--skip-istio-addon is no longer supported"
+        ;; # This flag is a noop
       *)
         case ${parameter} in
           --cloud-provider) shift; CLOUD_PROVIDER="$1" ;;
@@ -185,11 +180,7 @@ function initialize() {
   (( IS_PROW )) && [[ -z "${GCP_PROJECT_ID:-}" ]] && IS_BOSKOS=1
 
   if [[ "${CLOUD_PROVIDER}" == "gke" ]]; then
-    if (( SKIP_ISTIO_ADDON )); then
       custom_flags+=("--addons=NodeLocalDNS")
-    else
-      custom_flags+=("--addons=Istio,NodeLocalDNS")
-    fi
   fi
 
   readonly IS_BOSKOS
diff --git a/vendor/knative.dev/pkg/apis/testing/fuzzer/fuzzer.go b/vendor/knative.dev/pkg/apis/testing/fuzzer/fuzzer.go
index ab7b71536..412ff195a 100644
--- a/vendor/knative.dev/pkg/apis/testing/fuzzer/fuzzer.go
+++ b/vendor/knative.dev/pkg/apis/testing/fuzzer/fuzzer.go
@@ -54,16 +54,16 @@ var Funcs = fuzzer.MergeFuzzerFuncs(
 // Consumers should initialize their conditions prior to fuzzing them.
 // For example:
 //
-// func(s *SomeStatus, c fuzz.Continue) {
-//   c.FuzzNoCustom(s) // fuzz the status object
+//	func(s *SomeStatus, c fuzz.Continue) {
+//	  c.FuzzNoCustom(s) // fuzz the status object
 //
-//   // Clear the random fuzzed condition
-//   s.Status.SetConditions(nil)
+//	  // Clear the random fuzzed condition
+//	  s.Status.SetConditions(nil)
 //
-//   // Fuzz the known conditions except their type value
-//   s.InitializeConditions()
-//   fuzz.Conditions(&s.Status, c)
-// }
+//	  // Fuzz the known conditions except their type value
+//	  s.InitializeConditions()
+//	  fuzz.Conditions(&s.Status, c)
+//	}
 func FuzzConditions(accessor apis.ConditionsAccessor, c fuzz.Continue) {
 	conds := accessor.GetConditions()
 	for i, cond := range conds {
diff --git a/vendor/knative.dev/pkg/reconciler/testing/hooks.go b/vendor/knative.dev/pkg/reconciler/testing/hooks.go
index f60d6ebed..c89be34a0 100644
--- a/vendor/knative.dev/pkg/reconciler/testing/hooks.go
+++ b/vendor/knative.dev/pkg/reconciler/testing/hooks.go
@@ -44,7 +44,7 @@ CreateHookFunc is a function for handling a Create hook. Its runtime.Object
 parameter will be the Kubernetes resource created. The resource can be cast
 to its actual type like this:
 
-		pod := obj.(*v1.Pod)
+	pod := obj.(*v1.Pod)
 
 A return value of true marks the hook as completed. Returning false allows
 the hook to run again when the next resource of the requested type is
@@ -57,7 +57,7 @@ UpdateHookFunc is a function for handling an update hook. its runtime.Object
 parameter will be the Kubernetes resource updated. The resource can be cast
 to its actual type like this:
 
-		pod := obj.(*v1.Pod)
+	pod := obj.(*v1.Pod)
 
 A return value of true marks the hook as completed. Returning false allows
 the hook to run again when the next resource of the requested type is
diff --git a/vendor/knative.dev/pkg/reconciler/testing/reactions.go b/vendor/knative.dev/pkg/reconciler/testing/reactions.go
index d66b41a71..bd77d4090 100644
--- a/vendor/knative.dev/pkg/reconciler/testing/reactions.go
+++ b/vendor/knative.dev/pkg/reconciler/testing/reactions.go
@@ -28,15 +28,18 @@ import (
 
 // InduceFailure is used in conjunction with TableTest's WithReactors field.
 // Tests that want to induce a failure in a row of a TableTest would add:
-//   WithReactors: []clientgotesting.ReactionFunc{
-//      // Makes calls to create revisions return an error.
-//      InduceFailure("create", "revisions"),
-//   },
+//
+//	WithReactors: []clientgotesting.ReactionFunc{
+//	   // Makes calls to create revisions return an error.
+//	   InduceFailure("create", "revisions"),
+//	},
+//
 // Or to target a subresource, say a patch to InMemoryChannel.Status, you would add:
-//   WithReactors: []clientgotesting.ReactionFunc{
-//      // Makes calls to patch inmemorychannels status subresource return an error.
-//      InduceFailure("patch", "inmemorychannels/status"),
-//   },
+//
+//	WithReactors: []clientgotesting.ReactionFunc{
+//	   // Makes calls to patch inmemorychannels status subresource return an error.
+//	   InduceFailure("patch", "inmemorychannels/status"),
+//	},
 func InduceFailure(verb, resource string) clientgotesting.ReactionFunc {
 	return func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
 		if !action.Matches(verb, resource) {
@@ -52,7 +55,8 @@ func ValidateCreates(ctx context.Context, action clientgotesting.Action) (handle
 	if !ok {
 		return false, nil, nil
 	}
-	if err := obj.Validate(ctx); err != nil {
+	// Only return error-level errors; warnings should not block API calls.
+	if err := obj.Validate(ctx).Filter(apis.ErrorLevel); err != nil {
 		return true, nil, err
 	}
 	return false, nil, nil
@@ -64,7 +68,8 @@ func ValidateUpdates(ctx context.Context, action clientgotesting.Action) (handle
 	if !ok {
 		return false, nil, nil
 	}
-	if err := obj.Validate(ctx); err != nil {
+	// Only return error-level errors; warnings should not block API calls.
+	if err := obj.Validate(ctx).Filter(apis.ErrorLevel); err != nil {
 		return true, nil, err
 	}
 	return false, nil, nil
diff --git a/vendor/knative.dev/pkg/reconciler/testing/sorter.go b/vendor/knative.dev/pkg/reconciler/testing/sorter.go
index 2c1e91923..a55286f7b 100644
--- a/vendor/knative.dev/pkg/reconciler/testing/sorter.go
+++ b/vendor/knative.dev/pkg/reconciler/testing/sorter.go
@@ -5,7 +5,7 @@ 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
+	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,
diff --git a/vendor/knative.dev/pkg/reconciler/testing/table.go b/vendor/knative.dev/pkg/reconciler/testing/table.go
index 962ce94ba..bfeb6825e 100644
--- a/vendor/knative.dev/pkg/reconciler/testing/table.go
+++ b/vendor/knative.dev/pkg/reconciler/testing/table.go
@@ -387,10 +387,13 @@ func (tt TableTest) Test(t *testing.T, factory Factory) {
 		t.Run(test.Name, func(t *testing.T) {
 			t.Helper()
 			test.Test(t, factory)
+			opts := make([]cmp.Option, 0, len(defaultCmpOpts)+len(test.CmpOpts))
+			opts = append(opts, defaultCmpOpts...)
+			opts = append(opts, test.CmpOpts...)
 			// Validate cached objects do not get soiled after controller loops.
-			if !cmp.Equal(originObjects, test.Objects, defaultCmpOpts...) {
+			if !cmp.Equal(originObjects, test.Objects, opts...) {
 				t.Errorf("Unexpected objects (-want, +got):\n%s",
-					cmp.Diff(originObjects, test.Objects, defaultCmpOpts...))
+					cmp.Diff(originObjects, test.Objects, opts...))
 			}
 		})
 	}
diff --git a/vendor/knative.dev/pkg/test/gcs/gcs.go b/vendor/knative.dev/pkg/test/gcs/gcs.go
index 380548d5f..fa0bba380 100644
--- a/vendor/knative.dev/pkg/test/gcs/gcs.go
+++ b/vendor/knative.dev/pkg/test/gcs/gcs.go
@@ -30,7 +30,7 @@ import (
 	"google.golang.org/api/option"
 )
 
-//nolint // there's also Client so they collide.
+// nolint // there's also Client so they collide.
 type GCSClient struct {
 	*storage.Client
 }
diff --git a/vendor/knative.dev/pkg/test/ingress/ingress.go b/vendor/knative.dev/pkg/test/ingress/ingress.go
index fc9f9a19c..8de4052c7 100644
--- a/vendor/knative.dev/pkg/test/ingress/ingress.go
+++ b/vendor/knative.dev/pkg/test/ingress/ingress.go
@@ -35,8 +35,10 @@ const (
 // GetIngressEndpoint gets the ingress public IP or hostname.
 // address - is the endpoint to which we should actually connect.
 // portMap - translates the request's port to the port on address to which the caller
-//    should connect.  This is used when the resolution to address goes through some
-//    sort of port-mapping, e.g. Kubernetes node ports.
+//
+//	should connect.  This is used when the resolution to address goes through some
+//	sort of port-mapping, e.g. Kubernetes node ports.
+//
 // err - an error when address/portMap cannot be established.
 func GetIngressEndpoint(ctx context.Context, kubeClientset kubernetes.Interface, endpointOverride string) (address string, portMap func(string) string, err error) {
 	ingressName := istioIngressName
diff --git a/vendor/knative.dev/pkg/test/security/security.go b/vendor/knative.dev/pkg/test/security/security.go
new file mode 100644
index 000000000..112601dbf
--- /dev/null
+++ b/vendor/knative.dev/pkg/test/security/security.go
@@ -0,0 +1,70 @@
+/*
+Copyright 2022 The Knative 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 security
+
+import (
+	"context"
+
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	"knative.dev/pkg/ptr"
+)
+
+var DefaultPodSecurityContext = corev1.PodSecurityContext{
+	RunAsNonRoot: ptr.Bool(true),
+	SeccompProfile: &corev1.SeccompProfile{
+		Type: corev1.SeccompProfileTypeRuntimeDefault,
+	},
+}
+
+var DefaultContainerSecurityContext = corev1.SecurityContext{
+	AllowPrivilegeEscalation: ptr.Bool(false),
+	Capabilities: &corev1.Capabilities{
+		Drop: []corev1.Capability{"ALL"},
+	},
+}
+
+// AllowRestrictedPodSecurityStandard adds SecurityContext to Pod and its containers so that it can run
+// in a namespace with enforced "restricted" security standard.
+func AllowRestrictedPodSecurityStandard(ctx context.Context, kubeClient kubernetes.Interface, pod *corev1.Pod) error {
+	enforced, err := IsRestrictedPodSecurityEnforced(ctx, kubeClient, pod.Namespace)
+	if err != nil {
+		return err
+	}
+	if enforced {
+		pod.Spec.SecurityContext = &DefaultPodSecurityContext
+		for _, c := range pod.Spec.Containers {
+			c.SecurityContext = &DefaultContainerSecurityContext
+		}
+	}
+	return nil
+}
+
+// IsRestrictedPodSecurityEnforced checks if the given namespace has enforced restricted security standard.
+func IsRestrictedPodSecurityEnforced(ctx context.Context, kubeClient kubernetes.Interface, namespace string) (bool, error) {
+	ns, err := kubeClient.CoreV1().Namespaces().Get(ctx, namespace, metav1.GetOptions{})
+	if err != nil {
+		return false, err
+	}
+	for k, v := range ns.Labels {
+		if k == "pod-security.kubernetes.io/enforce" && v == "restricted" {
+			return true, nil
+		}
+	}
+	return false, nil
+}
diff --git a/vendor/knative.dev/pkg/test/zipkin/doc.go b/vendor/knative.dev/pkg/test/zipkin/doc.go
index c4464f459..81c15343f 100644
--- a/vendor/knative.dev/pkg/test/zipkin/doc.go
+++ b/vendor/knative.dev/pkg/test/zipkin/doc.go
@@ -33,9 +33,8 @@ This package exposes following methods:
 
 A general flow for a Test Suite to use Zipkin Tracing support is as follows:
 
-		1. Call SetupZipkinTracing(kubernetes.Interface) in TestMain.
-		2. Use SpoofingClient to make HTTP requests.
-		3. Call CleanupZipkinTracingSetup on cleanup after tests are executed.
-
+ 1. Call SetupZipkinTracing(kubernetes.Interface) in TestMain.
+ 2. Use SpoofingClient to make HTTP requests.
+ 3. Call CleanupZipkinTracingSetup on cleanup after tests are executed.
 */
 package zipkin
diff --git a/vendor/knative.dev/pkg/test/zipkin/util.go b/vendor/knative.dev/pkg/test/zipkin/util.go
index 481dddb42..f22efa441 100644
--- a/vendor/knative.dev/pkg/test/zipkin/util.go
+++ b/vendor/knative.dev/pkg/test/zipkin/util.go
@@ -110,9 +110,10 @@ func SetupZipkinTracingFromConfigTracingOrFail(ctx context.Context, t testing.TB
 }
 
 // SetupZipkinTracing sets up zipkin tracing which involves:
-// 1. Setting up port-forwarding from localhost to zipkin pod on the cluster
-//    (pid of the process doing Port-Forward is stored in a global variable).
-// 2. Enable AlwaysSample config for tracing for the SpoofingClient.
+//  1. Setting up port-forwarding from localhost to zipkin pod on the cluster
+//     (pid of the process doing Port-Forward is stored in a global variable).
+//  2. Enable AlwaysSample config for tracing for the SpoofingClient.
+//
 // The zipkin deployment must have the label app=zipkin
 func SetupZipkinTracing(ctx context.Context, kubeClientset kubernetes.Interface, logf logging.FormatLogger, zipkinRemotePort int, zipkinNamespace string) (err error) {
 	setupOnce.Do(func() {
@@ -152,13 +153,13 @@ func SetupZipkinTracingOrFail(ctx context.Context, t testing.TB, kubeClientset k
 // CleanupZipkinTracingSetup cleans up the Zipkin tracing setup on the machine. This involves killing the process performing port-forward.
 // This should be called exactly once in TestMain. Likely in the form:
 //
-// func TestMain(m *testing.M) {
-//     os.Exit(func() int {
-//       // Any setup required for the tests.
-//       defer zipkin.CleanupZipkinTracingSetup(logger)
-//       return m.Run()
-//     }())
-// }
+//	func TestMain(m *testing.M) {
+//	    os.Exit(func() int {
+//	      // Any setup required for the tests.
+//	      defer zipkin.CleanupZipkinTracingSetup(logger)
+//	      return m.Run()
+//	    }())
+//	}
 func CleanupZipkinTracingSetup(logf logging.FormatLogger) {
 	teardownOnce.Do(func() {
 		// Because CleanupZipkinTracingSetup only runs once, make sure that now that it has been
diff --git a/vendor/knative.dev/reconciler-test/pkg/environment/magic.go b/vendor/knative.dev/reconciler-test/pkg/environment/magic.go
index d79479fa9..a469c9c04 100644
--- a/vendor/knative.dev/reconciler-test/pkg/environment/magic.go
+++ b/vendor/knative.dev/reconciler-test/pkg/environment/magic.go
@@ -121,8 +121,8 @@ func WithPollTimings(interval, timeout time.Duration) EnvOpts {
 
 // Managed enables auto-lifecycle management of the environment. Including
 // registration of following opts:
-//  - Cleanup,
-//  - WithTestLogger.
+//   - Cleanup,
+//   - WithTestLogger.
 func Managed(t feature.T) EnvOpts {
 	return UnionOpts(Cleanup(t), WithTestLogger(t))
 }
diff --git a/vendor/knative.dev/reconciler-test/pkg/eventshub/103-pod.yaml b/vendor/knative.dev/reconciler-test/pkg/eventshub/103-pod.yaml
index da12b92a2..2b8ad28d3 100644
--- a/vendor/knative.dev/reconciler-test/pkg/eventshub/103-pod.yaml
+++ b/vendor/knative.dev/reconciler-test/pkg/eventshub/103-pod.yaml
@@ -22,8 +22,31 @@ metadata:
 spec:
   serviceAccountName: "{{ .namespace }}"
   restartPolicy: "Never"
+  {{ if .podSecurityContext }}
+  securityContext:
+    runAsNonRoot: {{ .podSecurityContext.runAsNonRoot }}
+    seccompProfile:
+      type: {{ .podSecurityContext.seccompProfile.type }}
+  {{ end }}
   containers:
     - name: eventshub
+      {{ if .containerSecurityContext }}
+      securityContext:
+        capabilities:
+          {{ if .containerSecurityContext.capabilities.drop }}
+          drop:
+            {{ range $_, $value := .containerSecurityContext.capabilities.drop }}
+            - {{ $value }}
+            {{ end }}
+          {{ end }}
+          {{ if .containerSecurityContext.capabilities.add }}
+          add:
+            {{ range $_, $value := .containerSecurityContext.capabilities.add }}
+            - {{ $value }}
+            {{ end }}
+          {{ end }}
+        allowPrivilegeEscalation: {{ .containerSecurityContext.allowPrivilegeEscalation }}
+      {{ end }}
       image: {{ .image }}
       imagePullPolicy: "IfNotPresent"
       {{ if .withReadiness }}
diff --git a/vendor/knative.dev/reconciler-test/pkg/eventshub/resources.go b/vendor/knative.dev/reconciler-test/pkg/eventshub/resources.go
index f1ab17a14..2d1b29682 100644
--- a/vendor/knative.dev/reconciler-test/pkg/eventshub/resources.go
+++ b/vendor/knative.dev/reconciler-test/pkg/eventshub/resources.go
@@ -37,12 +37,12 @@ var templates embed.FS
 // Note: this function expects that the Environment is configured with the
 // following options, otherwise it will panic:
 //
-//   ctx, env := global.Environment(
-//     knative.WithKnativeNamespace("knative-namespace"),
-//     knative.WithLoggingConfig,
-//     knative.WithTracingConfig,
-//     k8s.WithEventListener,
-//   )
+//	ctx, env := global.Environment(
+//	  knative.WithKnativeNamespace("knative-namespace"),
+//	  knative.WithLoggingConfig,
+//	  knative.WithTracingConfig,
+//	  k8s.WithEventListener,
+//	)
 func Install(name string, options ...EventsHubOption) feature.StepFn {
 	return func(ctx context.Context, t feature.T) {
 		if err := registerImage(ctx); err != nil {
@@ -71,13 +71,17 @@ func Install(name string, options ...EventsHubOption) feature.StepFn {
 
 		isReceiver := strings.Contains(envs["EVENT_GENERATORS"], "receiver")
 
-		// Deploy
-		if _, err := manifest.InstallYamlFS(ctx, templates, map[string]interface{}{
+		cfg := map[string]interface{}{
 			"name":          name,
 			"envs":          envs,
 			"image":         ImageFromContext(ctx),
 			"withReadiness": isReceiver,
-		}); err != nil {
+		}
+
+		manifest.PodSecurityCfgFn(ctx, t)(cfg)
+
+		// Deploy
+		if _, err := manifest.InstallYamlFS(ctx, templates, cfg); err != nil {
 			log.Fatal(err)
 		}
 
diff --git a/vendor/knative.dev/reconciler-test/pkg/k8s/pod.go b/vendor/knative.dev/reconciler-test/pkg/k8s/pod.go
index c1276a579..4f6422a80 100644
--- a/vendor/knative.dev/reconciler-test/pkg/k8s/pod.go
+++ b/vendor/knative.dev/reconciler-test/pkg/k8s/pod.go
@@ -26,6 +26,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"knative.dev/pkg/kmeta"
+	pkgsecurity "knative.dev/pkg/test/security"
 )
 
 func GetFirstTerminationMessage(pod *corev1.Pod) string {
@@ -77,3 +78,35 @@ func PodReference(namespace string, name string) (corev1.ObjectReference, error)
 	pod.APIVersion, pod.Kind = kind.ToAPIVersionAndKind()
 	return kmeta.ObjectReference(pod), nil
 }
+
+func WithDefaultPodSecurityContext(cfg map[string]interface{}) {
+	if _, set := cfg["podSecurityContext"]; !set {
+		cfg["podSecurityContext"] = map[string]interface{}{}
+	}
+	podSecurityContext := cfg["podSecurityContext"].(map[string]interface{})
+	podSecurityContext["runAsNonRoot"] = pkgsecurity.DefaultPodSecurityContext.RunAsNonRoot
+	podSecurityContext["seccompProfile"] = map[string]interface{}{}
+	seccompProfile := podSecurityContext["seccompProfile"].(map[string]interface{})
+	seccompProfile["type"] = pkgsecurity.DefaultPodSecurityContext.SeccompProfile.Type
+
+	if _, set := cfg["containerSecurityContext"]; !set {
+		cfg["containerSecurityContext"] = map[string]interface{}{}
+	}
+	containerSecurityContext := cfg["containerSecurityContext"].(map[string]interface{})
+	containerSecurityContext["allowPrivilegeEscalation"] =
+		pkgsecurity.DefaultContainerSecurityContext.AllowPrivilegeEscalation
+	containerSecurityContext["capabilities"] = map[string]interface{}{}
+	capabilities := containerSecurityContext["capabilities"].(map[string]interface{})
+	if len(pkgsecurity.DefaultContainerSecurityContext.Capabilities.Drop) != 0 {
+		capabilities["drop"] = []string{}
+		for _, drop := range pkgsecurity.DefaultContainerSecurityContext.Capabilities.Drop {
+			capabilities["drop"] = append(capabilities["drop"].([]string), string(drop))
+		}
+	}
+	if len(pkgsecurity.DefaultContainerSecurityContext.Capabilities.Add) != 0 {
+		capabilities["add"] = []string{}
+		for _, drop := range pkgsecurity.DefaultContainerSecurityContext.Capabilities.Drop {
+			capabilities["add"] = append(capabilities["add"].([]string), string(drop))
+		}
+	}
+}
diff --git a/vendor/knative.dev/reconciler-test/pkg/manifest/options.go b/vendor/knative.dev/reconciler-test/pkg/manifest/options.go
new file mode 100644
index 000000000..6a9dcf780
--- /dev/null
+++ b/vendor/knative.dev/reconciler-test/pkg/manifest/options.go
@@ -0,0 +1,41 @@
+/*
+Copyright 2022 The Knative 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 manifest
+
+import (
+	"context"
+
+	kubeclient "knative.dev/pkg/client/injection/kube/client"
+	pkgsecurity "knative.dev/pkg/test/security"
+	"knative.dev/reconciler-test/pkg/environment"
+	"knative.dev/reconciler-test/pkg/feature"
+	"knative.dev/reconciler-test/pkg/k8s"
+)
+
+// PodSecurityCfgFn returns a function for configuring security context for Pod, depending
+// on security settings of the enclosing namespace.
+func PodSecurityCfgFn(ctx context.Context, t feature.T) CfgFn {
+	namespace := environment.FromContext(ctx).Namespace()
+	restrictedMode, err := pkgsecurity.IsRestrictedPodSecurityEnforced(ctx, kubeclient.Get(ctx), namespace)
+	if err != nil {
+		t.Fatalf("Error while checking restricted pod security mode for namespace %s", namespace)
+	}
+	if restrictedMode {
+		return k8s.WithDefaultPodSecurityContext
+	}
+	return func(map[string]interface{}) {}
+}
diff --git a/vendor/knative.dev/reconciler-test/pkg/manifest/yaml.go b/vendor/knative.dev/reconciler-test/pkg/manifest/yaml.go
index 8506997f3..40645d8a3 100644
--- a/vendor/knative.dev/reconciler-test/pkg/manifest/yaml.go
+++ b/vendor/knative.dev/reconciler-test/pkg/manifest/yaml.go
@@ -32,14 +32,14 @@ import (
 // Parse parses YAML files into Unstructured objects.
 //
 // It supports 5 cases today:
-// 1. pathname = path to a file --> parses that file.
-// 2. pathname = path to a directory, recursive = false --> parses all files in
-//    that directory.
-// 3. pathname = path to a directory, recursive = true --> parses all files in
-//    that directory and it's descendants
-// 4. pathname = url --> fetches the contents of that URL and parses them as YAML.
-// 5. pathname = combination of all previous cases, the string can contain
-//    multiple records (file, directory or url) separated by comma
+//  1. pathname = path to a file --> parses that file.
+//  2. pathname = path to a directory, recursive = false --> parses all files in
+//     that directory.
+//  3. pathname = path to a directory, recursive = true --> parses all files in
+//     that directory and it's descendants
+//  4. pathname = url --> fetches the contents of that URL and parses them as YAML.
+//  5. pathname = combination of all previous cases, the string can contain
+//     multiple records (file, directory or url) separated by comma
 func Parse(pathname string, recursive bool) ([]unstructured.Unstructured, error) {
 
 	pathnames := strings.Split(pathname, ",")
diff --git a/vendor/knative.dev/reconciler-test/pkg/milestone/emitter.go b/vendor/knative.dev/reconciler-test/pkg/milestone/emitter.go
index 935286917..83a4bbe7b 100644
--- a/vendor/knative.dev/reconciler-test/pkg/milestone/emitter.go
+++ b/vendor/knative.dev/reconciler-test/pkg/milestone/emitter.go
@@ -77,7 +77,6 @@ func NewMilestoneEmitterFromEnv(instance, namespace string) (Emitter, error) {
 }
 
 // NewMilestoneEmitter will convert target uri to a milestone event sender and return it.
-//
 func NewMilestoneEmitter(instance, namespace, uri string) (Emitter, error) {
 	target, err := apis.ParseURL(uri)
 	if err != nil {