Repository: kubernetes-csi/external-snapshotter

Issue:
Need to discuss how to handle the case when a PV is deleted while creating a VolumeGroupSnapshot
<!-- Please use this template while reporting a bug and provide as much info as possible. Not doing so may result in your bug not being addressed in a timely manner. Thanks!
-->


**What happened**:
This was brought up during the code review: https://github.com/kubernetes-csi/external-snapshotter/pull/1171#discussion_r1826010750. If a PV is deleted while creating a VolumeGroupSnapshot, should we bail out and fail the entire VolumeGroupSnapshot creation or should we continue and just leave the field for PV empty. If we do the later, that means we don't have a way to restore the PV that got deleted.

**What you expected to happen**:

**How to reproduce it**:

**Anything else we need to know?**:

**Environment**:
- Driver version:
- Kubernetes version (use `kubectl version`):
- OS (e.g. from /etc/os-release):
- Kernel (e.g. `uname -a`):
- Install tools:
- Others:


Discussion:
@yati1998: in my opinion it would be better to return error that pv has been deleted. Let me know how do you want it to work
cc @xing-yang 
also please feel free to tag people who could answer it better and lets work on it.@yati1998: @jsafrane any decision or suggestion on this?@jsafrane: I think it's fair to create a VolumeSnapshotContent + VolumeSnapshot for such a snapshot, and not to refer to  a PV / PVC in them. It's up to the user to figure out what data is on the snapshot.
I think the current implementation is written this way.@k8s-triage-robot: The Kubernetes project currently lacks enough contributors to adequately respond to all issues.

This bot triages un-triaged issues according to the following rules:
- After 90d of inactivity, `lifecycle/stale` is applied
- After 30d of inactivity since `lifecycle/stale` was applied, `lifecycle/rotten` is applied
- After 30d of inactivity since `lifecycle/rotten` was applied, the issue is closed

You can:
- Mark this issue as fresh with `/remove-lifecycle stale`
- Close this issue with `/close`
- Offer to help out with [Issue Triage][1]

Please send feedback to sig-contributor-experience at [kubernetes/community](https://github.com/kubernetes/community).

/lifecycle stale

[1]: https://www.kubernetes.dev/docs/guide/issue-triage/@k8s-triage-robot: The Kubernetes project currently lacks enough active contributors to adequately respond to all issues.

This bot triages un-triaged issues according to the following rules:
- After 90d of inactivity, `lifecycle/stale` is applied
- After 30d of inactivity since `lifecycle/stale` was applied, `lifecycle/rotten` is applied
- After 30d of inactivity since `lifecycle/rotten` was applied, the issue is closed

You can:
- Mark this issue as fresh with `/remove-lifecycle rotten`
- Close this issue with `/close`
- Offer to help out with [Issue Triage][1]

Please send feedback to sig-contributor-experience at [kubernetes/community](https://github.com/kubernetes/community).

/lifecycle rotten

[1]: https://www.kubernetes.dev/docs/guide/issue-triage/@k8s-triage-robot: The Kubernetes project currently lacks enough active contributors to adequately respond to all issues and PRs.

This bot triages issues according to the following rules:
- After 90d of inactivity, `lifecycle/stale` is applied
- After 30d of inactivity since `lifecycle/stale` was applied, `lifecycle/rotten` is applied
- After 30d of inactivity since `lifecycle/rotten` was applied, the issue is closed

You can:
- Reopen this issue with `/reopen`
- Mark this issue as fresh with `/remove-lifecycle rotten`
- Offer to help out with [Issue Triage][1]

Please send feedback to sig-contributor-experience at [kubernetes/community](https://github.com/kubernetes/community).

/close not-planned

[1]: https://www.kubernetes.dev/docs/guide/issue-triage/@k8s-ci-robot: @k8s-triage-robot: Closing this issue, marking it as "Not Planned".

<details>

In response to [this](https://github.com/kubernetes-csi/external-snapshotter/issues/1183#issuecomment-2815607389):

>The Kubernetes project currently lacks enough active contributors to adequately respond to all issues and PRs.
>
>This bot triages issues according to the following rules:
>- After 90d of inactivity, `lifecycle/stale` is applied
>- After 30d of inactivity since `lifecycle/stale` was applied, `lifecycle/rotten` is applied
>- After 30d of inactivity since `lifecycle/rotten` was applied, the issue is closed
>
>You can:
>- Reopen this issue with `/reopen`
>- Mark this issue as fresh with `/remove-lifecycle rotten`
>- Offer to help out with [Issue Triage][1]
>
>Please send feedback to sig-contributor-experience at [kubernetes/community](https://github.com/kubernetes/community).
>
>/close not-planned
>
>[1]: https://www.kubernetes.dev/docs/guide/issue-triage/


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-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository.
</details>

Solution patch:
diff --git a/deploy/kubernetes/csi-snapshotter/rbac-csi-snapshotter.yaml b/deploy/kubernetes/csi-snapshotter/rbac-csi-snapshotter.yaml
index 837c80b39..f5ffa19c9 100644
--- a/deploy/kubernetes/csi-snapshotter/rbac-csi-snapshotter.yaml
+++ b/deploy/kubernetes/csi-snapshotter/rbac-csi-snapshotter.yaml
@@ -34,12 +34,9 @@ rules:
   - apiGroups: ["snapshot.storage.k8s.io"]
     resources: ["volumesnapshotclasses"]
     verbs: ["get", "list", "watch"]
-  - apiGroups: ["snapshot.storage.k8s.io"]
-    resources: ["volumesnapshots"]
-    verbs: ["get", "list", "watch", "update", "patch", "create"]
   - apiGroups: ["snapshot.storage.k8s.io"]
     resources: ["volumesnapshotcontents"]
-    verbs: ["get", "list", "watch", "update", "patch", "create"]
+    verbs: ["get", "list", "watch", "update", "patch"]
   - apiGroups: ["snapshot.storage.k8s.io"]
     resources: ["volumesnapshotcontents/status"]
     verbs: ["update", "patch"]
diff --git a/deploy/kubernetes/snapshot-controller/rbac-snapshot-controller.yaml b/deploy/kubernetes/snapshot-controller/rbac-snapshot-controller.yaml
index 336c7100f..5571fbfc5 100644
--- a/deploy/kubernetes/snapshot-controller/rbac-snapshot-controller.yaml
+++ b/deploy/kubernetes/snapshot-controller/rbac-snapshot-controller.yaml
@@ -38,7 +38,7 @@ rules:
     verbs: ["patch"]
   - apiGroups: ["snapshot.storage.k8s.io"]
     resources: ["volumesnapshots"]
-    verbs: ["get", "list", "watch", "update", "patch", "delete"]
+    verbs: ["create", "get", "list", "watch", "update", "patch", "delete"]
   - apiGroups: ["snapshot.storage.k8s.io"]
     resources: ["volumesnapshots/status"]
     verbs: ["update", "patch"]
diff --git a/go.mod b/go.mod
index b5280a422..a4880cf13 100644
--- a/go.mod
+++ b/go.mod
@@ -3,13 +3,14 @@ module github.com/kubernetes-csi/external-snapshotter/v8
 go 1.23.1
 
 require (
-	github.com/container-storage-interface/spec v1.9.0
+	// TODO: update version once it is officially released
+	github.com/container-storage-interface/spec v1.10.1-0.20241022120259-f6b6d53db606
 	github.com/evanphx/json-patch v5.9.0+incompatible
 	github.com/fsnotify/fsnotify v1.8.0
 	github.com/golang/mock v1.6.0
 	github.com/google/gofuzz v1.2.0
 	github.com/kubernetes-csi/csi-lib-utils v0.19.0
-	github.com/kubernetes-csi/csi-test/v5 v5.2.0
+	github.com/kubernetes-csi/csi-test/v5 v5.3.1
 	github.com/kubernetes-csi/external-snapshotter/client/v8 v8.0.0
 	github.com/prometheus/client_golang v1.20.5
 	github.com/prometheus/client_model v0.6.1
diff --git a/go.sum b/go.sum
index 3aa7a8914..41cd2f3fe 100644
--- a/go.sum
+++ b/go.sum
@@ -4,8 +4,8 @@ github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM
 github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/container-storage-interface/spec v1.9.0 h1:zKtX4STsq31Knz3gciCYCi1SXtO2HJDecIjDVboYavY=
-github.com/container-storage-interface/spec v1.9.0/go.mod h1:ZfDu+3ZRyeVqxZM0Ds19MVLkN2d1XJ5MAfi1L3VjlT0=
+github.com/container-storage-interface/spec v1.10.1-0.20241022120259-f6b6d53db606 h1:PtXpku0GhORJLv9g2RRenXXdmJB+dklYJXSeJePxPmo=
+github.com/container-storage-interface/spec v1.10.1-0.20241022120259-f6b6d53db606/go.mod h1:DtUvaQszPml1YJfIK7c00mlv6/g4wNMLanLgiUbKFRI=
 github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -71,8 +71,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kubernetes-csi/csi-lib-utils v0.19.0 h1:3sT8mL9+St2acyrEtuR7CQ5L78GR4lgsb+sfon9tGfA=
 github.com/kubernetes-csi/csi-lib-utils v0.19.0/go.mod h1:lBuMKvoyd8c3EG+itmnVWApLDHnLkU7ibxxZSPuOw0M=
-github.com/kubernetes-csi/csi-test/v5 v5.2.0 h1:Z+sdARWC6VrONrxB24clCLCmnqCnZF7dzXtzx8eM35o=
-github.com/kubernetes-csi/csi-test/v5 v5.2.0/go.mod h1:o/c5w+NU3RUNE+DbVRhEUTmkQVBGk+tFOB2yPXT8teo=
+github.com/kubernetes-csi/csi-test/v5 v5.3.1 h1:Wiukp1In+kif+BFo6q2ExjgB+MbrAz4jZWzGfijypuY=
+github.com/kubernetes-csi/csi-test/v5 v5.3.1/go.mod h1:7hA2cSYJ6T8CraEZPA6zqkLZwemjBD54XAnPsPC3VpA=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
diff --git a/pkg/common-controller/groupsnapshot_controller_helper.go b/pkg/common-controller/groupsnapshot_controller_helper.go
index f118b30ca..f317a3837 100644
--- a/pkg/common-controller/groupsnapshot_controller_helper.go
+++ b/pkg/common-controller/groupsnapshot_controller_helper.go
@@ -18,6 +18,7 @@ package common_controller
 
 import (
 	"context"
+	"crypto/sha256"
 	"fmt"
 	"time"
 
@@ -459,16 +460,24 @@ func (ctrl *csiSnapshotCommonController) syncUnreadyGroupSnapshot(groupSnapshot
 			return fmt.Errorf("VolumeGroupSnapshotHandle should not be set in the group snapshot content for dynamic provisioning for group snapshot %s", uniqueGroupSnapshotName)
 		}
 
-		newGroupSnapshot, err := ctrl.bindandUpdateVolumeGroupSnapshot(contentObj, groupSnapshot)
+		// TODO(leonardoce): introduce a current context in this function
+		newGroupSnapshotContentObj, err := ctrl.createSnapshotsForGroupSnapshotContent(context.TODO(), contentObj, groupSnapshot)
+		if err != nil {
+			klog.V(4).Infof("createSnapshotsForGroupSnapshotContent[%s]: failed to create snapshots and snapshotcontents for group snapshot %v: %v",
+				contentObj.Name, groupSnapshot.Name, err.Error())
+			return err
+		}
+
+		updatedGroupSnapshot, err := ctrl.bindandUpdateVolumeGroupSnapshot(newGroupSnapshotContentObj, groupSnapshot)
 		if err != nil {
 			klog.V(4).Infof("bindandUpdateVolumeGroupSnapshot[%s]: failed to bind group snapshot content [%s] to group snapshot %v", uniqueGroupSnapshotName, contentObj.Name, err)
 			return err
 		}
-		klog.V(5).Infof("bindandUpdateVolumeGroupSnapshot %v", newGroupSnapshot)
+		klog.V(5).Infof("bindandUpdateVolumeGroupSnapshot %v", updatedGroupSnapshot)
 		return nil
 	}
 
-	// If we reach here, it is a dynamically provisioned group snapshot, and the VolumeGroupSnapshotContent object is not yet created.
+	// If reach here, it is a dynamically provisioned group snapshot, and the VolumeGroupSnapshotContent object is not yet created.
 	var groupSnapshotContent *crdv1alpha1.VolumeGroupSnapshotContent
 	if groupSnapshotContent, err = ctrl.createGroupSnapshotContent(groupSnapshot); err != nil {
 		ctrl.updateGroupSnapshotErrorStatusWithEvent(groupSnapshot, true, v1.EventTypeWarning, "GroupSnapshotContentCreationFailed", fmt.Sprintf("failed to create group snapshot content with error %v", err))
@@ -485,6 +494,182 @@ func (ctrl *csiSnapshotCommonController) syncUnreadyGroupSnapshot(groupSnapshot
 	return nil
 }
 
+func (ctrl *csiSnapshotCommonController) createSnapshotsForGroupSnapshotContent(
+	ctx context.Context,
+	groupSnapshotContent *crdv1alpha1.VolumeGroupSnapshotContent,
+	groupSnapshot *crdv1alpha1.VolumeGroupSnapshot,
+) (*crdv1alpha1.VolumeGroupSnapshotContent, error) {
+	// No status is present, or no volume snapshot was provisioned.
+	// Let's wait for the snapshotter sidecar to fill it.
+	if groupSnapshotContent.Status == nil || len(groupSnapshotContent.Status.VolumeSnapshotHandlePairList) == 0 {
+		return groupSnapshotContent, nil
+	}
+
+	// The contents of the volume group snapshot class are needed to set the
+	// metadata containing the secrets to recover the snapshots
+	if groupSnapshot.Spec.VolumeGroupSnapshotClassName == nil {
+		return groupSnapshotContent, fmt.Errorf(
+			"createSnapshotsForGroupSnapshotContent: internal error: cannot find reference to volume group snapshot class")
+	}
+
+	groupSnapshotClass, err := ctrl.groupSnapshotClassLister.Get(*groupSnapshot.Spec.VolumeGroupSnapshotClassName)
+	if err != nil {
+		return groupSnapshotContent, fmt.Errorf(
+			"createSnapshotsForGroupSnapshotContent: failed to get volume snapshot class %s: %q",
+			*groupSnapshot.Spec.VolumeGroupSnapshotClassName, err)
+	}
+
+	groupSnapshotSecret, err := utils.GetGroupSnapshotSecretReference(
+		utils.GroupSnapshotterSecretParams,
+		groupSnapshotClass.Parameters,
+		groupSnapshotContent.GetObjectMeta().GetName(), nil)
+	if err != nil {
+		return groupSnapshotContent, fmt.Errorf(
+			"createSnapshotsForGroupSnapshotContent: failed to get secret reference for group snapshot content %s: %v",
+			groupSnapshotContent.Name, err)
+	}
+
+	// TODO(leonardoce): this API server call is very expensive. We need to introduce a
+	// PV lister on the controller and an indexer on spec.csi.driver + "^" + spec.csi.volumeHandle
+	// to be used for fast lookups
+	pvs, err := ctrl.client.CoreV1().PersistentVolumes().List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		return groupSnapshotContent, fmt.Errorf("createSnapshotsForGroupSnapshotContent: error get PersistentVolumes list from API server: %v", err)
+	}
+
+	// Phase 1: create the VolumeSnapshotContent and VolumeSnapshot objects
+	klog.V(4).Infof(
+		"createSnapshotsForGroupSnapshotContent[%s]: creating volumesnapshots and volumesnapshotcontent for group snapshot content",
+		groupSnapshotContent.Name)
+
+	groupSnapshotContent.Status.PVVolumeSnapshotContentList = make(
+		[]crdv1alpha1.PVVolumeSnapshotContentPair,
+		len(groupSnapshotContent.Status.VolumeSnapshotHandlePairList),
+	)
+	for i, snapshot := range groupSnapshotContent.Status.VolumeSnapshotHandlePairList {
+		snapshotHandle := snapshot.SnapshotHandle
+		volumeHandle := snapshot.VolumeHandle
+
+		pv := utils.GetPersistentVolumeFromHandle(pvs, groupSnapshotContent.Spec.Driver, volumeHandle)
+		if pv == nil {
+			klog.Errorf(
+				"updateGroupSnapshotContentStatus: unable to find PV for volumeHandle:[%s] and CSI driver:[%s]",
+				volumeHandle,
+				groupSnapshotContent.Spec.Driver)
+		}
+
+		volumeSnapshotContentName := getSnapshotContentNameForVolumeGroupSnapshotContent(
+			string(groupSnapshotContent.UID), volumeHandle)
+
+		volumeSnapshotName := getSnapshotNameForVolumeGroupSnapshotContent(
+			string(groupSnapshotContent.UID), volumeHandle)
+
+		volumeSnapshotNamespace := groupSnapshotContent.Spec.VolumeGroupSnapshotRef.Namespace
+
+		volumeSnapshotContent := &crdv1.VolumeSnapshotContent{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: volumeSnapshotContentName,
+			},
+			Spec: crdv1.VolumeSnapshotContentSpec{
+				VolumeSnapshotRef: v1.ObjectReference{
+					Kind:      "VolumeSnapshot",
+					Name:      volumeSnapshotName,
+					Namespace: volumeSnapshotNamespace,
+				},
+				DeletionPolicy: groupSnapshotContent.Spec.DeletionPolicy,
+				Driver:         groupSnapshotContent.Spec.Driver,
+				Source: crdv1.VolumeSnapshotContentSource{
+					SnapshotHandle: &snapshotHandle,
+				},
+			},
+			// The status will be set by VolumeSnapshotContent reconciler
+			// in the CSI snapshotter sidecar.
+		}
+
+		if pv != nil {
+			volumeSnapshotContent.Spec.SourceVolumeMode = pv.Spec.VolumeMode
+		}
+
+		if groupSnapshotSecret != nil {
+			klog.V(5).Infof("createSnapshotsForGroupSnapshotContent: set annotation [%s] on volume snapshot content [%s].", utils.AnnDeletionSecretRefName, volumeSnapshotContent.Name)
+			metav1.SetMetaDataAnnotation(&volumeSnapshotContent.ObjectMeta, utils.AnnDeletionSecretRefName, groupSnapshotSecret.Name)
+
+			klog.V(5).Infof("createSnapshotsForGroupSnapshotContent: set annotation [%s] on volume snapshot content [%s].", utils.AnnDeletionSecretRefNamespace, volumeSnapshotContent.Name)
+			metav1.SetMetaDataAnnotation(&volumeSnapshotContent.ObjectMeta, utils.AnnDeletionSecretRefNamespace, groupSnapshotSecret.Namespace)
+		}
+
+		label := make(map[string]string)
+		label[utils.VolumeGroupSnapshotNameLabel] = groupSnapshotContent.Spec.VolumeGroupSnapshotRef.Name
+		volumeSnapshot := &crdv1.VolumeSnapshot{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:       volumeSnapshotName,
+				Namespace:  volumeSnapshotNamespace,
+				Labels:     label,
+				Finalizers: []string{utils.VolumeSnapshotInGroupFinalizer},
+			},
+			Spec: crdv1.VolumeSnapshotSpec{
+				Source: crdv1.VolumeSnapshotSource{
+					VolumeSnapshotContentName: &volumeSnapshotContentName,
+				},
+			},
+			// The status will be set by VolumeSnapshot reconciler
+		}
+
+		_, err := ctrl.clientset.SnapshotV1().VolumeSnapshotContents().Create(ctx, volumeSnapshotContent, metav1.CreateOptions{})
+		if err != nil && !apierrs.IsAlreadyExists(err) {
+			return groupSnapshotContent, fmt.Errorf(
+				"createSnapshotsForGroupSnapshotContent: creating volumesnapshotcontent %w", err)
+		}
+
+		_, err = ctrl.clientset.SnapshotV1().VolumeSnapshots(volumeSnapshotNamespace).Create(ctx, volumeSnapshot, metav1.CreateOptions{})
+		if err != nil && !apierrs.IsAlreadyExists(err) {
+			return groupSnapshotContent, fmt.Errorf(
+				"createSnapshotsForGroupSnapshotContent: creating volumesnapshot %w", err)
+		}
+
+		groupSnapshotContent.Status.PVVolumeSnapshotContentList[i] = crdv1alpha1.PVVolumeSnapshotContentPair{
+			VolumeSnapshotContentRef: v1.LocalObjectReference{
+				Name: volumeSnapshotContentName,
+			},
+		}
+		if pv != nil {
+			groupSnapshotContent.Status.PVVolumeSnapshotContentList[i].PersistentVolumeRef = v1.LocalObjectReference{
+				Name: pv.Name,
+			}
+		}
+	}
+
+	// Phase 2: set the backlinks
+	var patches []utils.PatchOp
+	patches = append(patches, utils.PatchOp{
+		Op:    "replace",
+		Path:  "/status/pvVolumeSnapshotContentList",
+		Value: groupSnapshotContent.Status.PVVolumeSnapshotContentList,
+	})
+
+	newGroupSnapshotObj, err := utils.PatchVolumeGroupSnapshotContent(
+		groupSnapshotContent,
+		patches,
+		ctrl.clientset,
+		"status")
+	if err != nil {
+		return nil, newControllerUpdateError(utils.GroupSnapshotKey(groupSnapshot), err.Error())
+	}
+
+	return newGroupSnapshotObj, nil
+}
+
+// getSnapshotNameForVolumeGroupSnapshotContent returns a unique snapshot name for a VolumeGroupSnapshotContent.
+func getSnapshotNameForVolumeGroupSnapshotContent(groupSnapshotContentUUID, volumeHandle string) string {
+	return fmt.Sprintf("snapshot-%x", sha256.Sum256([]byte(groupSnapshotContentUUID+volumeHandle)))
+}
+
+// getSnapshotContentNameForVolumeGroupSnapshotContent returns a unique content name for the
+// passed in VolumeGroupSnapshotContent.
+func getSnapshotContentNameForVolumeGroupSnapshotContent(groupSnapshotContentUUID, volumeHandle string) string {
+	return fmt.Sprintf("snapcontent-%x", sha256.Sum256([]byte(groupSnapshotContentUUID+volumeHandle)))
+}
+
 // getPreprovisionedGroupSnapshotContentFromStore tries to find a pre-provisioned
 // volume group snapshot content object from group snapshot content cache store
 // for the passed in VolumeGroupSnapshot.
diff --git a/pkg/sidecar-controller/groupsnapshot_helper.go b/pkg/sidecar-controller/groupsnapshot_helper.go
index e586fe6ae..053c842ae 100644
--- a/pkg/sidecar-controller/groupsnapshot_helper.go
+++ b/pkg/sidecar-controller/groupsnapshot_helper.go
@@ -38,9 +38,8 @@ import (
 // snapshotContentNameVolumeHandlePair represent the link between a VolumeSnapshotContent and
 // the handle of the volume that was snapshotted
 type snapshotContentNameVolumeHandlePair struct {
-	snapshotContentName string
-	snapshotHandle      string
-	volumeHandle        string
+	snapshotHandle string
+	volumeHandle   string
 }
 
 func (ctrl *csiSnapshotSideCarController) storeGroupSnapshotContentUpdate(groupSnapshotContent interface{}) (bool, error) {
@@ -432,81 +431,13 @@ func (ctrl *csiSnapshotSideCarController) createGroupSnapshotWrapper(groupSnapsh
 		creationTime = time.Now()
 	}
 
-	groupSnapshotSecret, err := utils.GetGroupSnapshotSecretReference(utils.GroupSnapshotterSecretParams, class.Parameters, groupSnapshotContent.GetObjectMeta().GetName(), nil)
-	if err != nil {
-		klog.Errorf("Failed to get secret reference for group snapshot content %s: %v", groupSnapshotContent.Name, err)
-		return groupSnapshotContent, fmt.Errorf("failed to get secret reference for group snapshot content %s: %v", groupSnapshotContent.Name, err)
-	}
 	// Create individual snapshots and snapshot contents
 	var snapshotContentLinks []snapshotContentNameVolumeHandlePair
 	for _, snapshot := range snapshots {
-		volumeSnapshotContentName := GetSnapshotContentNameForVolumeGroupSnapshotContent(string(groupSnapshotContent.UID), snapshot.SourceVolumeId)
-		volumeSnapshotName := GetSnapshotNameForVolumeGroupSnapshotContent(string(groupSnapshotContent.UID), snapshot.SourceVolumeId)
-		volumeSnapshotNamespace := groupSnapshotContent.Spec.VolumeGroupSnapshotRef.Namespace
-		volumeSnapshotContent := &crdv1.VolumeSnapshotContent{
-			ObjectMeta: metav1.ObjectMeta{
-				Name: volumeSnapshotContentName,
-			},
-			Spec: crdv1.VolumeSnapshotContentSpec{
-				VolumeSnapshotRef: v1.ObjectReference{
-					Kind:      "VolumeSnapshots",
-					Name:      volumeSnapshotName,
-					Namespace: volumeSnapshotNamespace,
-				},
-				DeletionPolicy: groupSnapshotContent.Spec.DeletionPolicy,
-				Driver:         groupSnapshotContent.Spec.Driver,
-				Source: crdv1.VolumeSnapshotContentSource{
-					SnapshotHandle: &snapshot.SnapshotId,
-				},
-				// TODO: Populate this field when volume mode conversion is enabled by default
-				SourceVolumeMode: nil,
-			},
-			Status: &crdv1.VolumeSnapshotContentStatus{
-				VolumeGroupSnapshotHandle: &groupSnapshotContent.Name,
-			},
-		}
-
-		if groupSnapshotSecret != nil {
-			klog.V(5).Infof("createGroupSnapshotContent: set annotation [%s] on volume snapshot content [%s].", utils.AnnDeletionSecretRefName, volumeSnapshotContent.Name)
-			metav1.SetMetaDataAnnotation(&volumeSnapshotContent.ObjectMeta, utils.AnnDeletionSecretRefName, groupSnapshotSecret.Name)
-
-			klog.V(5).Infof("createGroupSnapshotContent: set annotation [%s] on volume snapshot content [%s].", utils.AnnDeletionSecretRefNamespace, volumeSnapshotContent.Name)
-			metav1.SetMetaDataAnnotation(&volumeSnapshotContent.ObjectMeta, utils.AnnDeletionSecretRefNamespace, groupSnapshotSecret.Namespace)
-		}
-		label := make(map[string]string)
-		label["volumeGroupSnapshotName"] = groupSnapshotContent.Spec.VolumeGroupSnapshotRef.Name
-		volumeSnapshot := &crdv1.VolumeSnapshot{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:       volumeSnapshotName,
-				Namespace:  volumeSnapshotNamespace,
-				Labels:     label,
-				Finalizers: []string{utils.VolumeSnapshotInGroupFinalizer},
-			},
-			Spec: crdv1.VolumeSnapshotSpec{
-				Source: crdv1.VolumeSnapshotSource{
-					VolumeSnapshotContentName: &volumeSnapshotContentName,
-				},
-			},
-		}
-		vsc, err := ctrl.clientset.SnapshotV1().VolumeSnapshotContents().Create(context.TODO(), volumeSnapshotContent, metav1.CreateOptions{})
-		if err != nil {
-			return groupSnapshotContent, err
-		}
 		snapshotContentLinks = append(snapshotContentLinks, snapshotContentNameVolumeHandlePair{
-			snapshotContentName: vsc.Name,
-			snapshotHandle:      snapshot.SnapshotId,
-			volumeHandle:        snapshot.SourceVolumeId,
+			snapshotHandle: snapshot.SnapshotId,
+			volumeHandle:   snapshot.SourceVolumeId,
 		})
-
-		_, err = ctrl.clientset.SnapshotV1().VolumeSnapshots(volumeSnapshotNamespace).Create(context.TODO(), volumeSnapshot, metav1.CreateOptions{})
-		if err != nil {
-			return groupSnapshotContent, err
-		}
-
-		_, err = ctrl.updateSnapshotContentStatus(volumeSnapshotContent, snapshot.SnapshotId, snapshot.ReadyToUse, snapshot.CreationTime.AsTime().UnixNano(), snapshot.SizeBytes, groupSnapshotID)
-		if err != nil {
-			return groupSnapshotContent, err
-		}
 	}
 
 	newGroupSnapshotContent, err := ctrl.updateGroupSnapshotContentStatus(groupSnapshotContent, groupSnapshotID, readyToUse, creationTime.UnixNano(), snapshotContentLinks)
@@ -654,11 +585,6 @@ func (ctrl *csiSnapshotSideCarController) updateGroupSnapshotContentStatus(
 		return nil, fmt.Errorf("error get group snapshot content %s from api server: %v", groupSnapshotContent.Name, err)
 	}
 
-	pvs, err := ctrl.client.CoreV1().PersistentVolumes().List(context.TODO(), metav1.ListOptions{})
-	if err != nil {
-		return nil, fmt.Errorf("error get PersistentVolumes list from API server: %v", err)
-	}
-
 	var newStatus *crdv1alpha1.VolumeGroupSnapshotContentStatus
 	updated := false
 	if groupSnapshotContentObj.Status == nil {
@@ -668,25 +594,6 @@ func (ctrl *csiSnapshotSideCarController) updateGroupSnapshotContentStatus(
 			CreationTime:              &createdAt,
 		}
 		for _, snapshotContentLink := range snapshotContentLinks {
-			pv := utils.GetPersistentVolumeFromHandle(pvs, groupSnapshotContent.Spec.Driver, snapshotContentLink.volumeHandle)
-			pvName := ""
-			if pv != nil {
-				pvName = pv.Name
-			} else {
-				klog.Errorf(
-					"updateGroupSnapshotContentStatus: unable to find PV for volumeHandle:[%s] and CSI driver:[%s]",
-					snapshotContentLink.volumeHandle,
-					groupSnapshotContent.Spec.Driver)
-			}
-
-			newStatus.PVVolumeSnapshotContentList = append(newStatus.PVVolumeSnapshotContentList, crdv1alpha1.PVVolumeSnapshotContentPair{
-				VolumeSnapshotContentRef: v1.LocalObjectReference{
-					Name: snapshotContentLink.snapshotContentName,
-				},
-				PersistentVolumeRef: v1.LocalObjectReference{
-					Name: pvName,
-				},
-			})
 
 			newStatus.VolumeSnapshotHandlePairList = append(newStatus.VolumeSnapshotHandlePairList, crdv1alpha1.VolumeSnapshotHandlePair{
 				VolumeHandle:   snapshotContentLink.volumeHandle,
@@ -712,30 +619,6 @@ func (ctrl *csiSnapshotSideCarController) updateGroupSnapshotContentStatus(
 			newStatus.CreationTime = &createdAt
 			updated = true
 		}
-		if len(newStatus.PVVolumeSnapshotContentList) == 0 {
-			for _, snapshotContentLink := range snapshotContentLinks {
-				pv := utils.GetPersistentVolumeFromHandle(pvs, groupSnapshotContent.Spec.Driver, snapshotContentLink.volumeHandle)
-				pvName := ""
-				if pv != nil {
-					pvName = pv.Name
-				} else {
-					klog.Errorf(
-						"updateGroupSnapshotContentStatus: unable to find PV for volumeHandle:[%s] and CSI driver:[%s] (existing status)",
-						snapshotContentLink.volumeHandle,
-						groupSnapshotContent.Spec.Driver)
-				}
-
-				newStatus.PVVolumeSnapshotContentList = append(newStatus.PVVolumeSnapshotContentList, crdv1alpha1.PVVolumeSnapshotContentPair{
-					VolumeSnapshotContentRef: v1.LocalObjectReference{
-						Name: snapshotContentLink.snapshotContentName,
-					},
-					PersistentVolumeRef: v1.LocalObjectReference{
-						Name: pvName,
-					},
-				})
-			}
-			updated = true
-		}
 		if len(newStatus.VolumeSnapshotHandlePairList) == 0 {
 			for _, snapshotContentLink := range snapshotContentLinks {
 				newStatus.VolumeSnapshotHandlePairList = append(newStatus.VolumeSnapshotHandlePairList, crdv1alpha1.VolumeSnapshotHandlePair{
diff --git a/pkg/utils/util.go b/pkg/utils/util.go
index 1c7c7c949..ee3326bc9 100644
--- a/pkg/utils/util.go
+++ b/pkg/utils/util.go
@@ -143,6 +143,10 @@ const (
 	AnnDeletionGroupSecretRefName      = "groupsnapshot.storage.kubernetes.io/deletion-secret-name"
 	AnnDeletionGroupSecretRefNamespace = "groupsnapshot.storage.kubernetes.io/deletion-secret-namespace"
 
+	// VolumeGroupSnapshotNameLabel is applied to VolumeSnapshots that are member
+	// of a VolumeGroupSnapshot, and indicates the name of the latter.
+	VolumeGroupSnapshotNameLabel = "groupsnapshot.storage.k8s.io/volumeGroupSnapshotName"
+
 	// VolumeSnapshotContentInvalidLabel is applied to invalid content as a label key. The value does not matter.
 	// See https://github.com/kubernetes/enhancements/blob/master/keps/sig-storage/177-volume-snapshot/tighten-validation-webhook-crd.md#automatic-labelling-of-invalid-objects
 	VolumeSnapshotContentInvalidLabel = "snapshot.storage.kubernetes.io/invalid-snapshot-content-resource"
diff --git a/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi.pb.go b/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi.pb.go
index ad6cc651c..e763bc3ea 100644
--- a/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi.pb.go
+++ b/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi.pb.go
@@ -1,31 +1,82 @@
+// Code generated by make; DO NOT EDIT.
+
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/container-storage-interface/spec/csi.proto
+// versions:
+// 	protoc-gen-go v1.33.0
+// 	protoc        v4.25.2
+// source: csi.proto
 
 package csi
 
 import (
-	context "context"
-	fmt "fmt"
-	proto "github.com/golang/protobuf/proto"
-	descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
-	timestamp "github.com/golang/protobuf/ptypes/timestamp"
-	wrappers "github.com/golang/protobuf/ptypes/wrappers"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-	math "math"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type BlockMetadataType int32
+
+const (
+	BlockMetadataType_UNKNOWN BlockMetadataType = 0
+	// The FIXED_LENGTH value indicates that data ranges are
+	// returned in fixed size blocks.
+	BlockMetadataType_FIXED_LENGTH BlockMetadataType = 1
+	// The VARIABLE_LENGTH value indicates that data ranges
+	// are returned in potentially variable sized extents.
+	BlockMetadataType_VARIABLE_LENGTH BlockMetadataType = 2
 )
 
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
+// Enum value maps for BlockMetadataType.
+var (
+	BlockMetadataType_name = map[int32]string{
+		0: "UNKNOWN",
+		1: "FIXED_LENGTH",
+		2: "VARIABLE_LENGTH",
+	}
+	BlockMetadataType_value = map[string]int32{
+		"UNKNOWN":         0,
+		"FIXED_LENGTH":    1,
+		"VARIABLE_LENGTH": 2,
+	}
+)
+
+func (x BlockMetadataType) Enum() *BlockMetadataType {
+	p := new(BlockMetadataType)
+	*p = x
+	return p
+}
+
+func (x BlockMetadataType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (BlockMetadataType) Descriptor() protoreflect.EnumDescriptor {
+	return file_csi_proto_enumTypes[0].Descriptor()
+}
+
+func (BlockMetadataType) Type() protoreflect.EnumType {
+	return &file_csi_proto_enumTypes[0]
+}
+
+func (x BlockMetadataType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+// Deprecated: Use BlockMetadataType.Descriptor instead.
+func (BlockMetadataType) EnumDescriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{0}
+}
 
 type PluginCapability_Service_Type int32
 
@@ -55,28 +106,58 @@ const (
 	// well as specific RPCs as indicated by
 	// GroupControllerGetCapabilities.
 	PluginCapability_Service_GROUP_CONTROLLER_SERVICE PluginCapability_Service_Type = 3
+	// SNAPSHOT_METADATA_SERVICE indicates that the Plugin provides
+	// RPCs to retrieve metadata on the allocated blocks of a single
+	// snapshot, or the changed blocks between a pair of snapshots of
+	// the same block volume.
+	// The presence of this capability determines whether the CO will
+	// attempt to invoke the OPTIONAL SnapshotMetadata service RPCs.
+	PluginCapability_Service_SNAPSHOT_METADATA_SERVICE PluginCapability_Service_Type = 4
 )
 
-var PluginCapability_Service_Type_name = map[int32]string{
-	0: "UNKNOWN",
-	1: "CONTROLLER_SERVICE",
-	2: "VOLUME_ACCESSIBILITY_CONSTRAINTS",
-	3: "GROUP_CONTROLLER_SERVICE",
-}
+// Enum value maps for PluginCapability_Service_Type.
+var (
+	PluginCapability_Service_Type_name = map[int32]string{
+		0: "UNKNOWN",
+		1: "CONTROLLER_SERVICE",
+		2: "VOLUME_ACCESSIBILITY_CONSTRAINTS",
+		3: "GROUP_CONTROLLER_SERVICE",
+		4: "SNAPSHOT_METADATA_SERVICE",
+	}
+	PluginCapability_Service_Type_value = map[string]int32{
+		"UNKNOWN":                          0,
+		"CONTROLLER_SERVICE":               1,
+		"VOLUME_ACCESSIBILITY_CONSTRAINTS": 2,
+		"GROUP_CONTROLLER_SERVICE":         3,
+		"SNAPSHOT_METADATA_SERVICE":        4,
+	}
+)
 
-var PluginCapability_Service_Type_value = map[string]int32{
-	"UNKNOWN":                          0,
-	"CONTROLLER_SERVICE":               1,
-	"VOLUME_ACCESSIBILITY_CONSTRAINTS": 2,
-	"GROUP_CONTROLLER_SERVICE":         3,
+func (x PluginCapability_Service_Type) Enum() *PluginCapability_Service_Type {
+	p := new(PluginCapability_Service_Type)
+	*p = x
+	return p
 }
 
 func (x PluginCapability_Service_Type) String() string {
-	return proto.EnumName(PluginCapability_Service_Type_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (PluginCapability_Service_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_csi_proto_enumTypes[1].Descriptor()
+}
+
+func (PluginCapability_Service_Type) Type() protoreflect.EnumType {
+	return &file_csi_proto_enumTypes[1]
+}
+
+func (x PluginCapability_Service_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
+// Deprecated: Use PluginCapability_Service_Type.Descriptor instead.
 func (PluginCapability_Service_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{4, 0, 0}
+	return file_csi_proto_rawDescGZIP(), []int{4, 0, 0}
 }
 
 type PluginCapability_VolumeExpansion_Type int32
@@ -126,24 +207,45 @@ const (
 	PluginCapability_VolumeExpansion_OFFLINE PluginCapability_VolumeExpansion_Type = 2
 )
 
-var PluginCapability_VolumeExpansion_Type_name = map[int32]string{
-	0: "UNKNOWN",
-	1: "ONLINE",
-	2: "OFFLINE",
-}
+// Enum value maps for PluginCapability_VolumeExpansion_Type.
+var (
+	PluginCapability_VolumeExpansion_Type_name = map[int32]string{
+		0: "UNKNOWN",
+		1: "ONLINE",
+		2: "OFFLINE",
+	}
+	PluginCapability_VolumeExpansion_Type_value = map[string]int32{
+		"UNKNOWN": 0,
+		"ONLINE":  1,
+		"OFFLINE": 2,
+	}
+)
 
-var PluginCapability_VolumeExpansion_Type_value = map[string]int32{
-	"UNKNOWN": 0,
-	"ONLINE":  1,
-	"OFFLINE": 2,
+func (x PluginCapability_VolumeExpansion_Type) Enum() *PluginCapability_VolumeExpansion_Type {
+	p := new(PluginCapability_VolumeExpansion_Type)
+	*p = x
+	return p
 }
 
 func (x PluginCapability_VolumeExpansion_Type) String() string {
-	return proto.EnumName(PluginCapability_VolumeExpansion_Type_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (PluginCapability_VolumeExpansion_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_csi_proto_enumTypes[2].Descriptor()
+}
+
+func (PluginCapability_VolumeExpansion_Type) Type() protoreflect.EnumType {
+	return &file_csi_proto_enumTypes[2]
 }
 
+func (x PluginCapability_VolumeExpansion_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use PluginCapability_VolumeExpansion_Type.Descriptor instead.
 func (PluginCapability_VolumeExpansion_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{4, 1, 0}
+	return file_csi_proto_rawDescGZIP(), []int{4, 1, 0}
 }
 
 type VolumeCapability_AccessMode_Mode int32
@@ -176,34 +278,55 @@ const (
 	VolumeCapability_AccessMode_SINGLE_NODE_MULTI_WRITER VolumeCapability_AccessMode_Mode = 7
 )
 
-var VolumeCapability_AccessMode_Mode_name = map[int32]string{
-	0: "UNKNOWN",
-	1: "SINGLE_NODE_WRITER",
-	2: "SINGLE_NODE_READER_ONLY",
-	3: "MULTI_NODE_READER_ONLY",
-	4: "MULTI_NODE_SINGLE_WRITER",
-	5: "MULTI_NODE_MULTI_WRITER",
-	6: "SINGLE_NODE_SINGLE_WRITER",
-	7: "SINGLE_NODE_MULTI_WRITER",
-}
+// Enum value maps for VolumeCapability_AccessMode_Mode.
+var (
+	VolumeCapability_AccessMode_Mode_name = map[int32]string{
+		0: "UNKNOWN",
+		1: "SINGLE_NODE_WRITER",
+		2: "SINGLE_NODE_READER_ONLY",
+		3: "MULTI_NODE_READER_ONLY",
+		4: "MULTI_NODE_SINGLE_WRITER",
+		5: "MULTI_NODE_MULTI_WRITER",
+		6: "SINGLE_NODE_SINGLE_WRITER",
+		7: "SINGLE_NODE_MULTI_WRITER",
+	}
+	VolumeCapability_AccessMode_Mode_value = map[string]int32{
+		"UNKNOWN":                   0,
+		"SINGLE_NODE_WRITER":        1,
+		"SINGLE_NODE_READER_ONLY":   2,
+		"MULTI_NODE_READER_ONLY":    3,
+		"MULTI_NODE_SINGLE_WRITER":  4,
+		"MULTI_NODE_MULTI_WRITER":   5,
+		"SINGLE_NODE_SINGLE_WRITER": 6,
+		"SINGLE_NODE_MULTI_WRITER":  7,
+	}
+)
 
-var VolumeCapability_AccessMode_Mode_value = map[string]int32{
-	"UNKNOWN":                   0,
-	"SINGLE_NODE_WRITER":        1,
-	"SINGLE_NODE_READER_ONLY":   2,
-	"MULTI_NODE_READER_ONLY":    3,
-	"MULTI_NODE_SINGLE_WRITER":  4,
-	"MULTI_NODE_MULTI_WRITER":   5,
-	"SINGLE_NODE_SINGLE_WRITER": 6,
-	"SINGLE_NODE_MULTI_WRITER":  7,
+func (x VolumeCapability_AccessMode_Mode) Enum() *VolumeCapability_AccessMode_Mode {
+	p := new(VolumeCapability_AccessMode_Mode)
+	*p = x
+	return p
 }
 
 func (x VolumeCapability_AccessMode_Mode) String() string {
-	return proto.EnumName(VolumeCapability_AccessMode_Mode_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (VolumeCapability_AccessMode_Mode) Descriptor() protoreflect.EnumDescriptor {
+	return file_csi_proto_enumTypes[3].Descriptor()
+}
+
+func (VolumeCapability_AccessMode_Mode) Type() protoreflect.EnumType {
+	return &file_csi_proto_enumTypes[3]
+}
+
+func (x VolumeCapability_AccessMode_Mode) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
+// Deprecated: Use VolumeCapability_AccessMode_Mode.Descriptor instead.
 func (VolumeCapability_AccessMode_Mode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{10, 2, 0}
+	return file_csi_proto_rawDescGZIP(), []int{10, 2, 0}
 }
 
 type ControllerServiceCapability_RPC_Type int32
@@ -265,48 +388,69 @@ const (
 	ControllerServiceCapability_RPC_MODIFY_VOLUME ControllerServiceCapability_RPC_Type = 14
 )
 
-var ControllerServiceCapability_RPC_Type_name = map[int32]string{
-	0:  "UNKNOWN",
-	1:  "CREATE_DELETE_VOLUME",
-	2:  "PUBLISH_UNPUBLISH_VOLUME",
-	3:  "LIST_VOLUMES",
-	4:  "GET_CAPACITY",
-	5:  "CREATE_DELETE_SNAPSHOT",
-	6:  "LIST_SNAPSHOTS",
-	7:  "CLONE_VOLUME",
-	8:  "PUBLISH_READONLY",
-	9:  "EXPAND_VOLUME",
-	10: "LIST_VOLUMES_PUBLISHED_NODES",
-	11: "VOLUME_CONDITION",
-	12: "GET_VOLUME",
-	13: "SINGLE_NODE_MULTI_WRITER",
-	14: "MODIFY_VOLUME",
-}
-
-var ControllerServiceCapability_RPC_Type_value = map[string]int32{
-	"UNKNOWN":                      0,
-	"CREATE_DELETE_VOLUME":         1,
-	"PUBLISH_UNPUBLISH_VOLUME":     2,
-	"LIST_VOLUMES":                 3,
-	"GET_CAPACITY":                 4,
-	"CREATE_DELETE_SNAPSHOT":       5,
-	"LIST_SNAPSHOTS":               6,
-	"CLONE_VOLUME":                 7,
-	"PUBLISH_READONLY":             8,
-	"EXPAND_VOLUME":                9,
-	"LIST_VOLUMES_PUBLISHED_NODES": 10,
-	"VOLUME_CONDITION":             11,
-	"GET_VOLUME":                   12,
-	"SINGLE_NODE_MULTI_WRITER":     13,
-	"MODIFY_VOLUME":                14,
+// Enum value maps for ControllerServiceCapability_RPC_Type.
+var (
+	ControllerServiceCapability_RPC_Type_name = map[int32]string{
+		0:  "UNKNOWN",
+		1:  "CREATE_DELETE_VOLUME",
+		2:  "PUBLISH_UNPUBLISH_VOLUME",
+		3:  "LIST_VOLUMES",
+		4:  "GET_CAPACITY",
+		5:  "CREATE_DELETE_SNAPSHOT",
+		6:  "LIST_SNAPSHOTS",
+		7:  "CLONE_VOLUME",
+		8:  "PUBLISH_READONLY",
+		9:  "EXPAND_VOLUME",
+		10: "LIST_VOLUMES_PUBLISHED_NODES",
+		11: "VOLUME_CONDITION",
+		12: "GET_VOLUME",
+		13: "SINGLE_NODE_MULTI_WRITER",
+		14: "MODIFY_VOLUME",
+	}
+	ControllerServiceCapability_RPC_Type_value = map[string]int32{
+		"UNKNOWN":                      0,
+		"CREATE_DELETE_VOLUME":         1,
+		"PUBLISH_UNPUBLISH_VOLUME":     2,
+		"LIST_VOLUMES":                 3,
+		"GET_CAPACITY":                 4,
+		"CREATE_DELETE_SNAPSHOT":       5,
+		"LIST_SNAPSHOTS":               6,
+		"CLONE_VOLUME":                 7,
+		"PUBLISH_READONLY":             8,
+		"EXPAND_VOLUME":                9,
+		"LIST_VOLUMES_PUBLISHED_NODES": 10,
+		"VOLUME_CONDITION":             11,
+		"GET_VOLUME":                   12,
+		"SINGLE_NODE_MULTI_WRITER":     13,
+		"MODIFY_VOLUME":                14,
+	}
+)
+
+func (x ControllerServiceCapability_RPC_Type) Enum() *ControllerServiceCapability_RPC_Type {
+	p := new(ControllerServiceCapability_RPC_Type)
+	*p = x
+	return p
 }
 
 func (x ControllerServiceCapability_RPC_Type) String() string {
-	return proto.EnumName(ControllerServiceCapability_RPC_Type_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ControllerServiceCapability_RPC_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_csi_proto_enumTypes[4].Descriptor()
 }
 
+func (ControllerServiceCapability_RPC_Type) Type() protoreflect.EnumType {
+	return &file_csi_proto_enumTypes[4]
+}
+
+func (x ControllerServiceCapability_RPC_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use ControllerServiceCapability_RPC_Type.Descriptor instead.
 func (ControllerServiceCapability_RPC_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{33, 0, 0}
+	return file_csi_proto_rawDescGZIP(), []int{33, 0, 0}
 }
 
 type VolumeUsage_Unit int32
@@ -317,24 +461,45 @@ const (
 	VolumeUsage_INODES  VolumeUsage_Unit = 2
 )
 
-var VolumeUsage_Unit_name = map[int32]string{
-	0: "UNKNOWN",
-	1: "BYTES",
-	2: "INODES",
-}
+// Enum value maps for VolumeUsage_Unit.
+var (
+	VolumeUsage_Unit_name = map[int32]string{
+		0: "UNKNOWN",
+		1: "BYTES",
+		2: "INODES",
+	}
+	VolumeUsage_Unit_value = map[string]int32{
+		"UNKNOWN": 0,
+		"BYTES":   1,
+		"INODES":  2,
+	}
+)
 
-var VolumeUsage_Unit_value = map[string]int32{
-	"UNKNOWN": 0,
-	"BYTES":   1,
-	"INODES":  2,
+func (x VolumeUsage_Unit) Enum() *VolumeUsage_Unit {
+	p := new(VolumeUsage_Unit)
+	*p = x
+	return p
 }
 
 func (x VolumeUsage_Unit) String() string {
-	return proto.EnumName(VolumeUsage_Unit_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
 }
 
+func (VolumeUsage_Unit) Descriptor() protoreflect.EnumDescriptor {
+	return file_csi_proto_enumTypes[5].Descriptor()
+}
+
+func (VolumeUsage_Unit) Type() protoreflect.EnumType {
+	return &file_csi_proto_enumTypes[5]
+}
+
+func (x VolumeUsage_Unit) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use VolumeUsage_Unit.Descriptor instead.
 func (VolumeUsage_Unit) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{53, 0}
+	return file_csi_proto_rawDescGZIP(), []int{53, 0}
 }
 
 type NodeServiceCapability_RPC_Type int32
@@ -376,32 +541,53 @@ const (
 	NodeServiceCapability_RPC_VOLUME_MOUNT_GROUP NodeServiceCapability_RPC_Type = 6
 )
 
-var NodeServiceCapability_RPC_Type_name = map[int32]string{
-	0: "UNKNOWN",
-	1: "STAGE_UNSTAGE_VOLUME",
-	2: "GET_VOLUME_STATS",
-	3: "EXPAND_VOLUME",
-	4: "VOLUME_CONDITION",
-	5: "SINGLE_NODE_MULTI_WRITER",
-	6: "VOLUME_MOUNT_GROUP",
-}
+// Enum value maps for NodeServiceCapability_RPC_Type.
+var (
+	NodeServiceCapability_RPC_Type_name = map[int32]string{
+		0: "UNKNOWN",
+		1: "STAGE_UNSTAGE_VOLUME",
+		2: "GET_VOLUME_STATS",
+		3: "EXPAND_VOLUME",
+		4: "VOLUME_CONDITION",
+		5: "SINGLE_NODE_MULTI_WRITER",
+		6: "VOLUME_MOUNT_GROUP",
+	}
+	NodeServiceCapability_RPC_Type_value = map[string]int32{
+		"UNKNOWN":                  0,
+		"STAGE_UNSTAGE_VOLUME":     1,
+		"GET_VOLUME_STATS":         2,
+		"EXPAND_VOLUME":            3,
+		"VOLUME_CONDITION":         4,
+		"SINGLE_NODE_MULTI_WRITER": 5,
+		"VOLUME_MOUNT_GROUP":       6,
+	}
+)
 
-var NodeServiceCapability_RPC_Type_value = map[string]int32{
-	"UNKNOWN":                  0,
-	"STAGE_UNSTAGE_VOLUME":     1,
-	"GET_VOLUME_STATS":         2,
-	"EXPAND_VOLUME":            3,
-	"VOLUME_CONDITION":         4,
-	"SINGLE_NODE_MULTI_WRITER": 5,
-	"VOLUME_MOUNT_GROUP":       6,
+func (x NodeServiceCapability_RPC_Type) Enum() *NodeServiceCapability_RPC_Type {
+	p := new(NodeServiceCapability_RPC_Type)
+	*p = x
+	return p
 }
 
 func (x NodeServiceCapability_RPC_Type) String() string {
-	return proto.EnumName(NodeServiceCapability_RPC_Type_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (NodeServiceCapability_RPC_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_csi_proto_enumTypes[6].Descriptor()
+}
+
+func (NodeServiceCapability_RPC_Type) Type() protoreflect.EnumType {
+	return &file_csi_proto_enumTypes[6]
+}
+
+func (x NodeServiceCapability_RPC_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
+// Deprecated: Use NodeServiceCapability_RPC_Type.Descriptor instead.
 func (NodeServiceCapability_RPC_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{57, 0, 0}
+	return file_csi_proto_rawDescGZIP(), []int{57, 0, 0}
 }
 
 type GroupControllerServiceCapability_RPC_Type int32
@@ -414,56 +600,88 @@ const (
 	GroupControllerServiceCapability_RPC_CREATE_DELETE_GET_VOLUME_GROUP_SNAPSHOT GroupControllerServiceCapability_RPC_Type = 1
 )
 
-var GroupControllerServiceCapability_RPC_Type_name = map[int32]string{
-	0: "UNKNOWN",
-	1: "CREATE_DELETE_GET_VOLUME_GROUP_SNAPSHOT",
-}
+// Enum value maps for GroupControllerServiceCapability_RPC_Type.
+var (
+	GroupControllerServiceCapability_RPC_Type_name = map[int32]string{
+		0: "UNKNOWN",
+		1: "CREATE_DELETE_GET_VOLUME_GROUP_SNAPSHOT",
+	}
+	GroupControllerServiceCapability_RPC_Type_value = map[string]int32{
+		"UNKNOWN": 0,
+		"CREATE_DELETE_GET_VOLUME_GROUP_SNAPSHOT": 1,
+	}
+)
 
-var GroupControllerServiceCapability_RPC_Type_value = map[string]int32{
-	"UNKNOWN": 0,
-	"CREATE_DELETE_GET_VOLUME_GROUP_SNAPSHOT": 1,
+func (x GroupControllerServiceCapability_RPC_Type) Enum() *GroupControllerServiceCapability_RPC_Type {
+	p := new(GroupControllerServiceCapability_RPC_Type)
+	*p = x
+	return p
 }
 
 func (x GroupControllerServiceCapability_RPC_Type) String() string {
-	return proto.EnumName(GroupControllerServiceCapability_RPC_Type_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
 }
 
-func (GroupControllerServiceCapability_RPC_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{64, 0, 0}
+func (GroupControllerServiceCapability_RPC_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_csi_proto_enumTypes[7].Descriptor()
 }
 
-type GetPluginInfoRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+func (GroupControllerServiceCapability_RPC_Type) Type() protoreflect.EnumType {
+	return &file_csi_proto_enumTypes[7]
 }
 
-func (m *GetPluginInfoRequest) Reset()         { *m = GetPluginInfoRequest{} }
-func (m *GetPluginInfoRequest) String() string { return proto.CompactTextString(m) }
-func (*GetPluginInfoRequest) ProtoMessage()    {}
-func (*GetPluginInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{0}
+func (x GroupControllerServiceCapability_RPC_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (m *GetPluginInfoRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetPluginInfoRequest.Unmarshal(m, b)
+// Deprecated: Use GroupControllerServiceCapability_RPC_Type.Descriptor instead.
+func (GroupControllerServiceCapability_RPC_Type) EnumDescriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{64, 0, 0}
 }
-func (m *GetPluginInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetPluginInfoRequest.Marshal(b, m, deterministic)
+
+type GetPluginInfoRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
-func (m *GetPluginInfoRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetPluginInfoRequest.Merge(m, src)
+
+func (x *GetPluginInfoRequest) Reset() {
+	*x = GetPluginInfoRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *GetPluginInfoRequest) XXX_Size() int {
-	return xxx_messageInfo_GetPluginInfoRequest.Size(m)
+
+func (x *GetPluginInfoRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GetPluginInfoRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetPluginInfoRequest.DiscardUnknown(m)
+
+func (*GetPluginInfoRequest) ProtoMessage() {}
+
+func (x *GetPluginInfoRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GetPluginInfoRequest proto.InternalMessageInfo
+// Deprecated: Use GetPluginInfoRequest.ProtoReflect.Descriptor instead.
+func (*GetPluginInfoRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{0}
+}
 
 type GetPluginInfoResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The name MUST follow domain name notation format
 	// (https://tools.ietf.org/html/rfc1035#section-2.3.1). It SHOULD
 	// include the plugin's host company name and the plugin name,
@@ -475,183 +693,194 @@ type GetPluginInfoResponse struct {
 	// This field is REQUIRED. Value of this field is opaque to the CO.
 	VendorVersion string `protobuf:"bytes,2,opt,name=vendor_version,json=vendorVersion,proto3" json:"vendor_version,omitempty"`
 	// This field is OPTIONAL. Values are opaque to the CO.
-	Manifest             map[string]string `protobuf:"bytes,3,rep,name=manifest,proto3" json:"manifest,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Manifest map[string]string `protobuf:"bytes,3,rep,name=manifest,proto3" json:"manifest,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *GetPluginInfoResponse) Reset()         { *m = GetPluginInfoResponse{} }
-func (m *GetPluginInfoResponse) String() string { return proto.CompactTextString(m) }
-func (*GetPluginInfoResponse) ProtoMessage()    {}
-func (*GetPluginInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{1}
+func (x *GetPluginInfoResponse) Reset() {
+	*x = GetPluginInfoResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GetPluginInfoResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetPluginInfoResponse.Unmarshal(m, b)
+func (x *GetPluginInfoResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GetPluginInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetPluginInfoResponse.Marshal(b, m, deterministic)
-}
-func (m *GetPluginInfoResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetPluginInfoResponse.Merge(m, src)
-}
-func (m *GetPluginInfoResponse) XXX_Size() int {
-	return xxx_messageInfo_GetPluginInfoResponse.Size(m)
-}
-func (m *GetPluginInfoResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetPluginInfoResponse.DiscardUnknown(m)
+
+func (*GetPluginInfoResponse) ProtoMessage() {}
+
+func (x *GetPluginInfoResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GetPluginInfoResponse proto.InternalMessageInfo
+// Deprecated: Use GetPluginInfoResponse.ProtoReflect.Descriptor instead.
+func (*GetPluginInfoResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{1}
+}
 
-func (m *GetPluginInfoResponse) GetName() string {
-	if m != nil {
-		return m.Name
+func (x *GetPluginInfoResponse) GetName() string {
+	if x != nil {
+		return x.Name
 	}
 	return ""
 }
 
-func (m *GetPluginInfoResponse) GetVendorVersion() string {
-	if m != nil {
-		return m.VendorVersion
+func (x *GetPluginInfoResponse) GetVendorVersion() string {
+	if x != nil {
+		return x.VendorVersion
 	}
 	return ""
 }
 
-func (m *GetPluginInfoResponse) GetManifest() map[string]string {
-	if m != nil {
-		return m.Manifest
+func (x *GetPluginInfoResponse) GetManifest() map[string]string {
+	if x != nil {
+		return x.Manifest
 	}
 	return nil
 }
 
 type GetPluginCapabilitiesRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *GetPluginCapabilitiesRequest) Reset()         { *m = GetPluginCapabilitiesRequest{} }
-func (m *GetPluginCapabilitiesRequest) String() string { return proto.CompactTextString(m) }
-func (*GetPluginCapabilitiesRequest) ProtoMessage()    {}
-func (*GetPluginCapabilitiesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{2}
+func (x *GetPluginCapabilitiesRequest) Reset() {
+	*x = GetPluginCapabilitiesRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GetPluginCapabilitiesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetPluginCapabilitiesRequest.Unmarshal(m, b)
-}
-func (m *GetPluginCapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetPluginCapabilitiesRequest.Marshal(b, m, deterministic)
-}
-func (m *GetPluginCapabilitiesRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetPluginCapabilitiesRequest.Merge(m, src)
-}
-func (m *GetPluginCapabilitiesRequest) XXX_Size() int {
-	return xxx_messageInfo_GetPluginCapabilitiesRequest.Size(m)
+func (x *GetPluginCapabilitiesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GetPluginCapabilitiesRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetPluginCapabilitiesRequest.DiscardUnknown(m)
+
+func (*GetPluginCapabilitiesRequest) ProtoMessage() {}
+
+func (x *GetPluginCapabilitiesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GetPluginCapabilitiesRequest proto.InternalMessageInfo
+// Deprecated: Use GetPluginCapabilitiesRequest.ProtoReflect.Descriptor instead.
+func (*GetPluginCapabilitiesRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{2}
+}
 
 type GetPluginCapabilitiesResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// All the capabilities that the controller service supports. This
 	// field is OPTIONAL.
-	Capabilities         []*PluginCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
-	XXX_unrecognized     []byte              `json:"-"`
-	XXX_sizecache        int32               `json:"-"`
+	Capabilities []*PluginCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
 }
 
-func (m *GetPluginCapabilitiesResponse) Reset()         { *m = GetPluginCapabilitiesResponse{} }
-func (m *GetPluginCapabilitiesResponse) String() string { return proto.CompactTextString(m) }
-func (*GetPluginCapabilitiesResponse) ProtoMessage()    {}
-func (*GetPluginCapabilitiesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{3}
+func (x *GetPluginCapabilitiesResponse) Reset() {
+	*x = GetPluginCapabilitiesResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GetPluginCapabilitiesResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetPluginCapabilitiesResponse.Unmarshal(m, b)
+func (x *GetPluginCapabilitiesResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GetPluginCapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetPluginCapabilitiesResponse.Marshal(b, m, deterministic)
-}
-func (m *GetPluginCapabilitiesResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetPluginCapabilitiesResponse.Merge(m, src)
-}
-func (m *GetPluginCapabilitiesResponse) XXX_Size() int {
-	return xxx_messageInfo_GetPluginCapabilitiesResponse.Size(m)
-}
-func (m *GetPluginCapabilitiesResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetPluginCapabilitiesResponse.DiscardUnknown(m)
+
+func (*GetPluginCapabilitiesResponse) ProtoMessage() {}
+
+func (x *GetPluginCapabilitiesResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GetPluginCapabilitiesResponse proto.InternalMessageInfo
+// Deprecated: Use GetPluginCapabilitiesResponse.ProtoReflect.Descriptor instead.
+func (*GetPluginCapabilitiesResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{3}
+}
 
-func (m *GetPluginCapabilitiesResponse) GetCapabilities() []*PluginCapability {
-	if m != nil {
-		return m.Capabilities
+func (x *GetPluginCapabilitiesResponse) GetCapabilities() []*PluginCapability {
+	if x != nil {
+		return x.Capabilities
 	}
 	return nil
 }
 
 // Specifies a capability of the plugin.
 type PluginCapability struct {
-	// Types that are valid to be assigned to Type:
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Type:
 	//
 	//	*PluginCapability_Service_
 	//	*PluginCapability_VolumeExpansion_
-	Type                 isPluginCapability_Type `protobuf_oneof:"type"`
-	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
-	XXX_unrecognized     []byte                  `json:"-"`
-	XXX_sizecache        int32                   `json:"-"`
+	Type isPluginCapability_Type `protobuf_oneof:"type"`
 }
 
-func (m *PluginCapability) Reset()         { *m = PluginCapability{} }
-func (m *PluginCapability) String() string { return proto.CompactTextString(m) }
-func (*PluginCapability) ProtoMessage()    {}
-func (*PluginCapability) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{4}
+func (x *PluginCapability) Reset() {
+	*x = PluginCapability{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *PluginCapability) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PluginCapability.Unmarshal(m, b)
-}
-func (m *PluginCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PluginCapability.Marshal(b, m, deterministic)
-}
-func (m *PluginCapability) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PluginCapability.Merge(m, src)
-}
-func (m *PluginCapability) XXX_Size() int {
-	return xxx_messageInfo_PluginCapability.Size(m)
-}
-func (m *PluginCapability) XXX_DiscardUnknown() {
-	xxx_messageInfo_PluginCapability.DiscardUnknown(m)
+func (x *PluginCapability) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_PluginCapability proto.InternalMessageInfo
-
-type isPluginCapability_Type interface {
-	isPluginCapability_Type()
-}
+func (*PluginCapability) ProtoMessage() {}
 
-type PluginCapability_Service_ struct {
-	Service *PluginCapability_Service `protobuf:"bytes,1,opt,name=service,proto3,oneof"`
+func (x *PluginCapability) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-type PluginCapability_VolumeExpansion_ struct {
-	VolumeExpansion *PluginCapability_VolumeExpansion `protobuf:"bytes,2,opt,name=volume_expansion,json=volumeExpansion,proto3,oneof"`
+// Deprecated: Use PluginCapability.ProtoReflect.Descriptor instead.
+func (*PluginCapability) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{4}
 }
 
-func (*PluginCapability_Service_) isPluginCapability_Type() {}
-
-func (*PluginCapability_VolumeExpansion_) isPluginCapability_Type() {}
-
 func (m *PluginCapability) GetType() isPluginCapability_Type {
 	if m != nil {
 		return m.Type
@@ -659,138 +888,80 @@ func (m *PluginCapability) GetType() isPluginCapability_Type {
 	return nil
 }
 
-func (m *PluginCapability) GetService() *PluginCapability_Service {
-	if x, ok := m.GetType().(*PluginCapability_Service_); ok {
+func (x *PluginCapability) GetService() *PluginCapability_Service {
+	if x, ok := x.GetType().(*PluginCapability_Service_); ok {
 		return x.Service
 	}
 	return nil
 }
 
-func (m *PluginCapability) GetVolumeExpansion() *PluginCapability_VolumeExpansion {
-	if x, ok := m.GetType().(*PluginCapability_VolumeExpansion_); ok {
+func (x *PluginCapability) GetVolumeExpansion() *PluginCapability_VolumeExpansion {
+	if x, ok := x.GetType().(*PluginCapability_VolumeExpansion_); ok {
 		return x.VolumeExpansion
 	}
 	return nil
 }
 
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*PluginCapability) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
-		(*PluginCapability_Service_)(nil),
-		(*PluginCapability_VolumeExpansion_)(nil),
-	}
-}
-
-type PluginCapability_Service struct {
-	Type                 PluginCapability_Service_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.PluginCapability_Service_Type" json:"type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
-	XXX_unrecognized     []byte                        `json:"-"`
-	XXX_sizecache        int32                         `json:"-"`
+type isPluginCapability_Type interface {
+	isPluginCapability_Type()
 }
 
-func (m *PluginCapability_Service) Reset()         { *m = PluginCapability_Service{} }
-func (m *PluginCapability_Service) String() string { return proto.CompactTextString(m) }
-func (*PluginCapability_Service) ProtoMessage()    {}
-func (*PluginCapability_Service) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{4, 0}
+type PluginCapability_Service_ struct {
+	// Service that the plugin supports.
+	Service *PluginCapability_Service `protobuf:"bytes,1,opt,name=service,proto3,oneof"`
 }
 
-func (m *PluginCapability_Service) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PluginCapability_Service.Unmarshal(m, b)
-}
-func (m *PluginCapability_Service) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PluginCapability_Service.Marshal(b, m, deterministic)
-}
-func (m *PluginCapability_Service) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PluginCapability_Service.Merge(m, src)
-}
-func (m *PluginCapability_Service) XXX_Size() int {
-	return xxx_messageInfo_PluginCapability_Service.Size(m)
-}
-func (m *PluginCapability_Service) XXX_DiscardUnknown() {
-	xxx_messageInfo_PluginCapability_Service.DiscardUnknown(m)
+type PluginCapability_VolumeExpansion_ struct {
+	VolumeExpansion *PluginCapability_VolumeExpansion `protobuf:"bytes,2,opt,name=volume_expansion,json=volumeExpansion,proto3,oneof"`
 }
 
-var xxx_messageInfo_PluginCapability_Service proto.InternalMessageInfo
+func (*PluginCapability_Service_) isPluginCapability_Type() {}
 
-func (m *PluginCapability_Service) GetType() PluginCapability_Service_Type {
-	if m != nil {
-		return m.Type
-	}
-	return PluginCapability_Service_UNKNOWN
-}
+func (*PluginCapability_VolumeExpansion_) isPluginCapability_Type() {}
 
-type PluginCapability_VolumeExpansion struct {
-	Type                 PluginCapability_VolumeExpansion_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.PluginCapability_VolumeExpansion_Type" json:"type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
-	XXX_unrecognized     []byte                                `json:"-"`
-	XXX_sizecache        int32                                 `json:"-"`
+type ProbeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *PluginCapability_VolumeExpansion) Reset()         { *m = PluginCapability_VolumeExpansion{} }
-func (m *PluginCapability_VolumeExpansion) String() string { return proto.CompactTextString(m) }
-func (*PluginCapability_VolumeExpansion) ProtoMessage()    {}
-func (*PluginCapability_VolumeExpansion) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{4, 1}
+func (x *ProbeRequest) Reset() {
+	*x = ProbeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *PluginCapability_VolumeExpansion) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PluginCapability_VolumeExpansion.Unmarshal(m, b)
-}
-func (m *PluginCapability_VolumeExpansion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PluginCapability_VolumeExpansion.Marshal(b, m, deterministic)
-}
-func (m *PluginCapability_VolumeExpansion) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PluginCapability_VolumeExpansion.Merge(m, src)
-}
-func (m *PluginCapability_VolumeExpansion) XXX_Size() int {
-	return xxx_messageInfo_PluginCapability_VolumeExpansion.Size(m)
-}
-func (m *PluginCapability_VolumeExpansion) XXX_DiscardUnknown() {
-	xxx_messageInfo_PluginCapability_VolumeExpansion.DiscardUnknown(m)
+func (x *ProbeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_PluginCapability_VolumeExpansion proto.InternalMessageInfo
+func (*ProbeRequest) ProtoMessage() {}
 
-func (m *PluginCapability_VolumeExpansion) GetType() PluginCapability_VolumeExpansion_Type {
-	if m != nil {
-		return m.Type
+func (x *ProbeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return PluginCapability_VolumeExpansion_UNKNOWN
-}
-
-type ProbeRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	return mi.MessageOf(x)
 }
 
-func (m *ProbeRequest) Reset()         { *m = ProbeRequest{} }
-func (m *ProbeRequest) String() string { return proto.CompactTextString(m) }
-func (*ProbeRequest) ProtoMessage()    {}
+// Deprecated: Use ProbeRequest.ProtoReflect.Descriptor instead.
 func (*ProbeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{5}
+	return file_csi_proto_rawDescGZIP(), []int{5}
 }
 
-func (m *ProbeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ProbeRequest.Unmarshal(m, b)
-}
-func (m *ProbeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ProbeRequest.Marshal(b, m, deterministic)
-}
-func (m *ProbeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ProbeRequest.Merge(m, src)
-}
-func (m *ProbeRequest) XXX_Size() int {
-	return xxx_messageInfo_ProbeRequest.Size(m)
-}
-func (m *ProbeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ProbeRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ProbeRequest proto.InternalMessageInfo
-
 type ProbeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Readiness allows a plugin to report its initialization status back
 	// to the CO. Initialization for some plugins MAY be time consuming
 	// and it is important for a CO to distinguish between the following
@@ -811,45 +982,53 @@ type ProbeResponse struct {
 	// that the plugin is in a ready state and is accepting calls to its
 	// Controller and/or Node services (according to the plugin's reported
 	// capabilities).
-	Ready                *wrappers.BoolValue `protobuf:"bytes,1,opt,name=ready,proto3" json:"ready,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
-	XXX_unrecognized     []byte              `json:"-"`
-	XXX_sizecache        int32               `json:"-"`
+	Ready *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=ready,proto3" json:"ready,omitempty"`
 }
 
-func (m *ProbeResponse) Reset()         { *m = ProbeResponse{} }
-func (m *ProbeResponse) String() string { return proto.CompactTextString(m) }
-func (*ProbeResponse) ProtoMessage()    {}
-func (*ProbeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{6}
+func (x *ProbeResponse) Reset() {
+	*x = ProbeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ProbeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ProbeResponse.Unmarshal(m, b)
-}
-func (m *ProbeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ProbeResponse.Marshal(b, m, deterministic)
-}
-func (m *ProbeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ProbeResponse.Merge(m, src)
+func (x *ProbeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ProbeResponse) XXX_Size() int {
-	return xxx_messageInfo_ProbeResponse.Size(m)
-}
-func (m *ProbeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ProbeResponse.DiscardUnknown(m)
+
+func (*ProbeResponse) ProtoMessage() {}
+
+func (x *ProbeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ProbeResponse proto.InternalMessageInfo
+// Deprecated: Use ProbeResponse.ProtoReflect.Descriptor instead.
+func (*ProbeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{6}
+}
 
-func (m *ProbeResponse) GetReady() *wrappers.BoolValue {
-	if m != nil {
-		return m.Ready
+func (x *ProbeResponse) GetReady() *wrapperspb.BoolValue {
+	if x != nil {
+		return x.Ready
 	}
 	return nil
 }
 
 type CreateVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The suggested name for the storage space. This field is REQUIRED.
 	// It serves two purposes:
 	//  1. Idempotency - This name is generated by the CO to achieve
@@ -928,89 +1107,93 @@ type CreateVolumeRequest struct {
 	// as if they take precedence over the parameters field.
 	// This field SHALL NOT be specified unless the SP has the
 	// MODIFY_VOLUME plugin capability.
-	MutableParameters    map[string]string `protobuf:"bytes,8,rep,name=mutable_parameters,json=mutableParameters,proto3" json:"mutable_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	MutableParameters map[string]string `protobuf:"bytes,8,rep,name=mutable_parameters,json=mutableParameters,proto3" json:"mutable_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *CreateVolumeRequest) Reset()         { *m = CreateVolumeRequest{} }
-func (m *CreateVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*CreateVolumeRequest) ProtoMessage()    {}
-func (*CreateVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{7}
+func (x *CreateVolumeRequest) Reset() {
+	*x = CreateVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *CreateVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CreateVolumeRequest.Unmarshal(m, b)
-}
-func (m *CreateVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CreateVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *CreateVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateVolumeRequest.Merge(m, src)
+func (x *CreateVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CreateVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_CreateVolumeRequest.Size(m)
-}
-func (m *CreateVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateVolumeRequest.DiscardUnknown(m)
+
+func (*CreateVolumeRequest) ProtoMessage() {}
+
+func (x *CreateVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CreateVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use CreateVolumeRequest.ProtoReflect.Descriptor instead.
+func (*CreateVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{7}
+}
 
-func (m *CreateVolumeRequest) GetName() string {
-	if m != nil {
-		return m.Name
+func (x *CreateVolumeRequest) GetName() string {
+	if x != nil {
+		return x.Name
 	}
 	return ""
 }
 
-func (m *CreateVolumeRequest) GetCapacityRange() *CapacityRange {
-	if m != nil {
-		return m.CapacityRange
+func (x *CreateVolumeRequest) GetCapacityRange() *CapacityRange {
+	if x != nil {
+		return x.CapacityRange
 	}
 	return nil
 }
 
-func (m *CreateVolumeRequest) GetVolumeCapabilities() []*VolumeCapability {
-	if m != nil {
-		return m.VolumeCapabilities
+func (x *CreateVolumeRequest) GetVolumeCapabilities() []*VolumeCapability {
+	if x != nil {
+		return x.VolumeCapabilities
 	}
 	return nil
 }
 
-func (m *CreateVolumeRequest) GetParameters() map[string]string {
-	if m != nil {
-		return m.Parameters
+func (x *CreateVolumeRequest) GetParameters() map[string]string {
+	if x != nil {
+		return x.Parameters
 	}
 	return nil
 }
 
-func (m *CreateVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *CreateVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *CreateVolumeRequest) GetVolumeContentSource() *VolumeContentSource {
-	if m != nil {
-		return m.VolumeContentSource
+func (x *CreateVolumeRequest) GetVolumeContentSource() *VolumeContentSource {
+	if x != nil {
+		return x.VolumeContentSource
 	}
 	return nil
 }
 
-func (m *CreateVolumeRequest) GetAccessibilityRequirements() *TopologyRequirement {
-	if m != nil {
-		return m.AccessibilityRequirements
+func (x *CreateVolumeRequest) GetAccessibilityRequirements() *TopologyRequirement {
+	if x != nil {
+		return x.AccessibilityRequirements
 	}
 	return nil
 }
 
-func (m *CreateVolumeRequest) GetMutableParameters() map[string]string {
-	if m != nil {
-		return m.MutableParameters
+func (x *CreateVolumeRequest) GetMutableParameters() map[string]string {
+	if x != nil {
+		return x.MutableParameters
 	}
 	return nil
 }
@@ -1018,57 +1201,49 @@ func (m *CreateVolumeRequest) GetMutableParameters() map[string]string {
 // Specifies what source the volume will be created from. One of the
 // type fields MUST be specified.
 type VolumeContentSource struct {
-	// Types that are valid to be assigned to Type:
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Type:
 	//
 	//	*VolumeContentSource_Snapshot
 	//	*VolumeContentSource_Volume
-	Type                 isVolumeContentSource_Type `protobuf_oneof:"type"`
-	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
-	XXX_unrecognized     []byte                     `json:"-"`
-	XXX_sizecache        int32                      `json:"-"`
+	Type isVolumeContentSource_Type `protobuf_oneof:"type"`
 }
 
-func (m *VolumeContentSource) Reset()         { *m = VolumeContentSource{} }
-func (m *VolumeContentSource) String() string { return proto.CompactTextString(m) }
-func (*VolumeContentSource) ProtoMessage()    {}
-func (*VolumeContentSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{8}
+func (x *VolumeContentSource) Reset() {
+	*x = VolumeContentSource{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *VolumeContentSource) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeContentSource.Unmarshal(m, b)
-}
-func (m *VolumeContentSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeContentSource.Marshal(b, m, deterministic)
-}
-func (m *VolumeContentSource) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeContentSource.Merge(m, src)
-}
-func (m *VolumeContentSource) XXX_Size() int {
-	return xxx_messageInfo_VolumeContentSource.Size(m)
+func (x *VolumeContentSource) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *VolumeContentSource) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeContentSource.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VolumeContentSource proto.InternalMessageInfo
 
-type isVolumeContentSource_Type interface {
-	isVolumeContentSource_Type()
-}
+func (*VolumeContentSource) ProtoMessage() {}
 
-type VolumeContentSource_Snapshot struct {
-	Snapshot *VolumeContentSource_SnapshotSource `protobuf:"bytes,1,opt,name=snapshot,proto3,oneof"`
+func (x *VolumeContentSource) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-type VolumeContentSource_Volume struct {
-	Volume *VolumeContentSource_VolumeSource `protobuf:"bytes,2,opt,name=volume,proto3,oneof"`
+// Deprecated: Use VolumeContentSource.ProtoReflect.Descriptor instead.
+func (*VolumeContentSource) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{8}
 }
 
-func (*VolumeContentSource_Snapshot) isVolumeContentSource_Type() {}
-
-func (*VolumeContentSource_Volume) isVolumeContentSource_Type() {}
-
 func (m *VolumeContentSource) GetType() isVolumeContentSource_Type {
 	if m != nil {
 		return m.Type
@@ -1076,213 +1251,136 @@ func (m *VolumeContentSource) GetType() isVolumeContentSource_Type {
 	return nil
 }
 
-func (m *VolumeContentSource) GetSnapshot() *VolumeContentSource_SnapshotSource {
-	if x, ok := m.GetType().(*VolumeContentSource_Snapshot); ok {
+func (x *VolumeContentSource) GetSnapshot() *VolumeContentSource_SnapshotSource {
+	if x, ok := x.GetType().(*VolumeContentSource_Snapshot); ok {
 		return x.Snapshot
 	}
 	return nil
 }
 
-func (m *VolumeContentSource) GetVolume() *VolumeContentSource_VolumeSource {
-	if x, ok := m.GetType().(*VolumeContentSource_Volume); ok {
+func (x *VolumeContentSource) GetVolume() *VolumeContentSource_VolumeSource {
+	if x, ok := x.GetType().(*VolumeContentSource_Volume); ok {
 		return x.Volume
 	}
 	return nil
 }
 
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*VolumeContentSource) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
-		(*VolumeContentSource_Snapshot)(nil),
-		(*VolumeContentSource_Volume)(nil),
-	}
+type isVolumeContentSource_Type interface {
+	isVolumeContentSource_Type()
 }
 
-type VolumeContentSource_SnapshotSource struct {
-	// Contains identity information for the existing source snapshot.
-	// This field is REQUIRED. Plugin is REQUIRED to support creating
-	// volume from snapshot if it supports the capability
-	// CREATE_DELETE_SNAPSHOT.
-	SnapshotId           string   `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+type VolumeContentSource_Snapshot struct {
+	Snapshot *VolumeContentSource_SnapshotSource `protobuf:"bytes,1,opt,name=snapshot,proto3,oneof"`
 }
 
-func (m *VolumeContentSource_SnapshotSource) Reset()         { *m = VolumeContentSource_SnapshotSource{} }
-func (m *VolumeContentSource_SnapshotSource) String() string { return proto.CompactTextString(m) }
-func (*VolumeContentSource_SnapshotSource) ProtoMessage()    {}
-func (*VolumeContentSource_SnapshotSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{8, 0}
+type VolumeContentSource_Volume struct {
+	Volume *VolumeContentSource_VolumeSource `protobuf:"bytes,2,opt,name=volume,proto3,oneof"`
 }
 
-func (m *VolumeContentSource_SnapshotSource) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeContentSource_SnapshotSource.Unmarshal(m, b)
-}
-func (m *VolumeContentSource_SnapshotSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeContentSource_SnapshotSource.Marshal(b, m, deterministic)
-}
-func (m *VolumeContentSource_SnapshotSource) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeContentSource_SnapshotSource.Merge(m, src)
-}
-func (m *VolumeContentSource_SnapshotSource) XXX_Size() int {
-	return xxx_messageInfo_VolumeContentSource_SnapshotSource.Size(m)
-}
-func (m *VolumeContentSource_SnapshotSource) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeContentSource_SnapshotSource.DiscardUnknown(m)
-}
+func (*VolumeContentSource_Snapshot) isVolumeContentSource_Type() {}
 
-var xxx_messageInfo_VolumeContentSource_SnapshotSource proto.InternalMessageInfo
+func (*VolumeContentSource_Volume) isVolumeContentSource_Type() {}
 
-func (m *VolumeContentSource_SnapshotSource) GetSnapshotId() string {
-	if m != nil {
-		return m.SnapshotId
-	}
-	return ""
-}
+type CreateVolumeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 
-type VolumeContentSource_VolumeSource struct {
-	// Contains identity information for the existing source volume.
-	// This field is REQUIRED. Plugins reporting CLONE_VOLUME
-	// capability MUST support creating a volume from another volume.
-	VolumeId             string   `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	// Contains all attributes of the newly created volume that are
+	// relevant to the CO along with information required by the Plugin
+	// to uniquely identify the volume. This field is REQUIRED.
+	Volume *Volume `protobuf:"bytes,1,opt,name=volume,proto3" json:"volume,omitempty"`
 }
 
-func (m *VolumeContentSource_VolumeSource) Reset()         { *m = VolumeContentSource_VolumeSource{} }
-func (m *VolumeContentSource_VolumeSource) String() string { return proto.CompactTextString(m) }
-func (*VolumeContentSource_VolumeSource) ProtoMessage()    {}
-func (*VolumeContentSource_VolumeSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{8, 1}
+func (x *CreateVolumeResponse) Reset() {
+	*x = CreateVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *VolumeContentSource_VolumeSource) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeContentSource_VolumeSource.Unmarshal(m, b)
-}
-func (m *VolumeContentSource_VolumeSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeContentSource_VolumeSource.Marshal(b, m, deterministic)
-}
-func (m *VolumeContentSource_VolumeSource) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeContentSource_VolumeSource.Merge(m, src)
-}
-func (m *VolumeContentSource_VolumeSource) XXX_Size() int {
-	return xxx_messageInfo_VolumeContentSource_VolumeSource.Size(m)
-}
-func (m *VolumeContentSource_VolumeSource) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeContentSource_VolumeSource.DiscardUnknown(m)
+func (x *CreateVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_VolumeContentSource_VolumeSource proto.InternalMessageInfo
+func (*CreateVolumeResponse) ProtoMessage() {}
 
-func (m *VolumeContentSource_VolumeSource) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *CreateVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return ""
-}
-
-type CreateVolumeResponse struct {
-	// Contains all attributes of the newly created volume that are
-	// relevant to the CO along with information required by the Plugin
-	// to uniquely identify the volume. This field is REQUIRED.
-	Volume               *Volume  `protobuf:"bytes,1,opt,name=volume,proto3" json:"volume,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	return mi.MessageOf(x)
 }
 
-func (m *CreateVolumeResponse) Reset()         { *m = CreateVolumeResponse{} }
-func (m *CreateVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*CreateVolumeResponse) ProtoMessage()    {}
+// Deprecated: Use CreateVolumeResponse.ProtoReflect.Descriptor instead.
 func (*CreateVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{9}
-}
-
-func (m *CreateVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CreateVolumeResponse.Unmarshal(m, b)
-}
-func (m *CreateVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CreateVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *CreateVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateVolumeResponse.Merge(m, src)
-}
-func (m *CreateVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_CreateVolumeResponse.Size(m)
-}
-func (m *CreateVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateVolumeResponse.DiscardUnknown(m)
+	return file_csi_proto_rawDescGZIP(), []int{9}
 }
 
-var xxx_messageInfo_CreateVolumeResponse proto.InternalMessageInfo
-
-func (m *CreateVolumeResponse) GetVolume() *Volume {
-	if m != nil {
-		return m.Volume
+func (x *CreateVolumeResponse) GetVolume() *Volume {
+	if x != nil {
+		return x.Volume
 	}
 	return nil
 }
 
 // Specify a capability of a volume.
 type VolumeCapability struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Specifies what API the volume will be accessed using. One of the
 	// following fields MUST be specified.
 	//
-	// Types that are valid to be assigned to AccessType:
+	// Types that are assignable to AccessType:
 	//
 	//	*VolumeCapability_Block
 	//	*VolumeCapability_Mount
 	AccessType isVolumeCapability_AccessType `protobuf_oneof:"access_type"`
 	// This is a REQUIRED field.
-	AccessMode           *VolumeCapability_AccessMode `protobuf:"bytes,3,opt,name=access_mode,json=accessMode,proto3" json:"access_mode,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
-	XXX_unrecognized     []byte                       `json:"-"`
-	XXX_sizecache        int32                        `json:"-"`
+	AccessMode *VolumeCapability_AccessMode `protobuf:"bytes,3,opt,name=access_mode,json=accessMode,proto3" json:"access_mode,omitempty"`
 }
 
-func (m *VolumeCapability) Reset()         { *m = VolumeCapability{} }
-func (m *VolumeCapability) String() string { return proto.CompactTextString(m) }
-func (*VolumeCapability) ProtoMessage()    {}
-func (*VolumeCapability) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{10}
+func (x *VolumeCapability) Reset() {
+	*x = VolumeCapability{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *VolumeCapability) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeCapability.Unmarshal(m, b)
-}
-func (m *VolumeCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeCapability.Marshal(b, m, deterministic)
-}
-func (m *VolumeCapability) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeCapability.Merge(m, src)
-}
-func (m *VolumeCapability) XXX_Size() int {
-	return xxx_messageInfo_VolumeCapability.Size(m)
-}
-func (m *VolumeCapability) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeCapability.DiscardUnknown(m)
+func (x *VolumeCapability) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_VolumeCapability proto.InternalMessageInfo
-
-type isVolumeCapability_AccessType interface {
-	isVolumeCapability_AccessType()
-}
+func (*VolumeCapability) ProtoMessage() {}
 
-type VolumeCapability_Block struct {
-	Block *VolumeCapability_BlockVolume `protobuf:"bytes,1,opt,name=block,proto3,oneof"`
+func (x *VolumeCapability) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-type VolumeCapability_Mount struct {
-	Mount *VolumeCapability_MountVolume `protobuf:"bytes,2,opt,name=mount,proto3,oneof"`
+// Deprecated: Use VolumeCapability.ProtoReflect.Descriptor instead.
+func (*VolumeCapability) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{10}
 }
 
-func (*VolumeCapability_Block) isVolumeCapability_AccessType() {}
-
-func (*VolumeCapability_Mount) isVolumeCapability_AccessType() {}
-
 func (m *VolumeCapability) GetAccessType() isVolumeCapability_AccessType {
 	if m != nil {
 		return m.AccessType
@@ -1290,186 +1388,51 @@ func (m *VolumeCapability) GetAccessType() isVolumeCapability_AccessType {
 	return nil
 }
 
-func (m *VolumeCapability) GetBlock() *VolumeCapability_BlockVolume {
-	if x, ok := m.GetAccessType().(*VolumeCapability_Block); ok {
+func (x *VolumeCapability) GetBlock() *VolumeCapability_BlockVolume {
+	if x, ok := x.GetAccessType().(*VolumeCapability_Block); ok {
 		return x.Block
 	}
 	return nil
 }
 
-func (m *VolumeCapability) GetMount() *VolumeCapability_MountVolume {
-	if x, ok := m.GetAccessType().(*VolumeCapability_Mount); ok {
+func (x *VolumeCapability) GetMount() *VolumeCapability_MountVolume {
+	if x, ok := x.GetAccessType().(*VolumeCapability_Mount); ok {
 		return x.Mount
 	}
 	return nil
 }
 
-func (m *VolumeCapability) GetAccessMode() *VolumeCapability_AccessMode {
-	if m != nil {
-		return m.AccessMode
-	}
-	return nil
-}
-
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*VolumeCapability) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
-		(*VolumeCapability_Block)(nil),
-		(*VolumeCapability_Mount)(nil),
-	}
-}
-
-// Indicate that the volume will be accessed via the block device API.
-type VolumeCapability_BlockVolume struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *VolumeCapability_BlockVolume) Reset()         { *m = VolumeCapability_BlockVolume{} }
-func (m *VolumeCapability_BlockVolume) String() string { return proto.CompactTextString(m) }
-func (*VolumeCapability_BlockVolume) ProtoMessage()    {}
-func (*VolumeCapability_BlockVolume) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{10, 0}
-}
-
-func (m *VolumeCapability_BlockVolume) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeCapability_BlockVolume.Unmarshal(m, b)
-}
-func (m *VolumeCapability_BlockVolume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeCapability_BlockVolume.Marshal(b, m, deterministic)
-}
-func (m *VolumeCapability_BlockVolume) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeCapability_BlockVolume.Merge(m, src)
-}
-func (m *VolumeCapability_BlockVolume) XXX_Size() int {
-	return xxx_messageInfo_VolumeCapability_BlockVolume.Size(m)
-}
-func (m *VolumeCapability_BlockVolume) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeCapability_BlockVolume.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VolumeCapability_BlockVolume proto.InternalMessageInfo
-
-// Indicate that the volume will be accessed via the filesystem API.
-type VolumeCapability_MountVolume struct {
-	// The filesystem type. This field is OPTIONAL.
-	// An empty string is equal to an unspecified field value.
-	FsType string `protobuf:"bytes,1,opt,name=fs_type,json=fsType,proto3" json:"fs_type,omitempty"`
-	// The mount options that can be used for the volume. This field is
-	// OPTIONAL. `mount_flags` MAY contain sensitive information.
-	// Therefore, the CO and the Plugin MUST NOT leak this information
-	// to untrusted entities. The total size of this repeated field
-	// SHALL NOT exceed 4 KiB.
-	MountFlags []string `protobuf:"bytes,2,rep,name=mount_flags,json=mountFlags,proto3" json:"mount_flags,omitempty"`
-	// If SP has VOLUME_MOUNT_GROUP node capability and CO provides
-	// this field then SP MUST ensure that the volume_mount_group
-	// parameter is passed as the group identifier to the underlying
-	// operating system mount system call, with the understanding
-	// that the set of available mount call parameters and/or
-	// mount implementations may vary across operating systems.
-	// Additionally, new file and/or directory entries written to
-	// the underlying filesystem SHOULD be permission-labeled in such a
-	// manner, unless otherwise modified by a workload, that they are
-	// both readable and writable by said mount group identifier.
-	// This is an OPTIONAL field.
-	VolumeMountGroup     string   `protobuf:"bytes,3,opt,name=volume_mount_group,json=volumeMountGroup,proto3" json:"volume_mount_group,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *VolumeCapability_MountVolume) Reset()         { *m = VolumeCapability_MountVolume{} }
-func (m *VolumeCapability_MountVolume) String() string { return proto.CompactTextString(m) }
-func (*VolumeCapability_MountVolume) ProtoMessage()    {}
-func (*VolumeCapability_MountVolume) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{10, 1}
-}
-
-func (m *VolumeCapability_MountVolume) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeCapability_MountVolume.Unmarshal(m, b)
-}
-func (m *VolumeCapability_MountVolume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeCapability_MountVolume.Marshal(b, m, deterministic)
-}
-func (m *VolumeCapability_MountVolume) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeCapability_MountVolume.Merge(m, src)
-}
-func (m *VolumeCapability_MountVolume) XXX_Size() int {
-	return xxx_messageInfo_VolumeCapability_MountVolume.Size(m)
-}
-func (m *VolumeCapability_MountVolume) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeCapability_MountVolume.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VolumeCapability_MountVolume proto.InternalMessageInfo
-
-func (m *VolumeCapability_MountVolume) GetFsType() string {
-	if m != nil {
-		return m.FsType
-	}
-	return ""
-}
-
-func (m *VolumeCapability_MountVolume) GetMountFlags() []string {
-	if m != nil {
-		return m.MountFlags
+func (x *VolumeCapability) GetAccessMode() *VolumeCapability_AccessMode {
+	if x != nil {
+		return x.AccessMode
 	}
 	return nil
 }
 
-func (m *VolumeCapability_MountVolume) GetVolumeMountGroup() string {
-	if m != nil {
-		return m.VolumeMountGroup
-	}
-	return ""
-}
-
-// Specify how a volume can be accessed.
-type VolumeCapability_AccessMode struct {
-	// This field is REQUIRED.
-	Mode                 VolumeCapability_AccessMode_Mode `protobuf:"varint,1,opt,name=mode,proto3,enum=csi.v1.VolumeCapability_AccessMode_Mode" json:"mode,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
-	XXX_unrecognized     []byte                           `json:"-"`
-	XXX_sizecache        int32                            `json:"-"`
+type isVolumeCapability_AccessType interface {
+	isVolumeCapability_AccessType()
 }
 
-func (m *VolumeCapability_AccessMode) Reset()         { *m = VolumeCapability_AccessMode{} }
-func (m *VolumeCapability_AccessMode) String() string { return proto.CompactTextString(m) }
-func (*VolumeCapability_AccessMode) ProtoMessage()    {}
-func (*VolumeCapability_AccessMode) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{10, 2}
+type VolumeCapability_Block struct {
+	Block *VolumeCapability_BlockVolume `protobuf:"bytes,1,opt,name=block,proto3,oneof"`
 }
 
-func (m *VolumeCapability_AccessMode) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeCapability_AccessMode.Unmarshal(m, b)
-}
-func (m *VolumeCapability_AccessMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeCapability_AccessMode.Marshal(b, m, deterministic)
-}
-func (m *VolumeCapability_AccessMode) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeCapability_AccessMode.Merge(m, src)
-}
-func (m *VolumeCapability_AccessMode) XXX_Size() int {
-	return xxx_messageInfo_VolumeCapability_AccessMode.Size(m)
-}
-func (m *VolumeCapability_AccessMode) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeCapability_AccessMode.DiscardUnknown(m)
+type VolumeCapability_Mount struct {
+	Mount *VolumeCapability_MountVolume `protobuf:"bytes,2,opt,name=mount,proto3,oneof"`
 }
 
-var xxx_messageInfo_VolumeCapability_AccessMode proto.InternalMessageInfo
+func (*VolumeCapability_Block) isVolumeCapability_AccessType() {}
 
-func (m *VolumeCapability_AccessMode) GetMode() VolumeCapability_AccessMode_Mode {
-	if m != nil {
-		return m.Mode
-	}
-	return VolumeCapability_AccessMode_UNKNOWN
-}
+func (*VolumeCapability_Mount) isVolumeCapability_AccessType() {}
 
 // The capacity of the storage space in bytes. To specify an exact size,
 // `required_bytes` and `limit_bytes` SHALL be set to the same value. At
 // least one of the these fields MUST be specified.
 type CapacityRange struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Volume MUST be at least this big. This field is OPTIONAL.
 	// A value of 0 is equal to an unspecified field value.
 	// The value of this field MUST NOT be negative.
@@ -1477,53 +1440,61 @@ type CapacityRange struct {
 	// Volume MUST not be bigger than this. This field is OPTIONAL.
 	// A value of 0 is equal to an unspecified field value.
 	// The value of this field MUST NOT be negative.
-	LimitBytes           int64    `protobuf:"varint,2,opt,name=limit_bytes,json=limitBytes,proto3" json:"limit_bytes,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	LimitBytes int64 `protobuf:"varint,2,opt,name=limit_bytes,json=limitBytes,proto3" json:"limit_bytes,omitempty"`
 }
 
-func (m *CapacityRange) Reset()         { *m = CapacityRange{} }
-func (m *CapacityRange) String() string { return proto.CompactTextString(m) }
-func (*CapacityRange) ProtoMessage()    {}
-func (*CapacityRange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{11}
+func (x *CapacityRange) Reset() {
+	*x = CapacityRange{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *CapacityRange) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CapacityRange.Unmarshal(m, b)
-}
-func (m *CapacityRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CapacityRange.Marshal(b, m, deterministic)
-}
-func (m *CapacityRange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CapacityRange.Merge(m, src)
+func (x *CapacityRange) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CapacityRange) XXX_Size() int {
-	return xxx_messageInfo_CapacityRange.Size(m)
-}
-func (m *CapacityRange) XXX_DiscardUnknown() {
-	xxx_messageInfo_CapacityRange.DiscardUnknown(m)
+
+func (*CapacityRange) ProtoMessage() {}
+
+func (x *CapacityRange) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CapacityRange proto.InternalMessageInfo
+// Deprecated: Use CapacityRange.ProtoReflect.Descriptor instead.
+func (*CapacityRange) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{11}
+}
 
-func (m *CapacityRange) GetRequiredBytes() int64 {
-	if m != nil {
-		return m.RequiredBytes
+func (x *CapacityRange) GetRequiredBytes() int64 {
+	if x != nil {
+		return x.RequiredBytes
 	}
 	return 0
 }
 
-func (m *CapacityRange) GetLimitBytes() int64 {
-	if m != nil {
-		return m.LimitBytes
+func (x *CapacityRange) GetLimitBytes() int64 {
+	if x != nil {
+		return x.LimitBytes
 	}
 	return 0
 }
 
 // Information about a specific volume.
 type Volume struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The capacity of the volume in bytes. This field is OPTIONAL. If not
 	// set (value of 0), it indicates that the capacity of the volume is
 	// unknown (e.g., NFS share).
@@ -1587,73 +1558,81 @@ type Volume struct {
 	//
 	// Indicates a volume accessible from both "zone" "Z2" and "zone" "Z3"
 	// in the "region" "R1".
-	AccessibleTopology   []*Topology `protobuf:"bytes,5,rep,name=accessible_topology,json=accessibleTopology,proto3" json:"accessible_topology,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
+	AccessibleTopology []*Topology `protobuf:"bytes,5,rep,name=accessible_topology,json=accessibleTopology,proto3" json:"accessible_topology,omitempty"`
 }
 
-func (m *Volume) Reset()         { *m = Volume{} }
-func (m *Volume) String() string { return proto.CompactTextString(m) }
-func (*Volume) ProtoMessage()    {}
-func (*Volume) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{12}
+func (x *Volume) Reset() {
+	*x = Volume{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *Volume) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Volume.Unmarshal(m, b)
-}
-func (m *Volume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Volume.Marshal(b, m, deterministic)
+func (x *Volume) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *Volume) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Volume.Merge(m, src)
-}
-func (m *Volume) XXX_Size() int {
-	return xxx_messageInfo_Volume.Size(m)
-}
-func (m *Volume) XXX_DiscardUnknown() {
-	xxx_messageInfo_Volume.DiscardUnknown(m)
+
+func (*Volume) ProtoMessage() {}
+
+func (x *Volume) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_Volume proto.InternalMessageInfo
+// Deprecated: Use Volume.ProtoReflect.Descriptor instead.
+func (*Volume) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{12}
+}
 
-func (m *Volume) GetCapacityBytes() int64 {
-	if m != nil {
-		return m.CapacityBytes
+func (x *Volume) GetCapacityBytes() int64 {
+	if x != nil {
+		return x.CapacityBytes
 	}
 	return 0
 }
 
-func (m *Volume) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *Volume) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *Volume) GetVolumeContext() map[string]string {
-	if m != nil {
-		return m.VolumeContext
+func (x *Volume) GetVolumeContext() map[string]string {
+	if x != nil {
+		return x.VolumeContext
 	}
 	return nil
 }
 
-func (m *Volume) GetContentSource() *VolumeContentSource {
-	if m != nil {
-		return m.ContentSource
+func (x *Volume) GetContentSource() *VolumeContentSource {
+	if x != nil {
+		return x.ContentSource
 	}
 	return nil
 }
 
-func (m *Volume) GetAccessibleTopology() []*Topology {
-	if m != nil {
-		return m.AccessibleTopology
+func (x *Volume) GetAccessibleTopology() []*Topology {
+	if x != nil {
+		return x.AccessibleTopology
 	}
 	return nil
 }
 
 type TopologyRequirement struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Specifies the list of topologies the provisioned volume MUST be
 	// accessible from.
 	// This field is OPTIONAL. If TopologyRequirement is specified either
@@ -1805,47 +1784,51 @@ type TopologyRequirement struct {
 	// combination of "Z3" and other possibilities from the list of
 	// requisite. If that's not possible, it should fall back  to a
 	// combination of other possibilities from the list of requisite.
-	Preferred            []*Topology `protobuf:"bytes,2,rep,name=preferred,proto3" json:"preferred,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
+	Preferred []*Topology `protobuf:"bytes,2,rep,name=preferred,proto3" json:"preferred,omitempty"`
 }
 
-func (m *TopologyRequirement) Reset()         { *m = TopologyRequirement{} }
-func (m *TopologyRequirement) String() string { return proto.CompactTextString(m) }
-func (*TopologyRequirement) ProtoMessage()    {}
-func (*TopologyRequirement) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{13}
+func (x *TopologyRequirement) Reset() {
+	*x = TopologyRequirement{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *TopologyRequirement) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TopologyRequirement.Unmarshal(m, b)
-}
-func (m *TopologyRequirement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TopologyRequirement.Marshal(b, m, deterministic)
+func (x *TopologyRequirement) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *TopologyRequirement) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TopologyRequirement.Merge(m, src)
-}
-func (m *TopologyRequirement) XXX_Size() int {
-	return xxx_messageInfo_TopologyRequirement.Size(m)
-}
-func (m *TopologyRequirement) XXX_DiscardUnknown() {
-	xxx_messageInfo_TopologyRequirement.DiscardUnknown(m)
+
+func (*TopologyRequirement) ProtoMessage() {}
+
+func (x *TopologyRequirement) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_TopologyRequirement proto.InternalMessageInfo
+// Deprecated: Use TopologyRequirement.ProtoReflect.Descriptor instead.
+func (*TopologyRequirement) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{13}
+}
 
-func (m *TopologyRequirement) GetRequisite() []*Topology {
-	if m != nil {
-		return m.Requisite
+func (x *TopologyRequirement) GetRequisite() []*Topology {
+	if x != nil {
+		return x.Requisite
 	}
 	return nil
 }
 
-func (m *TopologyRequirement) GetPreferred() []*Topology {
-	if m != nil {
-		return m.Preferred
+func (x *TopologyRequirement) GetPreferred() []*Topology {
+	if x != nil {
+		return x.Preferred
 	}
 	return nil
 }
@@ -1880,128 +1863,155 @@ func (m *TopologyRequirement) GetPreferred() []*Topology {
 // alphanumeric character with '-', '_', '.', or alphanumerics in
 // between.
 type Topology struct {
-	Segments             map[string]string `protobuf:"bytes,1,rep,name=segments,proto3" json:"segments,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
-}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 
-func (m *Topology) Reset()         { *m = Topology{} }
-func (m *Topology) String() string { return proto.CompactTextString(m) }
-func (*Topology) ProtoMessage()    {}
-func (*Topology) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{14}
+	Segments map[string]string `protobuf:"bytes,1,rep,name=segments,proto3" json:"segments,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *Topology) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Topology.Unmarshal(m, b)
-}
-func (m *Topology) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Topology.Marshal(b, m, deterministic)
-}
-func (m *Topology) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Topology.Merge(m, src)
+func (x *Topology) Reset() {
+	*x = Topology{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *Topology) XXX_Size() int {
-	return xxx_messageInfo_Topology.Size(m)
+
+func (x *Topology) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *Topology) XXX_DiscardUnknown() {
-	xxx_messageInfo_Topology.DiscardUnknown(m)
+
+func (*Topology) ProtoMessage() {}
+
+func (x *Topology) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_Topology proto.InternalMessageInfo
+// Deprecated: Use Topology.ProtoReflect.Descriptor instead.
+func (*Topology) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{14}
+}
 
-func (m *Topology) GetSegments() map[string]string {
-	if m != nil {
-		return m.Segments
+func (x *Topology) GetSegments() map[string]string {
+	if x != nil {
+		return x.Segments
 	}
 	return nil
 }
 
 type DeleteVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume to be deprovisioned.
 	// This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// Secrets required by plugin to complete volume deletion request.
 	// This field is OPTIONAL. Refer to the `Secrets Requirements`
 	// section on how to use this field.
-	Secrets              map[string]string `protobuf:"bytes,2,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Secrets map[string]string `protobuf:"bytes,2,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *DeleteVolumeRequest) Reset()         { *m = DeleteVolumeRequest{} }
-func (m *DeleteVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*DeleteVolumeRequest) ProtoMessage()    {}
-func (*DeleteVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{15}
+func (x *DeleteVolumeRequest) Reset() {
+	*x = DeleteVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *DeleteVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DeleteVolumeRequest.Unmarshal(m, b)
-}
-func (m *DeleteVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DeleteVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *DeleteVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteVolumeRequest.Merge(m, src)
-}
-func (m *DeleteVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_DeleteVolumeRequest.Size(m)
+func (x *DeleteVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *DeleteVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_DeleteVolumeRequest.DiscardUnknown(m)
+
+func (*DeleteVolumeRequest) ProtoMessage() {}
+
+func (x *DeleteVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_DeleteVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use DeleteVolumeRequest.ProtoReflect.Descriptor instead.
+func (*DeleteVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{15}
+}
 
-func (m *DeleteVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *DeleteVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *DeleteVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *DeleteVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
 type DeleteVolumeResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *DeleteVolumeResponse) Reset()         { *m = DeleteVolumeResponse{} }
-func (m *DeleteVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*DeleteVolumeResponse) ProtoMessage()    {}
-func (*DeleteVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{16}
+func (x *DeleteVolumeResponse) Reset() {
+	*x = DeleteVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *DeleteVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DeleteVolumeResponse.Unmarshal(m, b)
-}
-func (m *DeleteVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DeleteVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *DeleteVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteVolumeResponse.Merge(m, src)
-}
-func (m *DeleteVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_DeleteVolumeResponse.Size(m)
+func (x *DeleteVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *DeleteVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_DeleteVolumeResponse.DiscardUnknown(m)
+
+func (*DeleteVolumeResponse) ProtoMessage() {}
+
+func (x *DeleteVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_DeleteVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use DeleteVolumeResponse.ProtoReflect.Descriptor instead.
+func (*DeleteVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{16}
+}
 
 type ControllerPublishVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume to be used on a node.
 	// This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
@@ -2026,80 +2036,88 @@ type ControllerPublishVolumeRequest struct {
 	// CreateVolumeResponse.Volume.volume_context.
 	// This field is OPTIONAL and MUST match the volume_context of the
 	// volume identified by `volume_id`.
-	VolumeContext        map[string]string `protobuf:"bytes,6,rep,name=volume_context,json=volumeContext,proto3" json:"volume_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	VolumeContext map[string]string `protobuf:"bytes,6,rep,name=volume_context,json=volumeContext,proto3" json:"volume_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *ControllerPublishVolumeRequest) Reset()         { *m = ControllerPublishVolumeRequest{} }
-func (m *ControllerPublishVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*ControllerPublishVolumeRequest) ProtoMessage()    {}
-func (*ControllerPublishVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{17}
+func (x *ControllerPublishVolumeRequest) Reset() {
+	*x = ControllerPublishVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerPublishVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerPublishVolumeRequest.Unmarshal(m, b)
+func (x *ControllerPublishVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerPublishVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerPublishVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *ControllerPublishVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerPublishVolumeRequest.Merge(m, src)
-}
-func (m *ControllerPublishVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_ControllerPublishVolumeRequest.Size(m)
-}
-func (m *ControllerPublishVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerPublishVolumeRequest.DiscardUnknown(m)
+
+func (*ControllerPublishVolumeRequest) ProtoMessage() {}
+
+func (x *ControllerPublishVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerPublishVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use ControllerPublishVolumeRequest.ProtoReflect.Descriptor instead.
+func (*ControllerPublishVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{17}
+}
 
-func (m *ControllerPublishVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *ControllerPublishVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *ControllerPublishVolumeRequest) GetNodeId() string {
-	if m != nil {
-		return m.NodeId
+func (x *ControllerPublishVolumeRequest) GetNodeId() string {
+	if x != nil {
+		return x.NodeId
 	}
 	return ""
 }
 
-func (m *ControllerPublishVolumeRequest) GetVolumeCapability() *VolumeCapability {
-	if m != nil {
-		return m.VolumeCapability
+func (x *ControllerPublishVolumeRequest) GetVolumeCapability() *VolumeCapability {
+	if x != nil {
+		return x.VolumeCapability
 	}
 	return nil
 }
 
-func (m *ControllerPublishVolumeRequest) GetReadonly() bool {
-	if m != nil {
-		return m.Readonly
+func (x *ControllerPublishVolumeRequest) GetReadonly() bool {
+	if x != nil {
+		return x.Readonly
 	}
 	return false
 }
 
-func (m *ControllerPublishVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *ControllerPublishVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *ControllerPublishVolumeRequest) GetVolumeContext() map[string]string {
-	if m != nil {
-		return m.VolumeContext
+func (x *ControllerPublishVolumeRequest) GetVolumeContext() map[string]string {
+	if x != nil {
+		return x.VolumeContext
 	}
 	return nil
 }
 
 type ControllerPublishVolumeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Opaque static publish properties of the volume. SP MAY use this
 	// field to ensure subsequent `NodeStageVolume` or `NodePublishVolume`
 	// calls calls have contextual information.
@@ -2113,45 +2131,53 @@ type ControllerPublishVolumeResponse struct {
 	// identify the volume.
 	// This field is OPTIONAL and when present MUST be passed to
 	// subsequent `NodeStageVolume` or `NodePublishVolume` calls
-	PublishContext       map[string]string `protobuf:"bytes,1,rep,name=publish_context,json=publishContext,proto3" json:"publish_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	PublishContext map[string]string `protobuf:"bytes,1,rep,name=publish_context,json=publishContext,proto3" json:"publish_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *ControllerPublishVolumeResponse) Reset()         { *m = ControllerPublishVolumeResponse{} }
-func (m *ControllerPublishVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*ControllerPublishVolumeResponse) ProtoMessage()    {}
-func (*ControllerPublishVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{18}
+func (x *ControllerPublishVolumeResponse) Reset() {
+	*x = ControllerPublishVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerPublishVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerPublishVolumeResponse.Unmarshal(m, b)
-}
-func (m *ControllerPublishVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerPublishVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *ControllerPublishVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerPublishVolumeResponse.Merge(m, src)
-}
-func (m *ControllerPublishVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_ControllerPublishVolumeResponse.Size(m)
+func (x *ControllerPublishVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerPublishVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerPublishVolumeResponse.DiscardUnknown(m)
+
+func (*ControllerPublishVolumeResponse) ProtoMessage() {}
+
+func (x *ControllerPublishVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerPublishVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use ControllerPublishVolumeResponse.ProtoReflect.Descriptor instead.
+func (*ControllerPublishVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{18}
+}
 
-func (m *ControllerPublishVolumeResponse) GetPublishContext() map[string]string {
-	if m != nil {
-		return m.PublishContext
+func (x *ControllerPublishVolumeResponse) GetPublishContext() map[string]string {
+	if x != nil {
+		return x.PublishContext
 	}
 	return nil
 }
 
 type ControllerUnpublishVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// The ID of the node. This field is OPTIONAL. The CO SHOULD set this
@@ -2165,90 +2191,105 @@ type ControllerUnpublishVolumeRequest struct {
 	// ControllerPublishVolume call for the specified volume.
 	// This field is OPTIONAL. Refer to the `Secrets Requirements`
 	// section on how to use this field.
-	Secrets              map[string]string `protobuf:"bytes,3,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Secrets map[string]string `protobuf:"bytes,3,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *ControllerUnpublishVolumeRequest) Reset()         { *m = ControllerUnpublishVolumeRequest{} }
-func (m *ControllerUnpublishVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*ControllerUnpublishVolumeRequest) ProtoMessage()    {}
-func (*ControllerUnpublishVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{19}
+func (x *ControllerUnpublishVolumeRequest) Reset() {
+	*x = ControllerUnpublishVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerUnpublishVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerUnpublishVolumeRequest.Unmarshal(m, b)
-}
-func (m *ControllerUnpublishVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerUnpublishVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *ControllerUnpublishVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerUnpublishVolumeRequest.Merge(m, src)
+func (x *ControllerUnpublishVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerUnpublishVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_ControllerUnpublishVolumeRequest.Size(m)
-}
-func (m *ControllerUnpublishVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerUnpublishVolumeRequest.DiscardUnknown(m)
+
+func (*ControllerUnpublishVolumeRequest) ProtoMessage() {}
+
+func (x *ControllerUnpublishVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerUnpublishVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use ControllerUnpublishVolumeRequest.ProtoReflect.Descriptor instead.
+func (*ControllerUnpublishVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{19}
+}
 
-func (m *ControllerUnpublishVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *ControllerUnpublishVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *ControllerUnpublishVolumeRequest) GetNodeId() string {
-	if m != nil {
-		return m.NodeId
+func (x *ControllerUnpublishVolumeRequest) GetNodeId() string {
+	if x != nil {
+		return x.NodeId
 	}
 	return ""
 }
 
-func (m *ControllerUnpublishVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *ControllerUnpublishVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
 type ControllerUnpublishVolumeResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *ControllerUnpublishVolumeResponse) Reset()         { *m = ControllerUnpublishVolumeResponse{} }
-func (m *ControllerUnpublishVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*ControllerUnpublishVolumeResponse) ProtoMessage()    {}
-func (*ControllerUnpublishVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{20}
+func (x *ControllerUnpublishVolumeResponse) Reset() {
+	*x = ControllerUnpublishVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerUnpublishVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerUnpublishVolumeResponse.Unmarshal(m, b)
-}
-func (m *ControllerUnpublishVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerUnpublishVolumeResponse.Marshal(b, m, deterministic)
+func (x *ControllerUnpublishVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerUnpublishVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerUnpublishVolumeResponse.Merge(m, src)
-}
-func (m *ControllerUnpublishVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_ControllerUnpublishVolumeResponse.Size(m)
-}
-func (m *ControllerUnpublishVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerUnpublishVolumeResponse.DiscardUnknown(m)
+
+func (*ControllerUnpublishVolumeResponse) ProtoMessage() {}
+
+func (x *ControllerUnpublishVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerUnpublishVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use ControllerUnpublishVolumeResponse.ProtoReflect.Descriptor instead.
+func (*ControllerUnpublishVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{20}
+}
 
 type ValidateVolumeCapabilitiesRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume to check. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// Volume context as returned by SP in
@@ -2269,80 +2310,88 @@ type ValidateVolumeCapabilitiesRequest struct {
 	Secrets map[string]string `protobuf:"bytes,5,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	// See CreateVolumeRequest.mutable_parameters.
 	// This field is OPTIONAL.
-	MutableParameters    map[string]string `protobuf:"bytes,6,rep,name=mutable_parameters,json=mutableParameters,proto3" json:"mutable_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	MutableParameters map[string]string `protobuf:"bytes,6,rep,name=mutable_parameters,json=mutableParameters,proto3" json:"mutable_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *ValidateVolumeCapabilitiesRequest) Reset()         { *m = ValidateVolumeCapabilitiesRequest{} }
-func (m *ValidateVolumeCapabilitiesRequest) String() string { return proto.CompactTextString(m) }
-func (*ValidateVolumeCapabilitiesRequest) ProtoMessage()    {}
-func (*ValidateVolumeCapabilitiesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{21}
+func (x *ValidateVolumeCapabilitiesRequest) Reset() {
+	*x = ValidateVolumeCapabilitiesRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ValidateVolumeCapabilitiesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesRequest.Unmarshal(m, b)
-}
-func (m *ValidateVolumeCapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesRequest.Marshal(b, m, deterministic)
-}
-func (m *ValidateVolumeCapabilitiesRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValidateVolumeCapabilitiesRequest.Merge(m, src)
+func (x *ValidateVolumeCapabilitiesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ValidateVolumeCapabilitiesRequest) XXX_Size() int {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesRequest.Size(m)
-}
-func (m *ValidateVolumeCapabilitiesRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ValidateVolumeCapabilitiesRequest.DiscardUnknown(m)
+
+func (*ValidateVolumeCapabilitiesRequest) ProtoMessage() {}
+
+func (x *ValidateVolumeCapabilitiesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ValidateVolumeCapabilitiesRequest proto.InternalMessageInfo
+// Deprecated: Use ValidateVolumeCapabilitiesRequest.ProtoReflect.Descriptor instead.
+func (*ValidateVolumeCapabilitiesRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{21}
+}
 
-func (m *ValidateVolumeCapabilitiesRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *ValidateVolumeCapabilitiesRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *ValidateVolumeCapabilitiesRequest) GetVolumeContext() map[string]string {
-	if m != nil {
-		return m.VolumeContext
+func (x *ValidateVolumeCapabilitiesRequest) GetVolumeContext() map[string]string {
+	if x != nil {
+		return x.VolumeContext
 	}
 	return nil
 }
 
-func (m *ValidateVolumeCapabilitiesRequest) GetVolumeCapabilities() []*VolumeCapability {
-	if m != nil {
-		return m.VolumeCapabilities
+func (x *ValidateVolumeCapabilitiesRequest) GetVolumeCapabilities() []*VolumeCapability {
+	if x != nil {
+		return x.VolumeCapabilities
 	}
 	return nil
 }
 
-func (m *ValidateVolumeCapabilitiesRequest) GetParameters() map[string]string {
-	if m != nil {
-		return m.Parameters
+func (x *ValidateVolumeCapabilitiesRequest) GetParameters() map[string]string {
+	if x != nil {
+		return x.Parameters
 	}
 	return nil
 }
 
-func (m *ValidateVolumeCapabilitiesRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *ValidateVolumeCapabilitiesRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *ValidateVolumeCapabilitiesRequest) GetMutableParameters() map[string]string {
-	if m != nil {
-		return m.MutableParameters
+func (x *ValidateVolumeCapabilitiesRequest) GetMutableParameters() map[string]string {
+	if x != nil {
+		return x.MutableParameters
 	}
 	return nil
 }
 
 type ValidateVolumeCapabilitiesResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Confirmed indicates to the CO the set of capabilities that the
 	// plugin has validated. This field SHALL only be set to a non-empty
 	// value for successful validation responses.
@@ -2355,127 +2404,60 @@ type ValidateVolumeCapabilitiesResponse struct {
 	// Message to the CO if `confirmed` above is empty. This field is
 	// OPTIONAL.
 	// An empty string is equal to an unspecified field value.
-	Message              string   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ValidateVolumeCapabilitiesResponse) Reset()         { *m = ValidateVolumeCapabilitiesResponse{} }
-func (m *ValidateVolumeCapabilitiesResponse) String() string { return proto.CompactTextString(m) }
-func (*ValidateVolumeCapabilitiesResponse) ProtoMessage()    {}
-func (*ValidateVolumeCapabilitiesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{22}
-}
-
-func (m *ValidateVolumeCapabilitiesResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesResponse.Unmarshal(m, b)
-}
-func (m *ValidateVolumeCapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesResponse.Marshal(b, m, deterministic)
-}
-func (m *ValidateVolumeCapabilitiesResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValidateVolumeCapabilitiesResponse.Merge(m, src)
-}
-func (m *ValidateVolumeCapabilitiesResponse) XXX_Size() int {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesResponse.Size(m)
-}
-func (m *ValidateVolumeCapabilitiesResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ValidateVolumeCapabilitiesResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ValidateVolumeCapabilitiesResponse proto.InternalMessageInfo
-
-func (m *ValidateVolumeCapabilitiesResponse) GetConfirmed() *ValidateVolumeCapabilitiesResponse_Confirmed {
-	if m != nil {
-		return m.Confirmed
-	}
-	return nil
+	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
 }
 
-func (m *ValidateVolumeCapabilitiesResponse) GetMessage() string {
-	if m != nil {
-		return m.Message
+func (x *ValidateVolumeCapabilitiesResponse) Reset() {
+	*x = ValidateVolumeCapabilitiesResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return ""
-}
-
-type ValidateVolumeCapabilitiesResponse_Confirmed struct {
-	// Volume context validated by the plugin.
-	// This field is OPTIONAL.
-	VolumeContext map[string]string `protobuf:"bytes,1,rep,name=volume_context,json=volumeContext,proto3" json:"volume_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	// Volume capabilities supported by the plugin.
-	// This field is REQUIRED.
-	VolumeCapabilities []*VolumeCapability `protobuf:"bytes,2,rep,name=volume_capabilities,json=volumeCapabilities,proto3" json:"volume_capabilities,omitempty"`
-	// The volume creation parameters validated by the plugin.
-	// This field is OPTIONAL.
-	Parameters map[string]string `protobuf:"bytes,3,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	// The volume creation mutable_parameters validated by the plugin.
-	// This field is OPTIONAL.
-	MutableParameters    map[string]string `protobuf:"bytes,4,rep,name=mutable_parameters,json=mutableParameters,proto3" json:"mutable_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
 }
 
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) Reset() {
-	*m = ValidateVolumeCapabilitiesResponse_Confirmed{}
-}
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) String() string {
-	return proto.CompactTextString(m)
-}
-func (*ValidateVolumeCapabilitiesResponse_Confirmed) ProtoMessage() {}
-func (*ValidateVolumeCapabilitiesResponse_Confirmed) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{22, 0}
-}
-
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesResponse_Confirmed.Unmarshal(m, b)
-}
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesResponse_Confirmed.Marshal(b, m, deterministic)
-}
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValidateVolumeCapabilitiesResponse_Confirmed.Merge(m, src)
-}
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) XXX_Size() int {
-	return xxx_messageInfo_ValidateVolumeCapabilitiesResponse_Confirmed.Size(m)
-}
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) XXX_DiscardUnknown() {
-	xxx_messageInfo_ValidateVolumeCapabilitiesResponse_Confirmed.DiscardUnknown(m)
+func (x *ValidateVolumeCapabilitiesResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_ValidateVolumeCapabilitiesResponse_Confirmed proto.InternalMessageInfo
+func (*ValidateVolumeCapabilitiesResponse) ProtoMessage() {}
 
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) GetVolumeContext() map[string]string {
-	if m != nil {
-		return m.VolumeContext
+func (x *ValidateVolumeCapabilitiesResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return nil
+	return mi.MessageOf(x)
 }
 
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) GetVolumeCapabilities() []*VolumeCapability {
-	if m != nil {
-		return m.VolumeCapabilities
-	}
-	return nil
+// Deprecated: Use ValidateVolumeCapabilitiesResponse.ProtoReflect.Descriptor instead.
+func (*ValidateVolumeCapabilitiesResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{22}
 }
 
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) GetParameters() map[string]string {
-	if m != nil {
-		return m.Parameters
+func (x *ValidateVolumeCapabilitiesResponse) GetConfirmed() *ValidateVolumeCapabilitiesResponse_Confirmed {
+	if x != nil {
+		return x.Confirmed
 	}
 	return nil
 }
 
-func (m *ValidateVolumeCapabilitiesResponse_Confirmed) GetMutableParameters() map[string]string {
-	if m != nil {
-		return m.MutableParameters
+func (x *ValidateVolumeCapabilitiesResponse) GetMessage() string {
+	if x != nil {
+		return x.Message
 	}
-	return nil
+	return ""
 }
 
 type ListVolumesRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// If specified (non-zero value), the Plugin MUST NOT return more
 	// entries than this number in the response. If the actual number of
 	// entries is more than this number, the Plugin MUST set `next_token`
@@ -2489,52 +2471,60 @@ type ListVolumesRequest struct {
 	// `next_token` returned by a previous `ListVolumes` call to get the
 	// next page of entries. This field is OPTIONAL.
 	// An empty string is equal to an unspecified field value.
-	StartingToken        string   `protobuf:"bytes,2,opt,name=starting_token,json=startingToken,proto3" json:"starting_token,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	StartingToken string `protobuf:"bytes,2,opt,name=starting_token,json=startingToken,proto3" json:"starting_token,omitempty"`
 }
 
-func (m *ListVolumesRequest) Reset()         { *m = ListVolumesRequest{} }
-func (m *ListVolumesRequest) String() string { return proto.CompactTextString(m) }
-func (*ListVolumesRequest) ProtoMessage()    {}
-func (*ListVolumesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{23}
+func (x *ListVolumesRequest) Reset() {
+	*x = ListVolumesRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ListVolumesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ListVolumesRequest.Unmarshal(m, b)
+func (x *ListVolumesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ListVolumesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ListVolumesRequest.Marshal(b, m, deterministic)
-}
-func (m *ListVolumesRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListVolumesRequest.Merge(m, src)
-}
-func (m *ListVolumesRequest) XXX_Size() int {
-	return xxx_messageInfo_ListVolumesRequest.Size(m)
-}
-func (m *ListVolumesRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListVolumesRequest.DiscardUnknown(m)
+
+func (*ListVolumesRequest) ProtoMessage() {}
+
+func (x *ListVolumesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ListVolumesRequest proto.InternalMessageInfo
+// Deprecated: Use ListVolumesRequest.ProtoReflect.Descriptor instead.
+func (*ListVolumesRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{23}
+}
 
-func (m *ListVolumesRequest) GetMaxEntries() int32 {
-	if m != nil {
-		return m.MaxEntries
+func (x *ListVolumesRequest) GetMaxEntries() int32 {
+	if x != nil {
+		return x.MaxEntries
 	}
 	return 0
 }
 
-func (m *ListVolumesRequest) GetStartingToken() string {
-	if m != nil {
-		return m.StartingToken
+func (x *ListVolumesRequest) GetStartingToken() string {
+	if x != nil {
+		return x.StartingToken
 	}
 	return ""
 }
 
 type ListVolumesResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	Entries []*ListVolumesResponse_Entry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
 	// This token allows you to get the next page of entries for
 	// `ListVolumes` request. If the number of entries is larger than
@@ -2542,314 +2532,166 @@ type ListVolumesResponse struct {
 	// `starting_token` field in the next `ListVolumes` request. This
 	// field is OPTIONAL.
 	// An empty string is equal to an unspecified field value.
-	NextToken            string   `protobuf:"bytes,2,opt,name=next_token,json=nextToken,proto3" json:"next_token,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ListVolumesResponse) Reset()         { *m = ListVolumesResponse{} }
-func (m *ListVolumesResponse) String() string { return proto.CompactTextString(m) }
-func (*ListVolumesResponse) ProtoMessage()    {}
-func (*ListVolumesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{24}
-}
-
-func (m *ListVolumesResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ListVolumesResponse.Unmarshal(m, b)
-}
-func (m *ListVolumesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ListVolumesResponse.Marshal(b, m, deterministic)
-}
-func (m *ListVolumesResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListVolumesResponse.Merge(m, src)
-}
-func (m *ListVolumesResponse) XXX_Size() int {
-	return xxx_messageInfo_ListVolumesResponse.Size(m)
-}
-func (m *ListVolumesResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListVolumesResponse.DiscardUnknown(m)
+	NextToken string `protobuf:"bytes,2,opt,name=next_token,json=nextToken,proto3" json:"next_token,omitempty"`
 }
 
-var xxx_messageInfo_ListVolumesResponse proto.InternalMessageInfo
-
-func (m *ListVolumesResponse) GetEntries() []*ListVolumesResponse_Entry {
-	if m != nil {
-		return m.Entries
+func (x *ListVolumesResponse) Reset() {
+	*x = ListVolumesResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return nil
 }
 
-func (m *ListVolumesResponse) GetNextToken() string {
-	if m != nil {
-		return m.NextToken
-	}
-	return ""
+func (x *ListVolumesResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-type ListVolumesResponse_VolumeStatus struct {
-	// A list of all `node_id` of nodes that the volume in this entry
-	// is controller published on.
-	// This field is OPTIONAL. If it is not specified and the SP has
-	// the LIST_VOLUMES_PUBLISHED_NODES controller capability, the CO
-	// MAY assume the volume is not controller published to any nodes.
-	// If the field is not specified and the SP does not have the
-	// LIST_VOLUMES_PUBLISHED_NODES controller capability, the CO MUST
-	// not interpret this field.
-	// published_node_ids MAY include nodes not published to or
-	// reported by the SP. The CO MUST be resilient to that.
-	PublishedNodeIds []string `protobuf:"bytes,1,rep,name=published_node_ids,json=publishedNodeIds,proto3" json:"published_node_ids,omitempty"`
-	// Information about the current condition of the volume.
-	// This field is OPTIONAL.
-	// This field MUST be specified if the
-	// VOLUME_CONDITION controller capability is supported.
-	VolumeCondition      *VolumeCondition `protobuf:"bytes,2,opt,name=volume_condition,json=volumeCondition,proto3" json:"volume_condition,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
-}
+func (*ListVolumesResponse) ProtoMessage() {}
 
-func (m *ListVolumesResponse_VolumeStatus) Reset()         { *m = ListVolumesResponse_VolumeStatus{} }
-func (m *ListVolumesResponse_VolumeStatus) String() string { return proto.CompactTextString(m) }
-func (*ListVolumesResponse_VolumeStatus) ProtoMessage()    {}
-func (*ListVolumesResponse_VolumeStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{24, 0}
+func (x *ListVolumesResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-func (m *ListVolumesResponse_VolumeStatus) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ListVolumesResponse_VolumeStatus.Unmarshal(m, b)
-}
-func (m *ListVolumesResponse_VolumeStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ListVolumesResponse_VolumeStatus.Marshal(b, m, deterministic)
-}
-func (m *ListVolumesResponse_VolumeStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListVolumesResponse_VolumeStatus.Merge(m, src)
-}
-func (m *ListVolumesResponse_VolumeStatus) XXX_Size() int {
-	return xxx_messageInfo_ListVolumesResponse_VolumeStatus.Size(m)
-}
-func (m *ListVolumesResponse_VolumeStatus) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListVolumesResponse_VolumeStatus.DiscardUnknown(m)
+// Deprecated: Use ListVolumesResponse.ProtoReflect.Descriptor instead.
+func (*ListVolumesResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{24}
 }
 
-var xxx_messageInfo_ListVolumesResponse_VolumeStatus proto.InternalMessageInfo
-
-func (m *ListVolumesResponse_VolumeStatus) GetPublishedNodeIds() []string {
-	if m != nil {
-		return m.PublishedNodeIds
+func (x *ListVolumesResponse) GetEntries() []*ListVolumesResponse_Entry {
+	if x != nil {
+		return x.Entries
 	}
 	return nil
 }
 
-func (m *ListVolumesResponse_VolumeStatus) GetVolumeCondition() *VolumeCondition {
-	if m != nil {
-		return m.VolumeCondition
+func (x *ListVolumesResponse) GetNextToken() string {
+	if x != nil {
+		return x.NextToken
 	}
-	return nil
-}
-
-type ListVolumesResponse_Entry struct {
-	// This field is REQUIRED
-	Volume *Volume `protobuf:"bytes,1,opt,name=volume,proto3" json:"volume,omitempty"`
-	// This field is OPTIONAL. This field MUST be specified if the
-	// LIST_VOLUMES_PUBLISHED_NODES controller capability is
-	// supported.
-	Status               *ListVolumesResponse_VolumeStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
-	XXX_unrecognized     []byte                            `json:"-"`
-	XXX_sizecache        int32                             `json:"-"`
+	return ""
 }
 
-func (m *ListVolumesResponse_Entry) Reset()         { *m = ListVolumesResponse_Entry{} }
-func (m *ListVolumesResponse_Entry) String() string { return proto.CompactTextString(m) }
-func (*ListVolumesResponse_Entry) ProtoMessage()    {}
-func (*ListVolumesResponse_Entry) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{24, 1}
-}
+type ControllerGetVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 
-func (m *ListVolumesResponse_Entry) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ListVolumesResponse_Entry.Unmarshal(m, b)
-}
-func (m *ListVolumesResponse_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ListVolumesResponse_Entry.Marshal(b, m, deterministic)
-}
-func (m *ListVolumesResponse_Entry) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListVolumesResponse_Entry.Merge(m, src)
-}
-func (m *ListVolumesResponse_Entry) XXX_Size() int {
-	return xxx_messageInfo_ListVolumesResponse_Entry.Size(m)
-}
-func (m *ListVolumesResponse_Entry) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListVolumesResponse_Entry.DiscardUnknown(m)
+	// The ID of the volume to fetch current volume information for.
+	// This field is REQUIRED.
+	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 }
 
-var xxx_messageInfo_ListVolumesResponse_Entry proto.InternalMessageInfo
-
-func (m *ListVolumesResponse_Entry) GetVolume() *Volume {
-	if m != nil {
-		return m.Volume
+func (x *ControllerGetVolumeRequest) Reset() {
+	*x = ControllerGetVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return nil
 }
 
-func (m *ListVolumesResponse_Entry) GetStatus() *ListVolumesResponse_VolumeStatus {
-	if m != nil {
-		return m.Status
-	}
-	return nil
+func (x *ControllerGetVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-type ControllerGetVolumeRequest struct {
-	// The ID of the volume to fetch current volume information for.
-	// This field is REQUIRED.
-	VolumeId             string   `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
+func (*ControllerGetVolumeRequest) ProtoMessage() {}
 
-func (m *ControllerGetVolumeRequest) Reset()         { *m = ControllerGetVolumeRequest{} }
-func (m *ControllerGetVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*ControllerGetVolumeRequest) ProtoMessage()    {}
-func (*ControllerGetVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{25}
+func (x *ControllerGetVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-func (m *ControllerGetVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerGetVolumeRequest.Unmarshal(m, b)
-}
-func (m *ControllerGetVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerGetVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *ControllerGetVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerGetVolumeRequest.Merge(m, src)
-}
-func (m *ControllerGetVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_ControllerGetVolumeRequest.Size(m)
-}
-func (m *ControllerGetVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerGetVolumeRequest.DiscardUnknown(m)
+// Deprecated: Use ControllerGetVolumeRequest.ProtoReflect.Descriptor instead.
+func (*ControllerGetVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{25}
 }
 
-var xxx_messageInfo_ControllerGetVolumeRequest proto.InternalMessageInfo
-
-func (m *ControllerGetVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *ControllerGetVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
 type ControllerGetVolumeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// This field is REQUIRED
 	Volume *Volume `protobuf:"bytes,1,opt,name=volume,proto3" json:"volume,omitempty"`
 	// This field is REQUIRED.
-	Status               *ControllerGetVolumeResponse_VolumeStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                                  `json:"-"`
-	XXX_unrecognized     []byte                                    `json:"-"`
-	XXX_sizecache        int32                                     `json:"-"`
-}
-
-func (m *ControllerGetVolumeResponse) Reset()         { *m = ControllerGetVolumeResponse{} }
-func (m *ControllerGetVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*ControllerGetVolumeResponse) ProtoMessage()    {}
-func (*ControllerGetVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{26}
+	Status *ControllerGetVolumeResponse_VolumeStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
 }
 
-func (m *ControllerGetVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerGetVolumeResponse.Unmarshal(m, b)
-}
-func (m *ControllerGetVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerGetVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *ControllerGetVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerGetVolumeResponse.Merge(m, src)
-}
-func (m *ControllerGetVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_ControllerGetVolumeResponse.Size(m)
-}
-func (m *ControllerGetVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerGetVolumeResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ControllerGetVolumeResponse proto.InternalMessageInfo
-
-func (m *ControllerGetVolumeResponse) GetVolume() *Volume {
-	if m != nil {
-		return m.Volume
+func (x *ControllerGetVolumeResponse) Reset() {
+	*x = ControllerGetVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return nil
 }
 
-func (m *ControllerGetVolumeResponse) GetStatus() *ControllerGetVolumeResponse_VolumeStatus {
-	if m != nil {
-		return m.Status
-	}
-	return nil
+func (x *ControllerGetVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-type ControllerGetVolumeResponse_VolumeStatus struct {
-	// A list of all the `node_id` of nodes that this volume is
-	// controller published on.
-	// This field is OPTIONAL.
-	// This field MUST be specified if the LIST_VOLUMES_PUBLISHED_NODES
-	// controller capability is supported.
-	// published_node_ids MAY include nodes not published to or
-	// reported by the SP. The CO MUST be resilient to that.
-	PublishedNodeIds []string `protobuf:"bytes,1,rep,name=published_node_ids,json=publishedNodeIds,proto3" json:"published_node_ids,omitempty"`
-	// Information about the current condition of the volume.
-	// This field is OPTIONAL.
-	// This field MUST be specified if the
-	// VOLUME_CONDITION controller capability is supported.
-	VolumeCondition      *VolumeCondition `protobuf:"bytes,2,opt,name=volume_condition,json=volumeCondition,proto3" json:"volume_condition,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
-}
+func (*ControllerGetVolumeResponse) ProtoMessage() {}
 
-func (m *ControllerGetVolumeResponse_VolumeStatus) Reset() {
-	*m = ControllerGetVolumeResponse_VolumeStatus{}
-}
-func (m *ControllerGetVolumeResponse_VolumeStatus) String() string { return proto.CompactTextString(m) }
-func (*ControllerGetVolumeResponse_VolumeStatus) ProtoMessage()    {}
-func (*ControllerGetVolumeResponse_VolumeStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{26, 0}
+func (x *ControllerGetVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-func (m *ControllerGetVolumeResponse_VolumeStatus) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerGetVolumeResponse_VolumeStatus.Unmarshal(m, b)
-}
-func (m *ControllerGetVolumeResponse_VolumeStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerGetVolumeResponse_VolumeStatus.Marshal(b, m, deterministic)
-}
-func (m *ControllerGetVolumeResponse_VolumeStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerGetVolumeResponse_VolumeStatus.Merge(m, src)
-}
-func (m *ControllerGetVolumeResponse_VolumeStatus) XXX_Size() int {
-	return xxx_messageInfo_ControllerGetVolumeResponse_VolumeStatus.Size(m)
-}
-func (m *ControllerGetVolumeResponse_VolumeStatus) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerGetVolumeResponse_VolumeStatus.DiscardUnknown(m)
+// Deprecated: Use ControllerGetVolumeResponse.ProtoReflect.Descriptor instead.
+func (*ControllerGetVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{26}
 }
 
-var xxx_messageInfo_ControllerGetVolumeResponse_VolumeStatus proto.InternalMessageInfo
-
-func (m *ControllerGetVolumeResponse_VolumeStatus) GetPublishedNodeIds() []string {
-	if m != nil {
-		return m.PublishedNodeIds
+func (x *ControllerGetVolumeResponse) GetVolume() *Volume {
+	if x != nil {
+		return x.Volume
 	}
 	return nil
 }
 
-func (m *ControllerGetVolumeResponse_VolumeStatus) GetVolumeCondition() *VolumeCondition {
-	if m != nil {
-		return m.VolumeCondition
+func (x *ControllerGetVolumeResponse) GetStatus() *ControllerGetVolumeResponse_VolumeStatus {
+	if x != nil {
+		return x.Status
 	}
 	return nil
 }
 
 type ControllerModifyVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Contains identity information for the existing volume.
 	// This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
@@ -2865,90 +2707,105 @@ type ControllerModifyVolumeRequest struct {
 	// parameters it intends to modify. SPs MUST NOT modify volumes based
 	// on the absence of keys, only keys that are specified should result
 	// in modifications to the volume.
-	MutableParameters    map[string]string `protobuf:"bytes,3,rep,name=mutable_parameters,json=mutableParameters,proto3" json:"mutable_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	MutableParameters map[string]string `protobuf:"bytes,3,rep,name=mutable_parameters,json=mutableParameters,proto3" json:"mutable_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *ControllerModifyVolumeRequest) Reset()         { *m = ControllerModifyVolumeRequest{} }
-func (m *ControllerModifyVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*ControllerModifyVolumeRequest) ProtoMessage()    {}
-func (*ControllerModifyVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{27}
+func (x *ControllerModifyVolumeRequest) Reset() {
+	*x = ControllerModifyVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerModifyVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerModifyVolumeRequest.Unmarshal(m, b)
-}
-func (m *ControllerModifyVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerModifyVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *ControllerModifyVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerModifyVolumeRequest.Merge(m, src)
-}
-func (m *ControllerModifyVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_ControllerModifyVolumeRequest.Size(m)
-}
-func (m *ControllerModifyVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerModifyVolumeRequest.DiscardUnknown(m)
+func (x *ControllerModifyVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_ControllerModifyVolumeRequest proto.InternalMessageInfo
+func (*ControllerModifyVolumeRequest) ProtoMessage() {}
 
-func (m *ControllerModifyVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *ControllerModifyVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return ""
+	return mi.MessageOf(x)
 }
 
-func (m *ControllerModifyVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+// Deprecated: Use ControllerModifyVolumeRequest.ProtoReflect.Descriptor instead.
+func (*ControllerModifyVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *ControllerModifyVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
+	}
+	return ""
+}
+
+func (x *ControllerModifyVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *ControllerModifyVolumeRequest) GetMutableParameters() map[string]string {
-	if m != nil {
-		return m.MutableParameters
+func (x *ControllerModifyVolumeRequest) GetMutableParameters() map[string]string {
+	if x != nil {
+		return x.MutableParameters
 	}
 	return nil
 }
 
 type ControllerModifyVolumeResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *ControllerModifyVolumeResponse) Reset()         { *m = ControllerModifyVolumeResponse{} }
-func (m *ControllerModifyVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*ControllerModifyVolumeResponse) ProtoMessage()    {}
-func (*ControllerModifyVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{28}
+func (x *ControllerModifyVolumeResponse) Reset() {
+	*x = ControllerModifyVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerModifyVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerModifyVolumeResponse.Unmarshal(m, b)
-}
-func (m *ControllerModifyVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerModifyVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *ControllerModifyVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerModifyVolumeResponse.Merge(m, src)
+func (x *ControllerModifyVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerModifyVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_ControllerModifyVolumeResponse.Size(m)
-}
-func (m *ControllerModifyVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerModifyVolumeResponse.DiscardUnknown(m)
+
+func (*ControllerModifyVolumeResponse) ProtoMessage() {}
+
+func (x *ControllerModifyVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerModifyVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use ControllerModifyVolumeResponse.ProtoReflect.Descriptor instead.
+func (*ControllerModifyVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{28}
+}
 
 type GetCapacityRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// If specified, the Plugin SHALL report the capacity of the storage
 	// that can be used to provision volumes that satisfy ALL of the
 	// specified `volume_capabilities`. These are the same
@@ -2966,59 +2823,67 @@ type GetCapacityRequest struct {
 	// `accessible_topology` the CO returns in a `CreateVolumeResponse`.
 	// This field is OPTIONAL. This field SHALL NOT be set unless the
 	// plugin advertises the VOLUME_ACCESSIBILITY_CONSTRAINTS capability.
-	AccessibleTopology   *Topology `protobuf:"bytes,3,opt,name=accessible_topology,json=accessibleTopology,proto3" json:"accessible_topology,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	AccessibleTopology *Topology `protobuf:"bytes,3,opt,name=accessible_topology,json=accessibleTopology,proto3" json:"accessible_topology,omitempty"`
 }
 
-func (m *GetCapacityRequest) Reset()         { *m = GetCapacityRequest{} }
-func (m *GetCapacityRequest) String() string { return proto.CompactTextString(m) }
-func (*GetCapacityRequest) ProtoMessage()    {}
-func (*GetCapacityRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{29}
+func (x *GetCapacityRequest) Reset() {
+	*x = GetCapacityRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GetCapacityRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetCapacityRequest.Unmarshal(m, b)
-}
-func (m *GetCapacityRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetCapacityRequest.Marshal(b, m, deterministic)
-}
-func (m *GetCapacityRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetCapacityRequest.Merge(m, src)
-}
-func (m *GetCapacityRequest) XXX_Size() int {
-	return xxx_messageInfo_GetCapacityRequest.Size(m)
+func (x *GetCapacityRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GetCapacityRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetCapacityRequest.DiscardUnknown(m)
+
+func (*GetCapacityRequest) ProtoMessage() {}
+
+func (x *GetCapacityRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GetCapacityRequest proto.InternalMessageInfo
+// Deprecated: Use GetCapacityRequest.ProtoReflect.Descriptor instead.
+func (*GetCapacityRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{29}
+}
 
-func (m *GetCapacityRequest) GetVolumeCapabilities() []*VolumeCapability {
-	if m != nil {
-		return m.VolumeCapabilities
+func (x *GetCapacityRequest) GetVolumeCapabilities() []*VolumeCapability {
+	if x != nil {
+		return x.VolumeCapabilities
 	}
 	return nil
 }
 
-func (m *GetCapacityRequest) GetParameters() map[string]string {
-	if m != nil {
-		return m.Parameters
+func (x *GetCapacityRequest) GetParameters() map[string]string {
+	if x != nil {
+		return x.Parameters
 	}
 	return nil
 }
 
-func (m *GetCapacityRequest) GetAccessibleTopology() *Topology {
-	if m != nil {
-		return m.AccessibleTopology
+func (x *GetCapacityRequest) GetAccessibleTopology() *Topology {
+	if x != nil {
+		return x.AccessibleTopology
 	}
 	return nil
 }
 
 type GetCapacityResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The available capacity, in bytes, of the storage that can be used
 	// to provision volumes. If `volume_capabilities` or `parameters` is
 	// specified in the request, the Plugin SHALL take those into
@@ -3041,7 +2906,7 @@ type GetCapacityResponse struct {
 	// a maximum size for individual volumes and leave it unset
 	// otherwise. COs MAY use it to make decision about
 	// where to create volumes.
-	MaximumVolumeSize *wrappers.Int64Value `protobuf:"bytes,2,opt,name=maximum_volume_size,json=maximumVolumeSize,proto3" json:"maximum_volume_size,omitempty"`
+	MaximumVolumeSize *wrapperspb.Int64Value `protobuf:"bytes,2,opt,name=maximum_volume_size,json=maximumVolumeSize,proto3" json:"maximum_volume_size,omitempty"`
 	// The smallest size that may be used in a
 	// CreateVolumeRequest.capacity_range.limit_bytes field
 	// to create a volume with the same parameters as those in
@@ -3057,176 +2922,193 @@ type GetCapacityResponse struct {
 	// a minimum size for individual volumes and leave it unset
 	// otherwise. COs MAY use it to make decision about
 	// where to create volumes.
-	MinimumVolumeSize    *wrappers.Int64Value `protobuf:"bytes,3,opt,name=minimum_volume_size,json=minimumVolumeSize,proto3" json:"minimum_volume_size,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
-	XXX_unrecognized     []byte               `json:"-"`
-	XXX_sizecache        int32                `json:"-"`
+	MinimumVolumeSize *wrapperspb.Int64Value `protobuf:"bytes,3,opt,name=minimum_volume_size,json=minimumVolumeSize,proto3" json:"minimum_volume_size,omitempty"`
 }
 
-func (m *GetCapacityResponse) Reset()         { *m = GetCapacityResponse{} }
-func (m *GetCapacityResponse) String() string { return proto.CompactTextString(m) }
-func (*GetCapacityResponse) ProtoMessage()    {}
-func (*GetCapacityResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{30}
+func (x *GetCapacityResponse) Reset() {
+	*x = GetCapacityResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GetCapacityResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetCapacityResponse.Unmarshal(m, b)
-}
-func (m *GetCapacityResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetCapacityResponse.Marshal(b, m, deterministic)
+func (x *GetCapacityResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GetCapacityResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetCapacityResponse.Merge(m, src)
-}
-func (m *GetCapacityResponse) XXX_Size() int {
-	return xxx_messageInfo_GetCapacityResponse.Size(m)
-}
-func (m *GetCapacityResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetCapacityResponse.DiscardUnknown(m)
+
+func (*GetCapacityResponse) ProtoMessage() {}
+
+func (x *GetCapacityResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GetCapacityResponse proto.InternalMessageInfo
+// Deprecated: Use GetCapacityResponse.ProtoReflect.Descriptor instead.
+func (*GetCapacityResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{30}
+}
 
-func (m *GetCapacityResponse) GetAvailableCapacity() int64 {
-	if m != nil {
-		return m.AvailableCapacity
+func (x *GetCapacityResponse) GetAvailableCapacity() int64 {
+	if x != nil {
+		return x.AvailableCapacity
 	}
 	return 0
 }
 
-func (m *GetCapacityResponse) GetMaximumVolumeSize() *wrappers.Int64Value {
-	if m != nil {
-		return m.MaximumVolumeSize
+func (x *GetCapacityResponse) GetMaximumVolumeSize() *wrapperspb.Int64Value {
+	if x != nil {
+		return x.MaximumVolumeSize
 	}
 	return nil
 }
 
-func (m *GetCapacityResponse) GetMinimumVolumeSize() *wrappers.Int64Value {
-	if m != nil {
-		return m.MinimumVolumeSize
+func (x *GetCapacityResponse) GetMinimumVolumeSize() *wrapperspb.Int64Value {
+	if x != nil {
+		return x.MinimumVolumeSize
 	}
 	return nil
 }
 
 type ControllerGetCapabilitiesRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *ControllerGetCapabilitiesRequest) Reset()         { *m = ControllerGetCapabilitiesRequest{} }
-func (m *ControllerGetCapabilitiesRequest) String() string { return proto.CompactTextString(m) }
-func (*ControllerGetCapabilitiesRequest) ProtoMessage()    {}
-func (*ControllerGetCapabilitiesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{31}
+func (x *ControllerGetCapabilitiesRequest) Reset() {
+	*x = ControllerGetCapabilitiesRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerGetCapabilitiesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerGetCapabilitiesRequest.Unmarshal(m, b)
+func (x *ControllerGetCapabilitiesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerGetCapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerGetCapabilitiesRequest.Marshal(b, m, deterministic)
-}
-func (m *ControllerGetCapabilitiesRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerGetCapabilitiesRequest.Merge(m, src)
-}
-func (m *ControllerGetCapabilitiesRequest) XXX_Size() int {
-	return xxx_messageInfo_ControllerGetCapabilitiesRequest.Size(m)
-}
-func (m *ControllerGetCapabilitiesRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerGetCapabilitiesRequest.DiscardUnknown(m)
+
+func (*ControllerGetCapabilitiesRequest) ProtoMessage() {}
+
+func (x *ControllerGetCapabilitiesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerGetCapabilitiesRequest proto.InternalMessageInfo
+// Deprecated: Use ControllerGetCapabilitiesRequest.ProtoReflect.Descriptor instead.
+func (*ControllerGetCapabilitiesRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{31}
+}
 
 type ControllerGetCapabilitiesResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// All the capabilities that the controller service supports. This
 	// field is OPTIONAL.
-	Capabilities         []*ControllerServiceCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
-	XXX_unrecognized     []byte                         `json:"-"`
-	XXX_sizecache        int32                          `json:"-"`
+	Capabilities []*ControllerServiceCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
 }
 
-func (m *ControllerGetCapabilitiesResponse) Reset()         { *m = ControllerGetCapabilitiesResponse{} }
-func (m *ControllerGetCapabilitiesResponse) String() string { return proto.CompactTextString(m) }
-func (*ControllerGetCapabilitiesResponse) ProtoMessage()    {}
-func (*ControllerGetCapabilitiesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{32}
+func (x *ControllerGetCapabilitiesResponse) Reset() {
+	*x = ControllerGetCapabilitiesResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerGetCapabilitiesResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerGetCapabilitiesResponse.Unmarshal(m, b)
-}
-func (m *ControllerGetCapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerGetCapabilitiesResponse.Marshal(b, m, deterministic)
+func (x *ControllerGetCapabilitiesResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerGetCapabilitiesResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerGetCapabilitiesResponse.Merge(m, src)
-}
-func (m *ControllerGetCapabilitiesResponse) XXX_Size() int {
-	return xxx_messageInfo_ControllerGetCapabilitiesResponse.Size(m)
-}
-func (m *ControllerGetCapabilitiesResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerGetCapabilitiesResponse.DiscardUnknown(m)
+
+func (*ControllerGetCapabilitiesResponse) ProtoMessage() {}
+
+func (x *ControllerGetCapabilitiesResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerGetCapabilitiesResponse proto.InternalMessageInfo
+// Deprecated: Use ControllerGetCapabilitiesResponse.ProtoReflect.Descriptor instead.
+func (*ControllerGetCapabilitiesResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{32}
+}
 
-func (m *ControllerGetCapabilitiesResponse) GetCapabilities() []*ControllerServiceCapability {
-	if m != nil {
-		return m.Capabilities
+func (x *ControllerGetCapabilitiesResponse) GetCapabilities() []*ControllerServiceCapability {
+	if x != nil {
+		return x.Capabilities
 	}
 	return nil
 }
 
 // Specifies a capability of the controller service.
 type ControllerServiceCapability struct {
-	// Types that are valid to be assigned to Type:
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Type:
 	//
 	//	*ControllerServiceCapability_Rpc
-	Type                 isControllerServiceCapability_Type `protobuf_oneof:"type"`
-	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
-	XXX_unrecognized     []byte                             `json:"-"`
-	XXX_sizecache        int32                              `json:"-"`
+	Type isControllerServiceCapability_Type `protobuf_oneof:"type"`
 }
 
-func (m *ControllerServiceCapability) Reset()         { *m = ControllerServiceCapability{} }
-func (m *ControllerServiceCapability) String() string { return proto.CompactTextString(m) }
-func (*ControllerServiceCapability) ProtoMessage()    {}
-func (*ControllerServiceCapability) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{33}
+func (x *ControllerServiceCapability) Reset() {
+	*x = ControllerServiceCapability{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerServiceCapability) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerServiceCapability.Unmarshal(m, b)
-}
-func (m *ControllerServiceCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerServiceCapability.Marshal(b, m, deterministic)
-}
-func (m *ControllerServiceCapability) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerServiceCapability.Merge(m, src)
-}
-func (m *ControllerServiceCapability) XXX_Size() int {
-	return xxx_messageInfo_ControllerServiceCapability.Size(m)
-}
-func (m *ControllerServiceCapability) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerServiceCapability.DiscardUnknown(m)
+func (x *ControllerServiceCapability) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_ControllerServiceCapability proto.InternalMessageInfo
+func (*ControllerServiceCapability) ProtoMessage() {}
 
-type isControllerServiceCapability_Type interface {
-	isControllerServiceCapability_Type()
+func (x *ControllerServiceCapability) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-type ControllerServiceCapability_Rpc struct {
-	Rpc *ControllerServiceCapability_RPC `protobuf:"bytes,1,opt,name=rpc,proto3,oneof"`
+// Deprecated: Use ControllerServiceCapability.ProtoReflect.Descriptor instead.
+func (*ControllerServiceCapability) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{33}
 }
 
-func (*ControllerServiceCapability_Rpc) isControllerServiceCapability_Type() {}
-
 func (m *ControllerServiceCapability) GetType() isControllerServiceCapability_Type {
 	if m != nil {
 		return m.Type
@@ -3234,60 +3116,29 @@ func (m *ControllerServiceCapability) GetType() isControllerServiceCapability_Ty
 	return nil
 }
 
-func (m *ControllerServiceCapability) GetRpc() *ControllerServiceCapability_RPC {
-	if x, ok := m.GetType().(*ControllerServiceCapability_Rpc); ok {
+func (x *ControllerServiceCapability) GetRpc() *ControllerServiceCapability_RPC {
+	if x, ok := x.GetType().(*ControllerServiceCapability_Rpc); ok {
 		return x.Rpc
 	}
 	return nil
 }
 
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*ControllerServiceCapability) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
-		(*ControllerServiceCapability_Rpc)(nil),
-	}
-}
-
-type ControllerServiceCapability_RPC struct {
-	Type                 ControllerServiceCapability_RPC_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.ControllerServiceCapability_RPC_Type" json:"type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
-	XXX_unrecognized     []byte                               `json:"-"`
-	XXX_sizecache        int32                                `json:"-"`
-}
-
-func (m *ControllerServiceCapability_RPC) Reset()         { *m = ControllerServiceCapability_RPC{} }
-func (m *ControllerServiceCapability_RPC) String() string { return proto.CompactTextString(m) }
-func (*ControllerServiceCapability_RPC) ProtoMessage()    {}
-func (*ControllerServiceCapability_RPC) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{33, 0}
+type isControllerServiceCapability_Type interface {
+	isControllerServiceCapability_Type()
 }
 
-func (m *ControllerServiceCapability_RPC) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerServiceCapability_RPC.Unmarshal(m, b)
-}
-func (m *ControllerServiceCapability_RPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerServiceCapability_RPC.Marshal(b, m, deterministic)
-}
-func (m *ControllerServiceCapability_RPC) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerServiceCapability_RPC.Merge(m, src)
-}
-func (m *ControllerServiceCapability_RPC) XXX_Size() int {
-	return xxx_messageInfo_ControllerServiceCapability_RPC.Size(m)
-}
-func (m *ControllerServiceCapability_RPC) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerServiceCapability_RPC.DiscardUnknown(m)
+type ControllerServiceCapability_Rpc struct {
+	// RPC that the controller supports.
+	Rpc *ControllerServiceCapability_RPC `protobuf:"bytes,1,opt,name=rpc,proto3,oneof"`
 }
 
-var xxx_messageInfo_ControllerServiceCapability_RPC proto.InternalMessageInfo
-
-func (m *ControllerServiceCapability_RPC) GetType() ControllerServiceCapability_RPC_Type {
-	if m != nil {
-		return m.Type
-	}
-	return ControllerServiceCapability_RPC_UNKNOWN
-}
+func (*ControllerServiceCapability_Rpc) isControllerServiceCapability_Type() {}
 
 type CreateSnapshotRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the source volume to be snapshotted.
 	// This field is REQUIRED.
 	SourceVolumeId string `protobuf:"bytes,1,opt,name=source_volume_id,json=sourceVolumeId,proto3" json:"source_volume_id,omitempty"`
@@ -3312,109 +3163,125 @@ type CreateSnapshotRequest struct {
 	//   - Specify if the snapshot should be replicated to some place.
 	//   - Specify primary or secondary for replication systems that
 	//     support snapshotting only on primary.
-	Parameters           map[string]string `protobuf:"bytes,4,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Parameters map[string]string `protobuf:"bytes,4,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *CreateSnapshotRequest) Reset()         { *m = CreateSnapshotRequest{} }
-func (m *CreateSnapshotRequest) String() string { return proto.CompactTextString(m) }
-func (*CreateSnapshotRequest) ProtoMessage()    {}
-func (*CreateSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{34}
+func (x *CreateSnapshotRequest) Reset() {
+	*x = CreateSnapshotRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *CreateSnapshotRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CreateSnapshotRequest.Unmarshal(m, b)
-}
-func (m *CreateSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CreateSnapshotRequest.Marshal(b, m, deterministic)
-}
-func (m *CreateSnapshotRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateSnapshotRequest.Merge(m, src)
+func (x *CreateSnapshotRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CreateSnapshotRequest) XXX_Size() int {
-	return xxx_messageInfo_CreateSnapshotRequest.Size(m)
-}
-func (m *CreateSnapshotRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateSnapshotRequest.DiscardUnknown(m)
+
+func (*CreateSnapshotRequest) ProtoMessage() {}
+
+func (x *CreateSnapshotRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CreateSnapshotRequest proto.InternalMessageInfo
+// Deprecated: Use CreateSnapshotRequest.ProtoReflect.Descriptor instead.
+func (*CreateSnapshotRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{34}
+}
 
-func (m *CreateSnapshotRequest) GetSourceVolumeId() string {
-	if m != nil {
-		return m.SourceVolumeId
+func (x *CreateSnapshotRequest) GetSourceVolumeId() string {
+	if x != nil {
+		return x.SourceVolumeId
 	}
 	return ""
 }
 
-func (m *CreateSnapshotRequest) GetName() string {
-	if m != nil {
-		return m.Name
+func (x *CreateSnapshotRequest) GetName() string {
+	if x != nil {
+		return x.Name
 	}
 	return ""
 }
 
-func (m *CreateSnapshotRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *CreateSnapshotRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *CreateSnapshotRequest) GetParameters() map[string]string {
-	if m != nil {
-		return m.Parameters
+func (x *CreateSnapshotRequest) GetParameters() map[string]string {
+	if x != nil {
+		return x.Parameters
 	}
 	return nil
 }
 
 type CreateSnapshotResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Contains all attributes of the newly created snapshot that are
 	// relevant to the CO along with information required by the Plugin
 	// to uniquely identify the snapshot. This field is REQUIRED.
-	Snapshot             *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
 }
 
-func (m *CreateSnapshotResponse) Reset()         { *m = CreateSnapshotResponse{} }
-func (m *CreateSnapshotResponse) String() string { return proto.CompactTextString(m) }
-func (*CreateSnapshotResponse) ProtoMessage()    {}
-func (*CreateSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{35}
+func (x *CreateSnapshotResponse) Reset() {
+	*x = CreateSnapshotResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *CreateSnapshotResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CreateSnapshotResponse.Unmarshal(m, b)
-}
-func (m *CreateSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CreateSnapshotResponse.Marshal(b, m, deterministic)
-}
-func (m *CreateSnapshotResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateSnapshotResponse.Merge(m, src)
-}
-func (m *CreateSnapshotResponse) XXX_Size() int {
-	return xxx_messageInfo_CreateSnapshotResponse.Size(m)
+func (x *CreateSnapshotResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CreateSnapshotResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateSnapshotResponse.DiscardUnknown(m)
+
+func (*CreateSnapshotResponse) ProtoMessage() {}
+
+func (x *CreateSnapshotResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CreateSnapshotResponse proto.InternalMessageInfo
+// Deprecated: Use CreateSnapshotResponse.ProtoReflect.Descriptor instead.
+func (*CreateSnapshotResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{35}
+}
 
-func (m *CreateSnapshotResponse) GetSnapshot() *Snapshot {
-	if m != nil {
-		return m.Snapshot
+func (x *CreateSnapshotResponse) GetSnapshot() *Snapshot {
+	if x != nil {
+		return x.Snapshot
 	}
 	return nil
 }
 
 // Information about a specific snapshot.
 type Snapshot struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// This is the complete size of the snapshot in bytes. The purpose of
 	// this field is to give CO guidance on how much space is needed to
 	// create a volume from this snapshot. The size of the volume MUST NOT
@@ -3439,7 +3306,7 @@ type Snapshot struct {
 	SourceVolumeId string `protobuf:"bytes,3,opt,name=source_volume_id,json=sourceVolumeId,proto3" json:"source_volume_id,omitempty"`
 	// Timestamp when the point-in-time snapshot is taken on the storage
 	// system. This field is REQUIRED.
-	CreationTime *timestamp.Timestamp `protobuf:"bytes,4,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"`
+	CreationTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"`
 	// Indicates if a snapshot is ready to use as a
 	// `volume_content_source` in a `CreateVolumeRequest`. The default
 	// value is false. This field is REQUIRED.
@@ -3457,165 +3324,188 @@ type Snapshot struct {
 	// and SP SHALL allow it to be deleted separately.
 	// If this message is inside a VolumeGroupSnapshot message, the value
 	// MUST be the same as the group_snapshot_id in that message.
-	GroupSnapshotId      string   `protobuf:"bytes,6,opt,name=group_snapshot_id,json=groupSnapshotId,proto3" json:"group_snapshot_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	GroupSnapshotId string `protobuf:"bytes,6,opt,name=group_snapshot_id,json=groupSnapshotId,proto3" json:"group_snapshot_id,omitempty"`
 }
 
-func (m *Snapshot) Reset()         { *m = Snapshot{} }
-func (m *Snapshot) String() string { return proto.CompactTextString(m) }
-func (*Snapshot) ProtoMessage()    {}
-func (*Snapshot) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{36}
+func (x *Snapshot) Reset() {
+	*x = Snapshot{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *Snapshot) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Snapshot.Unmarshal(m, b)
-}
-func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic)
-}
-func (m *Snapshot) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Snapshot.Merge(m, src)
+func (x *Snapshot) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *Snapshot) XXX_Size() int {
-	return xxx_messageInfo_Snapshot.Size(m)
-}
-func (m *Snapshot) XXX_DiscardUnknown() {
-	xxx_messageInfo_Snapshot.DiscardUnknown(m)
+
+func (*Snapshot) ProtoMessage() {}
+
+func (x *Snapshot) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_Snapshot proto.InternalMessageInfo
+// Deprecated: Use Snapshot.ProtoReflect.Descriptor instead.
+func (*Snapshot) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{36}
+}
 
-func (m *Snapshot) GetSizeBytes() int64 {
-	if m != nil {
-		return m.SizeBytes
+func (x *Snapshot) GetSizeBytes() int64 {
+	if x != nil {
+		return x.SizeBytes
 	}
 	return 0
 }
 
-func (m *Snapshot) GetSnapshotId() string {
-	if m != nil {
-		return m.SnapshotId
+func (x *Snapshot) GetSnapshotId() string {
+	if x != nil {
+		return x.SnapshotId
 	}
 	return ""
 }
 
-func (m *Snapshot) GetSourceVolumeId() string {
-	if m != nil {
-		return m.SourceVolumeId
+func (x *Snapshot) GetSourceVolumeId() string {
+	if x != nil {
+		return x.SourceVolumeId
 	}
 	return ""
 }
 
-func (m *Snapshot) GetCreationTime() *timestamp.Timestamp {
-	if m != nil {
-		return m.CreationTime
+func (x *Snapshot) GetCreationTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CreationTime
 	}
 	return nil
 }
 
-func (m *Snapshot) GetReadyToUse() bool {
-	if m != nil {
-		return m.ReadyToUse
+func (x *Snapshot) GetReadyToUse() bool {
+	if x != nil {
+		return x.ReadyToUse
 	}
 	return false
 }
 
-func (m *Snapshot) GetGroupSnapshotId() string {
-	if m != nil {
-		return m.GroupSnapshotId
+func (x *Snapshot) GetGroupSnapshotId() string {
+	if x != nil {
+		return x.GroupSnapshotId
 	}
 	return ""
 }
 
 type DeleteSnapshotRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the snapshot to be deleted.
 	// This field is REQUIRED.
 	SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
 	// Secrets required by plugin to complete snapshot deletion request.
 	// This field is OPTIONAL. Refer to the `Secrets Requirements`
 	// section on how to use this field.
-	Secrets              map[string]string `protobuf:"bytes,2,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Secrets map[string]string `protobuf:"bytes,2,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *DeleteSnapshotRequest) Reset()         { *m = DeleteSnapshotRequest{} }
-func (m *DeleteSnapshotRequest) String() string { return proto.CompactTextString(m) }
-func (*DeleteSnapshotRequest) ProtoMessage()    {}
-func (*DeleteSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{37}
+func (x *DeleteSnapshotRequest) Reset() {
+	*x = DeleteSnapshotRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[37]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *DeleteSnapshotRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DeleteSnapshotRequest.Unmarshal(m, b)
+func (x *DeleteSnapshotRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *DeleteSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DeleteSnapshotRequest.Marshal(b, m, deterministic)
-}
-func (m *DeleteSnapshotRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteSnapshotRequest.Merge(m, src)
-}
-func (m *DeleteSnapshotRequest) XXX_Size() int {
-	return xxx_messageInfo_DeleteSnapshotRequest.Size(m)
-}
-func (m *DeleteSnapshotRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_DeleteSnapshotRequest.DiscardUnknown(m)
+
+func (*DeleteSnapshotRequest) ProtoMessage() {}
+
+func (x *DeleteSnapshotRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[37]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_DeleteSnapshotRequest proto.InternalMessageInfo
+// Deprecated: Use DeleteSnapshotRequest.ProtoReflect.Descriptor instead.
+func (*DeleteSnapshotRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{37}
+}
 
-func (m *DeleteSnapshotRequest) GetSnapshotId() string {
-	if m != nil {
-		return m.SnapshotId
+func (x *DeleteSnapshotRequest) GetSnapshotId() string {
+	if x != nil {
+		return x.SnapshotId
 	}
 	return ""
 }
 
-func (m *DeleteSnapshotRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *DeleteSnapshotRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
 type DeleteSnapshotResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *DeleteSnapshotResponse) Reset()         { *m = DeleteSnapshotResponse{} }
-func (m *DeleteSnapshotResponse) String() string { return proto.CompactTextString(m) }
-func (*DeleteSnapshotResponse) ProtoMessage()    {}
-func (*DeleteSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{38}
+func (x *DeleteSnapshotResponse) Reset() {
+	*x = DeleteSnapshotResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[38]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *DeleteSnapshotResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DeleteSnapshotResponse.Unmarshal(m, b)
+func (x *DeleteSnapshotResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *DeleteSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DeleteSnapshotResponse.Marshal(b, m, deterministic)
-}
-func (m *DeleteSnapshotResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteSnapshotResponse.Merge(m, src)
-}
-func (m *DeleteSnapshotResponse) XXX_Size() int {
-	return xxx_messageInfo_DeleteSnapshotResponse.Size(m)
-}
-func (m *DeleteSnapshotResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_DeleteSnapshotResponse.DiscardUnknown(m)
+
+func (*DeleteSnapshotResponse) ProtoMessage() {}
+
+func (x *DeleteSnapshotResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[38]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_DeleteSnapshotResponse proto.InternalMessageInfo
+// Deprecated: Use DeleteSnapshotResponse.ProtoReflect.Descriptor instead.
+func (*DeleteSnapshotResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{38}
+}
 
 // List all snapshots on the storage system regardless of how they were
 // created.
 type ListSnapshotsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// If specified (non-zero value), the Plugin MUST NOT return more
 	// entries than this number in the response. If the actual number of
 	// entries is more than this number, the Plugin MUST set `next_token`
@@ -3642,73 +3532,81 @@ type ListSnapshotsRequest struct {
 	// Secrets required by plugin to complete ListSnapshot request.
 	// This field is OPTIONAL. Refer to the `Secrets Requirements`
 	// section on how to use this field.
-	Secrets              map[string]string `protobuf:"bytes,5,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Secrets map[string]string `protobuf:"bytes,5,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *ListSnapshotsRequest) Reset()         { *m = ListSnapshotsRequest{} }
-func (m *ListSnapshotsRequest) String() string { return proto.CompactTextString(m) }
-func (*ListSnapshotsRequest) ProtoMessage()    {}
-func (*ListSnapshotsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{39}
+func (x *ListSnapshotsRequest) Reset() {
+	*x = ListSnapshotsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ListSnapshotsRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ListSnapshotsRequest.Unmarshal(m, b)
+func (x *ListSnapshotsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ListSnapshotsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ListSnapshotsRequest.Marshal(b, m, deterministic)
-}
-func (m *ListSnapshotsRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListSnapshotsRequest.Merge(m, src)
-}
-func (m *ListSnapshotsRequest) XXX_Size() int {
-	return xxx_messageInfo_ListSnapshotsRequest.Size(m)
-}
-func (m *ListSnapshotsRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListSnapshotsRequest.DiscardUnknown(m)
+
+func (*ListSnapshotsRequest) ProtoMessage() {}
+
+func (x *ListSnapshotsRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ListSnapshotsRequest proto.InternalMessageInfo
+// Deprecated: Use ListSnapshotsRequest.ProtoReflect.Descriptor instead.
+func (*ListSnapshotsRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{39}
+}
 
-func (m *ListSnapshotsRequest) GetMaxEntries() int32 {
-	if m != nil {
-		return m.MaxEntries
+func (x *ListSnapshotsRequest) GetMaxEntries() int32 {
+	if x != nil {
+		return x.MaxEntries
 	}
 	return 0
 }
 
-func (m *ListSnapshotsRequest) GetStartingToken() string {
-	if m != nil {
-		return m.StartingToken
+func (x *ListSnapshotsRequest) GetStartingToken() string {
+	if x != nil {
+		return x.StartingToken
 	}
 	return ""
 }
 
-func (m *ListSnapshotsRequest) GetSourceVolumeId() string {
-	if m != nil {
-		return m.SourceVolumeId
+func (x *ListSnapshotsRequest) GetSourceVolumeId() string {
+	if x != nil {
+		return x.SourceVolumeId
 	}
 	return ""
 }
 
-func (m *ListSnapshotsRequest) GetSnapshotId() string {
-	if m != nil {
-		return m.SnapshotId
+func (x *ListSnapshotsRequest) GetSnapshotId() string {
+	if x != nil {
+		return x.SnapshotId
 	}
 	return ""
 }
 
-func (m *ListSnapshotsRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *ListSnapshotsRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
 type ListSnapshotsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	Entries []*ListSnapshotsResponse_Entry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
 	// This token allows you to get the next page of entries for
 	// `ListSnapshots` request. If the number of entries is larger than
@@ -3716,91 +3614,60 @@ type ListSnapshotsResponse struct {
 	// `starting_token` field in the next `ListSnapshots` request. This
 	// field is OPTIONAL.
 	// An empty string is equal to an unspecified field value.
-	NextToken            string   `protobuf:"bytes,2,opt,name=next_token,json=nextToken,proto3" json:"next_token,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	NextToken string `protobuf:"bytes,2,opt,name=next_token,json=nextToken,proto3" json:"next_token,omitempty"`
 }
 
-func (m *ListSnapshotsResponse) Reset()         { *m = ListSnapshotsResponse{} }
-func (m *ListSnapshotsResponse) String() string { return proto.CompactTextString(m) }
-func (*ListSnapshotsResponse) ProtoMessage()    {}
-func (*ListSnapshotsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{40}
+func (x *ListSnapshotsResponse) Reset() {
+	*x = ListSnapshotsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ListSnapshotsResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ListSnapshotsResponse.Unmarshal(m, b)
-}
-func (m *ListSnapshotsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ListSnapshotsResponse.Marshal(b, m, deterministic)
-}
-func (m *ListSnapshotsResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListSnapshotsResponse.Merge(m, src)
-}
-func (m *ListSnapshotsResponse) XXX_Size() int {
-	return xxx_messageInfo_ListSnapshotsResponse.Size(m)
-}
-func (m *ListSnapshotsResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListSnapshotsResponse.DiscardUnknown(m)
+func (x *ListSnapshotsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_ListSnapshotsResponse proto.InternalMessageInfo
+func (*ListSnapshotsResponse) ProtoMessage() {}
 
-func (m *ListSnapshotsResponse) GetEntries() []*ListSnapshotsResponse_Entry {
-	if m != nil {
-		return m.Entries
-	}
-	return nil
-}
-
-func (m *ListSnapshotsResponse) GetNextToken() string {
-	if m != nil {
-		return m.NextToken
+func (x *ListSnapshotsResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return ""
-}
-
-type ListSnapshotsResponse_Entry struct {
-	Snapshot             *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	return mi.MessageOf(x)
 }
 
-func (m *ListSnapshotsResponse_Entry) Reset()         { *m = ListSnapshotsResponse_Entry{} }
-func (m *ListSnapshotsResponse_Entry) String() string { return proto.CompactTextString(m) }
-func (*ListSnapshotsResponse_Entry) ProtoMessage()    {}
-func (*ListSnapshotsResponse_Entry) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{40, 0}
+// Deprecated: Use ListSnapshotsResponse.ProtoReflect.Descriptor instead.
+func (*ListSnapshotsResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{40}
 }
 
-func (m *ListSnapshotsResponse_Entry) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ListSnapshotsResponse_Entry.Unmarshal(m, b)
-}
-func (m *ListSnapshotsResponse_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ListSnapshotsResponse_Entry.Marshal(b, m, deterministic)
-}
-func (m *ListSnapshotsResponse_Entry) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListSnapshotsResponse_Entry.Merge(m, src)
-}
-func (m *ListSnapshotsResponse_Entry) XXX_Size() int {
-	return xxx_messageInfo_ListSnapshotsResponse_Entry.Size(m)
-}
-func (m *ListSnapshotsResponse_Entry) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListSnapshotsResponse_Entry.DiscardUnknown(m)
+func (x *ListSnapshotsResponse) GetEntries() []*ListSnapshotsResponse_Entry {
+	if x != nil {
+		return x.Entries
+	}
+	return nil
 }
 
-var xxx_messageInfo_ListSnapshotsResponse_Entry proto.InternalMessageInfo
-
-func (m *ListSnapshotsResponse_Entry) GetSnapshot() *Snapshot {
-	if m != nil {
-		return m.Snapshot
+func (x *ListSnapshotsResponse) GetNextToken() string {
+	if x != nil {
+		return x.NextToken
 	}
-	return nil
+	return ""
 }
 
 type ControllerExpandVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume to expand. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// This allows CO to specify the capacity requirements of the volume
@@ -3816,117 +3683,133 @@ type ControllerExpandVolumeRequest struct {
 	// node_expansion_required to false in ControllerExpandVolumeResponse
 	// to skip invocation of NodeExpandVolume on the node by the CO.
 	// This is an OPTIONAL field.
-	VolumeCapability     *VolumeCapability `protobuf:"bytes,4,opt,name=volume_capability,json=volumeCapability,proto3" json:"volume_capability,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	VolumeCapability *VolumeCapability `protobuf:"bytes,4,opt,name=volume_capability,json=volumeCapability,proto3" json:"volume_capability,omitempty"`
 }
 
-func (m *ControllerExpandVolumeRequest) Reset()         { *m = ControllerExpandVolumeRequest{} }
-func (m *ControllerExpandVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*ControllerExpandVolumeRequest) ProtoMessage()    {}
-func (*ControllerExpandVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{41}
+func (x *ControllerExpandVolumeRequest) Reset() {
+	*x = ControllerExpandVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerExpandVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerExpandVolumeRequest.Unmarshal(m, b)
-}
-func (m *ControllerExpandVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerExpandVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *ControllerExpandVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerExpandVolumeRequest.Merge(m, src)
+func (x *ControllerExpandVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerExpandVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_ControllerExpandVolumeRequest.Size(m)
-}
-func (m *ControllerExpandVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerExpandVolumeRequest.DiscardUnknown(m)
+
+func (*ControllerExpandVolumeRequest) ProtoMessage() {}
+
+func (x *ControllerExpandVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerExpandVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use ControllerExpandVolumeRequest.ProtoReflect.Descriptor instead.
+func (*ControllerExpandVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{41}
+}
 
-func (m *ControllerExpandVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *ControllerExpandVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *ControllerExpandVolumeRequest) GetCapacityRange() *CapacityRange {
-	if m != nil {
-		return m.CapacityRange
+func (x *ControllerExpandVolumeRequest) GetCapacityRange() *CapacityRange {
+	if x != nil {
+		return x.CapacityRange
 	}
 	return nil
 }
 
-func (m *ControllerExpandVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *ControllerExpandVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *ControllerExpandVolumeRequest) GetVolumeCapability() *VolumeCapability {
-	if m != nil {
-		return m.VolumeCapability
+func (x *ControllerExpandVolumeRequest) GetVolumeCapability() *VolumeCapability {
+	if x != nil {
+		return x.VolumeCapability
 	}
 	return nil
 }
 
 type ControllerExpandVolumeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Capacity of volume after expansion. This field is REQUIRED.
 	CapacityBytes int64 `protobuf:"varint,1,opt,name=capacity_bytes,json=capacityBytes,proto3" json:"capacity_bytes,omitempty"`
 	// Whether node expansion is required for the volume. When true
 	// the CO MUST make NodeExpandVolume RPC call on the node. This field
 	// is REQUIRED.
-	NodeExpansionRequired bool     `protobuf:"varint,2,opt,name=node_expansion_required,json=nodeExpansionRequired,proto3" json:"node_expansion_required,omitempty"`
-	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
-	XXX_unrecognized      []byte   `json:"-"`
-	XXX_sizecache         int32    `json:"-"`
+	NodeExpansionRequired bool `protobuf:"varint,2,opt,name=node_expansion_required,json=nodeExpansionRequired,proto3" json:"node_expansion_required,omitempty"`
 }
 
-func (m *ControllerExpandVolumeResponse) Reset()         { *m = ControllerExpandVolumeResponse{} }
-func (m *ControllerExpandVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*ControllerExpandVolumeResponse) ProtoMessage()    {}
-func (*ControllerExpandVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{42}
+func (x *ControllerExpandVolumeResponse) Reset() {
+	*x = ControllerExpandVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *ControllerExpandVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ControllerExpandVolumeResponse.Unmarshal(m, b)
-}
-func (m *ControllerExpandVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ControllerExpandVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *ControllerExpandVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ControllerExpandVolumeResponse.Merge(m, src)
-}
-func (m *ControllerExpandVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_ControllerExpandVolumeResponse.Size(m)
+func (x *ControllerExpandVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *ControllerExpandVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ControllerExpandVolumeResponse.DiscardUnknown(m)
+
+func (*ControllerExpandVolumeResponse) ProtoMessage() {}
+
+func (x *ControllerExpandVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_ControllerExpandVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use ControllerExpandVolumeResponse.ProtoReflect.Descriptor instead.
+func (*ControllerExpandVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{42}
+}
 
-func (m *ControllerExpandVolumeResponse) GetCapacityBytes() int64 {
-	if m != nil {
-		return m.CapacityBytes
+func (x *ControllerExpandVolumeResponse) GetCapacityBytes() int64 {
+	if x != nil {
+		return x.CapacityBytes
 	}
 	return 0
 }
 
-func (m *ControllerExpandVolumeResponse) GetNodeExpansionRequired() bool {
-	if m != nil {
-		return m.NodeExpansionRequired
+func (x *ControllerExpandVolumeResponse) GetNodeExpansionRequired() bool {
+	if x != nil {
+		return x.NodeExpansionRequired
 	}
 	return false
 }
 
 type NodeStageVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume to publish. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// The CO SHALL set this field to the value returned by
@@ -3962,111 +3845,126 @@ type NodeStageVolumeRequest struct {
 	// CreateVolumeResponse.Volume.volume_context.
 	// This field is OPTIONAL and MUST match the volume_context of the
 	// volume identified by `volume_id`.
-	VolumeContext        map[string]string `protobuf:"bytes,6,rep,name=volume_context,json=volumeContext,proto3" json:"volume_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	VolumeContext map[string]string `protobuf:"bytes,6,rep,name=volume_context,json=volumeContext,proto3" json:"volume_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *NodeStageVolumeRequest) Reset()         { *m = NodeStageVolumeRequest{} }
-func (m *NodeStageVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*NodeStageVolumeRequest) ProtoMessage()    {}
-func (*NodeStageVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{43}
+func (x *NodeStageVolumeRequest) Reset() {
+	*x = NodeStageVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeStageVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeStageVolumeRequest.Unmarshal(m, b)
-}
-func (m *NodeStageVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeStageVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *NodeStageVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeStageVolumeRequest.Merge(m, src)
+func (x *NodeStageVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeStageVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_NodeStageVolumeRequest.Size(m)
-}
-func (m *NodeStageVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeStageVolumeRequest.DiscardUnknown(m)
+
+func (*NodeStageVolumeRequest) ProtoMessage() {}
+
+func (x *NodeStageVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeStageVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use NodeStageVolumeRequest.ProtoReflect.Descriptor instead.
+func (*NodeStageVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{43}
+}
 
-func (m *NodeStageVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *NodeStageVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *NodeStageVolumeRequest) GetPublishContext() map[string]string {
-	if m != nil {
-		return m.PublishContext
+func (x *NodeStageVolumeRequest) GetPublishContext() map[string]string {
+	if x != nil {
+		return x.PublishContext
 	}
 	return nil
 }
 
-func (m *NodeStageVolumeRequest) GetStagingTargetPath() string {
-	if m != nil {
-		return m.StagingTargetPath
+func (x *NodeStageVolumeRequest) GetStagingTargetPath() string {
+	if x != nil {
+		return x.StagingTargetPath
 	}
 	return ""
 }
 
-func (m *NodeStageVolumeRequest) GetVolumeCapability() *VolumeCapability {
-	if m != nil {
-		return m.VolumeCapability
+func (x *NodeStageVolumeRequest) GetVolumeCapability() *VolumeCapability {
+	if x != nil {
+		return x.VolumeCapability
 	}
 	return nil
 }
 
-func (m *NodeStageVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *NodeStageVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *NodeStageVolumeRequest) GetVolumeContext() map[string]string {
-	if m != nil {
-		return m.VolumeContext
+func (x *NodeStageVolumeRequest) GetVolumeContext() map[string]string {
+	if x != nil {
+		return x.VolumeContext
 	}
 	return nil
 }
 
 type NodeStageVolumeResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *NodeStageVolumeResponse) Reset()         { *m = NodeStageVolumeResponse{} }
-func (m *NodeStageVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*NodeStageVolumeResponse) ProtoMessage()    {}
-func (*NodeStageVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{44}
+func (x *NodeStageVolumeResponse) Reset() {
+	*x = NodeStageVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[44]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeStageVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeStageVolumeResponse.Unmarshal(m, b)
-}
-func (m *NodeStageVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeStageVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *NodeStageVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeStageVolumeResponse.Merge(m, src)
+func (x *NodeStageVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeStageVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_NodeStageVolumeResponse.Size(m)
-}
-func (m *NodeStageVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeStageVolumeResponse.DiscardUnknown(m)
+
+func (*NodeStageVolumeResponse) ProtoMessage() {}
+
+func (x *NodeStageVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[44]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeStageVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use NodeStageVolumeResponse.ProtoReflect.Descriptor instead.
+func (*NodeStageVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{44}
+}
 
 type NodeUnstageVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// The path at which the volume was staged. It MUST be an absolute
@@ -4076,83 +3974,98 @@ type NodeUnstageVolumeRequest struct {
 	// SP SHOULD support the maximum path length allowed by the operating
 	// system/filesystem, but, at a minimum, SP MUST accept a max path
 	// length of at least 128 bytes.
-	StagingTargetPath    string   `protobuf:"bytes,2,opt,name=staging_target_path,json=stagingTargetPath,proto3" json:"staging_target_path,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	StagingTargetPath string `protobuf:"bytes,2,opt,name=staging_target_path,json=stagingTargetPath,proto3" json:"staging_target_path,omitempty"`
 }
 
-func (m *NodeUnstageVolumeRequest) Reset()         { *m = NodeUnstageVolumeRequest{} }
-func (m *NodeUnstageVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*NodeUnstageVolumeRequest) ProtoMessage()    {}
-func (*NodeUnstageVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{45}
+func (x *NodeUnstageVolumeRequest) Reset() {
+	*x = NodeUnstageVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[45]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeUnstageVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeUnstageVolumeRequest.Unmarshal(m, b)
-}
-func (m *NodeUnstageVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeUnstageVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *NodeUnstageVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeUnstageVolumeRequest.Merge(m, src)
-}
-func (m *NodeUnstageVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_NodeUnstageVolumeRequest.Size(m)
+func (x *NodeUnstageVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeUnstageVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeUnstageVolumeRequest.DiscardUnknown(m)
+
+func (*NodeUnstageVolumeRequest) ProtoMessage() {}
+
+func (x *NodeUnstageVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[45]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeUnstageVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use NodeUnstageVolumeRequest.ProtoReflect.Descriptor instead.
+func (*NodeUnstageVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{45}
+}
 
-func (m *NodeUnstageVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *NodeUnstageVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *NodeUnstageVolumeRequest) GetStagingTargetPath() string {
-	if m != nil {
-		return m.StagingTargetPath
+func (x *NodeUnstageVolumeRequest) GetStagingTargetPath() string {
+	if x != nil {
+		return x.StagingTargetPath
 	}
 	return ""
 }
 
 type NodeUnstageVolumeResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *NodeUnstageVolumeResponse) Reset()         { *m = NodeUnstageVolumeResponse{} }
-func (m *NodeUnstageVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*NodeUnstageVolumeResponse) ProtoMessage()    {}
-func (*NodeUnstageVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{46}
+func (x *NodeUnstageVolumeResponse) Reset() {
+	*x = NodeUnstageVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[46]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeUnstageVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeUnstageVolumeResponse.Unmarshal(m, b)
-}
-func (m *NodeUnstageVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeUnstageVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *NodeUnstageVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeUnstageVolumeResponse.Merge(m, src)
-}
-func (m *NodeUnstageVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_NodeUnstageVolumeResponse.Size(m)
+func (x *NodeUnstageVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeUnstageVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeUnstageVolumeResponse.DiscardUnknown(m)
+
+func (*NodeUnstageVolumeResponse) ProtoMessage() {}
+
+func (x *NodeUnstageVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[46]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeUnstageVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use NodeUnstageVolumeResponse.ProtoReflect.Descriptor instead.
+func (*NodeUnstageVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{46}
+}
 
 type NodePublishVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume to publish. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// The CO SHALL set this field to the value returned by
@@ -4205,125 +4118,140 @@ type NodePublishVolumeRequest struct {
 	// CreateVolumeResponse.Volume.volume_context.
 	// This field is OPTIONAL and MUST match the volume_context of the
 	// volume identified by `volume_id`.
-	VolumeContext        map[string]string `protobuf:"bytes,8,rep,name=volume_context,json=volumeContext,proto3" json:"volume_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	VolumeContext map[string]string `protobuf:"bytes,8,rep,name=volume_context,json=volumeContext,proto3" json:"volume_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *NodePublishVolumeRequest) Reset()         { *m = NodePublishVolumeRequest{} }
-func (m *NodePublishVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*NodePublishVolumeRequest) ProtoMessage()    {}
-func (*NodePublishVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{47}
+func (x *NodePublishVolumeRequest) Reset() {
+	*x = NodePublishVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[47]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodePublishVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodePublishVolumeRequest.Unmarshal(m, b)
+func (x *NodePublishVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodePublishVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodePublishVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *NodePublishVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodePublishVolumeRequest.Merge(m, src)
-}
-func (m *NodePublishVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_NodePublishVolumeRequest.Size(m)
-}
-func (m *NodePublishVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodePublishVolumeRequest.DiscardUnknown(m)
+
+func (*NodePublishVolumeRequest) ProtoMessage() {}
+
+func (x *NodePublishVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[47]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodePublishVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use NodePublishVolumeRequest.ProtoReflect.Descriptor instead.
+func (*NodePublishVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{47}
+}
 
-func (m *NodePublishVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *NodePublishVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *NodePublishVolumeRequest) GetPublishContext() map[string]string {
-	if m != nil {
-		return m.PublishContext
+func (x *NodePublishVolumeRequest) GetPublishContext() map[string]string {
+	if x != nil {
+		return x.PublishContext
 	}
 	return nil
 }
 
-func (m *NodePublishVolumeRequest) GetStagingTargetPath() string {
-	if m != nil {
-		return m.StagingTargetPath
+func (x *NodePublishVolumeRequest) GetStagingTargetPath() string {
+	if x != nil {
+		return x.StagingTargetPath
 	}
 	return ""
 }
 
-func (m *NodePublishVolumeRequest) GetTargetPath() string {
-	if m != nil {
-		return m.TargetPath
+func (x *NodePublishVolumeRequest) GetTargetPath() string {
+	if x != nil {
+		return x.TargetPath
 	}
 	return ""
 }
 
-func (m *NodePublishVolumeRequest) GetVolumeCapability() *VolumeCapability {
-	if m != nil {
-		return m.VolumeCapability
+func (x *NodePublishVolumeRequest) GetVolumeCapability() *VolumeCapability {
+	if x != nil {
+		return x.VolumeCapability
 	}
 	return nil
 }
 
-func (m *NodePublishVolumeRequest) GetReadonly() bool {
-	if m != nil {
-		return m.Readonly
+func (x *NodePublishVolumeRequest) GetReadonly() bool {
+	if x != nil {
+		return x.Readonly
 	}
 	return false
 }
 
-func (m *NodePublishVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *NodePublishVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *NodePublishVolumeRequest) GetVolumeContext() map[string]string {
-	if m != nil {
-		return m.VolumeContext
+func (x *NodePublishVolumeRequest) GetVolumeContext() map[string]string {
+	if x != nil {
+		return x.VolumeContext
 	}
 	return nil
 }
 
 type NodePublishVolumeResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *NodePublishVolumeResponse) Reset()         { *m = NodePublishVolumeResponse{} }
-func (m *NodePublishVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*NodePublishVolumeResponse) ProtoMessage()    {}
-func (*NodePublishVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{48}
+func (x *NodePublishVolumeResponse) Reset() {
+	*x = NodePublishVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[48]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodePublishVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodePublishVolumeResponse.Unmarshal(m, b)
-}
-func (m *NodePublishVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodePublishVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *NodePublishVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodePublishVolumeResponse.Merge(m, src)
+func (x *NodePublishVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodePublishVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_NodePublishVolumeResponse.Size(m)
-}
-func (m *NodePublishVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodePublishVolumeResponse.DiscardUnknown(m)
+
+func (*NodePublishVolumeResponse) ProtoMessage() {}
+
+func (x *NodePublishVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[48]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodePublishVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use NodePublishVolumeResponse.ProtoReflect.Descriptor instead.
+func (*NodePublishVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{48}
+}
 
 type NodeUnpublishVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// The path at which the volume was published. It MUST be an absolute
@@ -4334,83 +4262,98 @@ type NodeUnpublishVolumeRequest struct {
 	// SP SHOULD support the maximum path length allowed by the operating
 	// system/filesystem, but, at a minimum, SP MUST accept a max path
 	// length of at least 128 bytes.
-	TargetPath           string   `protobuf:"bytes,2,opt,name=target_path,json=targetPath,proto3" json:"target_path,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	TargetPath string `protobuf:"bytes,2,opt,name=target_path,json=targetPath,proto3" json:"target_path,omitempty"`
 }
 
-func (m *NodeUnpublishVolumeRequest) Reset()         { *m = NodeUnpublishVolumeRequest{} }
-func (m *NodeUnpublishVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*NodeUnpublishVolumeRequest) ProtoMessage()    {}
-func (*NodeUnpublishVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{49}
+func (x *NodeUnpublishVolumeRequest) Reset() {
+	*x = NodeUnpublishVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[49]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeUnpublishVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeUnpublishVolumeRequest.Unmarshal(m, b)
-}
-func (m *NodeUnpublishVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeUnpublishVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *NodeUnpublishVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeUnpublishVolumeRequest.Merge(m, src)
-}
-func (m *NodeUnpublishVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_NodeUnpublishVolumeRequest.Size(m)
+func (x *NodeUnpublishVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeUnpublishVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeUnpublishVolumeRequest.DiscardUnknown(m)
+
+func (*NodeUnpublishVolumeRequest) ProtoMessage() {}
+
+func (x *NodeUnpublishVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[49]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeUnpublishVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use NodeUnpublishVolumeRequest.ProtoReflect.Descriptor instead.
+func (*NodeUnpublishVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{49}
+}
 
-func (m *NodeUnpublishVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *NodeUnpublishVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *NodeUnpublishVolumeRequest) GetTargetPath() string {
-	if m != nil {
-		return m.TargetPath
+func (x *NodeUnpublishVolumeRequest) GetTargetPath() string {
+	if x != nil {
+		return x.TargetPath
 	}
 	return ""
 }
 
 type NodeUnpublishVolumeResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *NodeUnpublishVolumeResponse) Reset()         { *m = NodeUnpublishVolumeResponse{} }
-func (m *NodeUnpublishVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*NodeUnpublishVolumeResponse) ProtoMessage()    {}
-func (*NodeUnpublishVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{50}
+func (x *NodeUnpublishVolumeResponse) Reset() {
+	*x = NodeUnpublishVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[50]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeUnpublishVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeUnpublishVolumeResponse.Unmarshal(m, b)
-}
-func (m *NodeUnpublishVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeUnpublishVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *NodeUnpublishVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeUnpublishVolumeResponse.Merge(m, src)
-}
-func (m *NodeUnpublishVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_NodeUnpublishVolumeResponse.Size(m)
+func (x *NodeUnpublishVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeUnpublishVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeUnpublishVolumeResponse.DiscardUnknown(m)
+
+func (*NodeUnpublishVolumeResponse) ProtoMessage() {}
+
+func (x *NodeUnpublishVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[50]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeUnpublishVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use NodeUnpublishVolumeResponse.ProtoReflect.Descriptor instead.
+func (*NodeUnpublishVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{50}
+}
 
 type NodeGetVolumeStatsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// It can be any valid path where volume was previously
@@ -4432,111 +4375,127 @@ type NodeGetVolumeStatsRequest struct {
 	// SP SHOULD support the maximum path length allowed by the operating
 	// system/filesystem, but, at a minimum, SP MUST accept a max path
 	// length of at least 128 bytes.
-	StagingTargetPath    string   `protobuf:"bytes,3,opt,name=staging_target_path,json=stagingTargetPath,proto3" json:"staging_target_path,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	StagingTargetPath string `protobuf:"bytes,3,opt,name=staging_target_path,json=stagingTargetPath,proto3" json:"staging_target_path,omitempty"`
 }
 
-func (m *NodeGetVolumeStatsRequest) Reset()         { *m = NodeGetVolumeStatsRequest{} }
-func (m *NodeGetVolumeStatsRequest) String() string { return proto.CompactTextString(m) }
-func (*NodeGetVolumeStatsRequest) ProtoMessage()    {}
-func (*NodeGetVolumeStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{51}
+func (x *NodeGetVolumeStatsRequest) Reset() {
+	*x = NodeGetVolumeStatsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[51]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeGetVolumeStatsRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeGetVolumeStatsRequest.Unmarshal(m, b)
-}
-func (m *NodeGetVolumeStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeGetVolumeStatsRequest.Marshal(b, m, deterministic)
-}
-func (m *NodeGetVolumeStatsRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeGetVolumeStatsRequest.Merge(m, src)
-}
-func (m *NodeGetVolumeStatsRequest) XXX_Size() int {
-	return xxx_messageInfo_NodeGetVolumeStatsRequest.Size(m)
+func (x *NodeGetVolumeStatsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeGetVolumeStatsRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeGetVolumeStatsRequest.DiscardUnknown(m)
+
+func (*NodeGetVolumeStatsRequest) ProtoMessage() {}
+
+func (x *NodeGetVolumeStatsRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[51]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeGetVolumeStatsRequest proto.InternalMessageInfo
+// Deprecated: Use NodeGetVolumeStatsRequest.ProtoReflect.Descriptor instead.
+func (*NodeGetVolumeStatsRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{51}
+}
 
-func (m *NodeGetVolumeStatsRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *NodeGetVolumeStatsRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *NodeGetVolumeStatsRequest) GetVolumePath() string {
-	if m != nil {
-		return m.VolumePath
+func (x *NodeGetVolumeStatsRequest) GetVolumePath() string {
+	if x != nil {
+		return x.VolumePath
 	}
 	return ""
 }
 
-func (m *NodeGetVolumeStatsRequest) GetStagingTargetPath() string {
-	if m != nil {
-		return m.StagingTargetPath
+func (x *NodeGetVolumeStatsRequest) GetStagingTargetPath() string {
+	if x != nil {
+		return x.StagingTargetPath
 	}
 	return ""
 }
 
 type NodeGetVolumeStatsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// This field is OPTIONAL.
 	Usage []*VolumeUsage `protobuf:"bytes,1,rep,name=usage,proto3" json:"usage,omitempty"`
 	// Information about the current condition of the volume.
 	// This field is OPTIONAL.
 	// This field MUST be specified if the VOLUME_CONDITION node
 	// capability is supported.
-	VolumeCondition      *VolumeCondition `protobuf:"bytes,2,opt,name=volume_condition,json=volumeCondition,proto3" json:"volume_condition,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
+	VolumeCondition *VolumeCondition `protobuf:"bytes,2,opt,name=volume_condition,json=volumeCondition,proto3" json:"volume_condition,omitempty"`
 }
 
-func (m *NodeGetVolumeStatsResponse) Reset()         { *m = NodeGetVolumeStatsResponse{} }
-func (m *NodeGetVolumeStatsResponse) String() string { return proto.CompactTextString(m) }
-func (*NodeGetVolumeStatsResponse) ProtoMessage()    {}
-func (*NodeGetVolumeStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{52}
+func (x *NodeGetVolumeStatsResponse) Reset() {
+	*x = NodeGetVolumeStatsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[52]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeGetVolumeStatsResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeGetVolumeStatsResponse.Unmarshal(m, b)
-}
-func (m *NodeGetVolumeStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeGetVolumeStatsResponse.Marshal(b, m, deterministic)
+func (x *NodeGetVolumeStatsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeGetVolumeStatsResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeGetVolumeStatsResponse.Merge(m, src)
-}
-func (m *NodeGetVolumeStatsResponse) XXX_Size() int {
-	return xxx_messageInfo_NodeGetVolumeStatsResponse.Size(m)
-}
-func (m *NodeGetVolumeStatsResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeGetVolumeStatsResponse.DiscardUnknown(m)
+
+func (*NodeGetVolumeStatsResponse) ProtoMessage() {}
+
+func (x *NodeGetVolumeStatsResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[52]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeGetVolumeStatsResponse proto.InternalMessageInfo
+// Deprecated: Use NodeGetVolumeStatsResponse.ProtoReflect.Descriptor instead.
+func (*NodeGetVolumeStatsResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{52}
+}
 
-func (m *NodeGetVolumeStatsResponse) GetUsage() []*VolumeUsage {
-	if m != nil {
-		return m.Usage
+func (x *NodeGetVolumeStatsResponse) GetUsage() []*VolumeUsage {
+	if x != nil {
+		return x.Usage
 	}
 	return nil
 }
 
-func (m *NodeGetVolumeStatsResponse) GetVolumeCondition() *VolumeCondition {
-	if m != nil {
-		return m.VolumeCondition
+func (x *NodeGetVolumeStatsResponse) GetVolumeCondition() *VolumeCondition {
+	if x != nil {
+		return x.VolumeCondition
 	}
 	return nil
 }
 
 type VolumeUsage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The available capacity in specified Unit. This field is OPTIONAL.
 	// The value of this field MUST NOT be negative.
 	Available int64 `protobuf:"varint,1,opt,name=available,proto3" json:"available,omitempty"`
@@ -4547,236 +4506,261 @@ type VolumeUsage struct {
 	// The value of this field MUST NOT be negative.
 	Used int64 `protobuf:"varint,3,opt,name=used,proto3" json:"used,omitempty"`
 	// Units by which values are measured. This field is REQUIRED.
-	Unit                 VolumeUsage_Unit `protobuf:"varint,4,opt,name=unit,proto3,enum=csi.v1.VolumeUsage_Unit" json:"unit,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
+	Unit VolumeUsage_Unit `protobuf:"varint,4,opt,name=unit,proto3,enum=csi.v1.VolumeUsage_Unit" json:"unit,omitempty"`
 }
 
-func (m *VolumeUsage) Reset()         { *m = VolumeUsage{} }
-func (m *VolumeUsage) String() string { return proto.CompactTextString(m) }
-func (*VolumeUsage) ProtoMessage()    {}
-func (*VolumeUsage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{53}
+func (x *VolumeUsage) Reset() {
+	*x = VolumeUsage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[53]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *VolumeUsage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeUsage.Unmarshal(m, b)
+func (x *VolumeUsage) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *VolumeUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeUsage.Marshal(b, m, deterministic)
-}
-func (m *VolumeUsage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeUsage.Merge(m, src)
-}
-func (m *VolumeUsage) XXX_Size() int {
-	return xxx_messageInfo_VolumeUsage.Size(m)
-}
-func (m *VolumeUsage) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeUsage.DiscardUnknown(m)
+
+func (*VolumeUsage) ProtoMessage() {}
+
+func (x *VolumeUsage) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[53]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_VolumeUsage proto.InternalMessageInfo
+// Deprecated: Use VolumeUsage.ProtoReflect.Descriptor instead.
+func (*VolumeUsage) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{53}
+}
 
-func (m *VolumeUsage) GetAvailable() int64 {
-	if m != nil {
-		return m.Available
+func (x *VolumeUsage) GetAvailable() int64 {
+	if x != nil {
+		return x.Available
 	}
 	return 0
 }
 
-func (m *VolumeUsage) GetTotal() int64 {
-	if m != nil {
-		return m.Total
+func (x *VolumeUsage) GetTotal() int64 {
+	if x != nil {
+		return x.Total
 	}
 	return 0
 }
 
-func (m *VolumeUsage) GetUsed() int64 {
-	if m != nil {
-		return m.Used
+func (x *VolumeUsage) GetUsed() int64 {
+	if x != nil {
+		return x.Used
 	}
 	return 0
 }
 
-func (m *VolumeUsage) GetUnit() VolumeUsage_Unit {
-	if m != nil {
-		return m.Unit
+func (x *VolumeUsage) GetUnit() VolumeUsage_Unit {
+	if x != nil {
+		return x.Unit
 	}
 	return VolumeUsage_UNKNOWN
 }
 
 // VolumeCondition represents the current condition of a volume.
 type VolumeCondition struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Normal volumes are available for use and operating optimally.
 	// An abnormal volume does not meet these criteria.
 	// This field is REQUIRED.
 	Abnormal bool `protobuf:"varint,1,opt,name=abnormal,proto3" json:"abnormal,omitempty"`
 	// The message describing the condition of the volume.
 	// This field is REQUIRED.
-	Message              string   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
 }
 
-func (m *VolumeCondition) Reset()         { *m = VolumeCondition{} }
-func (m *VolumeCondition) String() string { return proto.CompactTextString(m) }
-func (*VolumeCondition) ProtoMessage()    {}
-func (*VolumeCondition) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{54}
+func (x *VolumeCondition) Reset() {
+	*x = VolumeCondition{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[54]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *VolumeCondition) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeCondition.Unmarshal(m, b)
-}
-func (m *VolumeCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeCondition.Marshal(b, m, deterministic)
+func (x *VolumeCondition) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *VolumeCondition) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeCondition.Merge(m, src)
-}
-func (m *VolumeCondition) XXX_Size() int {
-	return xxx_messageInfo_VolumeCondition.Size(m)
-}
-func (m *VolumeCondition) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeCondition.DiscardUnknown(m)
+
+func (*VolumeCondition) ProtoMessage() {}
+
+func (x *VolumeCondition) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[54]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_VolumeCondition proto.InternalMessageInfo
+// Deprecated: Use VolumeCondition.ProtoReflect.Descriptor instead.
+func (*VolumeCondition) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{54}
+}
 
-func (m *VolumeCondition) GetAbnormal() bool {
-	if m != nil {
-		return m.Abnormal
+func (x *VolumeCondition) GetAbnormal() bool {
+	if x != nil {
+		return x.Abnormal
 	}
 	return false
 }
 
-func (m *VolumeCondition) GetMessage() string {
-	if m != nil {
-		return m.Message
+func (x *VolumeCondition) GetMessage() string {
+	if x != nil {
+		return x.Message
 	}
 	return ""
 }
 
 type NodeGetCapabilitiesRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *NodeGetCapabilitiesRequest) Reset()         { *m = NodeGetCapabilitiesRequest{} }
-func (m *NodeGetCapabilitiesRequest) String() string { return proto.CompactTextString(m) }
-func (*NodeGetCapabilitiesRequest) ProtoMessage()    {}
-func (*NodeGetCapabilitiesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{55}
+func (x *NodeGetCapabilitiesRequest) Reset() {
+	*x = NodeGetCapabilitiesRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[55]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeGetCapabilitiesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeGetCapabilitiesRequest.Unmarshal(m, b)
-}
-func (m *NodeGetCapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeGetCapabilitiesRequest.Marshal(b, m, deterministic)
+func (x *NodeGetCapabilitiesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeGetCapabilitiesRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeGetCapabilitiesRequest.Merge(m, src)
-}
-func (m *NodeGetCapabilitiesRequest) XXX_Size() int {
-	return xxx_messageInfo_NodeGetCapabilitiesRequest.Size(m)
-}
-func (m *NodeGetCapabilitiesRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeGetCapabilitiesRequest.DiscardUnknown(m)
+
+func (*NodeGetCapabilitiesRequest) ProtoMessage() {}
+
+func (x *NodeGetCapabilitiesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[55]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeGetCapabilitiesRequest proto.InternalMessageInfo
+// Deprecated: Use NodeGetCapabilitiesRequest.ProtoReflect.Descriptor instead.
+func (*NodeGetCapabilitiesRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{55}
+}
 
 type NodeGetCapabilitiesResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// All the capabilities that the node service supports. This field
 	// is OPTIONAL.
-	Capabilities         []*NodeServiceCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
-	XXX_unrecognized     []byte                   `json:"-"`
-	XXX_sizecache        int32                    `json:"-"`
+	Capabilities []*NodeServiceCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
 }
 
-func (m *NodeGetCapabilitiesResponse) Reset()         { *m = NodeGetCapabilitiesResponse{} }
-func (m *NodeGetCapabilitiesResponse) String() string { return proto.CompactTextString(m) }
-func (*NodeGetCapabilitiesResponse) ProtoMessage()    {}
-func (*NodeGetCapabilitiesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{56}
+func (x *NodeGetCapabilitiesResponse) Reset() {
+	*x = NodeGetCapabilitiesResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[56]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeGetCapabilitiesResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeGetCapabilitiesResponse.Unmarshal(m, b)
-}
-func (m *NodeGetCapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeGetCapabilitiesResponse.Marshal(b, m, deterministic)
-}
-func (m *NodeGetCapabilitiesResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeGetCapabilitiesResponse.Merge(m, src)
+func (x *NodeGetCapabilitiesResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeGetCapabilitiesResponse) XXX_Size() int {
-	return xxx_messageInfo_NodeGetCapabilitiesResponse.Size(m)
-}
-func (m *NodeGetCapabilitiesResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeGetCapabilitiesResponse.DiscardUnknown(m)
+
+func (*NodeGetCapabilitiesResponse) ProtoMessage() {}
+
+func (x *NodeGetCapabilitiesResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[56]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeGetCapabilitiesResponse proto.InternalMessageInfo
+// Deprecated: Use NodeGetCapabilitiesResponse.ProtoReflect.Descriptor instead.
+func (*NodeGetCapabilitiesResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{56}
+}
 
-func (m *NodeGetCapabilitiesResponse) GetCapabilities() []*NodeServiceCapability {
-	if m != nil {
-		return m.Capabilities
+func (x *NodeGetCapabilitiesResponse) GetCapabilities() []*NodeServiceCapability {
+	if x != nil {
+		return x.Capabilities
 	}
 	return nil
 }
 
 // Specifies a capability of the node service.
 type NodeServiceCapability struct {
-	// Types that are valid to be assigned to Type:
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Type:
 	//
 	//	*NodeServiceCapability_Rpc
-	Type                 isNodeServiceCapability_Type `protobuf_oneof:"type"`
-	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
-	XXX_unrecognized     []byte                       `json:"-"`
-	XXX_sizecache        int32                        `json:"-"`
+	Type isNodeServiceCapability_Type `protobuf_oneof:"type"`
 }
 
-func (m *NodeServiceCapability) Reset()         { *m = NodeServiceCapability{} }
-func (m *NodeServiceCapability) String() string { return proto.CompactTextString(m) }
-func (*NodeServiceCapability) ProtoMessage()    {}
-func (*NodeServiceCapability) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{57}
+func (x *NodeServiceCapability) Reset() {
+	*x = NodeServiceCapability{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[57]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeServiceCapability) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeServiceCapability.Unmarshal(m, b)
-}
-func (m *NodeServiceCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeServiceCapability.Marshal(b, m, deterministic)
-}
-func (m *NodeServiceCapability) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeServiceCapability.Merge(m, src)
-}
-func (m *NodeServiceCapability) XXX_Size() int {
-	return xxx_messageInfo_NodeServiceCapability.Size(m)
-}
-func (m *NodeServiceCapability) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeServiceCapability.DiscardUnknown(m)
+func (x *NodeServiceCapability) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_NodeServiceCapability proto.InternalMessageInfo
+func (*NodeServiceCapability) ProtoMessage() {}
 
-type isNodeServiceCapability_Type interface {
-	isNodeServiceCapability_Type()
+func (x *NodeServiceCapability) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[57]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-type NodeServiceCapability_Rpc struct {
-	Rpc *NodeServiceCapability_RPC `protobuf:"bytes,1,opt,name=rpc,proto3,oneof"`
+// Deprecated: Use NodeServiceCapability.ProtoReflect.Descriptor instead.
+func (*NodeServiceCapability) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{57}
 }
 
-func (*NodeServiceCapability_Rpc) isNodeServiceCapability_Type() {}
-
 func (m *NodeServiceCapability) GetType() isNodeServiceCapability_Type {
 	if m != nil {
 		return m.Type
@@ -4784,91 +4768,67 @@ func (m *NodeServiceCapability) GetType() isNodeServiceCapability_Type {
 	return nil
 }
 
-func (m *NodeServiceCapability) GetRpc() *NodeServiceCapability_RPC {
-	if x, ok := m.GetType().(*NodeServiceCapability_Rpc); ok {
+func (x *NodeServiceCapability) GetRpc() *NodeServiceCapability_RPC {
+	if x, ok := x.GetType().(*NodeServiceCapability_Rpc); ok {
 		return x.Rpc
 	}
 	return nil
 }
 
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*NodeServiceCapability) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
-		(*NodeServiceCapability_Rpc)(nil),
-	}
+type isNodeServiceCapability_Type interface {
+	isNodeServiceCapability_Type()
 }
 
-type NodeServiceCapability_RPC struct {
-	Type                 NodeServiceCapability_RPC_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.NodeServiceCapability_RPC_Type" json:"type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
-	XXX_unrecognized     []byte                         `json:"-"`
-	XXX_sizecache        int32                          `json:"-"`
+type NodeServiceCapability_Rpc struct {
+	// RPC that the controller supports.
+	Rpc *NodeServiceCapability_RPC `protobuf:"bytes,1,opt,name=rpc,proto3,oneof"`
 }
 
-func (m *NodeServiceCapability_RPC) Reset()         { *m = NodeServiceCapability_RPC{} }
-func (m *NodeServiceCapability_RPC) String() string { return proto.CompactTextString(m) }
-func (*NodeServiceCapability_RPC) ProtoMessage()    {}
-func (*NodeServiceCapability_RPC) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{57, 0}
-}
+func (*NodeServiceCapability_Rpc) isNodeServiceCapability_Type() {}
 
-func (m *NodeServiceCapability_RPC) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeServiceCapability_RPC.Unmarshal(m, b)
-}
-func (m *NodeServiceCapability_RPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeServiceCapability_RPC.Marshal(b, m, deterministic)
-}
-func (m *NodeServiceCapability_RPC) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeServiceCapability_RPC.Merge(m, src)
-}
-func (m *NodeServiceCapability_RPC) XXX_Size() int {
-	return xxx_messageInfo_NodeServiceCapability_RPC.Size(m)
-}
-func (m *NodeServiceCapability_RPC) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeServiceCapability_RPC.DiscardUnknown(m)
+type NodeGetInfoRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-var xxx_messageInfo_NodeServiceCapability_RPC proto.InternalMessageInfo
-
-func (m *NodeServiceCapability_RPC) GetType() NodeServiceCapability_RPC_Type {
-	if m != nil {
-		return m.Type
+func (x *NodeGetInfoRequest) Reset() {
+	*x = NodeGetInfoRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[58]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return NodeServiceCapability_RPC_UNKNOWN
 }
 
-type NodeGetInfoRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+func (x *NodeGetInfoRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func (m *NodeGetInfoRequest) Reset()         { *m = NodeGetInfoRequest{} }
-func (m *NodeGetInfoRequest) String() string { return proto.CompactTextString(m) }
-func (*NodeGetInfoRequest) ProtoMessage()    {}
-func (*NodeGetInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{58}
-}
+func (*NodeGetInfoRequest) ProtoMessage() {}
 
-func (m *NodeGetInfoRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeGetInfoRequest.Unmarshal(m, b)
-}
-func (m *NodeGetInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeGetInfoRequest.Marshal(b, m, deterministic)
-}
-func (m *NodeGetInfoRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeGetInfoRequest.Merge(m, src)
-}
-func (m *NodeGetInfoRequest) XXX_Size() int {
-	return xxx_messageInfo_NodeGetInfoRequest.Size(m)
-}
-func (m *NodeGetInfoRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeGetInfoRequest.DiscardUnknown(m)
+func (x *NodeGetInfoRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[58]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeGetInfoRequest proto.InternalMessageInfo
+// Deprecated: Use NodeGetInfoRequest.ProtoReflect.Descriptor instead.
+func (*NodeGetInfoRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{58}
+}
 
 type NodeGetInfoResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The identifier of the node as understood by the SP.
 	// This field is REQUIRED.
 	// This field MUST contain enough information to uniquely identify
@@ -4907,59 +4867,67 @@ type NodeGetInfoResponse struct {
 	//
 	// Indicates the node exists within the "region" "R1" and the "zone"
 	// "Z2".
-	AccessibleTopology   *Topology `protobuf:"bytes,3,opt,name=accessible_topology,json=accessibleTopology,proto3" json:"accessible_topology,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	AccessibleTopology *Topology `protobuf:"bytes,3,opt,name=accessible_topology,json=accessibleTopology,proto3" json:"accessible_topology,omitempty"`
 }
 
-func (m *NodeGetInfoResponse) Reset()         { *m = NodeGetInfoResponse{} }
-func (m *NodeGetInfoResponse) String() string { return proto.CompactTextString(m) }
-func (*NodeGetInfoResponse) ProtoMessage()    {}
-func (*NodeGetInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{59}
+func (x *NodeGetInfoResponse) Reset() {
+	*x = NodeGetInfoResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[59]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeGetInfoResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeGetInfoResponse.Unmarshal(m, b)
-}
-func (m *NodeGetInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeGetInfoResponse.Marshal(b, m, deterministic)
-}
-func (m *NodeGetInfoResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeGetInfoResponse.Merge(m, src)
+func (x *NodeGetInfoResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeGetInfoResponse) XXX_Size() int {
-	return xxx_messageInfo_NodeGetInfoResponse.Size(m)
-}
-func (m *NodeGetInfoResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeGetInfoResponse.DiscardUnknown(m)
+
+func (*NodeGetInfoResponse) ProtoMessage() {}
+
+func (x *NodeGetInfoResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[59]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeGetInfoResponse proto.InternalMessageInfo
+// Deprecated: Use NodeGetInfoResponse.ProtoReflect.Descriptor instead.
+func (*NodeGetInfoResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{59}
+}
 
-func (m *NodeGetInfoResponse) GetNodeId() string {
-	if m != nil {
-		return m.NodeId
+func (x *NodeGetInfoResponse) GetNodeId() string {
+	if x != nil {
+		return x.NodeId
 	}
 	return ""
 }
 
-func (m *NodeGetInfoResponse) GetMaxVolumesPerNode() int64 {
-	if m != nil {
-		return m.MaxVolumesPerNode
+func (x *NodeGetInfoResponse) GetMaxVolumesPerNode() int64 {
+	if x != nil {
+		return x.MaxVolumesPerNode
 	}
 	return 0
 }
 
-func (m *NodeGetInfoResponse) GetAccessibleTopology() *Topology {
-	if m != nil {
-		return m.AccessibleTopology
+func (x *NodeGetInfoResponse) GetAccessibleTopology() *Topology {
+	if x != nil {
+		return x.AccessibleTopology
 	}
 	return nil
 }
 
 type NodeExpandVolumeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the volume. This field is REQUIRED.
 	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
 	// The path on which volume is available. This field is REQUIRED.
@@ -4998,239 +4966,262 @@ type NodeExpandVolumeRequest struct {
 	// Secrets required by plugin to complete node expand volume request.
 	// This field is OPTIONAL. Refer to the `Secrets Requirements`
 	// section on how to use this field.
-	Secrets              map[string]string `protobuf:"bytes,6,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Secrets map[string]string `protobuf:"bytes,6,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *NodeExpandVolumeRequest) Reset()         { *m = NodeExpandVolumeRequest{} }
-func (m *NodeExpandVolumeRequest) String() string { return proto.CompactTextString(m) }
-func (*NodeExpandVolumeRequest) ProtoMessage()    {}
-func (*NodeExpandVolumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{60}
+func (x *NodeExpandVolumeRequest) Reset() {
+	*x = NodeExpandVolumeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[60]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeExpandVolumeRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeExpandVolumeRequest.Unmarshal(m, b)
+func (x *NodeExpandVolumeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeExpandVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeExpandVolumeRequest.Marshal(b, m, deterministic)
-}
-func (m *NodeExpandVolumeRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeExpandVolumeRequest.Merge(m, src)
-}
-func (m *NodeExpandVolumeRequest) XXX_Size() int {
-	return xxx_messageInfo_NodeExpandVolumeRequest.Size(m)
-}
-func (m *NodeExpandVolumeRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeExpandVolumeRequest.DiscardUnknown(m)
+
+func (*NodeExpandVolumeRequest) ProtoMessage() {}
+
+func (x *NodeExpandVolumeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[60]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeExpandVolumeRequest proto.InternalMessageInfo
+// Deprecated: Use NodeExpandVolumeRequest.ProtoReflect.Descriptor instead.
+func (*NodeExpandVolumeRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{60}
+}
 
-func (m *NodeExpandVolumeRequest) GetVolumeId() string {
-	if m != nil {
-		return m.VolumeId
+func (x *NodeExpandVolumeRequest) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
 	return ""
 }
 
-func (m *NodeExpandVolumeRequest) GetVolumePath() string {
-	if m != nil {
-		return m.VolumePath
+func (x *NodeExpandVolumeRequest) GetVolumePath() string {
+	if x != nil {
+		return x.VolumePath
 	}
 	return ""
 }
 
-func (m *NodeExpandVolumeRequest) GetCapacityRange() *CapacityRange {
-	if m != nil {
-		return m.CapacityRange
+func (x *NodeExpandVolumeRequest) GetCapacityRange() *CapacityRange {
+	if x != nil {
+		return x.CapacityRange
 	}
 	return nil
 }
 
-func (m *NodeExpandVolumeRequest) GetStagingTargetPath() string {
-	if m != nil {
-		return m.StagingTargetPath
+func (x *NodeExpandVolumeRequest) GetStagingTargetPath() string {
+	if x != nil {
+		return x.StagingTargetPath
 	}
 	return ""
 }
 
-func (m *NodeExpandVolumeRequest) GetVolumeCapability() *VolumeCapability {
-	if m != nil {
-		return m.VolumeCapability
+func (x *NodeExpandVolumeRequest) GetVolumeCapability() *VolumeCapability {
+	if x != nil {
+		return x.VolumeCapability
 	}
 	return nil
 }
 
-func (m *NodeExpandVolumeRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *NodeExpandVolumeRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
 type NodeExpandVolumeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The capacity of the volume in bytes. This field is OPTIONAL.
-	CapacityBytes        int64    `protobuf:"varint,1,opt,name=capacity_bytes,json=capacityBytes,proto3" json:"capacity_bytes,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	CapacityBytes int64 `protobuf:"varint,1,opt,name=capacity_bytes,json=capacityBytes,proto3" json:"capacity_bytes,omitempty"`
 }
 
-func (m *NodeExpandVolumeResponse) Reset()         { *m = NodeExpandVolumeResponse{} }
-func (m *NodeExpandVolumeResponse) String() string { return proto.CompactTextString(m) }
-func (*NodeExpandVolumeResponse) ProtoMessage()    {}
-func (*NodeExpandVolumeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{61}
+func (x *NodeExpandVolumeResponse) Reset() {
+	*x = NodeExpandVolumeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[61]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *NodeExpandVolumeResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_NodeExpandVolumeResponse.Unmarshal(m, b)
-}
-func (m *NodeExpandVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_NodeExpandVolumeResponse.Marshal(b, m, deterministic)
-}
-func (m *NodeExpandVolumeResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeExpandVolumeResponse.Merge(m, src)
+func (x *NodeExpandVolumeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *NodeExpandVolumeResponse) XXX_Size() int {
-	return xxx_messageInfo_NodeExpandVolumeResponse.Size(m)
-}
-func (m *NodeExpandVolumeResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_NodeExpandVolumeResponse.DiscardUnknown(m)
+
+func (*NodeExpandVolumeResponse) ProtoMessage() {}
+
+func (x *NodeExpandVolumeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[61]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_NodeExpandVolumeResponse proto.InternalMessageInfo
+// Deprecated: Use NodeExpandVolumeResponse.ProtoReflect.Descriptor instead.
+func (*NodeExpandVolumeResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{61}
+}
 
-func (m *NodeExpandVolumeResponse) GetCapacityBytes() int64 {
-	if m != nil {
-		return m.CapacityBytes
+func (x *NodeExpandVolumeResponse) GetCapacityBytes() int64 {
+	if x != nil {
+		return x.CapacityBytes
 	}
 	return 0
 }
 
 type GroupControllerGetCapabilitiesRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *GroupControllerGetCapabilitiesRequest) Reset()         { *m = GroupControllerGetCapabilitiesRequest{} }
-func (m *GroupControllerGetCapabilitiesRequest) String() string { return proto.CompactTextString(m) }
-func (*GroupControllerGetCapabilitiesRequest) ProtoMessage()    {}
-func (*GroupControllerGetCapabilitiesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{62}
+func (x *GroupControllerGetCapabilitiesRequest) Reset() {
+	*x = GroupControllerGetCapabilitiesRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[62]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GroupControllerGetCapabilitiesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GroupControllerGetCapabilitiesRequest.Unmarshal(m, b)
-}
-func (m *GroupControllerGetCapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GroupControllerGetCapabilitiesRequest.Marshal(b, m, deterministic)
-}
-func (m *GroupControllerGetCapabilitiesRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupControllerGetCapabilitiesRequest.Merge(m, src)
-}
-func (m *GroupControllerGetCapabilitiesRequest) XXX_Size() int {
-	return xxx_messageInfo_GroupControllerGetCapabilitiesRequest.Size(m)
+func (x *GroupControllerGetCapabilitiesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GroupControllerGetCapabilitiesRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_GroupControllerGetCapabilitiesRequest.DiscardUnknown(m)
+
+func (*GroupControllerGetCapabilitiesRequest) ProtoMessage() {}
+
+func (x *GroupControllerGetCapabilitiesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[62]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GroupControllerGetCapabilitiesRequest proto.InternalMessageInfo
+// Deprecated: Use GroupControllerGetCapabilitiesRequest.ProtoReflect.Descriptor instead.
+func (*GroupControllerGetCapabilitiesRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{62}
+}
 
 type GroupControllerGetCapabilitiesResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// All the capabilities that the group controller service supports.
 	// This field is OPTIONAL.
-	Capabilities         []*GroupControllerServiceCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
-	XXX_unrecognized     []byte                              `json:"-"`
-	XXX_sizecache        int32                               `json:"-"`
+	Capabilities []*GroupControllerServiceCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
 }
 
-func (m *GroupControllerGetCapabilitiesResponse) Reset() {
-	*m = GroupControllerGetCapabilitiesResponse{}
-}
-func (m *GroupControllerGetCapabilitiesResponse) String() string { return proto.CompactTextString(m) }
-func (*GroupControllerGetCapabilitiesResponse) ProtoMessage()    {}
-func (*GroupControllerGetCapabilitiesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{63}
+func (x *GroupControllerGetCapabilitiesResponse) Reset() {
+	*x = GroupControllerGetCapabilitiesResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[63]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GroupControllerGetCapabilitiesResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GroupControllerGetCapabilitiesResponse.Unmarshal(m, b)
-}
-func (m *GroupControllerGetCapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GroupControllerGetCapabilitiesResponse.Marshal(b, m, deterministic)
-}
-func (m *GroupControllerGetCapabilitiesResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupControllerGetCapabilitiesResponse.Merge(m, src)
-}
-func (m *GroupControllerGetCapabilitiesResponse) XXX_Size() int {
-	return xxx_messageInfo_GroupControllerGetCapabilitiesResponse.Size(m)
+func (x *GroupControllerGetCapabilitiesResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GroupControllerGetCapabilitiesResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_GroupControllerGetCapabilitiesResponse.DiscardUnknown(m)
+
+func (*GroupControllerGetCapabilitiesResponse) ProtoMessage() {}
+
+func (x *GroupControllerGetCapabilitiesResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[63]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GroupControllerGetCapabilitiesResponse proto.InternalMessageInfo
+// Deprecated: Use GroupControllerGetCapabilitiesResponse.ProtoReflect.Descriptor instead.
+func (*GroupControllerGetCapabilitiesResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{63}
+}
 
-func (m *GroupControllerGetCapabilitiesResponse) GetCapabilities() []*GroupControllerServiceCapability {
-	if m != nil {
-		return m.Capabilities
+func (x *GroupControllerGetCapabilitiesResponse) GetCapabilities() []*GroupControllerServiceCapability {
+	if x != nil {
+		return x.Capabilities
 	}
 	return nil
 }
 
 // Specifies a capability of the group controller service.
 type GroupControllerServiceCapability struct {
-	// Types that are valid to be assigned to Type:
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Type:
 	//
 	//	*GroupControllerServiceCapability_Rpc
-	Type                 isGroupControllerServiceCapability_Type `protobuf_oneof:"type"`
-	XXX_NoUnkeyedLiteral struct{}                                `json:"-"`
-	XXX_unrecognized     []byte                                  `json:"-"`
-	XXX_sizecache        int32                                   `json:"-"`
+	Type isGroupControllerServiceCapability_Type `protobuf_oneof:"type"`
 }
 
-func (m *GroupControllerServiceCapability) Reset()         { *m = GroupControllerServiceCapability{} }
-func (m *GroupControllerServiceCapability) String() string { return proto.CompactTextString(m) }
-func (*GroupControllerServiceCapability) ProtoMessage()    {}
-func (*GroupControllerServiceCapability) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{64}
+func (x *GroupControllerServiceCapability) Reset() {
+	*x = GroupControllerServiceCapability{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[64]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GroupControllerServiceCapability) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GroupControllerServiceCapability.Unmarshal(m, b)
-}
-func (m *GroupControllerServiceCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GroupControllerServiceCapability.Marshal(b, m, deterministic)
-}
-func (m *GroupControllerServiceCapability) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupControllerServiceCapability.Merge(m, src)
-}
-func (m *GroupControllerServiceCapability) XXX_Size() int {
-	return xxx_messageInfo_GroupControllerServiceCapability.Size(m)
-}
-func (m *GroupControllerServiceCapability) XXX_DiscardUnknown() {
-	xxx_messageInfo_GroupControllerServiceCapability.DiscardUnknown(m)
+func (x *GroupControllerServiceCapability) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_GroupControllerServiceCapability proto.InternalMessageInfo
+func (*GroupControllerServiceCapability) ProtoMessage() {}
 
-type isGroupControllerServiceCapability_Type interface {
-	isGroupControllerServiceCapability_Type()
+func (x *GroupControllerServiceCapability) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[64]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-type GroupControllerServiceCapability_Rpc struct {
-	Rpc *GroupControllerServiceCapability_RPC `protobuf:"bytes,1,opt,name=rpc,proto3,oneof"`
+// Deprecated: Use GroupControllerServiceCapability.ProtoReflect.Descriptor instead.
+func (*GroupControllerServiceCapability) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{64}
 }
 
-func (*GroupControllerServiceCapability_Rpc) isGroupControllerServiceCapability_Type() {}
-
 func (m *GroupControllerServiceCapability) GetType() isGroupControllerServiceCapability_Type {
 	if m != nil {
 		return m.Type
@@ -5238,60 +5229,29 @@ func (m *GroupControllerServiceCapability) GetType() isGroupControllerServiceCap
 	return nil
 }
 
-func (m *GroupControllerServiceCapability) GetRpc() *GroupControllerServiceCapability_RPC {
-	if x, ok := m.GetType().(*GroupControllerServiceCapability_Rpc); ok {
+func (x *GroupControllerServiceCapability) GetRpc() *GroupControllerServiceCapability_RPC {
+	if x, ok := x.GetType().(*GroupControllerServiceCapability_Rpc); ok {
 		return x.Rpc
 	}
 	return nil
 }
 
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*GroupControllerServiceCapability) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
-		(*GroupControllerServiceCapability_Rpc)(nil),
-	}
-}
-
-type GroupControllerServiceCapability_RPC struct {
-	Type                 GroupControllerServiceCapability_RPC_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.GroupControllerServiceCapability_RPC_Type" json:"type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                                  `json:"-"`
-	XXX_unrecognized     []byte                                    `json:"-"`
-	XXX_sizecache        int32                                     `json:"-"`
-}
-
-func (m *GroupControllerServiceCapability_RPC) Reset()         { *m = GroupControllerServiceCapability_RPC{} }
-func (m *GroupControllerServiceCapability_RPC) String() string { return proto.CompactTextString(m) }
-func (*GroupControllerServiceCapability_RPC) ProtoMessage()    {}
-func (*GroupControllerServiceCapability_RPC) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{64, 0}
+type isGroupControllerServiceCapability_Type interface {
+	isGroupControllerServiceCapability_Type()
 }
 
-func (m *GroupControllerServiceCapability_RPC) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GroupControllerServiceCapability_RPC.Unmarshal(m, b)
-}
-func (m *GroupControllerServiceCapability_RPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GroupControllerServiceCapability_RPC.Marshal(b, m, deterministic)
-}
-func (m *GroupControllerServiceCapability_RPC) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupControllerServiceCapability_RPC.Merge(m, src)
-}
-func (m *GroupControllerServiceCapability_RPC) XXX_Size() int {
-	return xxx_messageInfo_GroupControllerServiceCapability_RPC.Size(m)
-}
-func (m *GroupControllerServiceCapability_RPC) XXX_DiscardUnknown() {
-	xxx_messageInfo_GroupControllerServiceCapability_RPC.DiscardUnknown(m)
+type GroupControllerServiceCapability_Rpc struct {
+	// RPC that the controller supports.
+	Rpc *GroupControllerServiceCapability_RPC `protobuf:"bytes,1,opt,name=rpc,proto3,oneof"`
 }
 
-var xxx_messageInfo_GroupControllerServiceCapability_RPC proto.InternalMessageInfo
-
-func (m *GroupControllerServiceCapability_RPC) GetType() GroupControllerServiceCapability_RPC_Type {
-	if m != nil {
-		return m.Type
-	}
-	return GroupControllerServiceCapability_RPC_UNKNOWN
-}
+func (*GroupControllerServiceCapability_Rpc) isGroupControllerServiceCapability_Type() {}
 
 type CreateVolumeGroupSnapshotRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The suggested name for the group snapshot. This field is REQUIRED
 	// for idempotency.
 	// Any Unicode string that conforms to the length limit is allowed
@@ -5312,107 +5272,123 @@ type CreateVolumeGroupSnapshotRequest struct {
 	// Plugin specific parameters passed in as opaque key-value pairs.
 	// This field is OPTIONAL. The Plugin is responsible for parsing and
 	// validating these parameters. COs will treat these as opaque.
-	Parameters           map[string]string `protobuf:"bytes,4,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Parameters map[string]string `protobuf:"bytes,4,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *CreateVolumeGroupSnapshotRequest) Reset()         { *m = CreateVolumeGroupSnapshotRequest{} }
-func (m *CreateVolumeGroupSnapshotRequest) String() string { return proto.CompactTextString(m) }
-func (*CreateVolumeGroupSnapshotRequest) ProtoMessage()    {}
-func (*CreateVolumeGroupSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{65}
+func (x *CreateVolumeGroupSnapshotRequest) Reset() {
+	*x = CreateVolumeGroupSnapshotRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[65]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *CreateVolumeGroupSnapshotRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CreateVolumeGroupSnapshotRequest.Unmarshal(m, b)
+func (x *CreateVolumeGroupSnapshotRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CreateVolumeGroupSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CreateVolumeGroupSnapshotRequest.Marshal(b, m, deterministic)
-}
-func (m *CreateVolumeGroupSnapshotRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateVolumeGroupSnapshotRequest.Merge(m, src)
-}
-func (m *CreateVolumeGroupSnapshotRequest) XXX_Size() int {
-	return xxx_messageInfo_CreateVolumeGroupSnapshotRequest.Size(m)
-}
-func (m *CreateVolumeGroupSnapshotRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateVolumeGroupSnapshotRequest.DiscardUnknown(m)
+
+func (*CreateVolumeGroupSnapshotRequest) ProtoMessage() {}
+
+func (x *CreateVolumeGroupSnapshotRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[65]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CreateVolumeGroupSnapshotRequest proto.InternalMessageInfo
+// Deprecated: Use CreateVolumeGroupSnapshotRequest.ProtoReflect.Descriptor instead.
+func (*CreateVolumeGroupSnapshotRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{65}
+}
 
-func (m *CreateVolumeGroupSnapshotRequest) GetName() string {
-	if m != nil {
-		return m.Name
+func (x *CreateVolumeGroupSnapshotRequest) GetName() string {
+	if x != nil {
+		return x.Name
 	}
 	return ""
 }
 
-func (m *CreateVolumeGroupSnapshotRequest) GetSourceVolumeIds() []string {
-	if m != nil {
-		return m.SourceVolumeIds
+func (x *CreateVolumeGroupSnapshotRequest) GetSourceVolumeIds() []string {
+	if x != nil {
+		return x.SourceVolumeIds
 	}
 	return nil
 }
 
-func (m *CreateVolumeGroupSnapshotRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *CreateVolumeGroupSnapshotRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
-func (m *CreateVolumeGroupSnapshotRequest) GetParameters() map[string]string {
-	if m != nil {
-		return m.Parameters
+func (x *CreateVolumeGroupSnapshotRequest) GetParameters() map[string]string {
+	if x != nil {
+		return x.Parameters
 	}
 	return nil
 }
 
 type CreateVolumeGroupSnapshotResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// Contains all attributes of the newly created group snapshot.
 	// This field is REQUIRED.
-	GroupSnapshot        *VolumeGroupSnapshot `protobuf:"bytes,1,opt,name=group_snapshot,json=groupSnapshot,proto3" json:"group_snapshot,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
-	XXX_unrecognized     []byte               `json:"-"`
-	XXX_sizecache        int32                `json:"-"`
+	GroupSnapshot *VolumeGroupSnapshot `protobuf:"bytes,1,opt,name=group_snapshot,json=groupSnapshot,proto3" json:"group_snapshot,omitempty"`
 }
 
-func (m *CreateVolumeGroupSnapshotResponse) Reset()         { *m = CreateVolumeGroupSnapshotResponse{} }
-func (m *CreateVolumeGroupSnapshotResponse) String() string { return proto.CompactTextString(m) }
-func (*CreateVolumeGroupSnapshotResponse) ProtoMessage()    {}
-func (*CreateVolumeGroupSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{66}
+func (x *CreateVolumeGroupSnapshotResponse) Reset() {
+	*x = CreateVolumeGroupSnapshotResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[66]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *CreateVolumeGroupSnapshotResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CreateVolumeGroupSnapshotResponse.Unmarshal(m, b)
-}
-func (m *CreateVolumeGroupSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CreateVolumeGroupSnapshotResponse.Marshal(b, m, deterministic)
+func (x *CreateVolumeGroupSnapshotResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CreateVolumeGroupSnapshotResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateVolumeGroupSnapshotResponse.Merge(m, src)
-}
-func (m *CreateVolumeGroupSnapshotResponse) XXX_Size() int {
-	return xxx_messageInfo_CreateVolumeGroupSnapshotResponse.Size(m)
-}
-func (m *CreateVolumeGroupSnapshotResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateVolumeGroupSnapshotResponse.DiscardUnknown(m)
+
+func (*CreateVolumeGroupSnapshotResponse) ProtoMessage() {}
+
+func (x *CreateVolumeGroupSnapshotResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[66]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CreateVolumeGroupSnapshotResponse proto.InternalMessageInfo
+// Deprecated: Use CreateVolumeGroupSnapshotResponse.ProtoReflect.Descriptor instead.
+func (*CreateVolumeGroupSnapshotResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{66}
+}
 
-func (m *CreateVolumeGroupSnapshotResponse) GetGroupSnapshot() *VolumeGroupSnapshot {
-	if m != nil {
-		return m.GroupSnapshot
+func (x *CreateVolumeGroupSnapshotResponse) GetGroupSnapshot() *VolumeGroupSnapshot {
+	if x != nil {
+		return x.GroupSnapshot
 	}
 	return nil
 }
 
 type VolumeGroupSnapshot struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The identifier for this group snapshot, generated by the plugin.
 	// This field MUST contain enough information to uniquely identify
 	// this specific snapshot vs all other group snapshots supported by
@@ -5428,7 +5404,7 @@ type VolumeGroupSnapshot struct {
 	Snapshots []*Snapshot `protobuf:"bytes,2,rep,name=snapshots,proto3" json:"snapshots,omitempty"`
 	// Timestamp of when the volume group snapshot was taken.
 	// This field is REQUIRED.
-	CreationTime *timestamp.Timestamp `protobuf:"bytes,3,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"`
+	CreationTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"`
 	// Indicates if all individual snapshots in the group snapshot
 	// are ready to use as a `volume_content_source` in a
 	// `CreateVolumeRequest`. The default value is false.
@@ -5438,66 +5414,74 @@ type VolumeGroupSnapshot struct {
 	// have ready_to_use set to true, the SP SHOULD set this field to
 	// true.
 	// This field is REQUIRED.
-	ReadyToUse           bool     `protobuf:"varint,4,opt,name=ready_to_use,json=readyToUse,proto3" json:"ready_to_use,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	ReadyToUse bool `protobuf:"varint,4,opt,name=ready_to_use,json=readyToUse,proto3" json:"ready_to_use,omitempty"`
 }
 
-func (m *VolumeGroupSnapshot) Reset()         { *m = VolumeGroupSnapshot{} }
-func (m *VolumeGroupSnapshot) String() string { return proto.CompactTextString(m) }
-func (*VolumeGroupSnapshot) ProtoMessage()    {}
-func (*VolumeGroupSnapshot) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{67}
+func (x *VolumeGroupSnapshot) Reset() {
+	*x = VolumeGroupSnapshot{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[67]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *VolumeGroupSnapshot) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_VolumeGroupSnapshot.Unmarshal(m, b)
-}
-func (m *VolumeGroupSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_VolumeGroupSnapshot.Marshal(b, m, deterministic)
+func (x *VolumeGroupSnapshot) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *VolumeGroupSnapshot) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeGroupSnapshot.Merge(m, src)
-}
-func (m *VolumeGroupSnapshot) XXX_Size() int {
-	return xxx_messageInfo_VolumeGroupSnapshot.Size(m)
-}
-func (m *VolumeGroupSnapshot) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeGroupSnapshot.DiscardUnknown(m)
+
+func (*VolumeGroupSnapshot) ProtoMessage() {}
+
+func (x *VolumeGroupSnapshot) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[67]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_VolumeGroupSnapshot proto.InternalMessageInfo
+// Deprecated: Use VolumeGroupSnapshot.ProtoReflect.Descriptor instead.
+func (*VolumeGroupSnapshot) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{67}
+}
 
-func (m *VolumeGroupSnapshot) GetGroupSnapshotId() string {
-	if m != nil {
-		return m.GroupSnapshotId
+func (x *VolumeGroupSnapshot) GetGroupSnapshotId() string {
+	if x != nil {
+		return x.GroupSnapshotId
 	}
 	return ""
 }
 
-func (m *VolumeGroupSnapshot) GetSnapshots() []*Snapshot {
-	if m != nil {
-		return m.Snapshots
+func (x *VolumeGroupSnapshot) GetSnapshots() []*Snapshot {
+	if x != nil {
+		return x.Snapshots
 	}
 	return nil
 }
 
-func (m *VolumeGroupSnapshot) GetCreationTime() *timestamp.Timestamp {
-	if m != nil {
-		return m.CreationTime
+func (x *VolumeGroupSnapshot) GetCreationTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CreationTime
 	}
 	return nil
 }
 
-func (m *VolumeGroupSnapshot) GetReadyToUse() bool {
-	if m != nil {
-		return m.ReadyToUse
+func (x *VolumeGroupSnapshot) GetReadyToUse() bool {
+	if x != nil {
+		return x.ReadyToUse
 	}
 	return false
 }
 
 type DeleteVolumeGroupSnapshotRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the group snapshot to be deleted.
 	// This field is REQUIRED.
 	GroupSnapshotId string `protobuf:"bytes,1,opt,name=group_snapshot_id,json=groupSnapshotId,proto3" json:"group_snapshot_id,omitempty"`
@@ -5517,90 +5501,105 @@ type DeleteVolumeGroupSnapshotRequest struct {
 	// section on how to use this field.
 	// The secrets provided in this field SHOULD be the same for
 	// all group snapshot operations on the same group snapshot.
-	Secrets              map[string]string `protobuf:"bytes,3,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Secrets map[string]string `protobuf:"bytes,3,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *DeleteVolumeGroupSnapshotRequest) Reset()         { *m = DeleteVolumeGroupSnapshotRequest{} }
-func (m *DeleteVolumeGroupSnapshotRequest) String() string { return proto.CompactTextString(m) }
-func (*DeleteVolumeGroupSnapshotRequest) ProtoMessage()    {}
-func (*DeleteVolumeGroupSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{68}
+func (x *DeleteVolumeGroupSnapshotRequest) Reset() {
+	*x = DeleteVolumeGroupSnapshotRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[68]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *DeleteVolumeGroupSnapshotRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DeleteVolumeGroupSnapshotRequest.Unmarshal(m, b)
-}
-func (m *DeleteVolumeGroupSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DeleteVolumeGroupSnapshotRequest.Marshal(b, m, deterministic)
+func (x *DeleteVolumeGroupSnapshotRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *DeleteVolumeGroupSnapshotRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteVolumeGroupSnapshotRequest.Merge(m, src)
-}
-func (m *DeleteVolumeGroupSnapshotRequest) XXX_Size() int {
-	return xxx_messageInfo_DeleteVolumeGroupSnapshotRequest.Size(m)
-}
-func (m *DeleteVolumeGroupSnapshotRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_DeleteVolumeGroupSnapshotRequest.DiscardUnknown(m)
+
+func (*DeleteVolumeGroupSnapshotRequest) ProtoMessage() {}
+
+func (x *DeleteVolumeGroupSnapshotRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[68]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_DeleteVolumeGroupSnapshotRequest proto.InternalMessageInfo
+// Deprecated: Use DeleteVolumeGroupSnapshotRequest.ProtoReflect.Descriptor instead.
+func (*DeleteVolumeGroupSnapshotRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{68}
+}
 
-func (m *DeleteVolumeGroupSnapshotRequest) GetGroupSnapshotId() string {
-	if m != nil {
-		return m.GroupSnapshotId
+func (x *DeleteVolumeGroupSnapshotRequest) GetGroupSnapshotId() string {
+	if x != nil {
+		return x.GroupSnapshotId
 	}
 	return ""
 }
 
-func (m *DeleteVolumeGroupSnapshotRequest) GetSnapshotIds() []string {
-	if m != nil {
-		return m.SnapshotIds
+func (x *DeleteVolumeGroupSnapshotRequest) GetSnapshotIds() []string {
+	if x != nil {
+		return x.SnapshotIds
 	}
 	return nil
 }
 
-func (m *DeleteVolumeGroupSnapshotRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *DeleteVolumeGroupSnapshotRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
 type DeleteVolumeGroupSnapshotResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *DeleteVolumeGroupSnapshotResponse) Reset()         { *m = DeleteVolumeGroupSnapshotResponse{} }
-func (m *DeleteVolumeGroupSnapshotResponse) String() string { return proto.CompactTextString(m) }
-func (*DeleteVolumeGroupSnapshotResponse) ProtoMessage()    {}
-func (*DeleteVolumeGroupSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{69}
+func (x *DeleteVolumeGroupSnapshotResponse) Reset() {
+	*x = DeleteVolumeGroupSnapshotResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[69]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *DeleteVolumeGroupSnapshotResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DeleteVolumeGroupSnapshotResponse.Unmarshal(m, b)
+func (x *DeleteVolumeGroupSnapshotResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *DeleteVolumeGroupSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DeleteVolumeGroupSnapshotResponse.Marshal(b, m, deterministic)
-}
-func (m *DeleteVolumeGroupSnapshotResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteVolumeGroupSnapshotResponse.Merge(m, src)
-}
-func (m *DeleteVolumeGroupSnapshotResponse) XXX_Size() int {
-	return xxx_messageInfo_DeleteVolumeGroupSnapshotResponse.Size(m)
-}
-func (m *DeleteVolumeGroupSnapshotResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_DeleteVolumeGroupSnapshotResponse.DiscardUnknown(m)
+
+func (*DeleteVolumeGroupSnapshotResponse) ProtoMessage() {}
+
+func (x *DeleteVolumeGroupSnapshotResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[69]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_DeleteVolumeGroupSnapshotResponse proto.InternalMessageInfo
+// Deprecated: Use DeleteVolumeGroupSnapshotResponse.ProtoReflect.Descriptor instead.
+func (*DeleteVolumeGroupSnapshotResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{69}
+}
 
 type GetVolumeGroupSnapshotRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// The ID of the group snapshot to fetch current group snapshot
 	// information for.
 	// This field is REQUIRED.
@@ -5621,1773 +5620,4297 @@ type GetVolumeGroupSnapshotRequest struct {
 	// section on how to use this field.
 	// The secrets provided in this field SHOULD be the same for
 	// all group snapshot operations on the same group snapshot.
-	Secrets              map[string]string `protobuf:"bytes,3,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Secrets map[string]string `protobuf:"bytes,3,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (m *GetVolumeGroupSnapshotRequest) Reset()         { *m = GetVolumeGroupSnapshotRequest{} }
-func (m *GetVolumeGroupSnapshotRequest) String() string { return proto.CompactTextString(m) }
-func (*GetVolumeGroupSnapshotRequest) ProtoMessage()    {}
-func (*GetVolumeGroupSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{70}
+func (x *GetVolumeGroupSnapshotRequest) Reset() {
+	*x = GetVolumeGroupSnapshotRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[70]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GetVolumeGroupSnapshotRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetVolumeGroupSnapshotRequest.Unmarshal(m, b)
+func (x *GetVolumeGroupSnapshotRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *GetVolumeGroupSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetVolumeGroupSnapshotRequest.Marshal(b, m, deterministic)
-}
-func (m *GetVolumeGroupSnapshotRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetVolumeGroupSnapshotRequest.Merge(m, src)
-}
-func (m *GetVolumeGroupSnapshotRequest) XXX_Size() int {
-	return xxx_messageInfo_GetVolumeGroupSnapshotRequest.Size(m)
-}
-func (m *GetVolumeGroupSnapshotRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetVolumeGroupSnapshotRequest.DiscardUnknown(m)
+
+func (*GetVolumeGroupSnapshotRequest) ProtoMessage() {}
+
+func (x *GetVolumeGroupSnapshotRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[70]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_GetVolumeGroupSnapshotRequest proto.InternalMessageInfo
+// Deprecated: Use GetVolumeGroupSnapshotRequest.ProtoReflect.Descriptor instead.
+func (*GetVolumeGroupSnapshotRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{70}
+}
 
-func (m *GetVolumeGroupSnapshotRequest) GetGroupSnapshotId() string {
-	if m != nil {
-		return m.GroupSnapshotId
+func (x *GetVolumeGroupSnapshotRequest) GetGroupSnapshotId() string {
+	if x != nil {
+		return x.GroupSnapshotId
 	}
 	return ""
 }
 
-func (m *GetVolumeGroupSnapshotRequest) GetSnapshotIds() []string {
-	if m != nil {
-		return m.SnapshotIds
+func (x *GetVolumeGroupSnapshotRequest) GetSnapshotIds() []string {
+	if x != nil {
+		return x.SnapshotIds
 	}
 	return nil
 }
 
-func (m *GetVolumeGroupSnapshotRequest) GetSecrets() map[string]string {
-	if m != nil {
-		return m.Secrets
+func (x *GetVolumeGroupSnapshotRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
 	return nil
 }
 
 type GetVolumeGroupSnapshotResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	// This field is REQUIRED
-	GroupSnapshot        *VolumeGroupSnapshot `protobuf:"bytes,1,opt,name=group_snapshot,json=groupSnapshot,proto3" json:"group_snapshot,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
-	XXX_unrecognized     []byte               `json:"-"`
-	XXX_sizecache        int32                `json:"-"`
+	GroupSnapshot *VolumeGroupSnapshot `protobuf:"bytes,1,opt,name=group_snapshot,json=groupSnapshot,proto3" json:"group_snapshot,omitempty"`
 }
 
-func (m *GetVolumeGroupSnapshotResponse) Reset()         { *m = GetVolumeGroupSnapshotResponse{} }
-func (m *GetVolumeGroupSnapshotResponse) String() string { return proto.CompactTextString(m) }
-func (*GetVolumeGroupSnapshotResponse) ProtoMessage()    {}
-func (*GetVolumeGroupSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9cdb00adce470e01, []int{71}
+func (x *GetVolumeGroupSnapshotResponse) Reset() {
+	*x = GetVolumeGroupSnapshotResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[71]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (m *GetVolumeGroupSnapshotResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetVolumeGroupSnapshotResponse.Unmarshal(m, b)
-}
-func (m *GetVolumeGroupSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetVolumeGroupSnapshotResponse.Marshal(b, m, deterministic)
-}
-func (m *GetVolumeGroupSnapshotResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetVolumeGroupSnapshotResponse.Merge(m, src)
-}
-func (m *GetVolumeGroupSnapshotResponse) XXX_Size() int {
-	return xxx_messageInfo_GetVolumeGroupSnapshotResponse.Size(m)
-}
-func (m *GetVolumeGroupSnapshotResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetVolumeGroupSnapshotResponse.DiscardUnknown(m)
+func (x *GetVolumeGroupSnapshotResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_GetVolumeGroupSnapshotResponse proto.InternalMessageInfo
+func (*GetVolumeGroupSnapshotResponse) ProtoMessage() {}
 
-func (m *GetVolumeGroupSnapshotResponse) GetGroupSnapshot() *VolumeGroupSnapshot {
-	if m != nil {
-		return m.GroupSnapshot
+func (x *GetVolumeGroupSnapshotResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[71]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return nil
+	return mi.MessageOf(x)
 }
 
-var E_AlphaEnum = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         1060,
-	Name:          "csi.v1.alpha_enum",
-	Tag:           "varint,1060,opt,name=alpha_enum",
-	Filename:      "github.com/container-storage-interface/spec/csi.proto",
-}
-
-var E_AlphaEnumValue = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         1060,
-	Name:          "csi.v1.alpha_enum_value",
-	Tag:           "varint,1060,opt,name=alpha_enum_value",
-	Filename:      "github.com/container-storage-interface/spec/csi.proto",
-}
-
-var E_CsiSecret = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.FieldOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         1059,
-	Name:          "csi.v1.csi_secret",
-	Tag:           "varint,1059,opt,name=csi_secret",
-	Filename:      "github.com/container-storage-interface/spec/csi.proto",
-}
-
-var E_AlphaField = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.FieldOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         1060,
-	Name:          "csi.v1.alpha_field",
-	Tag:           "varint,1060,opt,name=alpha_field",
-	Filename:      "github.com/container-storage-interface/spec/csi.proto",
-}
-
-var E_AlphaMessage = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.MessageOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         1060,
-	Name:          "csi.v1.alpha_message",
-	Tag:           "varint,1060,opt,name=alpha_message",
-	Filename:      "github.com/container-storage-interface/spec/csi.proto",
-}
-
-var E_AlphaMethod = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.MethodOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         1060,
-	Name:          "csi.v1.alpha_method",
-	Tag:           "varint,1060,opt,name=alpha_method",
-	Filename:      "github.com/container-storage-interface/spec/csi.proto",
-}
-
-var E_AlphaService = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.ServiceOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         1060,
-	Name:          "csi.v1.alpha_service",
-	Tag:           "varint,1060,opt,name=alpha_service",
-	Filename:      "github.com/container-storage-interface/spec/csi.proto",
-}
-
-func init() {
-	proto.RegisterEnum("csi.v1.PluginCapability_Service_Type", PluginCapability_Service_Type_name, PluginCapability_Service_Type_value)
-	proto.RegisterEnum("csi.v1.PluginCapability_VolumeExpansion_Type", PluginCapability_VolumeExpansion_Type_name, PluginCapability_VolumeExpansion_Type_value)
-	proto.RegisterEnum("csi.v1.VolumeCapability_AccessMode_Mode", VolumeCapability_AccessMode_Mode_name, VolumeCapability_AccessMode_Mode_value)
-	proto.RegisterEnum("csi.v1.ControllerServiceCapability_RPC_Type", ControllerServiceCapability_RPC_Type_name, ControllerServiceCapability_RPC_Type_value)
-	proto.RegisterEnum("csi.v1.VolumeUsage_Unit", VolumeUsage_Unit_name, VolumeUsage_Unit_value)
-	proto.RegisterEnum("csi.v1.NodeServiceCapability_RPC_Type", NodeServiceCapability_RPC_Type_name, NodeServiceCapability_RPC_Type_value)
-	proto.RegisterEnum("csi.v1.GroupControllerServiceCapability_RPC_Type", GroupControllerServiceCapability_RPC_Type_name, GroupControllerServiceCapability_RPC_Type_value)
-	proto.RegisterType((*GetPluginInfoRequest)(nil), "csi.v1.GetPluginInfoRequest")
-	proto.RegisterType((*GetPluginInfoResponse)(nil), "csi.v1.GetPluginInfoResponse")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.GetPluginInfoResponse.ManifestEntry")
-	proto.RegisterType((*GetPluginCapabilitiesRequest)(nil), "csi.v1.GetPluginCapabilitiesRequest")
-	proto.RegisterType((*GetPluginCapabilitiesResponse)(nil), "csi.v1.GetPluginCapabilitiesResponse")
-	proto.RegisterType((*PluginCapability)(nil), "csi.v1.PluginCapability")
-	proto.RegisterType((*PluginCapability_Service)(nil), "csi.v1.PluginCapability.Service")
-	proto.RegisterType((*PluginCapability_VolumeExpansion)(nil), "csi.v1.PluginCapability.VolumeExpansion")
-	proto.RegisterType((*ProbeRequest)(nil), "csi.v1.ProbeRequest")
-	proto.RegisterType((*ProbeResponse)(nil), "csi.v1.ProbeResponse")
-	proto.RegisterType((*CreateVolumeRequest)(nil), "csi.v1.CreateVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.CreateVolumeRequest.MutableParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.CreateVolumeRequest.ParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.CreateVolumeRequest.SecretsEntry")
-	proto.RegisterType((*VolumeContentSource)(nil), "csi.v1.VolumeContentSource")
-	proto.RegisterType((*VolumeContentSource_SnapshotSource)(nil), "csi.v1.VolumeContentSource.SnapshotSource")
-	proto.RegisterType((*VolumeContentSource_VolumeSource)(nil), "csi.v1.VolumeContentSource.VolumeSource")
-	proto.RegisterType((*CreateVolumeResponse)(nil), "csi.v1.CreateVolumeResponse")
-	proto.RegisterType((*VolumeCapability)(nil), "csi.v1.VolumeCapability")
-	proto.RegisterType((*VolumeCapability_BlockVolume)(nil), "csi.v1.VolumeCapability.BlockVolume")
-	proto.RegisterType((*VolumeCapability_MountVolume)(nil), "csi.v1.VolumeCapability.MountVolume")
-	proto.RegisterType((*VolumeCapability_AccessMode)(nil), "csi.v1.VolumeCapability.AccessMode")
-	proto.RegisterType((*CapacityRange)(nil), "csi.v1.CapacityRange")
-	proto.RegisterType((*Volume)(nil), "csi.v1.Volume")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.Volume.VolumeContextEntry")
-	proto.RegisterType((*TopologyRequirement)(nil), "csi.v1.TopologyRequirement")
-	proto.RegisterType((*Topology)(nil), "csi.v1.Topology")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.Topology.SegmentsEntry")
-	proto.RegisterType((*DeleteVolumeRequest)(nil), "csi.v1.DeleteVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.DeleteVolumeRequest.SecretsEntry")
-	proto.RegisterType((*DeleteVolumeResponse)(nil), "csi.v1.DeleteVolumeResponse")
-	proto.RegisterType((*ControllerPublishVolumeRequest)(nil), "csi.v1.ControllerPublishVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ControllerPublishVolumeRequest.SecretsEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ControllerPublishVolumeRequest.VolumeContextEntry")
-	proto.RegisterType((*ControllerPublishVolumeResponse)(nil), "csi.v1.ControllerPublishVolumeResponse")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ControllerPublishVolumeResponse.PublishContextEntry")
-	proto.RegisterType((*ControllerUnpublishVolumeRequest)(nil), "csi.v1.ControllerUnpublishVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ControllerUnpublishVolumeRequest.SecretsEntry")
-	proto.RegisterType((*ControllerUnpublishVolumeResponse)(nil), "csi.v1.ControllerUnpublishVolumeResponse")
-	proto.RegisterType((*ValidateVolumeCapabilitiesRequest)(nil), "csi.v1.ValidateVolumeCapabilitiesRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ValidateVolumeCapabilitiesRequest.MutableParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ValidateVolumeCapabilitiesRequest.ParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ValidateVolumeCapabilitiesRequest.SecretsEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ValidateVolumeCapabilitiesRequest.VolumeContextEntry")
-	proto.RegisterType((*ValidateVolumeCapabilitiesResponse)(nil), "csi.v1.ValidateVolumeCapabilitiesResponse")
-	proto.RegisterType((*ValidateVolumeCapabilitiesResponse_Confirmed)(nil), "csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.MutableParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.ParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.VolumeContextEntry")
-	proto.RegisterType((*ListVolumesRequest)(nil), "csi.v1.ListVolumesRequest")
-	proto.RegisterType((*ListVolumesResponse)(nil), "csi.v1.ListVolumesResponse")
-	proto.RegisterType((*ListVolumesResponse_VolumeStatus)(nil), "csi.v1.ListVolumesResponse.VolumeStatus")
-	proto.RegisterType((*ListVolumesResponse_Entry)(nil), "csi.v1.ListVolumesResponse.Entry")
-	proto.RegisterType((*ControllerGetVolumeRequest)(nil), "csi.v1.ControllerGetVolumeRequest")
-	proto.RegisterType((*ControllerGetVolumeResponse)(nil), "csi.v1.ControllerGetVolumeResponse")
-	proto.RegisterType((*ControllerGetVolumeResponse_VolumeStatus)(nil), "csi.v1.ControllerGetVolumeResponse.VolumeStatus")
-	proto.RegisterType((*ControllerModifyVolumeRequest)(nil), "csi.v1.ControllerModifyVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ControllerModifyVolumeRequest.MutableParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ControllerModifyVolumeRequest.SecretsEntry")
-	proto.RegisterType((*ControllerModifyVolumeResponse)(nil), "csi.v1.ControllerModifyVolumeResponse")
-	proto.RegisterType((*GetCapacityRequest)(nil), "csi.v1.GetCapacityRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.GetCapacityRequest.ParametersEntry")
-	proto.RegisterType((*GetCapacityResponse)(nil), "csi.v1.GetCapacityResponse")
-	proto.RegisterType((*ControllerGetCapabilitiesRequest)(nil), "csi.v1.ControllerGetCapabilitiesRequest")
-	proto.RegisterType((*ControllerGetCapabilitiesResponse)(nil), "csi.v1.ControllerGetCapabilitiesResponse")
-	proto.RegisterType((*ControllerServiceCapability)(nil), "csi.v1.ControllerServiceCapability")
-	proto.RegisterType((*ControllerServiceCapability_RPC)(nil), "csi.v1.ControllerServiceCapability.RPC")
-	proto.RegisterType((*CreateSnapshotRequest)(nil), "csi.v1.CreateSnapshotRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.CreateSnapshotRequest.ParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.CreateSnapshotRequest.SecretsEntry")
-	proto.RegisterType((*CreateSnapshotResponse)(nil), "csi.v1.CreateSnapshotResponse")
-	proto.RegisterType((*Snapshot)(nil), "csi.v1.Snapshot")
-	proto.RegisterType((*DeleteSnapshotRequest)(nil), "csi.v1.DeleteSnapshotRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.DeleteSnapshotRequest.SecretsEntry")
-	proto.RegisterType((*DeleteSnapshotResponse)(nil), "csi.v1.DeleteSnapshotResponse")
-	proto.RegisterType((*ListSnapshotsRequest)(nil), "csi.v1.ListSnapshotsRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ListSnapshotsRequest.SecretsEntry")
-	proto.RegisterType((*ListSnapshotsResponse)(nil), "csi.v1.ListSnapshotsResponse")
-	proto.RegisterType((*ListSnapshotsResponse_Entry)(nil), "csi.v1.ListSnapshotsResponse.Entry")
-	proto.RegisterType((*ControllerExpandVolumeRequest)(nil), "csi.v1.ControllerExpandVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.ControllerExpandVolumeRequest.SecretsEntry")
-	proto.RegisterType((*ControllerExpandVolumeResponse)(nil), "csi.v1.ControllerExpandVolumeResponse")
-	proto.RegisterType((*NodeStageVolumeRequest)(nil), "csi.v1.NodeStageVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.NodeStageVolumeRequest.PublishContextEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.NodeStageVolumeRequest.SecretsEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.NodeStageVolumeRequest.VolumeContextEntry")
-	proto.RegisterType((*NodeStageVolumeResponse)(nil), "csi.v1.NodeStageVolumeResponse")
-	proto.RegisterType((*NodeUnstageVolumeRequest)(nil), "csi.v1.NodeUnstageVolumeRequest")
-	proto.RegisterType((*NodeUnstageVolumeResponse)(nil), "csi.v1.NodeUnstageVolumeResponse")
-	proto.RegisterType((*NodePublishVolumeRequest)(nil), "csi.v1.NodePublishVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.NodePublishVolumeRequest.PublishContextEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.NodePublishVolumeRequest.SecretsEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.NodePublishVolumeRequest.VolumeContextEntry")
-	proto.RegisterType((*NodePublishVolumeResponse)(nil), "csi.v1.NodePublishVolumeResponse")
-	proto.RegisterType((*NodeUnpublishVolumeRequest)(nil), "csi.v1.NodeUnpublishVolumeRequest")
-	proto.RegisterType((*NodeUnpublishVolumeResponse)(nil), "csi.v1.NodeUnpublishVolumeResponse")
-	proto.RegisterType((*NodeGetVolumeStatsRequest)(nil), "csi.v1.NodeGetVolumeStatsRequest")
-	proto.RegisterType((*NodeGetVolumeStatsResponse)(nil), "csi.v1.NodeGetVolumeStatsResponse")
-	proto.RegisterType((*VolumeUsage)(nil), "csi.v1.VolumeUsage")
-	proto.RegisterType((*VolumeCondition)(nil), "csi.v1.VolumeCondition")
-	proto.RegisterType((*NodeGetCapabilitiesRequest)(nil), "csi.v1.NodeGetCapabilitiesRequest")
-	proto.RegisterType((*NodeGetCapabilitiesResponse)(nil), "csi.v1.NodeGetCapabilitiesResponse")
-	proto.RegisterType((*NodeServiceCapability)(nil), "csi.v1.NodeServiceCapability")
-	proto.RegisterType((*NodeServiceCapability_RPC)(nil), "csi.v1.NodeServiceCapability.RPC")
-	proto.RegisterType((*NodeGetInfoRequest)(nil), "csi.v1.NodeGetInfoRequest")
-	proto.RegisterType((*NodeGetInfoResponse)(nil), "csi.v1.NodeGetInfoResponse")
-	proto.RegisterType((*NodeExpandVolumeRequest)(nil), "csi.v1.NodeExpandVolumeRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.NodeExpandVolumeRequest.SecretsEntry")
-	proto.RegisterType((*NodeExpandVolumeResponse)(nil), "csi.v1.NodeExpandVolumeResponse")
-	proto.RegisterType((*GroupControllerGetCapabilitiesRequest)(nil), "csi.v1.GroupControllerGetCapabilitiesRequest")
-	proto.RegisterType((*GroupControllerGetCapabilitiesResponse)(nil), "csi.v1.GroupControllerGetCapabilitiesResponse")
-	proto.RegisterType((*GroupControllerServiceCapability)(nil), "csi.v1.GroupControllerServiceCapability")
-	proto.RegisterType((*GroupControllerServiceCapability_RPC)(nil), "csi.v1.GroupControllerServiceCapability.RPC")
-	proto.RegisterType((*CreateVolumeGroupSnapshotRequest)(nil), "csi.v1.CreateVolumeGroupSnapshotRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.CreateVolumeGroupSnapshotRequest.ParametersEntry")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.CreateVolumeGroupSnapshotRequest.SecretsEntry")
-	proto.RegisterType((*CreateVolumeGroupSnapshotResponse)(nil), "csi.v1.CreateVolumeGroupSnapshotResponse")
-	proto.RegisterType((*VolumeGroupSnapshot)(nil), "csi.v1.VolumeGroupSnapshot")
-	proto.RegisterType((*DeleteVolumeGroupSnapshotRequest)(nil), "csi.v1.DeleteVolumeGroupSnapshotRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.DeleteVolumeGroupSnapshotRequest.SecretsEntry")
-	proto.RegisterType((*DeleteVolumeGroupSnapshotResponse)(nil), "csi.v1.DeleteVolumeGroupSnapshotResponse")
-	proto.RegisterType((*GetVolumeGroupSnapshotRequest)(nil), "csi.v1.GetVolumeGroupSnapshotRequest")
-	proto.RegisterMapType((map[string]string)(nil), "csi.v1.GetVolumeGroupSnapshotRequest.SecretsEntry")
-	proto.RegisterType((*GetVolumeGroupSnapshotResponse)(nil), "csi.v1.GetVolumeGroupSnapshotResponse")
-	proto.RegisterExtension(E_AlphaEnum)
-	proto.RegisterExtension(E_AlphaEnumValue)
-	proto.RegisterExtension(E_CsiSecret)
-	proto.RegisterExtension(E_AlphaField)
-	proto.RegisterExtension(E_AlphaMessage)
-	proto.RegisterExtension(E_AlphaMethod)
-	proto.RegisterExtension(E_AlphaService)
-}
-
-func init() {
-	proto.RegisterFile("github.com/container-storage-interface/spec/csi.proto", fileDescriptor_9cdb00adce470e01)
-}
-
-var fileDescriptor_9cdb00adce470e01 = []byte{
-	// 4327 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x3c, 0x4d, 0x6c, 0x1c, 0x59,
-	0x5a, 0xae, 0xfe, 0xb3, 0xfd, 0xf9, 0x27, 0xed, 0x67, 0xc7, 0xe9, 0x54, 0x12, 0xc7, 0xae, 0x6c,
-	0x32, 0x9e, 0x4c, 0xd2, 0x99, 0xf1, 0xce, 0x8c, 0x76, 0x3c, 0x99, 0xdd, 0x74, 0xdb, 0x1d, 0xbb,
-	0x37, 0x76, 0xb7, 0xa7, 0xba, 0x9d, 0xd9, 0x04, 0x46, 0x35, 0xe5, 0xee, 0xb2, 0x53, 0x9a, 0xee,
-	0xaa, 0x9e, 0xaa, 0x6a, 0x13, 0x2f, 0x87, 0x85, 0x5d, 0x21, 0x76, 0xc5, 0x05, 0x81, 0x04, 0x23,
-	0x21, 0xc1, 0x0a, 0x38, 0x2e, 0x5a, 0x21, 0x84, 0x90, 0xe0, 0xc0, 0x19, 0x4e, 0x1c, 0x81, 0x0b,
-	0x07, 0x24, 0x90, 0x56, 0x20, 0x2d, 0x12, 0xe2, 0xc0, 0x09, 0xd5, 0x7b, 0xaf, 0xaa, 0x5f, 0x55,
-	0xbd, 0xaa, 0xee, 0x8e, 0x1d, 0x96, 0x15, 0xa7, 0xb8, 0xdf, 0xfb, 0xfe, 0xde, 0xcf, 0xf7, 0xff,
-	0x2a, 0xf0, 0xde, 0x89, 0xee, 0xbc, 0xe8, 0x1f, 0x15, 0x5b, 0x66, 0xf7, 0x41, 0xcb, 0x34, 0x1c,
-	0x55, 0x37, 0x34, 0xeb, 0xbe, 0xed, 0x98, 0x96, 0x7a, 0xa2, 0xdd, 0xd7, 0x0d, 0x47, 0xb3, 0x8e,
-	0xd5, 0x96, 0xf6, 0xc0, 0xee, 0x69, 0xad, 0x07, 0x2d, 0x5b, 0x2f, 0xf6, 0x2c, 0xd3, 0x31, 0x51,
-	0xce, 0xfd, 0xf3, 0xf4, 0x1d, 0x71, 0xf5, 0xc4, 0x34, 0x4f, 0x3a, 0xda, 0x03, 0x3c, 0x7a, 0xd4,
-	0x3f, 0x7e, 0xd0, 0xd6, 0xec, 0x96, 0xa5, 0xf7, 0x1c, 0xd3, 0x22, 0x90, 0xe2, 0xcd, 0x30, 0x84,
-	0xa3, 0x77, 0x35, 0xdb, 0x51, 0xbb, 0x3d, 0x0a, 0xb0, 0x12, 0x06, 0xf8, 0x25, 0x4b, 0xed, 0xf5,
-	0x34, 0xcb, 0x26, 0xf3, 0xd2, 0x32, 0x2c, 0xed, 0x68, 0xce, 0x41, 0xa7, 0x7f, 0xa2, 0x1b, 0x55,
-	0xe3, 0xd8, 0x94, 0xb5, 0x2f, 0xfa, 0x9a, 0xed, 0x48, 0x7f, 0x2f, 0xc0, 0xe5, 0xd0, 0x84, 0xdd,
-	0x33, 0x0d, 0x5b, 0x43, 0x08, 0x32, 0x86, 0xda, 0xd5, 0x0a, 0xc2, 0xaa, 0xb0, 0x3e, 0x2d, 0xe3,
-	0xbf, 0xd1, 0x6d, 0x98, 0x3f, 0xd5, 0x8c, 0xb6, 0x69, 0x29, 0xa7, 0x9a, 0x65, 0xeb, 0xa6, 0x51,
-	0x48, 0xe1, 0xd9, 0x39, 0x32, 0xfa, 0x94, 0x0c, 0xa2, 0x1d, 0x98, 0xea, 0xaa, 0x86, 0x7e, 0xac,
-	0xd9, 0x4e, 0x21, 0xbd, 0x9a, 0x5e, 0x9f, 0xd9, 0x78, 0xab, 0x48, 0x96, 0x5a, 0xe4, 0xf2, 0x2a,
-	0xee, 0x53, 0xe8, 0x8a, 0xe1, 0x58, 0x67, 0xb2, 0x8f, 0x2c, 0x7e, 0x08, 0x73, 0x81, 0x29, 0x94,
-	0x87, 0xf4, 0xe7, 0xda, 0x19, 0x95, 0xc9, 0xfd, 0x13, 0x2d, 0x41, 0xf6, 0x54, 0xed, 0xf4, 0x35,
-	0x2a, 0x09, 0xf9, 0xb1, 0x99, 0xfa, 0x9a, 0x20, 0xad, 0xc0, 0x75, 0x9f, 0xdb, 0x96, 0xda, 0x53,
-	0x8f, 0xf4, 0x8e, 0xee, 0xe8, 0x9a, 0xed, 0x2d, 0xfd, 0x53, 0xb8, 0x11, 0x33, 0x4f, 0x77, 0xe0,
-	0x21, 0xcc, 0xb6, 0x98, 0xf1, 0x82, 0x80, 0x97, 0x52, 0xf0, 0x96, 0x12, 0xc2, 0x3c, 0x93, 0x03,
-	0xd0, 0xd2, 0x7f, 0xa4, 0x21, 0x1f, 0x06, 0x41, 0x0f, 0x61, 0xd2, 0xd6, 0xac, 0x53, 0xbd, 0x45,
-	0xf6, 0x75, 0x66, 0x63, 0x35, 0x8e, 0x5a, 0xb1, 0x41, 0xe0, 0x76, 0x27, 0x64, 0x0f, 0x05, 0x1d,
-	0x42, 0xfe, 0xd4, 0xec, 0xf4, 0xbb, 0x9a, 0xa2, 0xbd, 0xec, 0xa9, 0x86, 0x7f, 0x00, 0x33, 0x1b,
-	0xeb, 0xb1, 0x64, 0x9e, 0x62, 0x84, 0x8a, 0x07, 0xbf, 0x3b, 0x21, 0x5f, 0x3a, 0x0d, 0x0e, 0x89,
-	0x7f, 0x29, 0xc0, 0x24, 0xe5, 0x86, 0x3e, 0x80, 0x8c, 0x73, 0xd6, 0x23, 0xd2, 0xcd, 0x6f, 0xdc,
-	0x1e, 0x26, 0x5d, 0xb1, 0x79, 0xd6, 0xd3, 0x64, 0x8c, 0x22, 0x39, 0x90, 0x71, 0x7f, 0xa1, 0x19,
-	0x98, 0x3c, 0xac, 0x3d, 0xa9, 0xd5, 0x3f, 0xa9, 0xe5, 0x27, 0xd0, 0x32, 0xa0, 0xad, 0x7a, 0xad,
-	0x29, 0xd7, 0xf7, 0xf6, 0x2a, 0xb2, 0xd2, 0xa8, 0xc8, 0x4f, 0xab, 0x5b, 0x95, 0xbc, 0x80, 0xbe,
-	0x02, 0xab, 0x4f, 0xeb, 0x7b, 0x87, 0xfb, 0x15, 0xa5, 0xb4, 0xb5, 0x55, 0x69, 0x34, 0xaa, 0xe5,
-	0xea, 0x5e, 0xb5, 0xf9, 0x4c, 0xd9, 0xaa, 0xd7, 0x1a, 0x4d, 0xb9, 0x54, 0xad, 0x35, 0x1b, 0xf9,
-	0x14, 0x5a, 0x83, 0xc2, 0x8e, 0x5c, 0x3f, 0x3c, 0x50, 0x38, 0x34, 0xd2, 0x62, 0xfa, 0x87, 0x65,
-	0x41, 0xfc, 0xae, 0x00, 0x97, 0x42, 0x6b, 0x44, 0xa5, 0xc0, 0x22, 0xee, 0x8f, 0xba, 0x37, 0xec,
-	0x62, 0xee, 0xf1, 0x16, 0x03, 0x90, 0xab, 0xd7, 0xf6, 0xaa, 0x35, 0x77, 0x01, 0x33, 0x30, 0x59,
-	0x7f, 0xfc, 0x18, 0xff, 0x48, 0x95, 0x73, 0x84, 0xa1, 0x34, 0x0f, 0xb3, 0x07, 0x96, 0x79, 0xa4,
-	0x79, 0x57, 0xac, 0x04, 0x73, 0xf4, 0x37, 0xbd, 0x52, 0x6f, 0x43, 0xd6, 0xd2, 0xd4, 0xf6, 0x19,
-	0x3d, 0x7d, 0xb1, 0x48, 0xd4, 0xb6, 0xe8, 0xa9, 0x6d, 0xb1, 0x6c, 0x9a, 0x9d, 0xa7, 0xee, 0x15,
-	0x96, 0x09, 0xa0, 0xf4, 0xfb, 0x39, 0x58, 0xdc, 0xb2, 0x34, 0xd5, 0xd1, 0x88, 0xb4, 0x94, 0x34,
-	0x57, 0x3d, 0x1f, 0xc2, 0xbc, 0x7b, 0x05, 0x5b, 0xba, 0x73, 0xa6, 0x58, 0xaa, 0x71, 0xa2, 0xd1,
-	0xdb, 0x71, 0xd9, 0xdb, 0x81, 0x2d, 0x3a, 0x2b, 0xbb, 0x93, 0xf2, 0x5c, 0x8b, 0xfd, 0x89, 0xaa,
-	0xb0, 0x48, 0x6f, 0x57, 0xe0, 0xd6, 0xa7, 0x83, 0xb7, 0x9e, 0x48, 0xc1, 0xdc, 0x7a, 0x74, 0x1a,
-	0x1c, 0xd1, 0x35, 0x1b, 0x3d, 0x01, 0xe8, 0xa9, 0x96, 0xda, 0xd5, 0x1c, 0xcd, 0xb2, 0x0b, 0x99,
-	0xa0, 0x09, 0xe0, 0xac, 0xa6, 0x78, 0xe0, 0x43, 0x13, 0x13, 0xc0, 0xa0, 0xa3, 0x1d, 0x57, 0x67,
-	0x5a, 0x96, 0xe6, 0xd8, 0x85, 0x2c, 0xa6, 0xb4, 0x9e, 0x44, 0xa9, 0x41, 0x40, 0x31, 0x99, 0x72,
-	0xfa, 0xcb, 0xb2, 0x20, 0x7b, 0xd8, 0xa8, 0x0e, 0x97, 0xbd, 0x05, 0x9a, 0x86, 0xa3, 0x19, 0x8e,
-	0x62, 0x9b, 0x7d, 0xab, 0xa5, 0x15, 0x72, 0x78, 0x97, 0xae, 0x85, 0x96, 0x48, 0x60, 0x1a, 0x18,
-	0x44, 0xa6, 0x5b, 0x13, 0x18, 0x44, 0xcf, 0x41, 0x54, 0x5b, 0x2d, 0xcd, 0xb6, 0x75, 0xb2, 0x17,
-	0x8a, 0xa5, 0x7d, 0xd1, 0xd7, 0x2d, 0xad, 0xab, 0x19, 0x8e, 0x5d, 0x98, 0x0c, 0x52, 0x6d, 0x9a,
-	0x3d, 0xb3, 0x63, 0x9e, 0x9c, 0xc9, 0x03, 0x18, 0xf9, 0x6a, 0x00, 0x9d, 0x99, 0xb1, 0xd1, 0x31,
-	0xa0, 0x6e, 0xdf, 0x51, 0x8f, 0x3a, 0x9a, 0xc2, 0x6c, 0xe5, 0x14, 0xde, 0x80, 0x8d, 0xa4, 0x0d,
-	0xd8, 0x27, 0x58, 0xa1, 0x1d, 0x2d, 0xbb, 0xca, 0x22, 0x2f, 0x74, 0xc3, 0x93, 0xe2, 0x47, 0x70,
-	0x29, 0x04, 0x3a, 0x8e, 0x91, 0x15, 0x37, 0x61, 0x96, 0xdd, 0xf1, 0xb1, 0x70, 0xb7, 0x61, 0x99,
-	0x2f, 0xec, 0x58, 0x66, 0xfe, 0x37, 0x52, 0xb0, 0xc8, 0x39, 0x31, 0xb4, 0x0b, 0x53, 0xb6, 0xa1,
-	0xf6, 0xec, 0x17, 0xa6, 0x43, 0xb5, 0xed, 0x6e, 0xc2, 0x01, 0x17, 0x1b, 0x14, 0x96, 0xfc, 0xdc,
-	0x9d, 0x90, 0x7d, 0x6c, 0x54, 0x86, 0x1c, 0x39, 0xfd, 0xb0, 0xb1, 0xe5, 0xd1, 0x21, 0x63, 0x3e,
-	0x15, 0x8a, 0x29, 0xbe, 0x03, 0xf3, 0x41, 0x0e, 0xe8, 0x26, 0xcc, 0x78, 0x1c, 0x14, 0xbd, 0x4d,
-	0xd7, 0x0a, 0xde, 0x50, 0xb5, 0x2d, 0xbe, 0x05, 0xb3, 0x2c, 0x31, 0x74, 0x0d, 0xa6, 0xe9, 0xf5,
-	0xf5, 0xc1, 0xa7, 0xc8, 0x40, 0xb5, 0xed, 0x5b, 0xa0, 0xaf, 0xc3, 0x52, 0xf0, 0x52, 0x50, 0xc3,
-	0x73, 0xc7, 0x5f, 0x03, 0xd9, 0x8b, 0xf9, 0xe0, 0x1a, 0x3c, 0x39, 0xa5, 0x3f, 0xc8, 0x42, 0x3e,
-	0xac, 0xe2, 0xe8, 0x21, 0x64, 0x8f, 0x3a, 0x66, 0xeb, 0x73, 0x8a, 0xfb, 0x95, 0x38, 0x5b, 0x50,
-	0x2c, 0xbb, 0x50, 0x64, 0x74, 0x77, 0x42, 0x26, 0x48, 0x2e, 0x76, 0xd7, 0xec, 0x1b, 0x0e, 0xdd,
-	0xbd, 0x78, 0xec, 0x7d, 0x17, 0x6a, 0x80, 0x8d, 0x91, 0xd0, 0x36, 0xcc, 0x10, 0x25, 0x51, 0xba,
-	0x66, 0x5b, 0x2b, 0xa4, 0x31, 0x8d, 0x5b, 0xb1, 0x34, 0x4a, 0x18, 0x76, 0xdf, 0x6c, 0x6b, 0x32,
-	0xa8, 0xfe, 0xdf, 0xe2, 0x1c, 0xcc, 0x30, 0xb2, 0x89, 0x7d, 0x98, 0x61, 0x98, 0xa1, 0x2b, 0x30,
-	0x79, 0x6c, 0x2b, 0xbe, 0xcb, 0x98, 0x96, 0x73, 0xc7, 0x36, 0xb6, 0xfe, 0x37, 0x61, 0x06, 0x4b,
-	0xa1, 0x1c, 0x77, 0xd4, 0x13, 0xbb, 0x90, 0x5a, 0x4d, 0xbb, 0x67, 0x84, 0x87, 0x1e, 0xbb, 0x23,
-	0xe8, 0x1e, 0x50, 0xf3, 0xa7, 0x10, 0xb8, 0x13, 0xcb, 0xec, 0xf7, 0xb0, 0x90, 0xd3, 0x32, 0xf5,
-	0xd5, 0x98, 0xd1, 0x8e, 0x3b, 0x2e, 0xfe, 0x59, 0x0a, 0x60, 0x20, 0x20, 0x7a, 0x08, 0x19, 0xbc,
-	0x26, 0xe2, 0xa6, 0xd6, 0x47, 0x58, 0x53, 0x11, 0x2f, 0x0c, 0x63, 0x49, 0xff, 0x22, 0x40, 0x06,
-	0x93, 0x09, 0xfb, 0xdb, 0x46, 0xb5, 0xb6, 0xb3, 0x57, 0x51, 0x6a, 0xf5, 0xed, 0x8a, 0xf2, 0x89,
-	0x5c, 0x6d, 0x56, 0xe4, 0xbc, 0x80, 0xae, 0xc1, 0x15, 0x76, 0x5c, 0xae, 0x94, 0xb6, 0x2b, 0xb2,
-	0x52, 0xaf, 0xed, 0x3d, 0xcb, 0xa7, 0x90, 0x08, 0xcb, 0xfb, 0x87, 0x7b, 0xcd, 0x6a, 0x74, 0x2e,
-	0x8d, 0xae, 0x43, 0x81, 0x99, 0xa3, 0x34, 0x28, 0xd9, 0x8c, 0x4b, 0x96, 0x99, 0x25, 0x7f, 0xd2,
-	0xc9, 0x2c, 0x92, 0xe0, 0x2a, 0xcb, 0x33, 0x88, 0x9b, 0xc3, 0xee, 0xdb, 0xf5, 0xf0, 0x2c, 0x4c,
-	0x80, 0xc2, 0x24, 0x06, 0x29, 0xcf, 0xf9, 0x37, 0x00, 0xdf, 0xf0, 0x4f, 0x60, 0x2e, 0xe0, 0xc6,
-	0xdc, 0xa0, 0x94, 0xda, 0xdd, 0xb6, 0x72, 0x74, 0xe6, 0xe0, 0x40, 0x4d, 0x58, 0x4f, 0xcb, 0x73,
-	0xde, 0x68, 0xd9, 0x1d, 0x74, 0xcf, 0xb2, 0xa3, 0x77, 0x75, 0x87, 0xc2, 0xa4, 0x30, 0x0c, 0xe0,
-	0x21, 0x0c, 0x20, 0xfd, 0x53, 0x0a, 0x72, 0xf4, 0x42, 0xdc, 0x66, 0x1c, 0x69, 0x80, 0xa4, 0x37,
-	0x4a, 0x48, 0x06, 0x34, 0x32, 0x15, 0xd4, 0x48, 0xb4, 0x0b, 0xf3, 0xac, 0xb7, 0x79, 0xe9, 0x85,
-	0xc2, 0x6b, 0xc1, 0x73, 0x66, 0x8d, 0xc8, 0x4b, 0x1a, 0x00, 0xcf, 0x9d, 0xb2, 0x63, 0xa8, 0x0c,
-	0xf3, 0x21, 0x87, 0x95, 0x19, 0xee, 0xb0, 0xe6, 0x5a, 0x01, 0x6b, 0x58, 0x82, 0x45, 0xcf, 0xd7,
-	0x74, 0x34, 0xc5, 0xa1, 0xbe, 0x88, 0x3a, 0xd4, 0x7c, 0xc4, 0x47, 0xa1, 0x01, 0xb0, 0x37, 0x26,
-	0x3e, 0x02, 0x14, 0x95, 0x75, 0x2c, 0x53, 0xdd, 0x87, 0x45, 0x8e, 0x17, 0x44, 0x45, 0x98, 0xc6,
-	0x47, 0x65, 0xeb, 0x8e, 0x46, 0x83, 0xec, 0xa8, 0x44, 0x03, 0x10, 0x17, 0xbe, 0x67, 0x69, 0xc7,
-	0x9a, 0x65, 0x69, 0x6d, 0xac, 0x93, 0x5c, 0x78, 0x1f, 0x44, 0xfa, 0x9e, 0x00, 0x53, 0xde, 0x38,
-	0xda, 0x84, 0x29, 0x5b, 0x3b, 0x21, 0x1e, 0x9a, 0xf0, 0x5a, 0x09, 0xe3, 0x16, 0x1b, 0x14, 0x80,
-	0xa6, 0x23, 0x1e, 0xbc, 0x9b, 0x8e, 0x04, 0xa6, 0xc6, 0x5a, 0xfc, 0x5f, 0x08, 0xb0, 0xb8, 0xad,
-	0x75, 0xb4, 0x70, 0x20, 0x97, 0x64, 0xd6, 0xd9, 0xd8, 0x27, 0x15, 0x8c, 0x7d, 0x38, 0xa4, 0x12,
-	0x62, 0x9f, 0xf3, 0xf8, 0x69, 0x37, 0x77, 0x0c, 0x72, 0x23, 0x3e, 0x45, 0xfa, 0xf7, 0x34, 0xac,
-	0xb8, 0x77, 0xc1, 0x32, 0x3b, 0x1d, 0xcd, 0x3a, 0xe8, 0x1f, 0x75, 0x74, 0xfb, 0xc5, 0x18, 0x8b,
-	0xbb, 0x02, 0x93, 0x86, 0xd9, 0x66, 0x94, 0x27, 0xe7, 0xfe, 0xac, 0xb6, 0x51, 0x05, 0x16, 0xc2,
-	0x91, 0xe8, 0x19, 0xb5, 0xfc, 0xf1, 0x71, 0x68, 0xfe, 0x34, 0xec, 0xb6, 0x44, 0x98, 0x72, 0x63,
-	0x68, 0xd3, 0xe8, 0x9c, 0x61, 0x8d, 0x99, 0x92, 0xfd, 0xdf, 0x48, 0x0e, 0x07, 0x95, 0x5f, 0xf5,
-	0x63, 0xaa, 0xc4, 0x15, 0x25, 0xc5, 0x97, 0x9f, 0x45, 0x34, 0x3e, 0x87, 0x49, 0x7f, 0x30, 0x22,
-	0xe9, 0xa1, 0x96, 0xe0, 0x5c, 0xd1, 0xd6, 0xf9, 0xd5, 0xf7, 0x6f, 0x05, 0xb8, 0x19, 0xbb, 0x04,
-	0x1a, 0x67, 0xb4, 0xe1, 0x52, 0x8f, 0x4c, 0xf8, 0x9b, 0x40, 0xb4, 0xec, 0xc3, 0xa1, 0x9b, 0x40,
-	0x6b, 0x01, 0x74, 0x34, 0xb0, 0x0d, 0xf3, 0xbd, 0xc0, 0xa0, 0x58, 0x82, 0x45, 0x0e, 0xd8, 0x58,
-	0x8b, 0xf9, 0x89, 0x00, 0xab, 0x03, 0x51, 0x0e, 0x8d, 0xde, 0xc5, 0x5d, 0xdf, 0xe6, 0xe0, 0x6e,
-	0x11, 0x93, 0xff, 0x5e, 0x74, 0xed, 0x7c, 0x86, 0xaf, 0x4b, 0x83, 0x6f, 0xc1, 0x5a, 0x02, 0x6b,
-	0xaa, 0xce, 0xbf, 0x97, 0x83, 0xb5, 0xa7, 0x6a, 0x47, 0x6f, 0xfb, 0xd1, 0x23, 0xa7, 0x6a, 0x92,
-	0xbc, 0x25, 0xad, 0x88, 0x06, 0x10, 0xab, 0xf5, 0xd0, 0xd7, 0xda, 0x61, 0xf4, 0x47, 0x70, 0x87,
-	0x17, 0x98, 0xa7, 0x3e, 0xe3, 0xe4, 0xa9, 0x1f, 0x8c, 0x2e, 0x6b, 0x52, 0xd6, 0x7a, 0x18, 0x36,
-	0x30, 0xef, 0x8f, 0x4e, 0x37, 0xc1, 0xc6, 0x38, 0xdc, 0xb4, 0x90, 0xd8, 0x99, 0x47, 0xa3, 0x73,
-	0x18, 0x33, 0x49, 0x3c, 0xb7, 0xed, 0xf8, 0xf9, 0x4f, 0x33, 0x7f, 0x90, 0x03, 0x29, 0x69, 0x5f,
-	0xa9, 0xfd, 0x93, 0x61, 0xba, 0x65, 0x1a, 0xc7, 0xba, 0xd5, 0xd5, 0xda, 0x34, 0x5d, 0x7a, 0x77,
-	0x94, 0x63, 0xa1, 0xc6, 0x6f, 0xcb, 0xc3, 0x95, 0x07, 0x64, 0x50, 0x01, 0x26, 0xbb, 0x9a, 0x6d,
-	0xab, 0x27, 0x9e, 0x58, 0xde, 0x4f, 0xf1, 0x3f, 0x33, 0x30, 0xed, 0xa3, 0x20, 0x23, 0xa2, 0x7d,
-	0xc4, 0xf4, 0xee, 0xbc, 0x8a, 0x00, 0xaf, 0xae, 0x88, 0xa9, 0x57, 0x50, 0xc4, 0x76, 0x40, 0x11,
-	0x89, 0x2a, 0x6f, 0xbf, 0x92, 0xd8, 0x49, 0x3a, 0xf9, 0x1d, 0xae, 0xf2, 0x10, 0xb5, 0x7f, 0xf2,
-	0x4a, 0xdc, 0x7e, 0xde, 0xf4, 0xe8, 0x62, 0x74, 0xe1, 0x17, 0x01, 0xed, 0xe9, 0x36, 0xcd, 0x9e,
-	0x7d, 0xcf, 0xe0, 0x26, 0xcb, 0xea, 0x4b, 0x45, 0x33, 0x1c, 0x4b, 0xa7, 0x19, 0x53, 0x56, 0x86,
-	0xae, 0xfa, 0xb2, 0x42, 0x46, 0xdc, 0xac, 0xca, 0x76, 0x54, 0xcb, 0xd1, 0x8d, 0x13, 0xc5, 0x31,
-	0x3f, 0xd7, 0xfc, 0xee, 0x81, 0x37, 0xda, 0x74, 0x07, 0xa5, 0x7f, 0x4b, 0xc1, 0x62, 0x80, 0x3c,
-	0x55, 0xad, 0x0f, 0x61, 0x72, 0x40, 0x3b, 0x90, 0x49, 0x71, 0xa0, 0x8b, 0xe4, 0xf4, 0x3d, 0x0c,
-	0x74, 0x03, 0xc0, 0xd0, 0x5e, 0x3a, 0x01, 0xbe, 0xd3, 0xee, 0x08, 0xe6, 0x29, 0xfe, 0x9a, 0xe0,
-	0x17, 0x5b, 0x1c, 0xd5, 0xe9, 0xe3, 0xc4, 0x9e, 0x7a, 0x49, 0xad, 0xad, 0x50, 0x37, 0x4f, 0xf8,
-	0x4e, 0xcb, 0x79, 0x7f, 0xa6, 0x86, 0x1d, 0xbe, 0x8d, 0x76, 0xfc, 0xc2, 0x7c, 0xcb, 0x34, 0xda,
-	0xba, 0x33, 0x28, 0xcc, 0x5f, 0x89, 0xe4, 0x68, 0x64, 0x9a, 0x5c, 0x91, 0x4b, 0xa7, 0xc1, 0x51,
-	0xf1, 0x0b, 0xc8, 0x92, 0xe3, 0x18, 0xb1, 0x5e, 0x83, 0x1e, 0x41, 0xce, 0xc6, 0x12, 0x87, 0x6b,
-	0x53, 0xbc, 0x3d, 0x61, 0x57, 0x28, 0x53, 0x3c, 0xe9, 0xeb, 0x20, 0x0e, 0x62, 0x83, 0x1d, 0xcd,
-	0x19, 0x3d, 0x02, 0xda, 0x74, 0xd7, 0x20, 0xfd, 0x6e, 0x0a, 0xae, 0x71, 0x09, 0x8c, 0x57, 0x79,
-	0x42, 0xbb, 0xa1, 0x95, 0xbc, 0x1d, 0x0d, 0x9a, 0x22, 0xc4, 0xb9, 0x2b, 0x12, 0x7f, 0xe5, 0x7c,
-	0x87, 0x59, 0x1e, 0xfb, 0x30, 0x23, 0xe7, 0x48, 0x76, 0xe6, 0x7b, 0x69, 0xb8, 0x31, 0x10, 0x7e,
-	0xdf, 0x6c, 0xeb, 0xc7, 0x67, 0x63, 0xc4, 0x97, 0x1f, 0x87, 0x73, 0xbf, 0x8d, 0xe8, 0x8e, 0x70,
-	0x88, 0x26, 0x45, 0x0f, 0x9f, 0x73, 0x0d, 0x60, 0x3a, 0x18, 0xa3, 0x25, 0x53, 0xe7, 0x9b, 0x0f,
-	0x9e, 0xb1, 0xfb, 0x99, 0xfb, 0x6c, 0x72, 0x0a, 0xb7, 0xd9, 0x24, 0x35, 0xb8, 0x22, 0x72, 0x89,
-	0x08, 0xd8, 0x9f, 0xa4, 0x00, 0xed, 0x68, 0x8e, 0x5f, 0x5a, 0xa2, 0x27, 0x14, 0xe3, 0xe3, 0x84,
-	0x57, 0xf0, 0x71, 0xdf, 0x0c, 0xf8, 0x38, 0x72, 0xa4, 0x77, 0x99, 0xbe, 0x68, 0x88, 0x75, 0xa2,
-	0x27, 0x8b, 0x29, 0xe7, 0x90, 0x1c, 0x79, 0xb4, 0x72, 0xce, 0xf9, 0x3c, 0x89, 0xf4, 0xcf, 0x02,
-	0x2c, 0x06, 0x84, 0xa6, 0xea, 0x7e, 0x1f, 0x90, 0x7a, 0xaa, 0xea, 0x1d, 0x7c, 0xc9, 0xbc, 0x72,
-	0x19, 0x2d, 0x9f, 0x2d, 0xf8, 0x33, 0x1e, 0x1a, 0x7a, 0x02, 0x8b, 0x5d, 0xf5, 0xa5, 0xde, 0xed,
-	0x77, 0x15, 0xba, 0xcf, 0xb6, 0xfe, 0x6d, 0xaf, 0xd0, 0x7e, 0x2d, 0xd2, 0x1e, 0xab, 0x1a, 0xce,
-	0xfb, 0xef, 0x92, 0xfe, 0xd8, 0x02, 0xc5, 0xa3, 0x9a, 0xae, 0x7f, 0x5b, 0x43, 0x07, 0xb0, 0xd8,
-	0xd5, 0x8d, 0x08, 0xb1, 0xf4, 0x50, 0x62, 0x9e, 0xc3, 0x26, 0xc8, 0x03, 0x8a, 0x92, 0xc4, 0x26,
-	0x89, 0x74, 0xb9, 0xe1, 0x3e, 0x72, 0x87, 0x4d, 0xae, 0x22, 0x30, 0x74, 0x5b, 0x76, 0xb8, 0xbd,
-	0xe4, 0x5b, 0x51, 0x9d, 0xa3, 0x8d, 0xd5, 0xd8, 0xb6, 0xf2, 0xef, 0x64, 0x58, 0x73, 0x1b, 0x81,
-	0x46, 0x1f, 0x42, 0xda, 0xea, 0xb5, 0xa8, 0xad, 0x7d, 0x63, 0x04, 0xfa, 0x45, 0xf9, 0x60, 0x6b,
-	0x77, 0x42, 0x76, 0xb1, 0xc4, 0x3f, 0x4d, 0x43, 0x5a, 0x3e, 0xd8, 0x42, 0x8f, 0x02, 0x0d, 0xd4,
-	0x7b, 0x23, 0x52, 0x61, 0xfb, 0xa7, 0xff, 0x9a, 0xe2, 0x35, 0x50, 0x0b, 0xb0, 0xb4, 0x25, 0x57,
-	0x4a, 0xcd, 0x8a, 0xb2, 0x5d, 0xd9, 0xab, 0x34, 0x2b, 0x0a, 0xe9, 0x01, 0xe7, 0x05, 0x74, 0x1d,
-	0x0a, 0x07, 0x87, 0xe5, 0xbd, 0x6a, 0x63, 0x57, 0x39, 0xac, 0x79, 0x7f, 0xd1, 0xd9, 0x14, 0xca,
-	0xc3, 0xec, 0x5e, 0xb5, 0xd1, 0xa4, 0x03, 0x8d, 0x7c, 0xda, 0x1d, 0xd9, 0xa9, 0x34, 0x95, 0xad,
-	0xd2, 0x41, 0x69, 0xab, 0xda, 0x7c, 0x96, 0xcf, 0x20, 0x11, 0x96, 0x83, 0xb4, 0x1b, 0xb5, 0xd2,
-	0x41, 0x63, 0xb7, 0xde, 0xcc, 0x67, 0x11, 0x82, 0x79, 0x8c, 0xef, 0x0d, 0x35, 0xf2, 0x39, 0x97,
-	0xc2, 0xd6, 0x5e, 0xbd, 0xe6, 0xcb, 0x30, 0x89, 0x96, 0x20, 0xef, 0x71, 0x96, 0x2b, 0xa5, 0x6d,
-	0x5c, 0x00, 0x9f, 0x42, 0x0b, 0x30, 0x57, 0xf9, 0xd6, 0x41, 0xa9, 0xb6, 0xed, 0x01, 0x4e, 0xa3,
-	0x55, 0xb8, 0xce, 0x8a, 0xa3, 0x50, 0xac, 0xca, 0x36, 0x2e, 0x62, 0x37, 0xf2, 0x80, 0xae, 0x42,
-	0x9e, 0xb6, 0xb7, 0xb7, 0xea, 0xb5, 0xed, 0x6a, 0xb3, 0x5a, 0xaf, 0xe5, 0x67, 0x48, 0xc5, 0x7b,
-	0x11, 0xc0, 0x95, 0x9c, 0x12, 0x9b, 0x1d, 0x5e, 0x06, 0x9f, 0x23, 0x20, 0xcb, 0x30, 0xb7, 0x5f,
-	0xdf, 0xae, 0x3e, 0x7e, 0xe6, 0xa1, 0xce, 0x93, 0xf2, 0xb8, 0xd7, 0xf9, 0xf9, 0x49, 0x0a, 0x2e,
-	0x93, 0xd6, 0x8f, 0xd7, 0x68, 0xf2, 0x6c, 0xd8, 0x3a, 0xe4, 0x49, 0xdd, 0x58, 0x09, 0x3b, 0x9b,
-	0x79, 0x32, 0xfe, 0xd4, 0x73, 0x39, 0x5e, 0x53, 0x39, 0xc5, 0x34, 0x95, 0xab, 0xe1, 0x6a, 0xc6,
-	0xdd, 0x60, 0xf7, 0x31, 0xc4, 0x2d, 0xc9, 0xfd, 0xec, 0x73, 0xd2, 0xed, 0xfb, 0xc9, 0xd4, 0x12,
-	0x8c, 0xe0, 0xb9, 0x1c, 0xcc, 0x39, 0xad, 0xdf, 0x63, 0x58, 0x0e, 0xcb, 0x4b, 0x15, 0xfd, 0x5e,
-	0xa4, 0xed, 0xe8, 0x9b, 0x63, 0x1f, 0xd6, 0x87, 0x90, 0xbe, 0x9f, 0x82, 0x29, 0x6f, 0xd8, 0x8d,
-	0x51, 0x5d, 0x7b, 0x15, 0xe8, 0x38, 0x4c, 0xbb, 0x23, 0x7e, 0x03, 0x83, 0x6d, 0x18, 0xa6, 0xc2,
-	0x0d, 0x43, 0xee, 0x39, 0xa7, 0xb9, 0xe7, 0xfc, 0x0d, 0x98, 0x6b, 0xb9, 0xe2, 0xeb, 0xa6, 0xa1,
-	0x38, 0x7a, 0xd7, 0x6b, 0x28, 0x44, 0x9f, 0x23, 0x34, 0xbd, 0x67, 0x46, 0xf2, 0xac, 0x87, 0xe0,
-	0x0e, 0xa1, 0x55, 0x98, 0xc5, 0xcf, 0x13, 0x14, 0xc7, 0x54, 0xfa, 0xb6, 0x56, 0xc8, 0xe2, 0xf2,
-	0x2a, 0xe0, 0xb1, 0xa6, 0x79, 0x68, 0x6b, 0xe8, 0x01, 0x2c, 0xe0, 0x66, 0x98, 0xc2, 0xca, 0x9c,
-	0x73, 0xa5, 0xa1, 0xa1, 0x2f, 0x9e, 0x6d, 0xf8, 0xd2, 0x4b, 0x7f, 0x2d, 0xc0, 0x65, 0x52, 0x66,
-	0x0e, 0xdf, 0xdf, 0x61, 0x9d, 0x52, 0xf6, 0x8a, 0x86, 0xdc, 0x2a, 0x97, 0xe0, 0xeb, 0xaa, 0xb2,
-	0x15, 0x60, 0x39, 0xcc, 0x8f, 0x96, 0xd6, 0x7e, 0x9c, 0x82, 0x25, 0x37, 0x20, 0xf7, 0x26, 0x2e,
-	0x3a, 0x67, 0x1a, 0xe3, 0xe8, 0x43, 0x9b, 0x99, 0x89, 0x6c, 0xe6, 0x6e, 0xb8, 0x70, 0xf5, 0x26,
-	0x9b, 0x52, 0x84, 0x57, 0xf0, 0xba, 0xf6, 0xf2, 0x47, 0x02, 0x5c, 0x0e, 0xf1, 0xa3, 0x0a, 0xf6,
-	0x51, 0x38, 0x0d, 0xbc, 0x15, 0x23, 0xdf, 0x2b, 0x25, 0x82, 0xef, 0x79, 0x09, 0xd8, 0x78, 0x7a,
-	0xfc, 0x77, 0x29, 0x36, 0xd4, 0xc7, 0x2f, 0x8a, 0xda, 0x63, 0x84, 0xfa, 0xe7, 0x7b, 0xb8, 0xf3,
-	0x71, 0xd8, 0x42, 0x73, 0x12, 0x05, 0x8e, 0x48, 0x49, 0x96, 0x9a, 0xdb, 0x81, 0xc9, 0x8c, 0xdb,
-	0x81, 0x39, 0xd7, 0x0d, 0xf8, 0x0e, 0x1b, 0xb7, 0x07, 0xc5, 0xa7, 0x37, 0x61, 0xc4, 0x2e, 0xed,
-	0xfb, 0x70, 0x05, 0xe7, 0x7c, 0xfe, 0x9b, 0x39, 0xef, 0x99, 0x0e, 0xb1, 0xa1, 0x53, 0xf2, 0x65,
-	0x77, 0xda, 0x7f, 0x05, 0x46, 0x3b, 0x93, 0x6d, 0xe9, 0xa7, 0x19, 0x58, 0x76, 0x73, 0xc2, 0x86,
-	0xa3, 0x9e, 0x8c, 0xd3, 0xb3, 0xfb, 0x85, 0x68, 0x0b, 0x24, 0x94, 0xbf, 0xf1, 0xa9, 0x8e, 0xd2,
-	0xf9, 0x40, 0x45, 0x58, 0xb4, 0x1d, 0xf5, 0x04, 0x9b, 0x03, 0xd5, 0x3a, 0xd1, 0x1c, 0xa5, 0xa7,
-	0x3a, 0x2f, 0xa8, 0xae, 0x2f, 0xd0, 0xa9, 0x26, 0x9e, 0x39, 0x50, 0x9d, 0x17, 0x17, 0x74, 0x90,
-	0xe8, 0x9b, 0x61, 0xa3, 0xf0, 0xd6, 0x90, 0xb5, 0x24, 0xdc, 0xad, 0x6f, 0xc5, 0xb4, 0xc9, 0xde,
-	0x19, 0x42, 0x72, 0x78, 0x7b, 0xec, 0xfc, 0x6d, 0xa1, 0x9f, 0x71, 0x87, 0xed, 0x2a, 0x5c, 0x89,
-	0x2c, 0x9e, 0xba, 0x90, 0x13, 0x28, 0xb8, 0x53, 0x87, 0x86, 0x3d, 0xe6, 0x75, 0x8c, 0xb9, 0x31,
-	0xa9, 0x98, 0x1b, 0x23, 0x5d, 0x83, 0xab, 0x1c, 0x46, 0x54, 0x8a, 0x3f, 0xcf, 0x12, 0x31, 0xc6,
-	0x6f, 0xf6, 0x7e, 0x1a, 0xa7, 0x15, 0xef, 0xb2, 0xc7, 0xce, 0xed, 0x8b, 0xbe, 0x0e, 0xbd, 0xb8,
-	0x09, 0x33, 0x2c, 0x1c, 0x75, 0x83, 0xce, 0x10, 0xc5, 0xc9, 0x9e, 0xab, 0x07, 0x9d, 0x0b, 0xf5,
-	0xa0, 0xf7, 0x06, 0x4a, 0x35, 0x19, 0x8c, 0x85, 0x63, 0xb7, 0x22, 0x41, 0xad, 0x9e, 0x47, 0xd4,
-	0x6a, 0x2a, 0xd8, 0xd8, 0x8e, 0x25, 0xfa, 0xff, 0x40, 0xb1, 0xe8, 0xa5, 0xe6, 0x76, 0x9c, 0xa5,
-	0xe7, 0x20, 0x92, 0x1b, 0x3f, 0x7e, 0x0f, 0x38, 0x74, 0x8d, 0x52, 0xe1, 0x6b, 0x24, 0xdd, 0x80,
-	0x6b, 0x5c, 0xda, 0x94, 0xf5, 0x0f, 0x04, 0x22, 0x98, 0x5f, 0xd9, 0x6c, 0x38, 0xaa, 0x63, 0x8f,
-	0xca, 0x9a, 0x4e, 0xb2, 0xac, 0xc9, 0x10, 0xbe, 0xc1, 0x63, 0xaa, 0x84, 0xf4, 0x9b, 0x02, 0xd9,
-	0x87, 0xb0, 0x2c, 0xd4, 0xdb, 0xbe, 0x09, 0xd9, 0x3e, 0xee, 0x41, 0x91, 0xa8, 0x6b, 0x31, 0xa8,
-	0x04, 0x87, 0xee, 0x94, 0x4c, 0x20, 0x2e, 0xac, 0x1c, 0x2e, 0xfd, 0x58, 0x80, 0x19, 0x86, 0x3e,
-	0xba, 0x0e, 0xd3, 0x7e, 0x09, 0xc9, 0x4b, 0x90, 0xfc, 0x01, 0xf7, 0xf8, 0x1d, 0xd3, 0x51, 0x3b,
-	0xf4, 0x6d, 0x17, 0xf9, 0xe1, 0xe6, 0xb4, 0x7d, 0x5b, 0x23, 0xe1, 0x70, 0x5a, 0xc6, 0x7f, 0xa3,
-	0x7b, 0x90, 0xe9, 0x1b, 0xba, 0x83, 0xd5, 0x7e, 0x3e, 0xac, 0xcf, 0x98, 0x55, 0xf1, 0xd0, 0xd0,
-	0x1d, 0x19, 0x43, 0x49, 0x77, 0x21, 0xe3, 0xfe, 0x0a, 0x96, 0x32, 0xa6, 0x21, 0x5b, 0x7e, 0xd6,
-	0xac, 0x34, 0xf2, 0x02, 0x02, 0xc8, 0x55, 0x49, 0xe2, 0x9f, 0x92, 0xf6, 0xbc, 0xd7, 0xe8, 0xfe,
-	0x22, 0x5c, 0x13, 0xa0, 0x1e, 0x19, 0xa6, 0xd5, 0x55, 0x3b, 0x58, 0xe6, 0x29, 0xd9, 0xff, 0x1d,
-	0xdf, 0xda, 0x23, 0x45, 0xc9, 0xeb, 0xfe, 0x89, 0xf0, 0x0a, 0x4f, 0x9f, 0x91, 0xbb, 0x15, 0x57,
-	0x72, 0x2a, 0x71, 0x4b, 0x4e, 0x37, 0x02, 0x5e, 0x76, 0x48, 0xb1, 0xe9, 0x6f, 0x52, 0x70, 0x99,
-	0x0b, 0x87, 0xde, 0x63, 0xcb, 0x4c, 0x6b, 0x89, 0x34, 0xd9, 0x02, 0xd3, 0x4f, 0x05, 0x52, 0x60,
-	0xda, 0x0c, 0x14, 0x98, 0xee, 0x0c, 0xc5, 0x67, 0x4b, 0x4b, 0x3f, 0x12, 0x62, 0x4a, 0x4b, 0x8d,
-	0x66, 0x69, 0xa7, 0xa2, 0x1c, 0xd6, 0xc8, 0xbf, 0x7e, 0x69, 0x69, 0x09, 0xf2, 0x83, 0x82, 0x8b,
-	0xd2, 0x68, 0x96, 0xf0, 0xa7, 0x05, 0x91, 0xb2, 0x4e, 0x9a, 0x5b, 0xb4, 0xc9, 0x0c, 0xaf, 0xcf,
-	0x64, 0xbd, 0xfa, 0x0c, 0xa2, 0xd8, 0xfb, 0xf5, 0xc3, 0x5a, 0x53, 0xc1, 0x1f, 0x2e, 0xe4, 0x73,
-	0x7e, 0x7d, 0x66, 0x09, 0x10, 0x3d, 0x2d, 0xf6, 0xfb, 0x9b, 0x3f, 0x14, 0x60, 0x31, 0x30, 0x4c,
-	0x0f, 0x8f, 0x79, 0x5c, 0x22, 0x04, 0x1e, 0x97, 0x3c, 0x80, 0x25, 0x37, 0x63, 0x24, 0x9a, 0x62,
-	0x2b, 0x3d, 0xcd, 0xc2, 0x1d, 0x0d, 0x7a, 0xe7, 0x17, 0xba, 0xea, 0x4b, 0xda, 0xf5, 0x39, 0xd0,
-	0x2c, 0x97, 0xf0, 0x05, 0x94, 0x8a, 0xa5, 0x2f, 0xd3, 0x24, 0x2e, 0x19, 0x3b, 0xaf, 0x19, 0x6a,
-	0xa3, 0xa2, 0x89, 0x4f, 0x7a, 0x8c, 0xc4, 0x27, 0xc6, 0xc2, 0x65, 0xc6, 0x0a, 0x86, 0xc7, 0xf7,
-	0xe9, 0xb5, 0x81, 0xdf, 0x26, 0x91, 0xeb, 0x3d, 0xf6, 0xfe, 0x0e, 0xcd, 0xb4, 0x72, 0x5f, 0x96,
-	0x85, 0x1f, 0x5e, 0x54, 0x9e, 0x5c, 0x22, 0xf1, 0xd8, 0x39, 0xf2, 0x23, 0xe9, 0x1e, 0xdc, 0xc6,
-	0xcf, 0x93, 0x87, 0x15, 0xba, 0x89, 0x49, 0xfa, 0x65, 0xb8, 0x33, 0x0c, 0x9a, 0xb2, 0xdf, 0xe3,
-	0xda, 0x1f, 0xbf, 0x41, 0x19, 0xa2, 0x32, 0xc4, 0x14, 0x11, 0xe6, 0xbf, 0x9e, 0x82, 0xd5, 0x61,
-	0x78, 0xe8, 0x11, 0x6b, 0x9a, 0xee, 0x8d, 0xca, 0x8e, 0xb5, 0x52, 0xbf, 0x4d, 0xad, 0x54, 0x25,
-	0x60, 0xa5, 0xde, 0x19, 0x87, 0x14, 0x6b, 0xb0, 0x2a, 0x3c, 0x7b, 0xf5, 0x36, 0xbc, 0x11, 0x2c,
-	0x57, 0x33, 0x36, 0x8a, 0x7c, 0xf3, 0xe4, 0xd7, 0xaf, 0x05, 0x6c, 0x60, 0x36, 0x03, 0xd5, 0xde,
-	0xdf, 0x4a, 0xc3, 0x2a, 0xfb, 0xd0, 0x7f, 0x87, 0xad, 0xa6, 0x25, 0x7d, 0x23, 0x74, 0x17, 0x16,
-	0xc2, 0x95, 0x22, 0xef, 0x61, 0xfb, 0xa5, 0x60, 0xa9, 0xc8, 0x4e, 0x7a, 0xc8, 0x36, 0x84, 0x75,
-	0x72, 0xfe, 0x17, 0xad, 0x02, 0x7f, 0x6d, 0x64, 0xc2, 0xff, 0x37, 0x0b, 0xc2, 0xe4, 0x7a, 0x76,
-	0x60, 0x2d, 0x41, 0x7e, 0xaa, 0x16, 0x65, 0x98, 0x0f, 0x16, 0x46, 0xe9, 0x4d, 0x0d, 0xbd, 0xe6,
-	0x0e, 0x22, 0xcf, 0x05, 0xaa, 0xa5, 0x84, 0xdb, 0x3f, 0x08, 0xde, 0x87, 0x2f, 0x01, 0x58, 0xf7,
-	0x84, 0xa3, 0x95, 0x57, 0xb2, 0x88, 0x70, 0xd1, 0x15, 0x15, 0x61, 0xda, 0x83, 0xb2, 0xc3, 0x4f,
-	0xa9, 0x7d, 0xe6, 0x03, 0x90, 0x68, 0xe1, 0x38, 0x7d, 0xce, 0xc2, 0x71, 0x26, 0x5c, 0x38, 0x26,
-	0x6b, 0xfb, 0x7e, 0x0a, 0x56, 0xd9, 0x37, 0xc7, 0xdc, 0xeb, 0x3d, 0xce, 0x42, 0xd7, 0x60, 0x96,
-	0x81, 0xf2, 0x6e, 0xfc, 0xcc, 0xa0, 0xee, 0x99, 0x74, 0xdb, 0x87, 0x49, 0xf2, 0x9a, 0x8a, 0xa0,
-	0x64, 0x2b, 0xd6, 0x61, 0x2d, 0x81, 0x3f, 0xdb, 0xc2, 0xfe, 0x6e, 0x0a, 0x7f, 0xd1, 0xfa, 0xbf,
-	0xb7, 0x63, 0xf1, 0x85, 0xc7, 0x44, 0x31, 0x5e, 0xeb, 0x76, 0xe9, 0xb0, 0x12, 0xc7, 0xfc, 0x82,
-	0x15, 0x70, 0xe3, 0xbf, 0x05, 0x98, 0xaa, 0xb6, 0x35, 0xc3, 0x21, 0x41, 0xc1, 0x5c, 0xe0, 0xdb,
-	0x66, 0x74, 0x3d, 0xe6, 0x93, 0x67, 0xbc, 0x05, 0xe2, 0x8d, 0xc4, 0x0f, 0xa2, 0xa5, 0x09, 0x74,
-	0xcc, 0x7c, 0x97, 0x1d, 0x78, 0x46, 0xf0, 0x95, 0x08, 0x26, 0xc7, 0x57, 0x8b, 0xb7, 0x87, 0x40,
-	0xf9, 0x7c, 0xde, 0x87, 0x2c, 0xfe, 0x44, 0x15, 0x2d, 0xf9, 0x9f, 0xc9, 0x32, 0x5f, 0xb0, 0x8a,
-	0x97, 0x43, 0xa3, 0x1e, 0xde, 0xc6, 0x5f, 0x01, 0xc0, 0xc0, 0x07, 0xa2, 0x27, 0x30, 0xcb, 0x9a,
-	0x3e, 0x74, 0x2d, 0xe1, 0x13, 0x45, 0xf1, 0x3a, 0x7f, 0xd2, 0x97, 0xe9, 0x09, 0xcc, 0xb2, 0x57,
-	0x7e, 0x40, 0x8c, 0xf3, 0xd1, 0xc3, 0x80, 0x18, 0xf7, 0x1b, 0x85, 0x09, 0xd4, 0x81, 0x2b, 0x31,
-	0x4f, 0xce, 0xd1, 0x9d, 0xd1, 0x1e, 0xe6, 0x8b, 0x6f, 0x8c, 0xf8, 0x76, 0x5d, 0x9a, 0x40, 0x16,
-	0x5c, 0x8d, 0x7d, 0x69, 0x8d, 0xd6, 0x47, 0x7d, 0x07, 0x2e, 0xbe, 0x39, 0x02, 0xa4, 0xcf, 0xb3,
-	0x0f, 0x62, 0xfc, 0xa3, 0x45, 0xf4, 0xe6, 0xc8, 0xaf, 0x82, 0xc5, 0xbb, 0xa3, 0xbf, 0x81, 0x94,
-	0x26, 0xd0, 0x2e, 0xcc, 0x30, 0x8f, 0xcc, 0x90, 0xc8, 0x7d, 0x79, 0x46, 0x08, 0x5f, 0x4b, 0x78,
-	0x95, 0x46, 0x28, 0x31, 0x4f, 0x49, 0x06, 0x94, 0xa2, 0x8f, 0x62, 0x06, 0x94, 0x38, 0x6f, 0x4f,
-	0xc2, 0xdb, 0x1f, 0x0a, 0x4c, 0x79, 0xdb, 0xcf, 0x8f, 0x74, 0x79, 0xdb, 0x1f, 0x13, 0xe5, 0x4a,
-	0x13, 0xe8, 0x63, 0x98, 0x0f, 0xf6, 0x82, 0xd1, 0x8d, 0xc4, 0x9e, 0xb6, 0xb8, 0x12, 0x37, 0xcd,
-	0x92, 0x0c, 0x76, 0x12, 0x07, 0x24, 0xb9, 0x1d, 0xcd, 0x01, 0xc9, 0x98, 0x06, 0xe4, 0x84, 0x6b,
-	0x9f, 0x02, 0xfd, 0xb1, 0x81, 0x7d, 0xe2, 0xb5, 0xf5, 0x06, 0xf6, 0x89, 0xdb, 0x54, 0x93, 0x26,
-	0x90, 0x0e, 0xcb, 0xfc, 0xf6, 0x0c, 0xba, 0x3d, 0x52, 0xf7, 0x49, 0xbc, 0x33, 0x0c, 0xcc, 0x67,
-	0xd5, 0x82, 0x45, 0xce, 0x1b, 0x40, 0x24, 0x25, 0x3e, 0x10, 0x24, 0x4c, 0x6e, 0x8d, 0xf0, 0x88,
-	0x50, 0xc2, 0xe9, 0x7b, 0x87, 0x5d, 0x0f, 0xfb, 0x4c, 0x8c, 0xb7, 0x1e, 0xce, 0xc3, 0x38, 0xde,
-	0x7a, 0x78, 0xaf, 0xcd, 0x30, 0xb7, 0x8d, 0xff, 0x4a, 0xc3, 0xa5, 0x50, 0x1a, 0x81, 0x7e, 0x55,
-	0x80, 0x95, 0xe4, 0xd4, 0x0a, 0xdd, 0x8f, 0x49, 0x41, 0x62, 0xae, 0x71, 0x71, 0x54, 0x70, 0xc6,
-	0x94, 0x5c, 0x8d, 0x8d, 0x60, 0xd1, 0xfa, 0xa8, 0x41, 0x3a, 0xa3, 0x3f, 0xc3, 0xc2, 0x61, 0xb2,
-	0xf9, 0x7d, 0xb8, 0x1a, 0x1b, 0xe3, 0xa0, 0xf5, 0x51, 0xc3, 0xb0, 0x01, 0xdb, 0xa1, 0x01, 0x93,
-	0x7f, 0xe6, 0xfc, 0x58, 0x01, 0xdd, 0x1e, 0x29, 0x90, 0x19, 0x9c, 0x79, 0x72, 0xc8, 0x81, 0xb9,
-	0xe1, 0x24, 0x6e, 0xe3, 0x1f, 0xb3, 0x90, 0xc1, 0x65, 0x99, 0x26, 0x5c, 0x0a, 0xb5, 0x7a, 0xd0,
-	0x4a, 0x72, 0x03, 0x4c, 0xbc, 0x19, 0x3b, 0xef, 0x9f, 0xdf, 0x73, 0x58, 0x88, 0x34, 0x6f, 0xd0,
-	0x2a, 0x8b, 0xc7, 0x6b, 0x20, 0x89, 0x6b, 0x09, 0x10, 0x61, 0xda, 0x41, 0x17, 0xba, 0x3a, 0xac,
-	0xbb, 0x10, 0xa4, 0x1d, 0xe7, 0x36, 0x3f, 0x23, 0x55, 0xb0, 0xb0, 0xc3, 0x94, 0x82, 0x72, 0x71,
-	0x5d, 0xe5, 0xad, 0x44, 0x18, 0x9f, 0xc3, 0xa7, 0x7e, 0xf9, 0x8d, 0x29, 0x6e, 0xa3, 0x80, 0x70,
-	0xdc, 0x22, 0xbc, 0x28, 0x25, 0x81, 0xf8, 0xe4, 0x3f, 0x81, 0x7c, 0xb8, 0x0e, 0x83, 0x6e, 0x0e,
-	0x29, 0x0b, 0x89, 0xab, 0xf1, 0x00, 0xe1, 0x9d, 0x09, 0x5b, 0x82, 0xb0, 0x54, 0x3c, 0xf5, 0xbf,
-	0x95, 0x08, 0xc3, 0x7a, 0x5f, 0xa6, 0x02, 0x39, 0xf0, 0xbe, 0xd1, 0x6a, 0xe5, 0xc0, 0xfb, 0x72,
-	0x4a, 0x96, 0xd2, 0xc4, 0xe6, 0x43, 0x00, 0xb5, 0xd3, 0x7b, 0xa1, 0x2a, 0x9a, 0xd1, 0xef, 0xa2,
-	0xeb, 0x91, 0xa4, 0xb0, 0x62, 0xf4, 0xbb, 0xf5, 0x9e, 0x9b, 0x0b, 0xda, 0x85, 0x3f, 0x9e, 0xc2,
-	0x99, 0xdf, 0x34, 0x46, 0x70, 0x27, 0x36, 0xf7, 0x20, 0x3f, 0xc0, 0x56, 0x70, 0x58, 0x8f, 0xd6,
-	0xb8, 0x34, 0xf0, 0x9b, 0xcd, 0x10, 0xa1, 0x79, 0x9f, 0x10, 0x9e, 0xdd, 0xfc, 0x08, 0xa0, 0x65,
-	0xeb, 0x0a, 0xc9, 0x2b, 0xd0, 0x8d, 0x08, 0x9d, 0xc7, 0xba, 0xd6, 0x69, 0x7b, 0x34, 0xfe, 0x88,
-	0x0a, 0xd3, 0xb2, 0x75, 0x92, 0x7d, 0x6c, 0x7e, 0x03, 0x66, 0x88, 0x30, 0xc7, 0x2e, 0xdc, 0x30,
-	0x7c, 0x2a, 0x03, 0x59, 0x3d, 0x9e, 0xd9, 0xac, 0xc0, 0x1c, 0x21, 0x40, 0x0b, 0xfa, 0xe8, 0x66,
-	0x84, 0xc4, 0x3e, 0x99, 0x09, 0x11, 0x99, 0xc5, 0x68, 0x74, 0x6e, 0xb3, 0x0c, 0xb3, 0x1e, 0x19,
-	0xe7, 0x85, 0xd9, 0x46, 0x2b, 0x1c, 0x2a, 0xee, 0x44, 0x88, 0xc8, 0x0c, 0x25, 0xe2, 0x4e, 0x0d,
-	0x44, 0xf1, 0xfe, 0x1f, 0xa1, 0xa8, 0x28, 0xb4, 0x86, 0xc5, 0x15, 0x85, 0xce, 0x95, 0xb3, 0xcf,
-	0xd3, 0x2d, 0x5b, 0x3f, 0xca, 0x61, 0xa4, 0xaf, 0xfe, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x88,
-	0xc2, 0x11, 0x67, 0xf4, 0x4a, 0x00, 0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// IdentityClient is the client API for Identity service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type IdentityClient interface {
-	GetPluginInfo(ctx context.Context, in *GetPluginInfoRequest, opts ...grpc.CallOption) (*GetPluginInfoResponse, error)
-	GetPluginCapabilities(ctx context.Context, in *GetPluginCapabilitiesRequest, opts ...grpc.CallOption) (*GetPluginCapabilitiesResponse, error)
-	Probe(ctx context.Context, in *ProbeRequest, opts ...grpc.CallOption) (*ProbeResponse, error)
-}
-
-type identityClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewIdentityClient(cc *grpc.ClientConn) IdentityClient {
-	return &identityClient{cc}
-}
-
-func (c *identityClient) GetPluginInfo(ctx context.Context, in *GetPluginInfoRequest, opts ...grpc.CallOption) (*GetPluginInfoResponse, error) {
-	out := new(GetPluginInfoResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Identity/GetPluginInfo", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *identityClient) GetPluginCapabilities(ctx context.Context, in *GetPluginCapabilitiesRequest, opts ...grpc.CallOption) (*GetPluginCapabilitiesResponse, error) {
-	out := new(GetPluginCapabilitiesResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Identity/GetPluginCapabilities", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *identityClient) Probe(ctx context.Context, in *ProbeRequest, opts ...grpc.CallOption) (*ProbeResponse, error) {
-	out := new(ProbeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Identity/Probe", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+// Deprecated: Use GetVolumeGroupSnapshotResponse.ProtoReflect.Descriptor instead.
+func (*GetVolumeGroupSnapshotResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{71}
 }
 
-// IdentityServer is the server API for Identity service.
-type IdentityServer interface {
-	GetPluginInfo(context.Context, *GetPluginInfoRequest) (*GetPluginInfoResponse, error)
-	GetPluginCapabilities(context.Context, *GetPluginCapabilitiesRequest) (*GetPluginCapabilitiesResponse, error)
-	Probe(context.Context, *ProbeRequest) (*ProbeResponse, error)
+func (x *GetVolumeGroupSnapshotResponse) GetGroupSnapshot() *VolumeGroupSnapshot {
+	if x != nil {
+		return x.GroupSnapshot
+	}
+	return nil
 }
 
-// UnimplementedIdentityServer can be embedded to have forward compatible implementations.
-type UnimplementedIdentityServer struct {
-}
+// BlockMetadata specifies a data range.
+type BlockMetadata struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 
-func (*UnimplementedIdentityServer) GetPluginInfo(ctx context.Context, req *GetPluginInfoRequest) (*GetPluginInfoResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetPluginInfo not implemented")
-}
-func (*UnimplementedIdentityServer) GetPluginCapabilities(ctx context.Context, req *GetPluginCapabilitiesRequest) (*GetPluginCapabilitiesResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetPluginCapabilities not implemented")
+	// This is the zero based byte position in the volume or snapshot,
+	// measured from the start of the object.
+	// This field is REQUIRED.
+	ByteOffset int64 `protobuf:"varint,1,opt,name=byte_offset,json=byteOffset,proto3" json:"byte_offset,omitempty"`
+	// This is the size of the data range.
+	// size_bytes MUST be greater than zero.
+	// This field is REQUIRED.
+	SizeBytes int64 `protobuf:"varint,2,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"`
 }
-func (*UnimplementedIdentityServer) Probe(ctx context.Context, req *ProbeRequest) (*ProbeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Probe not implemented")
+
+func (x *BlockMetadata) Reset() {
+	*x = BlockMetadata{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[72]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func RegisterIdentityServer(s *grpc.Server, srv IdentityServer) {
-	s.RegisterService(&_Identity_serviceDesc, srv)
+func (x *BlockMetadata) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func _Identity_GetPluginInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetPluginInfoRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(IdentityServer).GetPluginInfo(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Identity/GetPluginInfo",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(IdentityServer).GetPluginInfo(ctx, req.(*GetPluginInfoRequest))
+func (*BlockMetadata) ProtoMessage() {}
+
+func (x *BlockMetadata) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[72]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return interceptor(ctx, in, info, handler)
+	return mi.MessageOf(x)
 }
 
-func _Identity_GetPluginCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetPluginCapabilitiesRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(IdentityServer).GetPluginCapabilities(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Identity/GetPluginCapabilities",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(IdentityServer).GetPluginCapabilities(ctx, req.(*GetPluginCapabilitiesRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+// Deprecated: Use BlockMetadata.ProtoReflect.Descriptor instead.
+func (*BlockMetadata) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{72}
 }
 
-func _Identity_Probe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ProbeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(IdentityServer).Probe(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Identity/Probe",
+func (x *BlockMetadata) GetByteOffset() int64 {
+	if x != nil {
+		return x.ByteOffset
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(IdentityServer).Probe(ctx, req.(*ProbeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+	return 0
 }
 
-var _Identity_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "csi.v1.Identity",
-	HandlerType: (*IdentityServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "GetPluginInfo",
-			Handler:    _Identity_GetPluginInfo_Handler,
-		},
-		{
-			MethodName: "GetPluginCapabilities",
-			Handler:    _Identity_GetPluginCapabilities_Handler,
-		},
-		{
-			MethodName: "Probe",
-			Handler:    _Identity_Probe_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "github.com/container-storage-interface/spec/csi.proto",
+func (x *BlockMetadata) GetSizeBytes() int64 {
+	if x != nil {
+		return x.SizeBytes
+	}
+	return 0
 }
 
-// ControllerClient is the client API for Controller service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type ControllerClient interface {
-	CreateVolume(ctx context.Context, in *CreateVolumeRequest, opts ...grpc.CallOption) (*CreateVolumeResponse, error)
-	DeleteVolume(ctx context.Context, in *DeleteVolumeRequest, opts ...grpc.CallOption) (*DeleteVolumeResponse, error)
-	ControllerPublishVolume(ctx context.Context, in *ControllerPublishVolumeRequest, opts ...grpc.CallOption) (*ControllerPublishVolumeResponse, error)
-	ControllerUnpublishVolume(ctx context.Context, in *ControllerUnpublishVolumeRequest, opts ...grpc.CallOption) (*ControllerUnpublishVolumeResponse, error)
-	ValidateVolumeCapabilities(ctx context.Context, in *ValidateVolumeCapabilitiesRequest, opts ...grpc.CallOption) (*ValidateVolumeCapabilitiesResponse, error)
-	ListVolumes(ctx context.Context, in *ListVolumesRequest, opts ...grpc.CallOption) (*ListVolumesResponse, error)
-	GetCapacity(ctx context.Context, in *GetCapacityRequest, opts ...grpc.CallOption) (*GetCapacityResponse, error)
-	ControllerGetCapabilities(ctx context.Context, in *ControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*ControllerGetCapabilitiesResponse, error)
-	CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*CreateSnapshotResponse, error)
-	DeleteSnapshot(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*DeleteSnapshotResponse, error)
-	ListSnapshots(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error)
-	ControllerExpandVolume(ctx context.Context, in *ControllerExpandVolumeRequest, opts ...grpc.CallOption) (*ControllerExpandVolumeResponse, error)
-	ControllerGetVolume(ctx context.Context, in *ControllerGetVolumeRequest, opts ...grpc.CallOption) (*ControllerGetVolumeResponse, error)
-	ControllerModifyVolume(ctx context.Context, in *ControllerModifyVolumeRequest, opts ...grpc.CallOption) (*ControllerModifyVolumeResponse, error)
+// The GetMetadataAllocatedRequest message is used to solicit metadata
+// on the allocated blocks of a snapshot: i.e. this identifies the
+// data ranges that have valid data as they were the target of some
+// previous write operation on the volume.
+type GetMetadataAllocatedRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// This is the identifier of the snapshot.
+	// This field is REQUIRED.
+	SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
+	// This indicates the zero based starting byte position in the volume
+	// snapshot from which the result should be computed.
+	// It is intended to be used to continue a previously interrupted
+	// call.
+	// The CO SHOULD specify this value to be the offset of the byte
+	// position immediately after the last byte of the last data range
+	// received, if continuing an interrupted operation, or zero if not.
+	// The SP MUST ensure that the returned response stream does not
+	// contain BlockMetadata tuples that end before the requested
+	// starting_offset: i.e. if S is the requested starting_offset, and
+	// B0 is block_metadata[0] of the first message in the response
+	// stream, then (S < B0.byte_offset + B0.size_bytes) must be true.
+	// This field is REQUIRED.
+	StartingOffset int64 `protobuf:"varint,2,opt,name=starting_offset,json=startingOffset,proto3" json:"starting_offset,omitempty"`
+	// This is an optional parameter, and if non-zero it specifies the
+	// maximum number of tuples to be returned in each
+	// GetMetadataAllocatedResponse message returned by the RPC stream.
+	// The plugin will determine an appropriate value if 0, and is
+	// always free to send less than the requested value.
+	// This field is OPTIONAL.
+	MaxResults int32 `protobuf:"varint,3,opt,name=max_results,json=maxResults,proto3" json:"max_results,omitempty"`
+	// Secrets required by plugin to complete the request.
+	// This field is OPTIONAL. Refer to the `Secrets Requirements`
+	// section on how to use this field.
+	Secrets map[string]string `protobuf:"bytes,4,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-type controllerClient struct {
-	cc *grpc.ClientConn
+func (x *GetMetadataAllocatedRequest) Reset() {
+	*x = GetMetadataAllocatedRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[73]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func NewControllerClient(cc *grpc.ClientConn) ControllerClient {
-	return &controllerClient{cc}
+func (x *GetMetadataAllocatedRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func (c *controllerClient) CreateVolume(ctx context.Context, in *CreateVolumeRequest, opts ...grpc.CallOption) (*CreateVolumeResponse, error) {
-	out := new(CreateVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/CreateVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (*GetMetadataAllocatedRequest) ProtoMessage() {}
+
+func (x *GetMetadataAllocatedRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[73]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return out, nil
+	return mi.MessageOf(x)
 }
 
-func (c *controllerClient) DeleteVolume(ctx context.Context, in *DeleteVolumeRequest, opts ...grpc.CallOption) (*DeleteVolumeResponse, error) {
-	out := new(DeleteVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/DeleteVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+// Deprecated: Use GetMetadataAllocatedRequest.ProtoReflect.Descriptor instead.
+func (*GetMetadataAllocatedRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{73}
 }
 
-func (c *controllerClient) ControllerPublishVolume(ctx context.Context, in *ControllerPublishVolumeRequest, opts ...grpc.CallOption) (*ControllerPublishVolumeResponse, error) {
-	out := new(ControllerPublishVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ControllerPublishVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *GetMetadataAllocatedRequest) GetSnapshotId() string {
+	if x != nil {
+		return x.SnapshotId
 	}
-	return out, nil
+	return ""
 }
 
-func (c *controllerClient) ControllerUnpublishVolume(ctx context.Context, in *ControllerUnpublishVolumeRequest, opts ...grpc.CallOption) (*ControllerUnpublishVolumeResponse, error) {
-	out := new(ControllerUnpublishVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ControllerUnpublishVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *GetMetadataAllocatedRequest) GetStartingOffset() int64 {
+	if x != nil {
+		return x.StartingOffset
 	}
-	return out, nil
+	return 0
 }
 
-func (c *controllerClient) ValidateVolumeCapabilities(ctx context.Context, in *ValidateVolumeCapabilitiesRequest, opts ...grpc.CallOption) (*ValidateVolumeCapabilitiesResponse, error) {
-	out := new(ValidateVolumeCapabilitiesResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ValidateVolumeCapabilities", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *GetMetadataAllocatedRequest) GetMaxResults() int32 {
+	if x != nil {
+		return x.MaxResults
 	}
-	return out, nil
+	return 0
 }
 
-func (c *controllerClient) ListVolumes(ctx context.Context, in *ListVolumesRequest, opts ...grpc.CallOption) (*ListVolumesResponse, error) {
-	out := new(ListVolumesResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ListVolumes", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *GetMetadataAllocatedRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
-	return out, nil
+	return nil
 }
 
-func (c *controllerClient) GetCapacity(ctx context.Context, in *GetCapacityRequest, opts ...grpc.CallOption) (*GetCapacityResponse, error) {
-	out := new(GetCapacityResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/GetCapacity", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+// GetMetadataAllocatedResponse messages are returned in a gRPC stream.
+// Cumulatively, they provide information on the allocated data
+// ranges in the snapshot.
+type GetMetadataAllocatedResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// This specifies the style used in the BlockMetadata sequence.
+	// This value must be the same in all such messages returned by
+	// the stream.
+	// If block_metadata_type is FIXED_LENGTH, then the size_bytes field
+	// of each message in the block_metadata list MUST be constant.
+	// This field is REQUIRED.
+	BlockMetadataType BlockMetadataType `protobuf:"varint,1,opt,name=block_metadata_type,json=blockMetadataType,proto3,enum=csi.v1.BlockMetadataType" json:"block_metadata_type,omitempty"`
+	// This returns the capacity of the underlying volume in bytes.
+	// This value must be the same in all such messages returned by
+	// the stream.
+	// This field is REQUIRED.
+	VolumeCapacityBytes int64 `protobuf:"varint,2,opt,name=volume_capacity_bytes,json=volumeCapacityBytes,proto3" json:"volume_capacity_bytes,omitempty"`
+	// This is a list of data range tuples.
+	// If the value of max_results in the GetMetadataAllocatedRequest
+	// message is greater than zero, then the number of entries in this
+	// list MUST be less than or equal to that value.
+	// The SP MUST respect the value of starting_offset in the request.
+	// The byte_offset fields of adjacent BlockMetadata messages
+	// MUST be strictly increasing and messages MUST NOT overlap:
+	// i.e. for any two BlockMetadata messages, A and B, if A is returned
+	// before B, then (A.byte_offset + A.size_bytes <= B.byte_offset)
+	// MUST be true.
+	// This MUST also be true if A and B are from block_metadata lists in
+	// different GetMetadataAllocatedResponse messages in the gRPC stream.
+	// This field is OPTIONAL.
+	BlockMetadata []*BlockMetadata `protobuf:"bytes,3,rep,name=block_metadata,json=blockMetadata,proto3" json:"block_metadata,omitempty"`
 }
 
-func (c *controllerClient) ControllerGetCapabilities(ctx context.Context, in *ControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*ControllerGetCapabilitiesResponse, error) {
-	out := new(ControllerGetCapabilitiesResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ControllerGetCapabilities", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *GetMetadataAllocatedResponse) Reset() {
+	*x = GetMetadataAllocatedResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[74]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return out, nil
 }
 
-func (c *controllerClient) CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*CreateSnapshotResponse, error) {
-	out := new(CreateSnapshotResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/CreateSnapshot", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+func (x *GetMetadataAllocatedResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func (c *controllerClient) DeleteSnapshot(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*DeleteSnapshotResponse, error) {
-	out := new(DeleteSnapshotResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/DeleteSnapshot", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (*GetMetadataAllocatedResponse) ProtoMessage() {}
+
+func (x *GetMetadataAllocatedResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[74]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return out, nil
+	return mi.MessageOf(x)
 }
 
-func (c *controllerClient) ListSnapshots(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error) {
-	out := new(ListSnapshotsResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ListSnapshots", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+// Deprecated: Use GetMetadataAllocatedResponse.ProtoReflect.Descriptor instead.
+func (*GetMetadataAllocatedResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{74}
 }
 
-func (c *controllerClient) ControllerExpandVolume(ctx context.Context, in *ControllerExpandVolumeRequest, opts ...grpc.CallOption) (*ControllerExpandVolumeResponse, error) {
-	out := new(ControllerExpandVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ControllerExpandVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *GetMetadataAllocatedResponse) GetBlockMetadataType() BlockMetadataType {
+	if x != nil {
+		return x.BlockMetadataType
 	}
-	return out, nil
+	return BlockMetadataType_UNKNOWN
 }
 
-func (c *controllerClient) ControllerGetVolume(ctx context.Context, in *ControllerGetVolumeRequest, opts ...grpc.CallOption) (*ControllerGetVolumeResponse, error) {
-	out := new(ControllerGetVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ControllerGetVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *GetMetadataAllocatedResponse) GetVolumeCapacityBytes() int64 {
+	if x != nil {
+		return x.VolumeCapacityBytes
 	}
-	return out, nil
+	return 0
 }
 
-func (c *controllerClient) ControllerModifyVolume(ctx context.Context, in *ControllerModifyVolumeRequest, opts ...grpc.CallOption) (*ControllerModifyVolumeResponse, error) {
-	out := new(ControllerModifyVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Controller/ControllerModifyVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *GetMetadataAllocatedResponse) GetBlockMetadata() []*BlockMetadata {
+	if x != nil {
+		return x.BlockMetadata
 	}
-	return out, nil
+	return nil
 }
 
-// ControllerServer is the server API for Controller service.
-type ControllerServer interface {
-	CreateVolume(context.Context, *CreateVolumeRequest) (*CreateVolumeResponse, error)
-	DeleteVolume(context.Context, *DeleteVolumeRequest) (*DeleteVolumeResponse, error)
-	ControllerPublishVolume(context.Context, *ControllerPublishVolumeRequest) (*ControllerPublishVolumeResponse, error)
-	ControllerUnpublishVolume(context.Context, *ControllerUnpublishVolumeRequest) (*ControllerUnpublishVolumeResponse, error)
-	ValidateVolumeCapabilities(context.Context, *ValidateVolumeCapabilitiesRequest) (*ValidateVolumeCapabilitiesResponse, error)
-	ListVolumes(context.Context, *ListVolumesRequest) (*ListVolumesResponse, error)
-	GetCapacity(context.Context, *GetCapacityRequest) (*GetCapacityResponse, error)
-	ControllerGetCapabilities(context.Context, *ControllerGetCapabilitiesRequest) (*ControllerGetCapabilitiesResponse, error)
-	CreateSnapshot(context.Context, *CreateSnapshotRequest) (*CreateSnapshotResponse, error)
-	DeleteSnapshot(context.Context, *DeleteSnapshotRequest) (*DeleteSnapshotResponse, error)
-	ListSnapshots(context.Context, *ListSnapshotsRequest) (*ListSnapshotsResponse, error)
-	ControllerExpandVolume(context.Context, *ControllerExpandVolumeRequest) (*ControllerExpandVolumeResponse, error)
-	ControllerGetVolume(context.Context, *ControllerGetVolumeRequest) (*ControllerGetVolumeResponse, error)
-	ControllerModifyVolume(context.Context, *ControllerModifyVolumeRequest) (*ControllerModifyVolumeResponse, error)
-}
+// The GetMetadataDeltaRequest message is used to solicit metadata on
+// the data ranges that have changed between two snapshots.
+type GetMetadataDeltaRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 
-// UnimplementedControllerServer can be embedded to have forward compatible implementations.
-type UnimplementedControllerServer struct {
+	// This is the identifier of the snapshot against which changes
+	// are to be computed.
+	// This field is REQUIRED.
+	BaseSnapshotId string `protobuf:"bytes,1,opt,name=base_snapshot_id,json=baseSnapshotId,proto3" json:"base_snapshot_id,omitempty"`
+	// This is the identifier of a second snapshot in the same volume,
+	// created after the base snapshot.
+	// This field is REQUIRED.
+	TargetSnapshotId string `protobuf:"bytes,2,opt,name=target_snapshot_id,json=targetSnapshotId,proto3" json:"target_snapshot_id,omitempty"`
+	// This indicates the zero based starting byte position in the volume
+	// snapshot from which the result should be computed.
+	// It is intended to be used to continue a previously interrupted
+	// call.
+	// The CO SHOULD specify this value to be the offset of the byte
+	// position immediately after the last byte of the last data range
+	// received, if continuing an interrupted operation, or zero if not.
+	// The SP MUST ensure that the returned response stream does not
+	// contain BlockMetadata tuples that end before the requested
+	// starting_offset: i.e. if S is the requested starting_offset, and
+	// B0 is block_metadata[0] of the first message in the response
+	// stream, then (S < B0.byte_offset + B0.size_bytes) must be true.
+	// This field is REQUIRED.
+	StartingOffset int64 `protobuf:"varint,3,opt,name=starting_offset,json=startingOffset,proto3" json:"starting_offset,omitempty"`
+	// This is an optional parameter, and if non-zero it specifies the
+	// maximum number of tuples to be returned in each
+	// GetMetadataDeltaResponse message returned by the RPC stream.
+	// The plugin will determine an appropriate value if 0, and is
+	// always free to send less than the requested value.
+	// This field is OPTIONAL.
+	MaxResults int32 `protobuf:"varint,4,opt,name=max_results,json=maxResults,proto3" json:"max_results,omitempty"`
+	// Secrets required by plugin to complete the request.
+	// This field is OPTIONAL. Refer to the `Secrets Requirements`
+	// section on how to use this field.
+	Secrets map[string]string `protobuf:"bytes,5,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func (*UnimplementedControllerServer) CreateVolume(ctx context.Context, req *CreateVolumeRequest) (*CreateVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CreateVolume not implemented")
-}
-func (*UnimplementedControllerServer) DeleteVolume(ctx context.Context, req *DeleteVolumeRequest) (*DeleteVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method DeleteVolume not implemented")
-}
-func (*UnimplementedControllerServer) ControllerPublishVolume(ctx context.Context, req *ControllerPublishVolumeRequest) (*ControllerPublishVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ControllerPublishVolume not implemented")
-}
-func (*UnimplementedControllerServer) ControllerUnpublishVolume(ctx context.Context, req *ControllerUnpublishVolumeRequest) (*ControllerUnpublishVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ControllerUnpublishVolume not implemented")
-}
-func (*UnimplementedControllerServer) ValidateVolumeCapabilities(ctx context.Context, req *ValidateVolumeCapabilitiesRequest) (*ValidateVolumeCapabilitiesResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ValidateVolumeCapabilities not implemented")
-}
-func (*UnimplementedControllerServer) ListVolumes(ctx context.Context, req *ListVolumesRequest) (*ListVolumesResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListVolumes not implemented")
-}
-func (*UnimplementedControllerServer) GetCapacity(ctx context.Context, req *GetCapacityRequest) (*GetCapacityResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetCapacity not implemented")
-}
-func (*UnimplementedControllerServer) ControllerGetCapabilities(ctx context.Context, req *ControllerGetCapabilitiesRequest) (*ControllerGetCapabilitiesResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ControllerGetCapabilities not implemented")
-}
-func (*UnimplementedControllerServer) CreateSnapshot(ctx context.Context, req *CreateSnapshotRequest) (*CreateSnapshotResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CreateSnapshot not implemented")
-}
-func (*UnimplementedControllerServer) DeleteSnapshot(ctx context.Context, req *DeleteSnapshotRequest) (*DeleteSnapshotResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method DeleteSnapshot not implemented")
-}
-func (*UnimplementedControllerServer) ListSnapshots(ctx context.Context, req *ListSnapshotsRequest) (*ListSnapshotsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListSnapshots not implemented")
-}
-func (*UnimplementedControllerServer) ControllerExpandVolume(ctx context.Context, req *ControllerExpandVolumeRequest) (*ControllerExpandVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ControllerExpandVolume not implemented")
+func (x *GetMetadataDeltaRequest) Reset() {
+	*x = GetMetadataDeltaRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[75]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (*UnimplementedControllerServer) ControllerGetVolume(ctx context.Context, req *ControllerGetVolumeRequest) (*ControllerGetVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ControllerGetVolume not implemented")
+
+func (x *GetMetadataDeltaRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (*UnimplementedControllerServer) ControllerModifyVolume(ctx context.Context, req *ControllerModifyVolumeRequest) (*ControllerModifyVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ControllerModifyVolume not implemented")
+
+func (*GetMetadataDeltaRequest) ProtoMessage() {}
+
+func (x *GetMetadataDeltaRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[75]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-func RegisterControllerServer(s *grpc.Server, srv ControllerServer) {
-	s.RegisterService(&_Controller_serviceDesc, srv)
+// Deprecated: Use GetMetadataDeltaRequest.ProtoReflect.Descriptor instead.
+func (*GetMetadataDeltaRequest) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{75}
 }
 
-func _Controller_CreateVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CreateVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *GetMetadataDeltaRequest) GetBaseSnapshotId() string {
+	if x != nil {
+		return x.BaseSnapshotId
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).CreateVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/CreateVolume",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).CreateVolume(ctx, req.(*CreateVolumeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+	return ""
 }
 
-func _Controller_DeleteVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DeleteVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *GetMetadataDeltaRequest) GetTargetSnapshotId() string {
+	if x != nil {
+		return x.TargetSnapshotId
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).DeleteVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/DeleteVolume",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).DeleteVolume(ctx, req.(*DeleteVolumeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+	return ""
 }
 
-func _Controller_ControllerPublishVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ControllerPublishVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *GetMetadataDeltaRequest) GetStartingOffset() int64 {
+	if x != nil {
+		return x.StartingOffset
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ControllerPublishVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ControllerPublishVolume",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ControllerPublishVolume(ctx, req.(*ControllerPublishVolumeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+	return 0
 }
 
-func _Controller_ControllerUnpublishVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ControllerUnpublishVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *GetMetadataDeltaRequest) GetMaxResults() int32 {
+	if x != nil {
+		return x.MaxResults
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ControllerUnpublishVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ControllerUnpublishVolume",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ControllerUnpublishVolume(ctx, req.(*ControllerUnpublishVolumeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+	return 0
 }
 
-func _Controller_ValidateVolumeCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ValidateVolumeCapabilitiesRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *GetMetadataDeltaRequest) GetSecrets() map[string]string {
+	if x != nil {
+		return x.Secrets
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ValidateVolumeCapabilities(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ValidateVolumeCapabilities",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ValidateVolumeCapabilities(ctx, req.(*ValidateVolumeCapabilitiesRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+	return nil
 }
 
-func _Controller_ListVolumes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListVolumesRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ListVolumes(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ListVolumes",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ListVolumes(ctx, req.(*ListVolumesRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+// GetMetadataDeltaResponse messages are returned in a gRPC stream.
+// Cumulatively, they provide information on the data ranges that
+// have changed between the base and target snapshots specified
+// in the GetMetadataDeltaRequest message.
+type GetMetadataDeltaResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// This specifies the style used in the BlockMetadata sequence.
+	// This value must be the same in all such messages returned by
+	// the stream.
+	// If block_metadata_type is FIXED_LENGTH, then the size_bytes field
+	// of each message in the block_metadata list MUST be constant.
+	// This field is REQUIRED.
+	BlockMetadataType BlockMetadataType `protobuf:"varint,1,opt,name=block_metadata_type,json=blockMetadataType,proto3,enum=csi.v1.BlockMetadataType" json:"block_metadata_type,omitempty"`
+	// This returns the capacity of the underlying volume in bytes.
+	// This value must be the same in all such messages returned by
+	// the stream.
+	// This field is REQUIRED.
+	VolumeCapacityBytes int64 `protobuf:"varint,2,opt,name=volume_capacity_bytes,json=volumeCapacityBytes,proto3" json:"volume_capacity_bytes,omitempty"`
+	// This is a list of data range tuples.
+	// If the value of max_results in the GetMetadataDeltaRequest message
+	// is greater than zero, then the number of entries in this list MUST
+	// be less than or equal to that value.
+	// The SP MUST respect the value of starting_offset in the request.
+	// The byte_offset fields of adjacent BlockMetadata messages
+	// MUST be strictly increasing and messages MUST NOT overlap:
+	// i.e. for any two BlockMetadata messages, A and B, if A is returned
+	// before B, then (A.byte_offset + A.size_bytes <= B.byte_offset)
+	// MUST be true.
+	// This MUST also be true if A and B are from block_metadata lists in
+	// different GetMetadataDeltaResponse messages in the gRPC stream.
+	// This field is OPTIONAL.
+	BlockMetadata []*BlockMetadata `protobuf:"bytes,3,rep,name=block_metadata,json=blockMetadata,proto3" json:"block_metadata,omitempty"`
 }
 
-func _Controller_GetCapacity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetCapacityRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *GetMetadataDeltaResponse) Reset() {
+	*x = GetMetadataDeltaResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[76]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).GetCapacity(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/GetCapacity",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).GetCapacity(ctx, req.(*GetCapacityRequest))
-	}
-	return interceptor(ctx, in, info, handler)
 }
 
-func _Controller_ControllerGetCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ControllerGetCapabilitiesRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ControllerGetCapabilities(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ControllerGetCapabilities",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ControllerGetCapabilities(ctx, req.(*ControllerGetCapabilitiesRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+func (x *GetMetadataDeltaResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func _Controller_CreateSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CreateSnapshotRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ControllerServer).CreateSnapshot(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/CreateSnapshot",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).CreateSnapshot(ctx, req.(*CreateSnapshotRequest))
+func (*GetMetadataDeltaResponse) ProtoMessage() {}
+
+func (x *GetMetadataDeltaResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[76]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return interceptor(ctx, in, info, handler)
+	return mi.MessageOf(x)
 }
 
-func _Controller_DeleteSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DeleteSnapshotRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(ControllerServer).DeleteSnapshot(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/DeleteSnapshot",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).DeleteSnapshot(ctx, req.(*DeleteSnapshotRequest))
+// Deprecated: Use GetMetadataDeltaResponse.ProtoReflect.Descriptor instead.
+func (*GetMetadataDeltaResponse) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{76}
+}
+
+func (x *GetMetadataDeltaResponse) GetBlockMetadataType() BlockMetadataType {
+	if x != nil {
+		return x.BlockMetadataType
 	}
-	return interceptor(ctx, in, info, handler)
+	return BlockMetadataType_UNKNOWN
 }
 
-func _Controller_ListSnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListSnapshotsRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *GetMetadataDeltaResponse) GetVolumeCapacityBytes() int64 {
+	if x != nil {
+		return x.VolumeCapacityBytes
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ListSnapshots(ctx, in)
+	return 0
+}
+
+func (x *GetMetadataDeltaResponse) GetBlockMetadata() []*BlockMetadata {
+	if x != nil {
+		return x.BlockMetadata
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ListSnapshots",
+	return nil
+}
+
+type PluginCapability_Service struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Type PluginCapability_Service_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.PluginCapability_Service_Type" json:"type,omitempty"`
+}
+
+func (x *PluginCapability_Service) Reset() {
+	*x = PluginCapability_Service{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[78]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ListSnapshots(ctx, req.(*ListSnapshotsRequest))
+}
+
+func (x *PluginCapability_Service) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PluginCapability_Service) ProtoMessage() {}
+
+func (x *PluginCapability_Service) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[78]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return interceptor(ctx, in, info, handler)
+	return mi.MessageOf(x)
 }
 
-func _Controller_ControllerExpandVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ControllerExpandVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+// Deprecated: Use PluginCapability_Service.ProtoReflect.Descriptor instead.
+func (*PluginCapability_Service) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{4, 0}
+}
+
+func (x *PluginCapability_Service) GetType() PluginCapability_Service_Type {
+	if x != nil {
+		return x.Type
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ControllerExpandVolume(ctx, in)
+	return PluginCapability_Service_UNKNOWN
+}
+
+type PluginCapability_VolumeExpansion struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Type PluginCapability_VolumeExpansion_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.PluginCapability_VolumeExpansion_Type" json:"type,omitempty"`
+}
+
+func (x *PluginCapability_VolumeExpansion) Reset() {
+	*x = PluginCapability_VolumeExpansion{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[79]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ControllerExpandVolume",
+}
+
+func (x *PluginCapability_VolumeExpansion) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PluginCapability_VolumeExpansion) ProtoMessage() {}
+
+func (x *PluginCapability_VolumeExpansion) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[79]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ControllerExpandVolume(ctx, req.(*ControllerExpandVolumeRequest))
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use PluginCapability_VolumeExpansion.ProtoReflect.Descriptor instead.
+func (*PluginCapability_VolumeExpansion) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{4, 1}
+}
+
+func (x *PluginCapability_VolumeExpansion) GetType() PluginCapability_VolumeExpansion_Type {
+	if x != nil {
+		return x.Type
 	}
-	return interceptor(ctx, in, info, handler)
+	return PluginCapability_VolumeExpansion_UNKNOWN
 }
 
-func _Controller_ControllerGetVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ControllerGetVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+type VolumeContentSource_SnapshotSource struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Contains identity information for the existing source snapshot.
+	// This field is REQUIRED. Plugin is REQUIRED to support creating
+	// volume from snapshot if it supports the capability
+	// CREATE_DELETE_SNAPSHOT.
+	SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
+}
+
+func (x *VolumeContentSource_SnapshotSource) Reset() {
+	*x = VolumeContentSource_SnapshotSource{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[83]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ControllerGetVolume(ctx, in)
+}
+
+func (x *VolumeContentSource_SnapshotSource) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*VolumeContentSource_SnapshotSource) ProtoMessage() {}
+
+func (x *VolumeContentSource_SnapshotSource) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[83]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ControllerGetVolume",
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use VolumeContentSource_SnapshotSource.ProtoReflect.Descriptor instead.
+func (*VolumeContentSource_SnapshotSource) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{8, 0}
+}
+
+func (x *VolumeContentSource_SnapshotSource) GetSnapshotId() string {
+	if x != nil {
+		return x.SnapshotId
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ControllerGetVolume(ctx, req.(*ControllerGetVolumeRequest))
+	return ""
+}
+
+type VolumeContentSource_VolumeSource struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Contains identity information for the existing source volume.
+	// This field is REQUIRED. Plugins reporting CLONE_VOLUME
+	// capability MUST support creating a volume from another volume.
+	VolumeId string `protobuf:"bytes,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
+}
+
+func (x *VolumeContentSource_VolumeSource) Reset() {
+	*x = VolumeContentSource_VolumeSource{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[84]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return interceptor(ctx, in, info, handler)
 }
 
-func _Controller_ControllerModifyVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ControllerModifyVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *VolumeContentSource_VolumeSource) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*VolumeContentSource_VolumeSource) ProtoMessage() {}
+
+func (x *VolumeContentSource_VolumeSource) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[84]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	if interceptor == nil {
-		return srv.(ControllerServer).ControllerModifyVolume(ctx, in)
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use VolumeContentSource_VolumeSource.ProtoReflect.Descriptor instead.
+func (*VolumeContentSource_VolumeSource) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{8, 1}
+}
+
+func (x *VolumeContentSource_VolumeSource) GetVolumeId() string {
+	if x != nil {
+		return x.VolumeId
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Controller/ControllerModifyVolume",
+	return ""
+}
+
+// Indicate that the volume will be accessed via the block device API.
+type VolumeCapability_BlockVolume struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *VolumeCapability_BlockVolume) Reset() {
+	*x = VolumeCapability_BlockVolume{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[85]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ControllerServer).ControllerModifyVolume(ctx, req.(*ControllerModifyVolumeRequest))
+}
+
+func (x *VolumeCapability_BlockVolume) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*VolumeCapability_BlockVolume) ProtoMessage() {}
+
+func (x *VolumeCapability_BlockVolume) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[85]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return interceptor(ctx, in, info, handler)
+	return mi.MessageOf(x)
 }
 
-var _Controller_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "csi.v1.Controller",
-	HandlerType: (*ControllerServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "CreateVolume",
-			Handler:    _Controller_CreateVolume_Handler,
-		},
-		{
-			MethodName: "DeleteVolume",
-			Handler:    _Controller_DeleteVolume_Handler,
-		},
-		{
-			MethodName: "ControllerPublishVolume",
-			Handler:    _Controller_ControllerPublishVolume_Handler,
-		},
-		{
-			MethodName: "ControllerUnpublishVolume",
-			Handler:    _Controller_ControllerUnpublishVolume_Handler,
-		},
-		{
-			MethodName: "ValidateVolumeCapabilities",
-			Handler:    _Controller_ValidateVolumeCapabilities_Handler,
-		},
-		{
-			MethodName: "ListVolumes",
-			Handler:    _Controller_ListVolumes_Handler,
-		},
-		{
-			MethodName: "GetCapacity",
-			Handler:    _Controller_GetCapacity_Handler,
-		},
-		{
-			MethodName: "ControllerGetCapabilities",
-			Handler:    _Controller_ControllerGetCapabilities_Handler,
-		},
-		{
-			MethodName: "CreateSnapshot",
-			Handler:    _Controller_CreateSnapshot_Handler,
-		},
-		{
-			MethodName: "DeleteSnapshot",
-			Handler:    _Controller_DeleteSnapshot_Handler,
-		},
-		{
-			MethodName: "ListSnapshots",
-			Handler:    _Controller_ListSnapshots_Handler,
-		},
-		{
-			MethodName: "ControllerExpandVolume",
-			Handler:    _Controller_ControllerExpandVolume_Handler,
-		},
-		{
-			MethodName: "ControllerGetVolume",
-			Handler:    _Controller_ControllerGetVolume_Handler,
-		},
-		{
-			MethodName: "ControllerModifyVolume",
-			Handler:    _Controller_ControllerModifyVolume_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "github.com/container-storage-interface/spec/csi.proto",
+// Deprecated: Use VolumeCapability_BlockVolume.ProtoReflect.Descriptor instead.
+func (*VolumeCapability_BlockVolume) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{10, 0}
 }
 
-// GroupControllerClient is the client API for GroupController service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type GroupControllerClient interface {
-	GroupControllerGetCapabilities(ctx context.Context, in *GroupControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*GroupControllerGetCapabilitiesResponse, error)
-	CreateVolumeGroupSnapshot(ctx context.Context, in *CreateVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*CreateVolumeGroupSnapshotResponse, error)
-	DeleteVolumeGroupSnapshot(ctx context.Context, in *DeleteVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*DeleteVolumeGroupSnapshotResponse, error)
-	GetVolumeGroupSnapshot(ctx context.Context, in *GetVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*GetVolumeGroupSnapshotResponse, error)
+// Indicate that the volume will be accessed via the filesystem API.
+type VolumeCapability_MountVolume struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The filesystem type. This field is OPTIONAL.
+	// An empty string is equal to an unspecified field value.
+	FsType string `protobuf:"bytes,1,opt,name=fs_type,json=fsType,proto3" json:"fs_type,omitempty"`
+	// The mount options that can be used for the volume. This field is
+	// OPTIONAL. `mount_flags` MAY contain sensitive information.
+	// Therefore, the CO and the Plugin MUST NOT leak this information
+	// to untrusted entities. The total size of this repeated field
+	// SHALL NOT exceed 4 KiB.
+	MountFlags []string `protobuf:"bytes,2,rep,name=mount_flags,json=mountFlags,proto3" json:"mount_flags,omitempty"`
+	// If SP has VOLUME_MOUNT_GROUP node capability and CO provides
+	// this field then SP MUST ensure that the volume_mount_group
+	// parameter is passed as the group identifier to the underlying
+	// operating system mount system call, with the understanding
+	// that the set of available mount call parameters and/or
+	// mount implementations may vary across operating systems.
+	// Additionally, new file and/or directory entries written to
+	// the underlying filesystem SHOULD be permission-labeled in such a
+	// manner, unless otherwise modified by a workload, that they are
+	// both readable and writable by said mount group identifier.
+	// This is an OPTIONAL field.
+	VolumeMountGroup string `protobuf:"bytes,3,opt,name=volume_mount_group,json=volumeMountGroup,proto3" json:"volume_mount_group,omitempty"`
 }
 
-type groupControllerClient struct {
-	cc *grpc.ClientConn
+func (x *VolumeCapability_MountVolume) Reset() {
+	*x = VolumeCapability_MountVolume{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[86]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func NewGroupControllerClient(cc *grpc.ClientConn) GroupControllerClient {
-	return &groupControllerClient{cc}
+func (x *VolumeCapability_MountVolume) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func (c *groupControllerClient) GroupControllerGetCapabilities(ctx context.Context, in *GroupControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*GroupControllerGetCapabilitiesResponse, error) {
-	out := new(GroupControllerGetCapabilitiesResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.GroupController/GroupControllerGetCapabilities", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (*VolumeCapability_MountVolume) ProtoMessage() {}
+
+func (x *VolumeCapability_MountVolume) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[86]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return out, nil
+	return mi.MessageOf(x)
 }
 
-func (c *groupControllerClient) CreateVolumeGroupSnapshot(ctx context.Context, in *CreateVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*CreateVolumeGroupSnapshotResponse, error) {
-	out := new(CreateVolumeGroupSnapshotResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.GroupController/CreateVolumeGroupSnapshot", in, out, opts...)
-	if err != nil {
-		return nil, err
+// Deprecated: Use VolumeCapability_MountVolume.ProtoReflect.Descriptor instead.
+func (*VolumeCapability_MountVolume) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{10, 1}
+}
+
+func (x *VolumeCapability_MountVolume) GetFsType() string {
+	if x != nil {
+		return x.FsType
 	}
-	return out, nil
+	return ""
 }
 
-func (c *groupControllerClient) DeleteVolumeGroupSnapshot(ctx context.Context, in *DeleteVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*DeleteVolumeGroupSnapshotResponse, error) {
-	out := new(DeleteVolumeGroupSnapshotResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.GroupController/DeleteVolumeGroupSnapshot", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *VolumeCapability_MountVolume) GetMountFlags() []string {
+	if x != nil {
+		return x.MountFlags
 	}
-	return out, nil
+	return nil
 }
 
-func (c *groupControllerClient) GetVolumeGroupSnapshot(ctx context.Context, in *GetVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*GetVolumeGroupSnapshotResponse, error) {
-	out := new(GetVolumeGroupSnapshotResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.GroupController/GetVolumeGroupSnapshot", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *VolumeCapability_MountVolume) GetVolumeMountGroup() string {
+	if x != nil {
+		return x.VolumeMountGroup
 	}
-	return out, nil
+	return ""
 }
 
-// GroupControllerServer is the server API for GroupController service.
-type GroupControllerServer interface {
-	GroupControllerGetCapabilities(context.Context, *GroupControllerGetCapabilitiesRequest) (*GroupControllerGetCapabilitiesResponse, error)
-	CreateVolumeGroupSnapshot(context.Context, *CreateVolumeGroupSnapshotRequest) (*CreateVolumeGroupSnapshotResponse, error)
-	DeleteVolumeGroupSnapshot(context.Context, *DeleteVolumeGroupSnapshotRequest) (*DeleteVolumeGroupSnapshotResponse, error)
-	GetVolumeGroupSnapshot(context.Context, *GetVolumeGroupSnapshotRequest) (*GetVolumeGroupSnapshotResponse, error)
+// Specify how a volume can be accessed.
+type VolumeCapability_AccessMode struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// This field is REQUIRED.
+	Mode VolumeCapability_AccessMode_Mode `protobuf:"varint,1,opt,name=mode,proto3,enum=csi.v1.VolumeCapability_AccessMode_Mode" json:"mode,omitempty"`
 }
 
-// UnimplementedGroupControllerServer can be embedded to have forward compatible implementations.
-type UnimplementedGroupControllerServer struct {
+func (x *VolumeCapability_AccessMode) Reset() {
+	*x = VolumeCapability_AccessMode{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[87]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (*UnimplementedGroupControllerServer) GroupControllerGetCapabilities(ctx context.Context, req *GroupControllerGetCapabilitiesRequest) (*GroupControllerGetCapabilitiesResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GroupControllerGetCapabilities not implemented")
+func (x *VolumeCapability_AccessMode) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (*UnimplementedGroupControllerServer) CreateVolumeGroupSnapshot(ctx context.Context, req *CreateVolumeGroupSnapshotRequest) (*CreateVolumeGroupSnapshotResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CreateVolumeGroupSnapshot not implemented")
+
+func (*VolumeCapability_AccessMode) ProtoMessage() {}
+
+func (x *VolumeCapability_AccessMode) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[87]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
-func (*UnimplementedGroupControllerServer) DeleteVolumeGroupSnapshot(ctx context.Context, req *DeleteVolumeGroupSnapshotRequest) (*DeleteVolumeGroupSnapshotResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method DeleteVolumeGroupSnapshot not implemented")
+
+// Deprecated: Use VolumeCapability_AccessMode.ProtoReflect.Descriptor instead.
+func (*VolumeCapability_AccessMode) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{10, 2}
 }
-func (*UnimplementedGroupControllerServer) GetVolumeGroupSnapshot(ctx context.Context, req *GetVolumeGroupSnapshotRequest) (*GetVolumeGroupSnapshotResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetVolumeGroupSnapshot not implemented")
+
+func (x *VolumeCapability_AccessMode) GetMode() VolumeCapability_AccessMode_Mode {
+	if x != nil {
+		return x.Mode
+	}
+	return VolumeCapability_AccessMode_UNKNOWN
 }
 
-func RegisterGroupControllerServer(s *grpc.Server, srv GroupControllerServer) {
-	s.RegisterService(&_GroupController_serviceDesc, srv)
+type ValidateVolumeCapabilitiesResponse_Confirmed struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Volume context validated by the plugin.
+	// This field is OPTIONAL.
+	VolumeContext map[string]string `protobuf:"bytes,1,rep,name=volume_context,json=volumeContext,proto3" json:"volume_context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	// Volume capabilities supported by the plugin.
+	// This field is REQUIRED.
+	VolumeCapabilities []*VolumeCapability `protobuf:"bytes,2,rep,name=volume_capabilities,json=volumeCapabilities,proto3" json:"volume_capabilities,omitempty"`
+	// The volume creation parameters validated by the plugin.
+	// This field is OPTIONAL.
+	Parameters map[string]string `protobuf:"bytes,3,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	// The volume creation mutable_parameters validated by the plugin.
+	// This field is OPTIONAL.
+	MutableParameters map[string]string `protobuf:"bytes,4,rep,name=mutable_parameters,json=mutableParameters,proto3" json:"mutable_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 }
 
-func _GroupController_GroupControllerGetCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GroupControllerGetCapabilitiesRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(GroupControllerServer).GroupControllerGetCapabilities(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.GroupController/GroupControllerGetCapabilities",
+func (x *ValidateVolumeCapabilitiesResponse_Confirmed) Reset() {
+	*x = ValidateVolumeCapabilitiesResponse_Confirmed{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[99]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(GroupControllerServer).GroupControllerGetCapabilities(ctx, req.(*GroupControllerGetCapabilitiesRequest))
-	}
-	return interceptor(ctx, in, info, handler)
 }
 
-func _GroupController_CreateVolumeGroupSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CreateVolumeGroupSnapshotRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(GroupControllerServer).CreateVolumeGroupSnapshot(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.GroupController/CreateVolumeGroupSnapshot",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(GroupControllerServer).CreateVolumeGroupSnapshot(ctx, req.(*CreateVolumeGroupSnapshotRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+func (x *ValidateVolumeCapabilitiesResponse_Confirmed) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func _GroupController_DeleteVolumeGroupSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DeleteVolumeGroupSnapshotRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(GroupControllerServer).DeleteVolumeGroupSnapshot(ctx, in)
+func (*ValidateVolumeCapabilitiesResponse_Confirmed) ProtoMessage() {}
+
+func (x *ValidateVolumeCapabilitiesResponse_Confirmed) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[99]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.GroupController/DeleteVolumeGroupSnapshot",
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ValidateVolumeCapabilitiesResponse_Confirmed.ProtoReflect.Descriptor instead.
+func (*ValidateVolumeCapabilitiesResponse_Confirmed) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{22, 0}
+}
+
+func (x *ValidateVolumeCapabilitiesResponse_Confirmed) GetVolumeContext() map[string]string {
+	if x != nil {
+		return x.VolumeContext
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(GroupControllerServer).DeleteVolumeGroupSnapshot(ctx, req.(*DeleteVolumeGroupSnapshotRequest))
+	return nil
+}
+
+func (x *ValidateVolumeCapabilitiesResponse_Confirmed) GetVolumeCapabilities() []*VolumeCapability {
+	if x != nil {
+		return x.VolumeCapabilities
 	}
-	return interceptor(ctx, in, info, handler)
+	return nil
 }
 
-func _GroupController_GetVolumeGroupSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetVolumeGroupSnapshotRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *ValidateVolumeCapabilitiesResponse_Confirmed) GetParameters() map[string]string {
+	if x != nil {
+		return x.Parameters
 	}
-	if interceptor == nil {
-		return srv.(GroupControllerServer).GetVolumeGroupSnapshot(ctx, in)
+	return nil
+}
+
+func (x *ValidateVolumeCapabilitiesResponse_Confirmed) GetMutableParameters() map[string]string {
+	if x != nil {
+		return x.MutableParameters
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.GroupController/GetVolumeGroupSnapshot",
+	return nil
+}
+
+type ListVolumesResponse_VolumeStatus struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// A list of all `node_id` of nodes that the volume in this entry
+	// is controller published on.
+	// This field is OPTIONAL. If it is not specified and the SP has
+	// the LIST_VOLUMES_PUBLISHED_NODES controller capability, the CO
+	// MAY assume the volume is not controller published to any nodes.
+	// If the field is not specified and the SP does not have the
+	// LIST_VOLUMES_PUBLISHED_NODES controller capability, the CO MUST
+	// not interpret this field.
+	// published_node_ids MAY include nodes not published to or
+	// reported by the SP. The CO MUST be resilient to that.
+	PublishedNodeIds []string `protobuf:"bytes,1,rep,name=published_node_ids,json=publishedNodeIds,proto3" json:"published_node_ids,omitempty"`
+	// Information about the current condition of the volume.
+	// This field is OPTIONAL.
+	// This field MUST be specified if the
+	// VOLUME_CONDITION controller capability is supported.
+	VolumeCondition *VolumeCondition `protobuf:"bytes,2,opt,name=volume_condition,json=volumeCondition,proto3" json:"volume_condition,omitempty"`
+}
+
+func (x *ListVolumesResponse_VolumeStatus) Reset() {
+	*x = ListVolumesResponse_VolumeStatus{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[103]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(GroupControllerServer).GetVolumeGroupSnapshot(ctx, req.(*GetVolumeGroupSnapshotRequest))
+}
+
+func (x *ListVolumesResponse_VolumeStatus) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListVolumesResponse_VolumeStatus) ProtoMessage() {}
+
+func (x *ListVolumesResponse_VolumeStatus) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[103]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return interceptor(ctx, in, info, handler)
+	return mi.MessageOf(x)
 }
 
-var _GroupController_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "csi.v1.GroupController",
-	HandlerType: (*GroupControllerServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "GroupControllerGetCapabilities",
-			Handler:    _GroupController_GroupControllerGetCapabilities_Handler,
-		},
-		{
-			MethodName: "CreateVolumeGroupSnapshot",
-			Handler:    _GroupController_CreateVolumeGroupSnapshot_Handler,
-		},
-		{
-			MethodName: "DeleteVolumeGroupSnapshot",
-			Handler:    _GroupController_DeleteVolumeGroupSnapshot_Handler,
-		},
-		{
-			MethodName: "GetVolumeGroupSnapshot",
-			Handler:    _GroupController_GetVolumeGroupSnapshot_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "github.com/container-storage-interface/spec/csi.proto",
+// Deprecated: Use ListVolumesResponse_VolumeStatus.ProtoReflect.Descriptor instead.
+func (*ListVolumesResponse_VolumeStatus) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{24, 0}
 }
 
-// NodeClient is the client API for Node service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type NodeClient interface {
-	NodeStageVolume(ctx context.Context, in *NodeStageVolumeRequest, opts ...grpc.CallOption) (*NodeStageVolumeResponse, error)
-	NodeUnstageVolume(ctx context.Context, in *NodeUnstageVolumeRequest, opts ...grpc.CallOption) (*NodeUnstageVolumeResponse, error)
-	NodePublishVolume(ctx context.Context, in *NodePublishVolumeRequest, opts ...grpc.CallOption) (*NodePublishVolumeResponse, error)
-	NodeUnpublishVolume(ctx context.Context, in *NodeUnpublishVolumeRequest, opts ...grpc.CallOption) (*NodeUnpublishVolumeResponse, error)
-	NodeGetVolumeStats(ctx context.Context, in *NodeGetVolumeStatsRequest, opts ...grpc.CallOption) (*NodeGetVolumeStatsResponse, error)
-	NodeExpandVolume(ctx context.Context, in *NodeExpandVolumeRequest, opts ...grpc.CallOption) (*NodeExpandVolumeResponse, error)
-	NodeGetCapabilities(ctx context.Context, in *NodeGetCapabilitiesRequest, opts ...grpc.CallOption) (*NodeGetCapabilitiesResponse, error)
-	NodeGetInfo(ctx context.Context, in *NodeGetInfoRequest, opts ...grpc.CallOption) (*NodeGetInfoResponse, error)
+func (x *ListVolumesResponse_VolumeStatus) GetPublishedNodeIds() []string {
+	if x != nil {
+		return x.PublishedNodeIds
+	}
+	return nil
 }
 
-type nodeClient struct {
-	cc *grpc.ClientConn
+func (x *ListVolumesResponse_VolumeStatus) GetVolumeCondition() *VolumeCondition {
+	if x != nil {
+		return x.VolumeCondition
+	}
+	return nil
 }
 
-func NewNodeClient(cc *grpc.ClientConn) NodeClient {
-	return &nodeClient{cc}
+type ListVolumesResponse_Entry struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// This field is REQUIRED
+	Volume *Volume `protobuf:"bytes,1,opt,name=volume,proto3" json:"volume,omitempty"`
+	// This field is OPTIONAL. This field MUST be specified if the
+	// LIST_VOLUMES_PUBLISHED_NODES controller capability is
+	// supported.
+	Status *ListVolumesResponse_VolumeStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
 }
 
-func (c *nodeClient) NodeStageVolume(ctx context.Context, in *NodeStageVolumeRequest, opts ...grpc.CallOption) (*NodeStageVolumeResponse, error) {
-	out := new(NodeStageVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Node/NodeStageVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *ListVolumesResponse_Entry) Reset() {
+	*x = ListVolumesResponse_Entry{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[104]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return out, nil
 }
 
-func (c *nodeClient) NodeUnstageVolume(ctx context.Context, in *NodeUnstageVolumeRequest, opts ...grpc.CallOption) (*NodeUnstageVolumeResponse, error) {
-	out := new(NodeUnstageVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Node/NodeUnstageVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *ListVolumesResponse_Entry) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListVolumesResponse_Entry) ProtoMessage() {}
+
+func (x *ListVolumesResponse_Entry) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[104]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return out, nil
+	return mi.MessageOf(x)
 }
 
-func (c *nodeClient) NodePublishVolume(ctx context.Context, in *NodePublishVolumeRequest, opts ...grpc.CallOption) (*NodePublishVolumeResponse, error) {
-	out := new(NodePublishVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Node/NodePublishVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+// Deprecated: Use ListVolumesResponse_Entry.ProtoReflect.Descriptor instead.
+func (*ListVolumesResponse_Entry) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{24, 1}
+}
+
+func (x *ListVolumesResponse_Entry) GetVolume() *Volume {
+	if x != nil {
+		return x.Volume
 	}
-	return out, nil
+	return nil
 }
 
-func (c *nodeClient) NodeUnpublishVolume(ctx context.Context, in *NodeUnpublishVolumeRequest, opts ...grpc.CallOption) (*NodeUnpublishVolumeResponse, error) {
-	out := new(NodeUnpublishVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Node/NodeUnpublishVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *ListVolumesResponse_Entry) GetStatus() *ListVolumesResponse_VolumeStatus {
+	if x != nil {
+		return x.Status
 	}
-	return out, nil
+	return nil
 }
 
-func (c *nodeClient) NodeGetVolumeStats(ctx context.Context, in *NodeGetVolumeStatsRequest, opts ...grpc.CallOption) (*NodeGetVolumeStatsResponse, error) {
-	out := new(NodeGetVolumeStatsResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Node/NodeGetVolumeStats", in, out, opts...)
-	if err != nil {
-		return nil, err
+type ControllerGetVolumeResponse_VolumeStatus struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// A list of all the `node_id` of nodes that this volume is
+	// controller published on.
+	// This field is OPTIONAL.
+	// This field MUST be specified if the LIST_VOLUMES_PUBLISHED_NODES
+	// controller capability is supported.
+	// published_node_ids MAY include nodes not published to or
+	// reported by the SP. The CO MUST be resilient to that.
+	PublishedNodeIds []string `protobuf:"bytes,1,rep,name=published_node_ids,json=publishedNodeIds,proto3" json:"published_node_ids,omitempty"`
+	// Information about the current condition of the volume.
+	// This field is OPTIONAL.
+	// This field MUST be specified if the
+	// VOLUME_CONDITION controller capability is supported.
+	VolumeCondition *VolumeCondition `protobuf:"bytes,2,opt,name=volume_condition,json=volumeCondition,proto3" json:"volume_condition,omitempty"`
+}
+
+func (x *ControllerGetVolumeResponse_VolumeStatus) Reset() {
+	*x = ControllerGetVolumeResponse_VolumeStatus{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[105]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return out, nil
 }
 
-func (c *nodeClient) NodeExpandVolume(ctx context.Context, in *NodeExpandVolumeRequest, opts ...grpc.CallOption) (*NodeExpandVolumeResponse, error) {
-	out := new(NodeExpandVolumeResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Node/NodeExpandVolume", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *ControllerGetVolumeResponse_VolumeStatus) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ControllerGetVolumeResponse_VolumeStatus) ProtoMessage() {}
+
+func (x *ControllerGetVolumeResponse_VolumeStatus) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[105]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return out, nil
+	return mi.MessageOf(x)
 }
 
-func (c *nodeClient) NodeGetCapabilities(ctx context.Context, in *NodeGetCapabilitiesRequest, opts ...grpc.CallOption) (*NodeGetCapabilitiesResponse, error) {
-	out := new(NodeGetCapabilitiesResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Node/NodeGetCapabilities", in, out, opts...)
-	if err != nil {
-		return nil, err
+// Deprecated: Use ControllerGetVolumeResponse_VolumeStatus.ProtoReflect.Descriptor instead.
+func (*ControllerGetVolumeResponse_VolumeStatus) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{26, 0}
+}
+
+func (x *ControllerGetVolumeResponse_VolumeStatus) GetPublishedNodeIds() []string {
+	if x != nil {
+		return x.PublishedNodeIds
 	}
-	return out, nil
+	return nil
 }
 
-func (c *nodeClient) NodeGetInfo(ctx context.Context, in *NodeGetInfoRequest, opts ...grpc.CallOption) (*NodeGetInfoResponse, error) {
-	out := new(NodeGetInfoResponse)
-	err := c.cc.Invoke(ctx, "/csi.v1.Node/NodeGetInfo", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (x *ControllerGetVolumeResponse_VolumeStatus) GetVolumeCondition() *VolumeCondition {
+	if x != nil {
+		return x.VolumeCondition
 	}
-	return out, nil
+	return nil
 }
 
-// NodeServer is the server API for Node service.
-type NodeServer interface {
-	NodeStageVolume(context.Context, *NodeStageVolumeRequest) (*NodeStageVolumeResponse, error)
-	NodeUnstageVolume(context.Context, *NodeUnstageVolumeRequest) (*NodeUnstageVolumeResponse, error)
-	NodePublishVolume(context.Context, *NodePublishVolumeRequest) (*NodePublishVolumeResponse, error)
-	NodeUnpublishVolume(context.Context, *NodeUnpublishVolumeRequest) (*NodeUnpublishVolumeResponse, error)
-	NodeGetVolumeStats(context.Context, *NodeGetVolumeStatsRequest) (*NodeGetVolumeStatsResponse, error)
-	NodeExpandVolume(context.Context, *NodeExpandVolumeRequest) (*NodeExpandVolumeResponse, error)
-	NodeGetCapabilities(context.Context, *NodeGetCapabilitiesRequest) (*NodeGetCapabilitiesResponse, error)
-	NodeGetInfo(context.Context, *NodeGetInfoRequest) (*NodeGetInfoResponse, error)
+type ControllerServiceCapability_RPC struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Type ControllerServiceCapability_RPC_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.ControllerServiceCapability_RPC_Type" json:"type,omitempty"`
 }
 
-// UnimplementedNodeServer can be embedded to have forward compatible implementations.
-type UnimplementedNodeServer struct {
+func (x *ControllerServiceCapability_RPC) Reset() {
+	*x = ControllerServiceCapability_RPC{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[109]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
 
-func (*UnimplementedNodeServer) NodeStageVolume(ctx context.Context, req *NodeStageVolumeRequest) (*NodeStageVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method NodeStageVolume not implemented")
+func (x *ControllerServiceCapability_RPC) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (*UnimplementedNodeServer) NodeUnstageVolume(ctx context.Context, req *NodeUnstageVolumeRequest) (*NodeUnstageVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method NodeUnstageVolume not implemented")
+
+func (*ControllerServiceCapability_RPC) ProtoMessage() {}
+
+func (x *ControllerServiceCapability_RPC) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[109]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
-func (*UnimplementedNodeServer) NodePublishVolume(ctx context.Context, req *NodePublishVolumeRequest) (*NodePublishVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method NodePublishVolume not implemented")
+
+// Deprecated: Use ControllerServiceCapability_RPC.ProtoReflect.Descriptor instead.
+func (*ControllerServiceCapability_RPC) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{33, 0}
 }
-func (*UnimplementedNodeServer) NodeUnpublishVolume(ctx context.Context, req *NodeUnpublishVolumeRequest) (*NodeUnpublishVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method NodeUnpublishVolume not implemented")
+
+func (x *ControllerServiceCapability_RPC) GetType() ControllerServiceCapability_RPC_Type {
+	if x != nil {
+		return x.Type
+	}
+	return ControllerServiceCapability_RPC_UNKNOWN
 }
-func (*UnimplementedNodeServer) NodeGetVolumeStats(ctx context.Context, req *NodeGetVolumeStatsRequest) (*NodeGetVolumeStatsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method NodeGetVolumeStats not implemented")
+
+type ListSnapshotsResponse_Entry struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
 }
-func (*UnimplementedNodeServer) NodeExpandVolume(ctx context.Context, req *NodeExpandVolumeRequest) (*NodeExpandVolumeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method NodeExpandVolume not implemented")
+
+func (x *ListSnapshotsResponse_Entry) Reset() {
+	*x = ListSnapshotsResponse_Entry{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[114]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (*UnimplementedNodeServer) NodeGetCapabilities(ctx context.Context, req *NodeGetCapabilitiesRequest) (*NodeGetCapabilitiesResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method NodeGetCapabilities not implemented")
+
+func (x *ListSnapshotsResponse_Entry) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (*UnimplementedNodeServer) NodeGetInfo(ctx context.Context, req *NodeGetInfoRequest) (*NodeGetInfoResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method NodeGetInfo not implemented")
+
+func (*ListSnapshotsResponse_Entry) ProtoMessage() {}
+
+func (x *ListSnapshotsResponse_Entry) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[114]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-func RegisterNodeServer(s *grpc.Server, srv NodeServer) {
-	s.RegisterService(&_Node_serviceDesc, srv)
+// Deprecated: Use ListSnapshotsResponse_Entry.ProtoReflect.Descriptor instead.
+func (*ListSnapshotsResponse_Entry) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{40, 0}
 }
 
-func _Node_NodeStageVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(NodeStageVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServer).NodeStageVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Node/NodeStageVolume",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServer).NodeStageVolume(ctx, req.(*NodeStageVolumeRequest))
+func (x *ListSnapshotsResponse_Entry) GetSnapshot() *Snapshot {
+	if x != nil {
+		return x.Snapshot
 	}
-	return interceptor(ctx, in, info, handler)
+	return nil
 }
 
-func _Node_NodeUnstageVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(NodeUnstageVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServer).NodeUnstageVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Node/NodeUnstageVolume",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServer).NodeUnstageVolume(ctx, req.(*NodeUnstageVolumeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+type NodeServiceCapability_RPC struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Type NodeServiceCapability_RPC_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.NodeServiceCapability_RPC_Type" json:"type,omitempty"`
 }
 
-func _Node_NodePublishVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(NodePublishVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServer).NodePublishVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Node/NodePublishVolume",
+func (x *NodeServiceCapability_RPC) Reset() {
+	*x = NodeServiceCapability_RPC{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[122]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServer).NodePublishVolume(ctx, req.(*NodePublishVolumeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
 }
 
-func _Node_NodeUnpublishVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(NodeUnpublishVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServer).NodeUnpublishVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Node/NodeUnpublishVolume",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServer).NodeUnpublishVolume(ctx, req.(*NodeUnpublishVolumeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+func (x *NodeServiceCapability_RPC) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func _Node_NodeGetVolumeStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(NodeGetVolumeStatsRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServer).NodeGetVolumeStats(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Node/NodeGetVolumeStats",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServer).NodeGetVolumeStats(ctx, req.(*NodeGetVolumeStatsRequest))
+func (*NodeServiceCapability_RPC) ProtoMessage() {}
+
+func (x *NodeServiceCapability_RPC) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[122]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return interceptor(ctx, in, info, handler)
+	return mi.MessageOf(x)
 }
 
-func _Node_NodeExpandVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(NodeExpandVolumeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServer).NodeExpandVolume(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Node/NodeExpandVolume",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServer).NodeExpandVolume(ctx, req.(*NodeExpandVolumeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+// Deprecated: Use NodeServiceCapability_RPC.ProtoReflect.Descriptor instead.
+func (*NodeServiceCapability_RPC) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{57, 0}
 }
 
-func _Node_NodeGetCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(NodeGetCapabilitiesRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+func (x *NodeServiceCapability_RPC) GetType() NodeServiceCapability_RPC_Type {
+	if x != nil {
+		return x.Type
 	}
-	if interceptor == nil {
-		return srv.(NodeServer).NodeGetCapabilities(ctx, in)
+	return NodeServiceCapability_RPC_UNKNOWN
+}
+
+type GroupControllerServiceCapability_RPC struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Type GroupControllerServiceCapability_RPC_Type `protobuf:"varint,1,opt,name=type,proto3,enum=csi.v1.GroupControllerServiceCapability_RPC_Type" json:"type,omitempty"`
+}
+
+func (x *GroupControllerServiceCapability_RPC) Reset() {
+	*x = GroupControllerServiceCapability_RPC{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_csi_proto_msgTypes[124]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Node/NodeGetCapabilities",
+}
+
+func (x *GroupControllerServiceCapability_RPC) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GroupControllerServiceCapability_RPC) ProtoMessage() {}
+
+func (x *GroupControllerServiceCapability_RPC) ProtoReflect() protoreflect.Message {
+	mi := &file_csi_proto_msgTypes[124]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServer).NodeGetCapabilities(ctx, req.(*NodeGetCapabilitiesRequest))
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GroupControllerServiceCapability_RPC.ProtoReflect.Descriptor instead.
+func (*GroupControllerServiceCapability_RPC) Descriptor() ([]byte, []int) {
+	return file_csi_proto_rawDescGZIP(), []int{64, 0}
+}
+
+func (x *GroupControllerServiceCapability_RPC) GetType() GroupControllerServiceCapability_RPC_Type {
+	if x != nil {
+		return x.Type
 	}
-	return interceptor(ctx, in, info, handler)
+	return GroupControllerServiceCapability_RPC_UNKNOWN
 }
 
-func _Node_NodeGetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(NodeGetInfoRequest)
-	if err := dec(in); err != nil {
-		return nil, err
+var file_csi_proto_extTypes = []protoimpl.ExtensionInfo{
+	{
+		ExtendedType:  (*descriptorpb.EnumOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1060,
+		Name:          "csi.v1.alpha_enum",
+		Tag:           "varint,1060,opt,name=alpha_enum",
+		Filename:      "csi.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.EnumValueOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1060,
+		Name:          "csi.v1.alpha_enum_value",
+		Tag:           "varint,1060,opt,name=alpha_enum_value",
+		Filename:      "csi.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.FieldOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1059,
+		Name:          "csi.v1.csi_secret",
+		Tag:           "varint,1059,opt,name=csi_secret",
+		Filename:      "csi.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.FieldOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1060,
+		Name:          "csi.v1.alpha_field",
+		Tag:           "varint,1060,opt,name=alpha_field",
+		Filename:      "csi.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1060,
+		Name:          "csi.v1.alpha_message",
+		Tag:           "varint,1060,opt,name=alpha_message",
+		Filename:      "csi.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.MethodOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1060,
+		Name:          "csi.v1.alpha_method",
+		Tag:           "varint,1060,opt,name=alpha_method",
+		Filename:      "csi.proto",
+	},
+	{
+		ExtendedType:  (*descriptorpb.ServiceOptions)(nil),
+		ExtensionType: (*bool)(nil),
+		Field:         1060,
+		Name:          "csi.v1.alpha_service",
+		Tag:           "varint,1060,opt,name=alpha_service",
+		Filename:      "csi.proto",
+	},
+}
+
+// Extension fields to descriptorpb.EnumOptions.
+var (
+	// Indicates that this enum is OPTIONAL and part of an experimental
+	// API that may be deprecated and eventually removed between minor
+	// releases.
+	//
+	// optional bool alpha_enum = 1060;
+	E_AlphaEnum = &file_csi_proto_extTypes[0]
+)
+
+// Extension fields to descriptorpb.EnumValueOptions.
+var (
+	// Indicates that this enum value is OPTIONAL and part of an
+	// experimental API that may be deprecated and eventually removed
+	// between minor releases.
+	//
+	// optional bool alpha_enum_value = 1060;
+	E_AlphaEnumValue = &file_csi_proto_extTypes[1]
+)
+
+// Extension fields to descriptorpb.FieldOptions.
+var (
+	// Indicates that a field MAY contain information that is sensitive
+	// and MUST be treated as such (e.g. not logged).
+	//
+	// optional bool csi_secret = 1059;
+	E_CsiSecret = &file_csi_proto_extTypes[2]
+	// Indicates that this field is OPTIONAL and part of an experimental
+	// API that may be deprecated and eventually removed between minor
+	// releases.
+	//
+	// optional bool alpha_field = 1060;
+	E_AlphaField = &file_csi_proto_extTypes[3]
+)
+
+// Extension fields to descriptorpb.MessageOptions.
+var (
+	// Indicates that this message is OPTIONAL and part of an experimental
+	// API that may be deprecated and eventually removed between minor
+	// releases.
+	//
+	// optional bool alpha_message = 1060;
+	E_AlphaMessage = &file_csi_proto_extTypes[4]
+)
+
+// Extension fields to descriptorpb.MethodOptions.
+var (
+	// Indicates that this method is OPTIONAL and part of an experimental
+	// API that may be deprecated and eventually removed between minor
+	// releases.
+	//
+	// optional bool alpha_method = 1060;
+	E_AlphaMethod = &file_csi_proto_extTypes[5]
+)
+
+// Extension fields to descriptorpb.ServiceOptions.
+var (
+	// Indicates that this service is OPTIONAL and part of an experimental
+	// API that may be deprecated and eventually removed between minor
+	// releases.
+	//
+	// optional bool alpha_service = 1060;
+	E_AlphaService = &file_csi_proto_extTypes[6]
+)
+
+var File_csi_proto protoreflect.FileDescriptor
+
+var file_csi_proto_rawDesc = []byte{
+	0x0a, 0x09, 0x63, 0x73, 0x69, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x16, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x50, 0x6c, 0x75,
+	0x67, 0x69, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xd8,
+	0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x49, 0x6e, 0x66, 0x6f,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e,
+	0x76, 0x65, 0x6e, 0x64, 0x6f, 0x72, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x76, 0x65, 0x6e, 0x64, 0x6f, 0x72, 0x56, 0x65, 0x72, 0x73,
+	0x69, 0x6f, 0x6e, 0x12, 0x47, 0x0a, 0x08, 0x6d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x18,
+	0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47,
+	0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x52, 0x08, 0x6d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x1a, 0x3b, 0x0a, 0x0d,
+	0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x1e, 0x0a, 0x1c, 0x47, 0x65, 0x74,
+	0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69,
+	0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x5d, 0x0a, 0x1d, 0x47, 0x65, 0x74,
+	0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69,
+	0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, 0x0a, 0x0c, 0x63, 0x61,
+	0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x18, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e,
+	0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x61,
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x91, 0x04, 0x0a, 0x10, 0x50, 0x6c, 0x75,
+	0x67, 0x69, 0x6e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x3c, 0x0a,
+	0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x61,
+	0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
+	0x48, 0x00, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x55, 0x0a, 0x10, 0x76,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50,
+	0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x48,
+	0x00, 0x52, 0x0f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69,
+	0x6f, 0x6e, 0x1a, 0xda, 0x01, 0x0a, 0x07, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x39,
+	0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x63,
+	0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x61, 0x70, 0x61,
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x54,
+	0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x93, 0x01, 0x0a, 0x04, 0x54, 0x79,
+	0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12,
+	0x16, 0x0a, 0x12, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x4f, 0x4c, 0x4c, 0x45, 0x52, 0x5f, 0x53, 0x45,
+	0x52, 0x56, 0x49, 0x43, 0x45, 0x10, 0x01, 0x12, 0x24, 0x0a, 0x20, 0x56, 0x4f, 0x4c, 0x55, 0x4d,
+	0x45, 0x5f, 0x41, 0x43, 0x43, 0x45, 0x53, 0x53, 0x49, 0x42, 0x49, 0x4c, 0x49, 0x54, 0x59, 0x5f,
+	0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, 0x49, 0x4e, 0x54, 0x53, 0x10, 0x02, 0x12, 0x1c, 0x0a,
+	0x18, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x4f, 0x4c, 0x4c, 0x45,
+	0x52, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x10, 0x03, 0x12, 0x22, 0x0a, 0x19, 0x53,
+	0x4e, 0x41, 0x50, 0x53, 0x48, 0x4f, 0x54, 0x5f, 0x4d, 0x45, 0x54, 0x41, 0x44, 0x41, 0x54, 0x41,
+	0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x10, 0x04, 0x1a, 0x03, 0xa0, 0x42, 0x01, 0x1a,
+	0x82, 0x01, 0x0a, 0x0f, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0e, 0x32, 0x2d, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69,
+	0x6e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x54, 0x79, 0x70, 0x65,
+	0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b,
+	0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x4f,
+	0x4e, 0x4c, 0x49, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4f, 0x46, 0x46, 0x4c, 0x49,
+	0x4e, 0x45, 0x10, 0x02, 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x0e, 0x0a, 0x0c,
+	0x50, 0x72, 0x6f, 0x62, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x41, 0x0a, 0x0d,
+	0x50, 0x72, 0x6f, 0x62, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a,
+	0x05, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42,
+	0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x72, 0x65, 0x61, 0x64, 0x79, 0x22,
+	0x9e, 0x06, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3c, 0x0a, 0x0e, 0x63,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x61, 0x70,
+	0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0d, 0x63, 0x61, 0x70, 0x61,
+	0x63, 0x69, 0x74, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x49, 0x0a, 0x13, 0x76, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73,
+	0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
+	0x52, 0x12, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
+	0x74, 0x69, 0x65, 0x73, 0x12, 0x4b, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
+	0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
+	0x73, 0x12, 0x47, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61,
+	0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e,
+	0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42,
+	0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x4f, 0x0a, 0x15, 0x76, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x6f, 0x75,
+	0x72, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x73, 0x69, 0x2e,
+	0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
+	0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x13, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f,
+	0x6e, 0x74, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x5a, 0x0a, 0x1a, 0x61,
+	0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x71,
+	0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67,
+	0x79, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x19, 0x61, 0x63,
+	0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x66, 0x0a, 0x12, 0x6d, 0x75, 0x74, 0x61, 0x62,
+	0x6c, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x08, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65,
+	0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x2e, 0x4d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
+	0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0xa0, 0x42, 0x01, 0x52, 0x11, 0x6d, 0x75,
+	0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x1a,
+	0x3d, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3a,
+	0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x75,
+	0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x22, 0x8b, 0x02, 0x0a, 0x13, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65,
+	0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x48, 0x0a, 0x08, 0x73, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
+	0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x48, 0x00, 0x52, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x12, 0x42, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x48, 0x00, 0x52, 0x06,
+	0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x1a, 0x31, 0x0a, 0x0e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x1a, 0x2b, 0x0a, 0x0c, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x76, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3e,
+	0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x22, 0x9f,
+	0x05, 0x0a, 0x10, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c,
+	0x69, 0x74, 0x79, 0x12, 0x3c, 0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x24, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x42, 0x6c, 0x6f,
+	0x63, 0x6b, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x48, 0x00, 0x52, 0x05, 0x62, 0x6c, 0x6f, 0x63,
+	0x6b, 0x12, 0x3c, 0x0a, 0x05, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x24, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x48, 0x00, 0x52, 0x05, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12,
+	0x44, 0x0a, 0x0b, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x41,
+	0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x0a, 0x61, 0x63, 0x63, 0x65, 0x73,
+	0x73, 0x4d, 0x6f, 0x64, 0x65, 0x1a, 0x0d, 0x0a, 0x0b, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x1a, 0x75, 0x0a, 0x0b, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b,
+	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0a, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x2c, 0x0a,
+	0x12, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x1a, 0xb3, 0x02, 0x0a, 0x0a,
+	0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x3c, 0x0a, 0x04, 0x6d, 0x6f,
+	0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
+	0x74, 0x79, 0x2e, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x64, 0x65, 0x2e, 0x4d, 0x6f,
+	0x64, 0x65, 0x52, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x22, 0xe6, 0x01, 0x0a, 0x04, 0x4d, 0x6f, 0x64,
+	0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x16,
+	0x0a, 0x12, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x57, 0x52,
+	0x49, 0x54, 0x45, 0x52, 0x10, 0x01, 0x12, 0x1b, 0x0a, 0x17, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45,
+	0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x45, 0x52, 0x5f, 0x4f, 0x4e, 0x4c,
+	0x59, 0x10, 0x02, 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x5f, 0x4e, 0x4f, 0x44,
+	0x45, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x45, 0x52, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x03, 0x12,
+	0x1c, 0x0a, 0x18, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49,
+	0x4e, 0x47, 0x4c, 0x45, 0x5f, 0x57, 0x52, 0x49, 0x54, 0x45, 0x52, 0x10, 0x04, 0x12, 0x1b, 0x0a,
+	0x17, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x4d, 0x55, 0x4c, 0x54,
+	0x49, 0x5f, 0x57, 0x52, 0x49, 0x54, 0x45, 0x52, 0x10, 0x05, 0x12, 0x22, 0x0a, 0x19, 0x53, 0x49,
+	0x4e, 0x47, 0x4c, 0x45, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45,
+	0x5f, 0x57, 0x52, 0x49, 0x54, 0x45, 0x52, 0x10, 0x06, 0x1a, 0x03, 0xa0, 0x42, 0x01, 0x12, 0x21,
+	0x0a, 0x18, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x4d, 0x55,
+	0x4c, 0x54, 0x49, 0x5f, 0x57, 0x52, 0x49, 0x54, 0x45, 0x52, 0x10, 0x07, 0x1a, 0x03, 0xa0, 0x42,
+	0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x22, 0x57, 0x0a, 0x0d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x61, 0x6e, 0x67,
+	0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x62, 0x79,
+	0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69,
+	0x72, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x69, 0x6d, 0x69,
+	0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x6c,
+	0x69, 0x6d, 0x69, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x22, 0xdf, 0x02, 0x0a, 0x06, 0x56, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79,
+	0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, 0x61,
+	0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x76,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
+	0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x48, 0x0a, 0x0e, 0x76, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x21, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x0d, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65,
+	0x78, 0x74, 0x12, 0x42, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x6f,
+	0x75, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
+	0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
+	0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x41, 0x0a, 0x13, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73,
+	0x69, 0x62, 0x6c, 0x65, 0x5f, 0x74, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x18, 0x05, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70,
+	0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x52, 0x12, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c,
+	0x65, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x1a, 0x40, 0x0a, 0x12, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x75, 0x0a, 0x13, 0x54,
+	0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65,
+	0x6e, 0x74, 0x12, 0x2e, 0x0a, 0x09, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54,
+	0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69,
+	0x74, 0x65, 0x12, 0x2e, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54,
+	0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x52, 0x09, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72,
+	0x65, 0x64, 0x22, 0x83, 0x01, 0x0a, 0x08, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x12,
+	0x3a, 0x0a, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x1e, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c,
+	0x6f, 0x67, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x53,
+	0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xb7, 0x01, 0x0a, 0x13, 0x44, 0x65, 0x6c,
+	0x65, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x1b, 0x0a, 0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x47, 0x0a,
+	0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72,
+	0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01, 0x52, 0x07, 0x73,
+	0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74,
+	0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02,
+	0x38, 0x01, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xed, 0x03, 0x0a, 0x1e, 0x43,
+	0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a,
+	0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f,
+	0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64,
+	0x65, 0x49, 0x64, 0x12, 0x45, 0x0a, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61,
+	0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61,
+	0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65,
+	0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65,
+	0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x12, 0x52, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74,
+	0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69,
+	0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e,
+	0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42,
+	0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x60, 0x0a, 0x0e, 0x76, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x06, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x39, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74,
+	0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x76,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x1a, 0x3a, 0x0a, 0x0c,
+	0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xca, 0x01, 0x0a, 0x1f, 0x43,
+	0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x64,
+	0x0a, 0x0f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78,
+	0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69,
+	0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x43, 0x6f, 0x6e,
+	0x74, 0x65, 0x78, 0x74, 0x1a, 0x41, 0x0a, 0x13, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x43,
+	0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xea, 0x01, 0x0a, 0x20, 0x43, 0x6f, 0x6e, 0x74,
+	0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09,
+	0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64,
+	0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65,
+	0x49, 0x64, 0x12, 0x54, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e,
+	0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53, 0x65,
+	0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01, 0x52,
+	0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72,
+	0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x3a, 0x02, 0x38, 0x01, 0x22, 0x23, 0x0a, 0x21, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c,
+	0x65, 0x72, 0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9b, 0x06, 0x0a, 0x21, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61,
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x1b, 0x0a, 0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x63, 0x0a, 0x0e,
+	0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61,
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x52, 0x0d, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
+	0x74, 0x12, 0x49, 0x0a, 0x13, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61, 0x70, 0x61,
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61,
+	0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x12, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x59, 0x0a, 0x0a,
+	0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x39, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
+	0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x61, 0x72,
+	0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x55, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65,
+	0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x42, 0x03, 0x98, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x74,
+	0x0a, 0x12, 0x6d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65,
+	0x74, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x40, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72,
+	0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0xa0, 0x42,
+	0x01, 0x52, 0x11, 0x6d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65,
+	0x74, 0x65, 0x72, 0x73, 0x1a, 0x40, 0x0a, 0x12, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f,
+	0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65,
+	0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x89, 0x06, 0x0a, 0x22, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69,
+	0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x52,
+	0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x34, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c,
+	0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6f,
+	0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d,
+	0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0xf4, 0x04, 0x0a,
+	0x09, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x12, 0x6e, 0x0a, 0x0e, 0x76, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x47, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69,
+	0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43,
+	0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43,
+	0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x76, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x49, 0x0a, 0x13, 0x76, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65,
+	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
+	0x79, 0x52, 0x12, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c,
+	0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x64, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
+	0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x63, 0x73, 0x69, 0x2e,
+	0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x2e,
+	0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
+	0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x7f, 0x0a, 0x12, 0x6d,
+	0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
+	0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43,
+	0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x2e, 0x4d, 0x75,
+	0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0xa0, 0x42, 0x01, 0x52, 0x11, 0x6d, 0x75, 0x74, 0x61, 0x62,
+	0x6c, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x40, 0x0a, 0x12,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d,
+	0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a,
+	0x16, 0x4d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
+	0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x22, 0x5c, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x78,
+	0x5f, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x6d, 0x61, 0x78, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x74,
+	0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0d, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x22, 0xec, 0x02, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x65, 0x6e, 0x74,
+	0x72, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x65,
+	0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x74,
+	0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x65, 0x78, 0x74,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x1a, 0x85, 0x01, 0x0a, 0x0c, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73,
+	0x68, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x10, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x4e, 0x6f, 0x64,
+	0x65, 0x49, 0x64, 0x73, 0x12, 0x47, 0x0a, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63,
+	0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f,
+	0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x03, 0xa0, 0x42, 0x01, 0x52, 0x0f, 0x76, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x71, 0x0a,
+	0x05, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x26, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x40,
+	0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
+	0x22, 0x3e, 0x0a, 0x1a, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65,
+	0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b,
+	0x0a, 0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x3a, 0x03, 0xa0, 0x42, 0x01,
+	0x22, 0x97, 0x02, 0x0a, 0x1b, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47,
+	0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x26, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x0e, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x48, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74,
+	0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65, 0x74, 0x56,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x56, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74,
+	0x75, 0x73, 0x1a, 0x80, 0x01, 0x0a, 0x0c, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x74, 0x61,
+	0x74, 0x75, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64,
+	0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52,
+	0x10, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64,
+	0x73, 0x12, 0x42, 0x0a, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x64,
+	0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x64, 0x69,
+	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x64,
+	0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x03, 0xa0, 0x42, 0x01, 0x22, 0x83, 0x03, 0x0a, 0x1d, 0x43,
+	0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x56,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09,
+	0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x51, 0x0a, 0x07, 0x73, 0x65, 0x63,
+	0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x4d, 0x6f,
+	0x64, 0x69, 0x66, 0x79, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03,
+	0x98, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x6b, 0x0a, 0x12,
+	0x6d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
+	0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x69,
+	0x66, 0x79, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e,
+	0x4d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
+	0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x6d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50,
+	0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63,
+	0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, 0x4d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65,
+	0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
+	0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
+	0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x3a, 0x03, 0xa0, 0x42, 0x01,
+	0x22, 0x25, 0x0a, 0x1e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x4d, 0x6f,
+	0x64, 0x69, 0x66, 0x79, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x3a, 0x03, 0xa0, 0x42, 0x01, 0x22, 0xad, 0x02, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x43,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x49,
+	0x0a, 0x13, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c,
+	0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62,
+	0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x12, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70,
+	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x4a, 0x0a, 0x0a, 0x70, 0x61, 0x72,
+	0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69,
+	0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65,
+	0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d,
+	0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x41, 0x0a, 0x13, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69,
+	0x62, 0x6c, 0x65, 0x5f, 0x74, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x10, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x6f,
+	0x6c, 0x6f, 0x67, 0x79, 0x52, 0x12, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65,
+	0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x1a, 0x3d, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xe3, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x43,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x2d, 0x0a, 0x12, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x63, 0x61, 0x70,
+	0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x61, 0x76, 0x61,
+	0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x4b,
+	0x0a, 0x13, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e,
+	0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x11, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75,
+	0x6d, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x50, 0x0a, 0x13, 0x6d,
+	0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x73, 0x69,
+	0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34,
+	0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x03, 0xa0, 0x42, 0x01, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x69,
+	0x6d, 0x75, 0x6d, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x22, 0x22, 0x0a,
+	0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65, 0x74, 0x43, 0x61,
+	0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x22, 0x6c, 0x0a, 0x21, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47,
+	0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69,
+	0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x63,
+	0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72,
+	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
+	0x79, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22,
+	0x96, 0x04, 0x0a, 0x1b, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x53, 0x65,
+	0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12,
+	0x3b, 0x0a, 0x03, 0x72, 0x70, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63,
+	0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72,
+	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
+	0x79, 0x2e, 0x52, 0x50, 0x43, 0x48, 0x00, 0x52, 0x03, 0x72, 0x70, 0x63, 0x1a, 0xb1, 0x03, 0x0a,
+	0x03, 0x52, 0x50, 0x43, 0x12, 0x40, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74,
+	0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x61, 0x70,
+	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x50, 0x43, 0x2e, 0x54, 0x79, 0x70, 0x65,
+	0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0xe7, 0x02, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12,
+	0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14,
+	0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x5f, 0x56, 0x4f,
+	0x4c, 0x55, 0x4d, 0x45, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x53,
+	0x48, 0x5f, 0x55, 0x4e, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x53, 0x48, 0x5f, 0x56, 0x4f, 0x4c, 0x55,
+	0x4d, 0x45, 0x10, 0x02, 0x12, 0x10, 0x0a, 0x0c, 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x56, 0x4f, 0x4c,
+	0x55, 0x4d, 0x45, 0x53, 0x10, 0x03, 0x12, 0x10, 0x0a, 0x0c, 0x47, 0x45, 0x54, 0x5f, 0x43, 0x41,
+	0x50, 0x41, 0x43, 0x49, 0x54, 0x59, 0x10, 0x04, 0x12, 0x1a, 0x0a, 0x16, 0x43, 0x52, 0x45, 0x41,
+	0x54, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x5f, 0x53, 0x4e, 0x41, 0x50, 0x53, 0x48,
+	0x4f, 0x54, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x53, 0x4e, 0x41,
+	0x50, 0x53, 0x48, 0x4f, 0x54, 0x53, 0x10, 0x06, 0x12, 0x10, 0x0a, 0x0c, 0x43, 0x4c, 0x4f, 0x4e,
+	0x45, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x10, 0x07, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x55,
+	0x42, 0x4c, 0x49, 0x53, 0x48, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x08,
+	0x12, 0x11, 0x0a, 0x0d, 0x45, 0x58, 0x50, 0x41, 0x4e, 0x44, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d,
+	0x45, 0x10, 0x09, 0x12, 0x20, 0x0a, 0x1c, 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x56, 0x4f, 0x4c, 0x55,
+	0x4d, 0x45, 0x53, 0x5f, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x53, 0x48, 0x45, 0x44, 0x5f, 0x4e, 0x4f,
+	0x44, 0x45, 0x53, 0x10, 0x0a, 0x12, 0x19, 0x0a, 0x10, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x5f,
+	0x43, 0x4f, 0x4e, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x0b, 0x1a, 0x03, 0xa0, 0x42, 0x01,
+	0x12, 0x13, 0x0a, 0x0a, 0x47, 0x45, 0x54, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x10, 0x0c,
+	0x1a, 0x03, 0xa0, 0x42, 0x01, 0x12, 0x21, 0x0a, 0x18, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45, 0x5f,
+	0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x5f, 0x57, 0x52, 0x49, 0x54, 0x45,
+	0x52, 0x10, 0x0d, 0x1a, 0x03, 0xa0, 0x42, 0x01, 0x12, 0x16, 0x0a, 0x0d, 0x4d, 0x4f, 0x44, 0x49,
+	0x46, 0x59, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x10, 0x0e, 0x1a, 0x03, 0xa0, 0x42, 0x01,
+	0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0xea, 0x02, 0x0a, 0x15, 0x43, 0x72, 0x65,
+	0x61, 0x74, 0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x6f,
+	0x75, 0x72, 0x63, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04,
+	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
+	0x12, 0x49, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2a, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74,
+	0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98,
+	0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x4d, 0x0a, 0x0a, 0x70,
+	0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2d, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50,
+	0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a,
+	0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65,
+	0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65,
+	0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x46, 0x0a, 0x16, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x2c, 0x0a, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x10, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x52, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x22, 0x83, 0x02,
+	0x0a, 0x08, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x69,
+	0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09,
+	0x73, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6e, 0x61,
+	0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x6f,
+	0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x49, 0x64, 0x12, 0x3f, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x5f, 0x74,
+	0x6f, 0x5f, 0x75, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x72, 0x65, 0x61,
+	0x64, 0x79, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x67, 0x72, 0x6f, 0x75, 0x70,
+	0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f,
+	0x74, 0x49, 0x64, 0x22, 0xbf, 0x01, 0x0a, 0x15, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a,
+	0x0b, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x49,
+	0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2a, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53,
+	0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01,
+	0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63,
+	0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x18, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0xaf, 0x02, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x78, 0x5f,
+	0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6d,
+	0x61, 0x78, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x74, 0x61,
+	0x72, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0d, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
+	0x12, 0x28, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72,
+	0x63, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x48, 0x0a, 0x07, 0x73,
+	0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x63,
+	0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65,
+	0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65,
+	0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x01, 0x22, 0xac, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x07, 0x65,
+	0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x63,
+	0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, 0x65,
+	0x78, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x6e, 0x65, 0x78, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x1a, 0x35, 0x0a, 0x05, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x2c, 0x0a, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x22, 0xd0, 0x02, 0x0a, 0x1d, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x45,
+	0x78, 0x70, 0x61, 0x6e, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12,
+	0x3c, 0x0a, 0x0e, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0d,
+	0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x51, 0x0a,
+	0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c,
+	0x65, 0x72, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73,
+	0x12, 0x45, 0x0a, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x62,
+	0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62,
+	0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70,
+	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65,
+	0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x22, 0x7f, 0x0a, 0x1e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65,
+	0x72, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74,
+	0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x36, 0x0a, 0x17,
+	0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72,
+	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x6e,
+	0x6f, 0x64, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75,
+	0x69, 0x72, 0x65, 0x64, 0x22, 0xf0, 0x04, 0x0a, 0x16, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61,
+	0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x1b, 0x0a, 0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x5b, 0x0a, 0x0f,
+	0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e,
+	0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x43, 0x6f, 0x6e,
+	0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x70, 0x75, 0x62, 0x6c, 0x69,
+	0x73, 0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x2e, 0x0a, 0x13, 0x73, 0x74, 0x61,
+	0x67, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x73, 0x74, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x54,
+	0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x61, 0x74, 0x68, 0x12, 0x45, 0x0a, 0x11, 0x76, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x10,
+	0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
+	0x12, 0x4a, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53,
+	0x74, 0x61, 0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03,
+	0x98, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x58, 0x0a, 0x0e,
+	0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x06,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f,
+	0x64, 0x65, 0x53, 0x74, 0x61, 0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65,
+	0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43,
+	0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x1a, 0x41, 0x0a, 0x13, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73,
+	0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63,
+	0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43,
+	0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x19, 0x0a, 0x17, 0x4e, 0x6f, 0x64, 0x65, 0x53,
+	0x74, 0x61, 0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x67, 0x0a, 0x18, 0x4e, 0x6f, 0x64, 0x65, 0x55, 0x6e, 0x73, 0x74, 0x61, 0x67,
+	0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b,
+	0x0a, 0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x13, 0x73,
+	0x74, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x61,
+	0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x73, 0x74, 0x61, 0x67, 0x69, 0x6e,
+	0x67, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x61, 0x74, 0x68, 0x22, 0x1b, 0x0a, 0x19, 0x4e,
+	0x6f, 0x64, 0x65, 0x55, 0x6e, 0x73, 0x74, 0x61, 0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xb5, 0x05, 0x0a, 0x18, 0x4e, 0x6f, 0x64,
+	0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f,
+	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x49, 0x64, 0x12, 0x5d, 0x0a, 0x0f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x5f, 0x63, 0x6f,
+	0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x75,
+	0x62, 0x6c, 0x69, 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x52, 0x0e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
+	0x74, 0x12, 0x2e, 0x0a, 0x13, 0x73, 0x74, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x72,
+	0x67, 0x65, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11,
+	0x73, 0x74, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x61, 0x74,
+	0x68, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x61,
+	0x74, 0x68, 0x12, 0x45, 0x0a, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61, 0x70,
+	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70,
+	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43,
+	0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x61,
+	0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x61,
+	0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x12, 0x4c, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73,
+	0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e,
+	0x4e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73,
+	0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72,
+	0x65, 0x74, 0x73, 0x12, 0x5a, 0x0a, 0x0e, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6f,
+	0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x56, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x52, 0x0d, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x1a,
+	0x41, 0x0a, 0x13, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
+	0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02,
+	0x38, 0x01, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40,
+	0x0a, 0x12, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
+	0x22, 0x1b, 0x0a, 0x19, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5a, 0x0a,
+	0x1a, 0x4e, 0x6f, 0x64, 0x65, 0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x76,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
+	0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67,
+	0x65, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74,
+	0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x61, 0x74, 0x68, 0x22, 0x1d, 0x0a, 0x1b, 0x4e, 0x6f, 0x64,
+	0x65, 0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x89, 0x01, 0x0a, 0x19, 0x4e, 0x6f, 0x64,
+	0x65, 0x47, 0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x76, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x70, 0x61,
+	0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x50, 0x61, 0x74, 0x68, 0x12, 0x2e, 0x0a, 0x13, 0x73, 0x74, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x5f,
+	0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x11, 0x73, 0x74, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74,
+	0x50, 0x61, 0x74, 0x68, 0x22, 0x90, 0x01, 0x0a, 0x1a, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x74,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x05, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x55, 0x73, 0x61, 0x67, 0x65, 0x52, 0x05, 0x75, 0x73, 0x61, 0x67, 0x65, 0x12, 0x47,
+	0x0a, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f,
+	0x6e, 0x42, 0x03, 0xa0, 0x42, 0x01, 0x52, 0x0f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6f,
+	0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xaf, 0x01, 0x0a, 0x0b, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x76, 0x61, 0x69, 0x6c,
+	0x61, 0x62, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x61, 0x76, 0x61, 0x69,
+	0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x75,
+	0x73, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x75, 0x73, 0x65, 0x64, 0x12,
+	0x2c, 0x0a, 0x04, 0x75, 0x6e, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x55, 0x73, 0x61,
+	0x67, 0x65, 0x2e, 0x55, 0x6e, 0x69, 0x74, 0x52, 0x04, 0x75, 0x6e, 0x69, 0x74, 0x22, 0x2a, 0x0a,
+	0x04, 0x55, 0x6e, 0x69, 0x74, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e,
+	0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x42, 0x59, 0x54, 0x45, 0x53, 0x10, 0x01, 0x12, 0x0a, 0x0a,
+	0x06, 0x49, 0x4e, 0x4f, 0x44, 0x45, 0x53, 0x10, 0x02, 0x22, 0x4c, 0x0a, 0x0f, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08,
+	0x61, 0x62, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08,
+	0x61, 0x62, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x3a, 0x03, 0xa0, 0x42, 0x01, 0x22, 0x1c, 0x0a, 0x1a, 0x4e, 0x6f, 0x64, 0x65, 0x47,
+	0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x60, 0x0a, 0x1b, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x74,
+	0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
+	0x74, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43,
+	0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62,
+	0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0xc9, 0x02, 0x0a, 0x15, 0x4e, 0x6f, 0x64, 0x65,
+	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
+	0x79, 0x12, 0x35, 0x0a, 0x03, 0x72, 0x70, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76,
+	0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x50,
+	0x43, 0x48, 0x00, 0x52, 0x03, 0x72, 0x70, 0x63, 0x1a, 0xf0, 0x01, 0x0a, 0x03, 0x52, 0x50, 0x43,
+	0x12, 0x3a, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76,
+	0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x50,
+	0x43, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0xac, 0x01, 0x0a,
+	0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e,
+	0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x54,
+	0x41, 0x47, 0x45, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10,
+	0x47, 0x45, 0x54, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x53,
+	0x10, 0x02, 0x12, 0x11, 0x0a, 0x0d, 0x45, 0x58, 0x50, 0x41, 0x4e, 0x44, 0x5f, 0x56, 0x4f, 0x4c,
+	0x55, 0x4d, 0x45, 0x10, 0x03, 0x12, 0x19, 0x0a, 0x10, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x5f,
+	0x43, 0x4f, 0x4e, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x04, 0x1a, 0x03, 0xa0, 0x42, 0x01,
+	0x12, 0x21, 0x0a, 0x18, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f,
+	0x4d, 0x55, 0x4c, 0x54, 0x49, 0x5f, 0x57, 0x52, 0x49, 0x54, 0x45, 0x52, 0x10, 0x05, 0x1a, 0x03,
+	0xa0, 0x42, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x5f, 0x4d, 0x4f,
+	0x55, 0x4e, 0x54, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x06, 0x42, 0x06, 0x0a, 0x04, 0x74,
+	0x79, 0x70, 0x65, 0x22, 0x14, 0x0a, 0x12, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x74, 0x49, 0x6e,
+	0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xa2, 0x01, 0x0a, 0x13, 0x4e, 0x6f,
+	0x64, 0x65, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x2f, 0x0a, 0x14, 0x6d, 0x61,
+	0x78, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6e, 0x6f,
+	0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x6d, 0x61, 0x78, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x73, 0x50, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x41, 0x0a, 0x13, 0x61,
+	0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x5f, 0x74, 0x6f, 0x70, 0x6f, 0x6c, 0x6f,
+	0x67, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x52, 0x12, 0x61, 0x63, 0x63, 0x65,
+	0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x22, 0x98,
+	0x03, 0x0a, 0x17, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x76,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x76, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x76, 0x6f,
+	0x6c, 0x75, 0x6d, 0x65, 0x50, 0x61, 0x74, 0x68, 0x12, 0x3c, 0x0a, 0x0e, 0x63, 0x61, 0x70, 0x61,
+	0x63, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x15, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69,
+	0x74, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0d, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74,
+	0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x73, 0x74, 0x61, 0x67, 0x69, 0x6e,
+	0x67, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x11, 0x73, 0x74, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x72, 0x67,
+	0x65, 0x74, 0x50, 0x61, 0x74, 0x68, 0x12, 0x45, 0x0a, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x5f, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x18, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x10, 0x76, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x4e, 0x0a,
+	0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x70, 0x61,
+	0x6e, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e,
+	0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x06, 0x98, 0x42,
+	0x01, 0xa0, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a,
+	0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
+	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
+	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x41, 0x0a, 0x18, 0x4e, 0x6f, 0x64,
+	0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74,
+	0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x22, 0x27, 0x0a, 0x25,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47,
+	0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x76, 0x0a, 0x26, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f,
+	0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62,
+	0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x4c, 0x0a, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x53, 0x65,
+	0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52,
+	0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0xfd, 0x01,
+	0x0a, 0x20, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65,
+	0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
+	0x74, 0x79, 0x12, 0x40, 0x0a, 0x03, 0x72, 0x70, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2c, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f,
+	0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43,
+	0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x50, 0x43, 0x48, 0x00, 0x52,
+	0x03, 0x72, 0x70, 0x63, 0x1a, 0x8e, 0x01, 0x0a, 0x03, 0x52, 0x50, 0x43, 0x12, 0x45, 0x0a, 0x04,
+	0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c,
+	0x6c, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69,
+	0x6c, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x50, 0x43, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74,
+	0x79, 0x70, 0x65, 0x22, 0x40, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55,
+	0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x2b, 0x0a, 0x27, 0x43, 0x52, 0x45, 0x41,
+	0x54, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x5f, 0x47, 0x45, 0x54, 0x5f, 0x56, 0x4f,
+	0x4c, 0x55, 0x4d, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x53, 0x4e, 0x41, 0x50, 0x53,
+	0x48, 0x4f, 0x54, 0x10, 0x01, 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x8d, 0x03,
+	0x0a, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
+	0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x49,
+	0x64, 0x73, 0x12, 0x54, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65,
+	0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53, 0x65,
+	0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01, 0x52,
+	0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x58, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61,
+	0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x63,
+	0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
+	0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
+	0x72, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d,
+	0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x67, 0x0a,
+	0x21, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f,
+	0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x42, 0x0a, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x22, 0xd4, 0x01, 0x0a, 0x13, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x2a,
+	0x0a, 0x11, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x67, 0x72, 0x6f, 0x75, 0x70,
+	0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x09, 0x73, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52,
+	0x09, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x73, 0x12, 0x3f, 0x0a, 0x0d, 0x63, 0x72,
+	0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0c, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0c, 0x72,
+	0x65, 0x61, 0x64, 0x79, 0x5f, 0x74, 0x6f, 0x5f, 0x75, 0x73, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x72, 0x65, 0x61, 0x64, 0x79, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x22, 0x83, 0x02,
+	0x0a, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x67,
+	0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x21,
+	0x0a, 0x0c, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64,
+	0x73, 0x12, 0x54, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x35, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65,
+	0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61,
+	0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53, 0x65, 0x63,
+	0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01, 0x52, 0x07,
+	0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65,
+	0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
+	0x02, 0x38, 0x01, 0x22, 0x23, 0x0a, 0x21, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xfd, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x73, 0x12, 0x51, 0x0a, 0x07, 0x73, 0x65, 0x63,
+	0x72, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f,
+	0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03,
+	0x98, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a, 0x0c,
+	0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x64, 0x0a, 0x1e, 0x47, 0x65, 0x74, 0x56,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x0e, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52,
+	0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x22, 0x4f,
+	0x0a, 0x0d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12,
+	0x1f, 0x0a, 0x0b, 0x62, 0x79, 0x74, 0x65, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x62, 0x79, 0x74, 0x65, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74,
+	0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x22,
+	0x95, 0x02, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x41,
+	0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x1f, 0x0a, 0x0b, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64,
+	0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x66, 0x66,
+	0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74,
+	0x69, 0x6e, 0x67, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x78,
+	0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x6d, 0x61, 0x78, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x4f, 0x0a, 0x07, 0x73, 0x65,
+	0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x03, 0x98,
+	0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53,
+	0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xdb, 0x01, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x4d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x13, 0x62, 0x6c, 0x6f, 0x63,
+	0x6b, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x42,
+	0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x54, 0x79, 0x70, 0x65,
+	0x52, 0x11, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x54,
+	0x79, 0x70, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x61,
+	0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x13, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69,
+	0x74, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+	0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x15, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65,
+	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74,
+	0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0xc4, 0x02, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74,
+	0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x28, 0x0a, 0x10, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x62, 0x61, 0x73,
+	0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x74,
+	0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x69,
+	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x53,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, 0x61,
+	0x72, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x4f, 0x66, 0x66, 0x73,
+	0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74,
+	0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x73, 0x75,
+	0x6c, 0x74, 0x73, 0x12, 0x4b, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x05,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65,
+	0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x42, 0x03, 0x98, 0x42, 0x01, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73,
+	0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b,
+	0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd7, 0x01, 0x0a,
+	0x18, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x65, 0x6c, 0x74,
+	0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x13, 0x62, 0x6c, 0x6f,
+	0x63, 0x6b, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e,
+	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x54, 0x79, 0x70,
+	0x65, 0x52, 0x11, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0x54, 0x79, 0x70, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x13, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x63,
+	0x69, 0x74, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x0e, 0x62, 0x6c, 0x6f, 0x63,
+	0x6b, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x15, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65,
+	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2a, 0x47, 0x0a, 0x11, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55,
+	0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x46, 0x49, 0x58, 0x45,
+	0x44, 0x5f, 0x4c, 0x45, 0x4e, 0x47, 0x54, 0x48, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x56, 0x41,
+	0x52, 0x49, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x4c, 0x45, 0x4e, 0x47, 0x54, 0x48, 0x10, 0x02, 0x32,
+	0xfa, 0x01, 0x0a, 0x08, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x4e, 0x0a, 0x0d,
+	0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1c, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e,
+	0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x49, 0x6e,
+	0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x15,
+	0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c,
+	0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x24, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47,
+	0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
+	0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x61,
+	0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x12, 0x36, 0x0a, 0x05, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x12, 0x14, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x15, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x6f,
+	0x62, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x32, 0xbb, 0x0a, 0x0a,
+	0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x4b, 0x0a, 0x0c, 0x43,
+	0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x1b, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0c, 0x44, 0x65, 0x6c, 0x65,
+	0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x1b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44,
+	0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x17, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c,
+	0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x12, 0x26, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f,
+	0x6c, 0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c,
+	0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x19, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65,
+	0x72, 0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x12, 0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f,
+	0x6c, 0x6c, 0x65, 0x72, 0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x55, 0x6e,
+	0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x1a, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c,
+	0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x29, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70,
+	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x2a, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
+	0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48,
+	0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x12, 0x1a, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x63, 0x73, 0x69, 0x2e,
+	0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x43,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x1a, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74,
+	0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x00, 0x12, 0x72, 0x0a, 0x19, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72,
+	0x47, 0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12,
+	0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c,
+	0x6c, 0x65, 0x72, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69,
+	0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x63, 0x73, 0x69, 0x2e,
+	0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65, 0x74,
+	0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x51, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
+	0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x1d, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x51, 0x0a, 0x0e, 0x44, 0x65, 0x6c,
+	0x65, 0x74, 0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x1d, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x63, 0x73, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x0d,
+	0x4c, 0x69, 0x73, 0x74, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x73, 0x12, 0x1c, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f,
+	0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x16,
+	0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x64,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x25, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e,
+	0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x64,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65,
+	0x72, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x13, 0x43, 0x6f, 0x6e, 0x74, 0x72,
+	0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x22,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c,
+	0x65, 0x72, 0x47, 0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x23, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74,
+	0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0xa0, 0x42, 0x01, 0x12, 0x6c, 0x0a, 0x16,
+	0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x25, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e,
+	0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65,
+	0x72, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0xa0, 0x42, 0x01, 0x32, 0xe8, 0x03, 0x0a, 0x0f, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x81,
+	0x01, 0x0a, 0x1e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c,
+	0x65, 0x72, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65,
+	0x73, 0x12, 0x2d, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70,
+	0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70,
+	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x2e, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43,
+	0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70, 0x61,
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x00, 0x12, 0x72, 0x0a, 0x19, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12,
+	0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x63, 0x73, 0x69, 0x2e,
+	0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x19, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x12, 0x28, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c,
+	0x65, 0x74, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x6f, 0x6c,
+	0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x16, 0x47, 0x65,
+	0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x12, 0x25, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65,
+	0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x63, 0x73,
+	0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x00, 0x32, 0xd9, 0x01, 0x0a, 0x10, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x65, 0x0a, 0x14, 0x47, 0x65,
+	0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74,
+	0x65, 0x64, 0x12, 0x23, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x41, 0x6c, 0x6c, 0x6f,
+	0x63, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30,
+	0x01, 0x12, 0x59, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x1f, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47,
+	0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e,
+	0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x65, 0x6c, 0x74, 0x61,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x1a, 0x03, 0xa0, 0x42,
+	0x01, 0x32, 0xda, 0x05, 0x0a, 0x04, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x54, 0x0a, 0x0f, 0x4e, 0x6f,
+	0x64, 0x65, 0x53, 0x74, 0x61, 0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x1e, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x67, 0x65,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x67, 0x65,
+	0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00,
+	0x12, 0x5a, 0x0a, 0x11, 0x4e, 0x6f, 0x64, 0x65, 0x55, 0x6e, 0x73, 0x74, 0x61, 0x67, 0x65, 0x56,
+	0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x20, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e,
+	0x6f, 0x64, 0x65, 0x55, 0x6e, 0x73, 0x74, 0x61, 0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31,
+	0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x55, 0x6e, 0x73, 0x74, 0x61, 0x67, 0x65, 0x56, 0x6f, 0x6c, 0x75,
+	0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x11,
+	0x4e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d,
+	0x65, 0x12, 0x20, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x50,
+	0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64,
+	0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x13, 0x4e, 0x6f, 0x64, 0x65,
+	0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12,
+	0x22, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x55, 0x6e, 0x70,
+	0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64,
+	0x65, 0x55, 0x6e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x12, 0x4e, 0x6f,
+	0x64, 0x65, 0x47, 0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73,
+	0x12, 0x21, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65,
+	0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64,
+	0x65, 0x47, 0x65, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x10, 0x4e, 0x6f, 0x64,
+	0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x1f, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e,
+	0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20,
+	0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x70, 0x61,
+	0x6e, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x00, 0x12, 0x60, 0x0a, 0x13, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70,
+	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x22, 0x2e, 0x63, 0x73, 0x69, 0x2e,
+	0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69,
+	0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e,
+	0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x74, 0x43, 0x61,
+	0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x74, 0x49,
+	0x6e, 0x66, 0x6f, 0x12, 0x1a, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64,
+	0x65, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x1b, 0x2e, 0x63, 0x73, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x74,
+	0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x3a, 0x3c,
+	0x0a, 0x0a, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x1c, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45,
+	0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xa4, 0x08, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x09, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x4c, 0x0a, 0x10,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0xa4, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x61, 0x6c, 0x70, 0x68,
+	0x61, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x3d, 0x0a, 0x0a, 0x63, 0x73,
+	0x69, 0x5f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xa3, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09,
+	0x63, 0x73, 0x69, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x3a, 0x3f, 0x0a, 0x0b, 0x61, 0x6c, 0x70,
+	0x68, 0x61, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xa4, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x3a, 0x45, 0x0a, 0x0d, 0x61, 0x6c,
+	0x70, 0x68, 0x61, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xa4, 0x08, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0c, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x3a, 0x42, 0x0a, 0x0c, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f,
+	0x64, 0x12, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x18, 0xa4, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x4d,
+	0x65, 0x74, 0x68, 0x6f, 0x64, 0x3a, 0x45, 0x0a, 0x0d, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x5f, 0x73,
+	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
+	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xa4, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x42, 0x38, 0x5a, 0x36,
+	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6f, 0x6e, 0x74, 0x61,
+	0x69, 0x6e, 0x65, 0x72, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2d, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2f, 0x73, 0x70, 0x65, 0x63, 0x2f, 0x6c, 0x69, 0x62, 0x2f,
+	0x67, 0x6f, 0x2f, 0x63, 0x73, 0x69, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_csi_proto_rawDescOnce sync.Once
+	file_csi_proto_rawDescData = file_csi_proto_rawDesc
+)
+
+func file_csi_proto_rawDescGZIP() []byte {
+	file_csi_proto_rawDescOnce.Do(func() {
+		file_csi_proto_rawDescData = protoimpl.X.CompressGZIP(file_csi_proto_rawDescData)
+	})
+	return file_csi_proto_rawDescData
+}
+
+var file_csi_proto_enumTypes = make([]protoimpl.EnumInfo, 8)
+var file_csi_proto_msgTypes = make([]protoimpl.MessageInfo, 131)
+var file_csi_proto_goTypes = []interface{}{
+	(BlockMetadataType)(0),                               // 0: csi.v1.BlockMetadataType
+	(PluginCapability_Service_Type)(0),                   // 1: csi.v1.PluginCapability.Service.Type
+	(PluginCapability_VolumeExpansion_Type)(0),           // 2: csi.v1.PluginCapability.VolumeExpansion.Type
+	(VolumeCapability_AccessMode_Mode)(0),                // 3: csi.v1.VolumeCapability.AccessMode.Mode
+	(ControllerServiceCapability_RPC_Type)(0),            // 4: csi.v1.ControllerServiceCapability.RPC.Type
+	(VolumeUsage_Unit)(0),                                // 5: csi.v1.VolumeUsage.Unit
+	(NodeServiceCapability_RPC_Type)(0),                  // 6: csi.v1.NodeServiceCapability.RPC.Type
+	(GroupControllerServiceCapability_RPC_Type)(0),       // 7: csi.v1.GroupControllerServiceCapability.RPC.Type
+	(*GetPluginInfoRequest)(nil),                         // 8: csi.v1.GetPluginInfoRequest
+	(*GetPluginInfoResponse)(nil),                        // 9: csi.v1.GetPluginInfoResponse
+	(*GetPluginCapabilitiesRequest)(nil),                 // 10: csi.v1.GetPluginCapabilitiesRequest
+	(*GetPluginCapabilitiesResponse)(nil),                // 11: csi.v1.GetPluginCapabilitiesResponse
+	(*PluginCapability)(nil),                             // 12: csi.v1.PluginCapability
+	(*ProbeRequest)(nil),                                 // 13: csi.v1.ProbeRequest
+	(*ProbeResponse)(nil),                                // 14: csi.v1.ProbeResponse
+	(*CreateVolumeRequest)(nil),                          // 15: csi.v1.CreateVolumeRequest
+	(*VolumeContentSource)(nil),                          // 16: csi.v1.VolumeContentSource
+	(*CreateVolumeResponse)(nil),                         // 17: csi.v1.CreateVolumeResponse
+	(*VolumeCapability)(nil),                             // 18: csi.v1.VolumeCapability
+	(*CapacityRange)(nil),                                // 19: csi.v1.CapacityRange
+	(*Volume)(nil),                                       // 20: csi.v1.Volume
+	(*TopologyRequirement)(nil),                          // 21: csi.v1.TopologyRequirement
+	(*Topology)(nil),                                     // 22: csi.v1.Topology
+	(*DeleteVolumeRequest)(nil),                          // 23: csi.v1.DeleteVolumeRequest
+	(*DeleteVolumeResponse)(nil),                         // 24: csi.v1.DeleteVolumeResponse
+	(*ControllerPublishVolumeRequest)(nil),               // 25: csi.v1.ControllerPublishVolumeRequest
+	(*ControllerPublishVolumeResponse)(nil),              // 26: csi.v1.ControllerPublishVolumeResponse
+	(*ControllerUnpublishVolumeRequest)(nil),             // 27: csi.v1.ControllerUnpublishVolumeRequest
+	(*ControllerUnpublishVolumeResponse)(nil),            // 28: csi.v1.ControllerUnpublishVolumeResponse
+	(*ValidateVolumeCapabilitiesRequest)(nil),            // 29: csi.v1.ValidateVolumeCapabilitiesRequest
+	(*ValidateVolumeCapabilitiesResponse)(nil),           // 30: csi.v1.ValidateVolumeCapabilitiesResponse
+	(*ListVolumesRequest)(nil),                           // 31: csi.v1.ListVolumesRequest
+	(*ListVolumesResponse)(nil),                          // 32: csi.v1.ListVolumesResponse
+	(*ControllerGetVolumeRequest)(nil),                   // 33: csi.v1.ControllerGetVolumeRequest
+	(*ControllerGetVolumeResponse)(nil),                  // 34: csi.v1.ControllerGetVolumeResponse
+	(*ControllerModifyVolumeRequest)(nil),                // 35: csi.v1.ControllerModifyVolumeRequest
+	(*ControllerModifyVolumeResponse)(nil),               // 36: csi.v1.ControllerModifyVolumeResponse
+	(*GetCapacityRequest)(nil),                           // 37: csi.v1.GetCapacityRequest
+	(*GetCapacityResponse)(nil),                          // 38: csi.v1.GetCapacityResponse
+	(*ControllerGetCapabilitiesRequest)(nil),             // 39: csi.v1.ControllerGetCapabilitiesRequest
+	(*ControllerGetCapabilitiesResponse)(nil),            // 40: csi.v1.ControllerGetCapabilitiesResponse
+	(*ControllerServiceCapability)(nil),                  // 41: csi.v1.ControllerServiceCapability
+	(*CreateSnapshotRequest)(nil),                        // 42: csi.v1.CreateSnapshotRequest
+	(*CreateSnapshotResponse)(nil),                       // 43: csi.v1.CreateSnapshotResponse
+	(*Snapshot)(nil),                                     // 44: csi.v1.Snapshot
+	(*DeleteSnapshotRequest)(nil),                        // 45: csi.v1.DeleteSnapshotRequest
+	(*DeleteSnapshotResponse)(nil),                       // 46: csi.v1.DeleteSnapshotResponse
+	(*ListSnapshotsRequest)(nil),                         // 47: csi.v1.ListSnapshotsRequest
+	(*ListSnapshotsResponse)(nil),                        // 48: csi.v1.ListSnapshotsResponse
+	(*ControllerExpandVolumeRequest)(nil),                // 49: csi.v1.ControllerExpandVolumeRequest
+	(*ControllerExpandVolumeResponse)(nil),               // 50: csi.v1.ControllerExpandVolumeResponse
+	(*NodeStageVolumeRequest)(nil),                       // 51: csi.v1.NodeStageVolumeRequest
+	(*NodeStageVolumeResponse)(nil),                      // 52: csi.v1.NodeStageVolumeResponse
+	(*NodeUnstageVolumeRequest)(nil),                     // 53: csi.v1.NodeUnstageVolumeRequest
+	(*NodeUnstageVolumeResponse)(nil),                    // 54: csi.v1.NodeUnstageVolumeResponse
+	(*NodePublishVolumeRequest)(nil),                     // 55: csi.v1.NodePublishVolumeRequest
+	(*NodePublishVolumeResponse)(nil),                    // 56: csi.v1.NodePublishVolumeResponse
+	(*NodeUnpublishVolumeRequest)(nil),                   // 57: csi.v1.NodeUnpublishVolumeRequest
+	(*NodeUnpublishVolumeResponse)(nil),                  // 58: csi.v1.NodeUnpublishVolumeResponse
+	(*NodeGetVolumeStatsRequest)(nil),                    // 59: csi.v1.NodeGetVolumeStatsRequest
+	(*NodeGetVolumeStatsResponse)(nil),                   // 60: csi.v1.NodeGetVolumeStatsResponse
+	(*VolumeUsage)(nil),                                  // 61: csi.v1.VolumeUsage
+	(*VolumeCondition)(nil),                              // 62: csi.v1.VolumeCondition
+	(*NodeGetCapabilitiesRequest)(nil),                   // 63: csi.v1.NodeGetCapabilitiesRequest
+	(*NodeGetCapabilitiesResponse)(nil),                  // 64: csi.v1.NodeGetCapabilitiesResponse
+	(*NodeServiceCapability)(nil),                        // 65: csi.v1.NodeServiceCapability
+	(*NodeGetInfoRequest)(nil),                           // 66: csi.v1.NodeGetInfoRequest
+	(*NodeGetInfoResponse)(nil),                          // 67: csi.v1.NodeGetInfoResponse
+	(*NodeExpandVolumeRequest)(nil),                      // 68: csi.v1.NodeExpandVolumeRequest
+	(*NodeExpandVolumeResponse)(nil),                     // 69: csi.v1.NodeExpandVolumeResponse
+	(*GroupControllerGetCapabilitiesRequest)(nil),        // 70: csi.v1.GroupControllerGetCapabilitiesRequest
+	(*GroupControllerGetCapabilitiesResponse)(nil),       // 71: csi.v1.GroupControllerGetCapabilitiesResponse
+	(*GroupControllerServiceCapability)(nil),             // 72: csi.v1.GroupControllerServiceCapability
+	(*CreateVolumeGroupSnapshotRequest)(nil),             // 73: csi.v1.CreateVolumeGroupSnapshotRequest
+	(*CreateVolumeGroupSnapshotResponse)(nil),            // 74: csi.v1.CreateVolumeGroupSnapshotResponse
+	(*VolumeGroupSnapshot)(nil),                          // 75: csi.v1.VolumeGroupSnapshot
+	(*DeleteVolumeGroupSnapshotRequest)(nil),             // 76: csi.v1.DeleteVolumeGroupSnapshotRequest
+	(*DeleteVolumeGroupSnapshotResponse)(nil),            // 77: csi.v1.DeleteVolumeGroupSnapshotResponse
+	(*GetVolumeGroupSnapshotRequest)(nil),                // 78: csi.v1.GetVolumeGroupSnapshotRequest
+	(*GetVolumeGroupSnapshotResponse)(nil),               // 79: csi.v1.GetVolumeGroupSnapshotResponse
+	(*BlockMetadata)(nil),                                // 80: csi.v1.BlockMetadata
+	(*GetMetadataAllocatedRequest)(nil),                  // 81: csi.v1.GetMetadataAllocatedRequest
+	(*GetMetadataAllocatedResponse)(nil),                 // 82: csi.v1.GetMetadataAllocatedResponse
+	(*GetMetadataDeltaRequest)(nil),                      // 83: csi.v1.GetMetadataDeltaRequest
+	(*GetMetadataDeltaResponse)(nil),                     // 84: csi.v1.GetMetadataDeltaResponse
+	nil,                                                  // 85: csi.v1.GetPluginInfoResponse.ManifestEntry
+	(*PluginCapability_Service)(nil),                     // 86: csi.v1.PluginCapability.Service
+	(*PluginCapability_VolumeExpansion)(nil),             // 87: csi.v1.PluginCapability.VolumeExpansion
+	nil,                                                  // 88: csi.v1.CreateVolumeRequest.ParametersEntry
+	nil,                                                  // 89: csi.v1.CreateVolumeRequest.SecretsEntry
+	nil,                                                  // 90: csi.v1.CreateVolumeRequest.MutableParametersEntry
+	(*VolumeContentSource_SnapshotSource)(nil),           // 91: csi.v1.VolumeContentSource.SnapshotSource
+	(*VolumeContentSource_VolumeSource)(nil),             // 92: csi.v1.VolumeContentSource.VolumeSource
+	(*VolumeCapability_BlockVolume)(nil),                 // 93: csi.v1.VolumeCapability.BlockVolume
+	(*VolumeCapability_MountVolume)(nil),                 // 94: csi.v1.VolumeCapability.MountVolume
+	(*VolumeCapability_AccessMode)(nil),                  // 95: csi.v1.VolumeCapability.AccessMode
+	nil,                                                  // 96: csi.v1.Volume.VolumeContextEntry
+	nil,                                                  // 97: csi.v1.Topology.SegmentsEntry
+	nil,                                                  // 98: csi.v1.DeleteVolumeRequest.SecretsEntry
+	nil,                                                  // 99: csi.v1.ControllerPublishVolumeRequest.SecretsEntry
+	nil,                                                  // 100: csi.v1.ControllerPublishVolumeRequest.VolumeContextEntry
+	nil,                                                  // 101: csi.v1.ControllerPublishVolumeResponse.PublishContextEntry
+	nil,                                                  // 102: csi.v1.ControllerUnpublishVolumeRequest.SecretsEntry
+	nil,                                                  // 103: csi.v1.ValidateVolumeCapabilitiesRequest.VolumeContextEntry
+	nil,                                                  // 104: csi.v1.ValidateVolumeCapabilitiesRequest.ParametersEntry
+	nil,                                                  // 105: csi.v1.ValidateVolumeCapabilitiesRequest.SecretsEntry
+	nil,                                                  // 106: csi.v1.ValidateVolumeCapabilitiesRequest.MutableParametersEntry
+	(*ValidateVolumeCapabilitiesResponse_Confirmed)(nil), // 107: csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed
+	nil,                                      // 108: csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.VolumeContextEntry
+	nil,                                      // 109: csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.ParametersEntry
+	nil,                                      // 110: csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.MutableParametersEntry
+	(*ListVolumesResponse_VolumeStatus)(nil), // 111: csi.v1.ListVolumesResponse.VolumeStatus
+	(*ListVolumesResponse_Entry)(nil),        // 112: csi.v1.ListVolumesResponse.Entry
+	(*ControllerGetVolumeResponse_VolumeStatus)(nil), // 113: csi.v1.ControllerGetVolumeResponse.VolumeStatus
+	nil,                                     // 114: csi.v1.ControllerModifyVolumeRequest.SecretsEntry
+	nil,                                     // 115: csi.v1.ControllerModifyVolumeRequest.MutableParametersEntry
+	nil,                                     // 116: csi.v1.GetCapacityRequest.ParametersEntry
+	(*ControllerServiceCapability_RPC)(nil), // 117: csi.v1.ControllerServiceCapability.RPC
+	nil,                                     // 118: csi.v1.CreateSnapshotRequest.SecretsEntry
+	nil,                                     // 119: csi.v1.CreateSnapshotRequest.ParametersEntry
+	nil,                                     // 120: csi.v1.DeleteSnapshotRequest.SecretsEntry
+	nil,                                     // 121: csi.v1.ListSnapshotsRequest.SecretsEntry
+	(*ListSnapshotsResponse_Entry)(nil),     // 122: csi.v1.ListSnapshotsResponse.Entry
+	nil,                                     // 123: csi.v1.ControllerExpandVolumeRequest.SecretsEntry
+	nil,                                     // 124: csi.v1.NodeStageVolumeRequest.PublishContextEntry
+	nil,                                     // 125: csi.v1.NodeStageVolumeRequest.SecretsEntry
+	nil,                                     // 126: csi.v1.NodeStageVolumeRequest.VolumeContextEntry
+	nil,                                     // 127: csi.v1.NodePublishVolumeRequest.PublishContextEntry
+	nil,                                     // 128: csi.v1.NodePublishVolumeRequest.SecretsEntry
+	nil,                                     // 129: csi.v1.NodePublishVolumeRequest.VolumeContextEntry
+	(*NodeServiceCapability_RPC)(nil),       // 130: csi.v1.NodeServiceCapability.RPC
+	nil,                                     // 131: csi.v1.NodeExpandVolumeRequest.SecretsEntry
+	(*GroupControllerServiceCapability_RPC)(nil), // 132: csi.v1.GroupControllerServiceCapability.RPC
+	nil,                                   // 133: csi.v1.CreateVolumeGroupSnapshotRequest.SecretsEntry
+	nil,                                   // 134: csi.v1.CreateVolumeGroupSnapshotRequest.ParametersEntry
+	nil,                                   // 135: csi.v1.DeleteVolumeGroupSnapshotRequest.SecretsEntry
+	nil,                                   // 136: csi.v1.GetVolumeGroupSnapshotRequest.SecretsEntry
+	nil,                                   // 137: csi.v1.GetMetadataAllocatedRequest.SecretsEntry
+	nil,                                   // 138: csi.v1.GetMetadataDeltaRequest.SecretsEntry
+	(*wrapperspb.BoolValue)(nil),          // 139: google.protobuf.BoolValue
+	(*wrapperspb.Int64Value)(nil),         // 140: google.protobuf.Int64Value
+	(*timestamppb.Timestamp)(nil),         // 141: google.protobuf.Timestamp
+	(*descriptorpb.EnumOptions)(nil),      // 142: google.protobuf.EnumOptions
+	(*descriptorpb.EnumValueOptions)(nil), // 143: google.protobuf.EnumValueOptions
+	(*descriptorpb.FieldOptions)(nil),     // 144: google.protobuf.FieldOptions
+	(*descriptorpb.MessageOptions)(nil),   // 145: google.protobuf.MessageOptions
+	(*descriptorpb.MethodOptions)(nil),    // 146: google.protobuf.MethodOptions
+	(*descriptorpb.ServiceOptions)(nil),   // 147: google.protobuf.ServiceOptions
+}
+var file_csi_proto_depIdxs = []int32{
+	85,  // 0: csi.v1.GetPluginInfoResponse.manifest:type_name -> csi.v1.GetPluginInfoResponse.ManifestEntry
+	12,  // 1: csi.v1.GetPluginCapabilitiesResponse.capabilities:type_name -> csi.v1.PluginCapability
+	86,  // 2: csi.v1.PluginCapability.service:type_name -> csi.v1.PluginCapability.Service
+	87,  // 3: csi.v1.PluginCapability.volume_expansion:type_name -> csi.v1.PluginCapability.VolumeExpansion
+	139, // 4: csi.v1.ProbeResponse.ready:type_name -> google.protobuf.BoolValue
+	19,  // 5: csi.v1.CreateVolumeRequest.capacity_range:type_name -> csi.v1.CapacityRange
+	18,  // 6: csi.v1.CreateVolumeRequest.volume_capabilities:type_name -> csi.v1.VolumeCapability
+	88,  // 7: csi.v1.CreateVolumeRequest.parameters:type_name -> csi.v1.CreateVolumeRequest.ParametersEntry
+	89,  // 8: csi.v1.CreateVolumeRequest.secrets:type_name -> csi.v1.CreateVolumeRequest.SecretsEntry
+	16,  // 9: csi.v1.CreateVolumeRequest.volume_content_source:type_name -> csi.v1.VolumeContentSource
+	21,  // 10: csi.v1.CreateVolumeRequest.accessibility_requirements:type_name -> csi.v1.TopologyRequirement
+	90,  // 11: csi.v1.CreateVolumeRequest.mutable_parameters:type_name -> csi.v1.CreateVolumeRequest.MutableParametersEntry
+	91,  // 12: csi.v1.VolumeContentSource.snapshot:type_name -> csi.v1.VolumeContentSource.SnapshotSource
+	92,  // 13: csi.v1.VolumeContentSource.volume:type_name -> csi.v1.VolumeContentSource.VolumeSource
+	20,  // 14: csi.v1.CreateVolumeResponse.volume:type_name -> csi.v1.Volume
+	93,  // 15: csi.v1.VolumeCapability.block:type_name -> csi.v1.VolumeCapability.BlockVolume
+	94,  // 16: csi.v1.VolumeCapability.mount:type_name -> csi.v1.VolumeCapability.MountVolume
+	95,  // 17: csi.v1.VolumeCapability.access_mode:type_name -> csi.v1.VolumeCapability.AccessMode
+	96,  // 18: csi.v1.Volume.volume_context:type_name -> csi.v1.Volume.VolumeContextEntry
+	16,  // 19: csi.v1.Volume.content_source:type_name -> csi.v1.VolumeContentSource
+	22,  // 20: csi.v1.Volume.accessible_topology:type_name -> csi.v1.Topology
+	22,  // 21: csi.v1.TopologyRequirement.requisite:type_name -> csi.v1.Topology
+	22,  // 22: csi.v1.TopologyRequirement.preferred:type_name -> csi.v1.Topology
+	97,  // 23: csi.v1.Topology.segments:type_name -> csi.v1.Topology.SegmentsEntry
+	98,  // 24: csi.v1.DeleteVolumeRequest.secrets:type_name -> csi.v1.DeleteVolumeRequest.SecretsEntry
+	18,  // 25: csi.v1.ControllerPublishVolumeRequest.volume_capability:type_name -> csi.v1.VolumeCapability
+	99,  // 26: csi.v1.ControllerPublishVolumeRequest.secrets:type_name -> csi.v1.ControllerPublishVolumeRequest.SecretsEntry
+	100, // 27: csi.v1.ControllerPublishVolumeRequest.volume_context:type_name -> csi.v1.ControllerPublishVolumeRequest.VolumeContextEntry
+	101, // 28: csi.v1.ControllerPublishVolumeResponse.publish_context:type_name -> csi.v1.ControllerPublishVolumeResponse.PublishContextEntry
+	102, // 29: csi.v1.ControllerUnpublishVolumeRequest.secrets:type_name -> csi.v1.ControllerUnpublishVolumeRequest.SecretsEntry
+	103, // 30: csi.v1.ValidateVolumeCapabilitiesRequest.volume_context:type_name -> csi.v1.ValidateVolumeCapabilitiesRequest.VolumeContextEntry
+	18,  // 31: csi.v1.ValidateVolumeCapabilitiesRequest.volume_capabilities:type_name -> csi.v1.VolumeCapability
+	104, // 32: csi.v1.ValidateVolumeCapabilitiesRequest.parameters:type_name -> csi.v1.ValidateVolumeCapabilitiesRequest.ParametersEntry
+	105, // 33: csi.v1.ValidateVolumeCapabilitiesRequest.secrets:type_name -> csi.v1.ValidateVolumeCapabilitiesRequest.SecretsEntry
+	106, // 34: csi.v1.ValidateVolumeCapabilitiesRequest.mutable_parameters:type_name -> csi.v1.ValidateVolumeCapabilitiesRequest.MutableParametersEntry
+	107, // 35: csi.v1.ValidateVolumeCapabilitiesResponse.confirmed:type_name -> csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed
+	112, // 36: csi.v1.ListVolumesResponse.entries:type_name -> csi.v1.ListVolumesResponse.Entry
+	20,  // 37: csi.v1.ControllerGetVolumeResponse.volume:type_name -> csi.v1.Volume
+	113, // 38: csi.v1.ControllerGetVolumeResponse.status:type_name -> csi.v1.ControllerGetVolumeResponse.VolumeStatus
+	114, // 39: csi.v1.ControllerModifyVolumeRequest.secrets:type_name -> csi.v1.ControllerModifyVolumeRequest.SecretsEntry
+	115, // 40: csi.v1.ControllerModifyVolumeRequest.mutable_parameters:type_name -> csi.v1.ControllerModifyVolumeRequest.MutableParametersEntry
+	18,  // 41: csi.v1.GetCapacityRequest.volume_capabilities:type_name -> csi.v1.VolumeCapability
+	116, // 42: csi.v1.GetCapacityRequest.parameters:type_name -> csi.v1.GetCapacityRequest.ParametersEntry
+	22,  // 43: csi.v1.GetCapacityRequest.accessible_topology:type_name -> csi.v1.Topology
+	140, // 44: csi.v1.GetCapacityResponse.maximum_volume_size:type_name -> google.protobuf.Int64Value
+	140, // 45: csi.v1.GetCapacityResponse.minimum_volume_size:type_name -> google.protobuf.Int64Value
+	41,  // 46: csi.v1.ControllerGetCapabilitiesResponse.capabilities:type_name -> csi.v1.ControllerServiceCapability
+	117, // 47: csi.v1.ControllerServiceCapability.rpc:type_name -> csi.v1.ControllerServiceCapability.RPC
+	118, // 48: csi.v1.CreateSnapshotRequest.secrets:type_name -> csi.v1.CreateSnapshotRequest.SecretsEntry
+	119, // 49: csi.v1.CreateSnapshotRequest.parameters:type_name -> csi.v1.CreateSnapshotRequest.ParametersEntry
+	44,  // 50: csi.v1.CreateSnapshotResponse.snapshot:type_name -> csi.v1.Snapshot
+	141, // 51: csi.v1.Snapshot.creation_time:type_name -> google.protobuf.Timestamp
+	120, // 52: csi.v1.DeleteSnapshotRequest.secrets:type_name -> csi.v1.DeleteSnapshotRequest.SecretsEntry
+	121, // 53: csi.v1.ListSnapshotsRequest.secrets:type_name -> csi.v1.ListSnapshotsRequest.SecretsEntry
+	122, // 54: csi.v1.ListSnapshotsResponse.entries:type_name -> csi.v1.ListSnapshotsResponse.Entry
+	19,  // 55: csi.v1.ControllerExpandVolumeRequest.capacity_range:type_name -> csi.v1.CapacityRange
+	123, // 56: csi.v1.ControllerExpandVolumeRequest.secrets:type_name -> csi.v1.ControllerExpandVolumeRequest.SecretsEntry
+	18,  // 57: csi.v1.ControllerExpandVolumeRequest.volume_capability:type_name -> csi.v1.VolumeCapability
+	124, // 58: csi.v1.NodeStageVolumeRequest.publish_context:type_name -> csi.v1.NodeStageVolumeRequest.PublishContextEntry
+	18,  // 59: csi.v1.NodeStageVolumeRequest.volume_capability:type_name -> csi.v1.VolumeCapability
+	125, // 60: csi.v1.NodeStageVolumeRequest.secrets:type_name -> csi.v1.NodeStageVolumeRequest.SecretsEntry
+	126, // 61: csi.v1.NodeStageVolumeRequest.volume_context:type_name -> csi.v1.NodeStageVolumeRequest.VolumeContextEntry
+	127, // 62: csi.v1.NodePublishVolumeRequest.publish_context:type_name -> csi.v1.NodePublishVolumeRequest.PublishContextEntry
+	18,  // 63: csi.v1.NodePublishVolumeRequest.volume_capability:type_name -> csi.v1.VolumeCapability
+	128, // 64: csi.v1.NodePublishVolumeRequest.secrets:type_name -> csi.v1.NodePublishVolumeRequest.SecretsEntry
+	129, // 65: csi.v1.NodePublishVolumeRequest.volume_context:type_name -> csi.v1.NodePublishVolumeRequest.VolumeContextEntry
+	61,  // 66: csi.v1.NodeGetVolumeStatsResponse.usage:type_name -> csi.v1.VolumeUsage
+	62,  // 67: csi.v1.NodeGetVolumeStatsResponse.volume_condition:type_name -> csi.v1.VolumeCondition
+	5,   // 68: csi.v1.VolumeUsage.unit:type_name -> csi.v1.VolumeUsage.Unit
+	65,  // 69: csi.v1.NodeGetCapabilitiesResponse.capabilities:type_name -> csi.v1.NodeServiceCapability
+	130, // 70: csi.v1.NodeServiceCapability.rpc:type_name -> csi.v1.NodeServiceCapability.RPC
+	22,  // 71: csi.v1.NodeGetInfoResponse.accessible_topology:type_name -> csi.v1.Topology
+	19,  // 72: csi.v1.NodeExpandVolumeRequest.capacity_range:type_name -> csi.v1.CapacityRange
+	18,  // 73: csi.v1.NodeExpandVolumeRequest.volume_capability:type_name -> csi.v1.VolumeCapability
+	131, // 74: csi.v1.NodeExpandVolumeRequest.secrets:type_name -> csi.v1.NodeExpandVolumeRequest.SecretsEntry
+	72,  // 75: csi.v1.GroupControllerGetCapabilitiesResponse.capabilities:type_name -> csi.v1.GroupControllerServiceCapability
+	132, // 76: csi.v1.GroupControllerServiceCapability.rpc:type_name -> csi.v1.GroupControllerServiceCapability.RPC
+	133, // 77: csi.v1.CreateVolumeGroupSnapshotRequest.secrets:type_name -> csi.v1.CreateVolumeGroupSnapshotRequest.SecretsEntry
+	134, // 78: csi.v1.CreateVolumeGroupSnapshotRequest.parameters:type_name -> csi.v1.CreateVolumeGroupSnapshotRequest.ParametersEntry
+	75,  // 79: csi.v1.CreateVolumeGroupSnapshotResponse.group_snapshot:type_name -> csi.v1.VolumeGroupSnapshot
+	44,  // 80: csi.v1.VolumeGroupSnapshot.snapshots:type_name -> csi.v1.Snapshot
+	141, // 81: csi.v1.VolumeGroupSnapshot.creation_time:type_name -> google.protobuf.Timestamp
+	135, // 82: csi.v1.DeleteVolumeGroupSnapshotRequest.secrets:type_name -> csi.v1.DeleteVolumeGroupSnapshotRequest.SecretsEntry
+	136, // 83: csi.v1.GetVolumeGroupSnapshotRequest.secrets:type_name -> csi.v1.GetVolumeGroupSnapshotRequest.SecretsEntry
+	75,  // 84: csi.v1.GetVolumeGroupSnapshotResponse.group_snapshot:type_name -> csi.v1.VolumeGroupSnapshot
+	137, // 85: csi.v1.GetMetadataAllocatedRequest.secrets:type_name -> csi.v1.GetMetadataAllocatedRequest.SecretsEntry
+	0,   // 86: csi.v1.GetMetadataAllocatedResponse.block_metadata_type:type_name -> csi.v1.BlockMetadataType
+	80,  // 87: csi.v1.GetMetadataAllocatedResponse.block_metadata:type_name -> csi.v1.BlockMetadata
+	138, // 88: csi.v1.GetMetadataDeltaRequest.secrets:type_name -> csi.v1.GetMetadataDeltaRequest.SecretsEntry
+	0,   // 89: csi.v1.GetMetadataDeltaResponse.block_metadata_type:type_name -> csi.v1.BlockMetadataType
+	80,  // 90: csi.v1.GetMetadataDeltaResponse.block_metadata:type_name -> csi.v1.BlockMetadata
+	1,   // 91: csi.v1.PluginCapability.Service.type:type_name -> csi.v1.PluginCapability.Service.Type
+	2,   // 92: csi.v1.PluginCapability.VolumeExpansion.type:type_name -> csi.v1.PluginCapability.VolumeExpansion.Type
+	3,   // 93: csi.v1.VolumeCapability.AccessMode.mode:type_name -> csi.v1.VolumeCapability.AccessMode.Mode
+	108, // 94: csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.volume_context:type_name -> csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.VolumeContextEntry
+	18,  // 95: csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.volume_capabilities:type_name -> csi.v1.VolumeCapability
+	109, // 96: csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.parameters:type_name -> csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.ParametersEntry
+	110, // 97: csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.mutable_parameters:type_name -> csi.v1.ValidateVolumeCapabilitiesResponse.Confirmed.MutableParametersEntry
+	62,  // 98: csi.v1.ListVolumesResponse.VolumeStatus.volume_condition:type_name -> csi.v1.VolumeCondition
+	20,  // 99: csi.v1.ListVolumesResponse.Entry.volume:type_name -> csi.v1.Volume
+	111, // 100: csi.v1.ListVolumesResponse.Entry.status:type_name -> csi.v1.ListVolumesResponse.VolumeStatus
+	62,  // 101: csi.v1.ControllerGetVolumeResponse.VolumeStatus.volume_condition:type_name -> csi.v1.VolumeCondition
+	4,   // 102: csi.v1.ControllerServiceCapability.RPC.type:type_name -> csi.v1.ControllerServiceCapability.RPC.Type
+	44,  // 103: csi.v1.ListSnapshotsResponse.Entry.snapshot:type_name -> csi.v1.Snapshot
+	6,   // 104: csi.v1.NodeServiceCapability.RPC.type:type_name -> csi.v1.NodeServiceCapability.RPC.Type
+	7,   // 105: csi.v1.GroupControllerServiceCapability.RPC.type:type_name -> csi.v1.GroupControllerServiceCapability.RPC.Type
+	142, // 106: csi.v1.alpha_enum:extendee -> google.protobuf.EnumOptions
+	143, // 107: csi.v1.alpha_enum_value:extendee -> google.protobuf.EnumValueOptions
+	144, // 108: csi.v1.csi_secret:extendee -> google.protobuf.FieldOptions
+	144, // 109: csi.v1.alpha_field:extendee -> google.protobuf.FieldOptions
+	145, // 110: csi.v1.alpha_message:extendee -> google.protobuf.MessageOptions
+	146, // 111: csi.v1.alpha_method:extendee -> google.protobuf.MethodOptions
+	147, // 112: csi.v1.alpha_service:extendee -> google.protobuf.ServiceOptions
+	8,   // 113: csi.v1.Identity.GetPluginInfo:input_type -> csi.v1.GetPluginInfoRequest
+	10,  // 114: csi.v1.Identity.GetPluginCapabilities:input_type -> csi.v1.GetPluginCapabilitiesRequest
+	13,  // 115: csi.v1.Identity.Probe:input_type -> csi.v1.ProbeRequest
+	15,  // 116: csi.v1.Controller.CreateVolume:input_type -> csi.v1.CreateVolumeRequest
+	23,  // 117: csi.v1.Controller.DeleteVolume:input_type -> csi.v1.DeleteVolumeRequest
+	25,  // 118: csi.v1.Controller.ControllerPublishVolume:input_type -> csi.v1.ControllerPublishVolumeRequest
+	27,  // 119: csi.v1.Controller.ControllerUnpublishVolume:input_type -> csi.v1.ControllerUnpublishVolumeRequest
+	29,  // 120: csi.v1.Controller.ValidateVolumeCapabilities:input_type -> csi.v1.ValidateVolumeCapabilitiesRequest
+	31,  // 121: csi.v1.Controller.ListVolumes:input_type -> csi.v1.ListVolumesRequest
+	37,  // 122: csi.v1.Controller.GetCapacity:input_type -> csi.v1.GetCapacityRequest
+	39,  // 123: csi.v1.Controller.ControllerGetCapabilities:input_type -> csi.v1.ControllerGetCapabilitiesRequest
+	42,  // 124: csi.v1.Controller.CreateSnapshot:input_type -> csi.v1.CreateSnapshotRequest
+	45,  // 125: csi.v1.Controller.DeleteSnapshot:input_type -> csi.v1.DeleteSnapshotRequest
+	47,  // 126: csi.v1.Controller.ListSnapshots:input_type -> csi.v1.ListSnapshotsRequest
+	49,  // 127: csi.v1.Controller.ControllerExpandVolume:input_type -> csi.v1.ControllerExpandVolumeRequest
+	33,  // 128: csi.v1.Controller.ControllerGetVolume:input_type -> csi.v1.ControllerGetVolumeRequest
+	35,  // 129: csi.v1.Controller.ControllerModifyVolume:input_type -> csi.v1.ControllerModifyVolumeRequest
+	70,  // 130: csi.v1.GroupController.GroupControllerGetCapabilities:input_type -> csi.v1.GroupControllerGetCapabilitiesRequest
+	73,  // 131: csi.v1.GroupController.CreateVolumeGroupSnapshot:input_type -> csi.v1.CreateVolumeGroupSnapshotRequest
+	76,  // 132: csi.v1.GroupController.DeleteVolumeGroupSnapshot:input_type -> csi.v1.DeleteVolumeGroupSnapshotRequest
+	78,  // 133: csi.v1.GroupController.GetVolumeGroupSnapshot:input_type -> csi.v1.GetVolumeGroupSnapshotRequest
+	81,  // 134: csi.v1.SnapshotMetadata.GetMetadataAllocated:input_type -> csi.v1.GetMetadataAllocatedRequest
+	83,  // 135: csi.v1.SnapshotMetadata.GetMetadataDelta:input_type -> csi.v1.GetMetadataDeltaRequest
+	51,  // 136: csi.v1.Node.NodeStageVolume:input_type -> csi.v1.NodeStageVolumeRequest
+	53,  // 137: csi.v1.Node.NodeUnstageVolume:input_type -> csi.v1.NodeUnstageVolumeRequest
+	55,  // 138: csi.v1.Node.NodePublishVolume:input_type -> csi.v1.NodePublishVolumeRequest
+	57,  // 139: csi.v1.Node.NodeUnpublishVolume:input_type -> csi.v1.NodeUnpublishVolumeRequest
+	59,  // 140: csi.v1.Node.NodeGetVolumeStats:input_type -> csi.v1.NodeGetVolumeStatsRequest
+	68,  // 141: csi.v1.Node.NodeExpandVolume:input_type -> csi.v1.NodeExpandVolumeRequest
+	63,  // 142: csi.v1.Node.NodeGetCapabilities:input_type -> csi.v1.NodeGetCapabilitiesRequest
+	66,  // 143: csi.v1.Node.NodeGetInfo:input_type -> csi.v1.NodeGetInfoRequest
+	9,   // 144: csi.v1.Identity.GetPluginInfo:output_type -> csi.v1.GetPluginInfoResponse
+	11,  // 145: csi.v1.Identity.GetPluginCapabilities:output_type -> csi.v1.GetPluginCapabilitiesResponse
+	14,  // 146: csi.v1.Identity.Probe:output_type -> csi.v1.ProbeResponse
+	17,  // 147: csi.v1.Controller.CreateVolume:output_type -> csi.v1.CreateVolumeResponse
+	24,  // 148: csi.v1.Controller.DeleteVolume:output_type -> csi.v1.DeleteVolumeResponse
+	26,  // 149: csi.v1.Controller.ControllerPublishVolume:output_type -> csi.v1.ControllerPublishVolumeResponse
+	28,  // 150: csi.v1.Controller.ControllerUnpublishVolume:output_type -> csi.v1.ControllerUnpublishVolumeResponse
+	30,  // 151: csi.v1.Controller.ValidateVolumeCapabilities:output_type -> csi.v1.ValidateVolumeCapabilitiesResponse
+	32,  // 152: csi.v1.Controller.ListVolumes:output_type -> csi.v1.ListVolumesResponse
+	38,  // 153: csi.v1.Controller.GetCapacity:output_type -> csi.v1.GetCapacityResponse
+	40,  // 154: csi.v1.Controller.ControllerGetCapabilities:output_type -> csi.v1.ControllerGetCapabilitiesResponse
+	43,  // 155: csi.v1.Controller.CreateSnapshot:output_type -> csi.v1.CreateSnapshotResponse
+	46,  // 156: csi.v1.Controller.DeleteSnapshot:output_type -> csi.v1.DeleteSnapshotResponse
+	48,  // 157: csi.v1.Controller.ListSnapshots:output_type -> csi.v1.ListSnapshotsResponse
+	50,  // 158: csi.v1.Controller.ControllerExpandVolume:output_type -> csi.v1.ControllerExpandVolumeResponse
+	34,  // 159: csi.v1.Controller.ControllerGetVolume:output_type -> csi.v1.ControllerGetVolumeResponse
+	36,  // 160: csi.v1.Controller.ControllerModifyVolume:output_type -> csi.v1.ControllerModifyVolumeResponse
+	71,  // 161: csi.v1.GroupController.GroupControllerGetCapabilities:output_type -> csi.v1.GroupControllerGetCapabilitiesResponse
+	74,  // 162: csi.v1.GroupController.CreateVolumeGroupSnapshot:output_type -> csi.v1.CreateVolumeGroupSnapshotResponse
+	77,  // 163: csi.v1.GroupController.DeleteVolumeGroupSnapshot:output_type -> csi.v1.DeleteVolumeGroupSnapshotResponse
+	79,  // 164: csi.v1.GroupController.GetVolumeGroupSnapshot:output_type -> csi.v1.GetVolumeGroupSnapshotResponse
+	82,  // 165: csi.v1.SnapshotMetadata.GetMetadataAllocated:output_type -> csi.v1.GetMetadataAllocatedResponse
+	84,  // 166: csi.v1.SnapshotMetadata.GetMetadataDelta:output_type -> csi.v1.GetMetadataDeltaResponse
+	52,  // 167: csi.v1.Node.NodeStageVolume:output_type -> csi.v1.NodeStageVolumeResponse
+	54,  // 168: csi.v1.Node.NodeUnstageVolume:output_type -> csi.v1.NodeUnstageVolumeResponse
+	56,  // 169: csi.v1.Node.NodePublishVolume:output_type -> csi.v1.NodePublishVolumeResponse
+	58,  // 170: csi.v1.Node.NodeUnpublishVolume:output_type -> csi.v1.NodeUnpublishVolumeResponse
+	60,  // 171: csi.v1.Node.NodeGetVolumeStats:output_type -> csi.v1.NodeGetVolumeStatsResponse
+	69,  // 172: csi.v1.Node.NodeExpandVolume:output_type -> csi.v1.NodeExpandVolumeResponse
+	64,  // 173: csi.v1.Node.NodeGetCapabilities:output_type -> csi.v1.NodeGetCapabilitiesResponse
+	67,  // 174: csi.v1.Node.NodeGetInfo:output_type -> csi.v1.NodeGetInfoResponse
+	144, // [144:175] is the sub-list for method output_type
+	113, // [113:144] is the sub-list for method input_type
+	113, // [113:113] is the sub-list for extension type_name
+	106, // [106:113] is the sub-list for extension extendee
+	0,   // [0:106] is the sub-list for field type_name
+}
+
+func init() { file_csi_proto_init() }
+func file_csi_proto_init() {
+	if File_csi_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_csi_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetPluginInfoRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetPluginInfoResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetPluginCapabilitiesRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetPluginCapabilitiesResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*PluginCapability); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ProbeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ProbeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CreateVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeContentSource); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CreateVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeCapability); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CapacityRange); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Volume); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*TopologyRequirement); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Topology); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeleteVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeleteVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerPublishVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerPublishVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerUnpublishVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerUnpublishVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ValidateVolumeCapabilitiesRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ValidateVolumeCapabilitiesResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListVolumesRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListVolumesResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerGetVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerGetVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerModifyVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerModifyVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetCapacityRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetCapacityResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerGetCapabilitiesRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerGetCapabilitiesResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerServiceCapability); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CreateSnapshotRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CreateSnapshotResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Snapshot); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeleteSnapshotRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeleteSnapshotResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListSnapshotsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListSnapshotsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerExpandVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerExpandVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeStageVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeStageVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeUnstageVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeUnstageVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodePublishVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodePublishVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeUnpublishVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeUnpublishVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeGetVolumeStatsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeGetVolumeStatsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeUsage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeCondition); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeGetCapabilitiesRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeGetCapabilitiesResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeServiceCapability); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeGetInfoRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeGetInfoResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeExpandVolumeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeExpandVolumeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GroupControllerGetCapabilitiesRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GroupControllerGetCapabilitiesResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GroupControllerServiceCapability); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CreateVolumeGroupSnapshotRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CreateVolumeGroupSnapshotResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeGroupSnapshot); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeleteVolumeGroupSnapshotRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeleteVolumeGroupSnapshotResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetVolumeGroupSnapshotRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetVolumeGroupSnapshotResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*BlockMetadata); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetMetadataAllocatedRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetMetadataAllocatedResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetMetadataDeltaRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetMetadataDeltaResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*PluginCapability_Service); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*PluginCapability_VolumeExpansion); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeContentSource_SnapshotSource); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeContentSource_VolumeSource); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeCapability_BlockVolume); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeCapability_MountVolume); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*VolumeCapability_AccessMode); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ValidateVolumeCapabilitiesResponse_Confirmed); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListVolumesResponse_VolumeStatus); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListVolumesResponse_Entry); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerGetVolumeResponse_VolumeStatus); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ControllerServiceCapability_RPC); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListSnapshotsResponse_Entry); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeServiceCapability_RPC); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_csi_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GroupControllerServiceCapability_RPC); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_csi_proto_msgTypes[4].OneofWrappers = []interface{}{
+		(*PluginCapability_Service_)(nil),
+		(*PluginCapability_VolumeExpansion_)(nil),
 	}
-	if interceptor == nil {
-		return srv.(NodeServer).NodeGetInfo(ctx, in)
+	file_csi_proto_msgTypes[8].OneofWrappers = []interface{}{
+		(*VolumeContentSource_Snapshot)(nil),
+		(*VolumeContentSource_Volume)(nil),
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/csi.v1.Node/NodeGetInfo",
+	file_csi_proto_msgTypes[10].OneofWrappers = []interface{}{
+		(*VolumeCapability_Block)(nil),
+		(*VolumeCapability_Mount)(nil),
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServer).NodeGetInfo(ctx, req.(*NodeGetInfoRequest))
+	file_csi_proto_msgTypes[33].OneofWrappers = []interface{}{
+		(*ControllerServiceCapability_Rpc)(nil),
 	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Node_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "csi.v1.Node",
-	HandlerType: (*NodeServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "NodeStageVolume",
-			Handler:    _Node_NodeStageVolume_Handler,
-		},
-		{
-			MethodName: "NodeUnstageVolume",
-			Handler:    _Node_NodeUnstageVolume_Handler,
-		},
-		{
-			MethodName: "NodePublishVolume",
-			Handler:    _Node_NodePublishVolume_Handler,
-		},
-		{
-			MethodName: "NodeUnpublishVolume",
-			Handler:    _Node_NodeUnpublishVolume_Handler,
-		},
-		{
-			MethodName: "NodeGetVolumeStats",
-			Handler:    _Node_NodeGetVolumeStats_Handler,
-		},
-		{
-			MethodName: "NodeExpandVolume",
-			Handler:    _Node_NodeExpandVolume_Handler,
-		},
-		{
-			MethodName: "NodeGetCapabilities",
-			Handler:    _Node_NodeGetCapabilities_Handler,
-		},
-		{
-			MethodName: "NodeGetInfo",
-			Handler:    _Node_NodeGetInfo_Handler,
+	file_csi_proto_msgTypes[57].OneofWrappers = []interface{}{
+		(*NodeServiceCapability_Rpc)(nil),
+	}
+	file_csi_proto_msgTypes[64].OneofWrappers = []interface{}{
+		(*GroupControllerServiceCapability_Rpc)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_csi_proto_rawDesc,
+			NumEnums:      8,
+			NumMessages:   131,
+			NumExtensions: 7,
+			NumServices:   5,
 		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "github.com/container-storage-interface/spec/csi.proto",
+		GoTypes:           file_csi_proto_goTypes,
+		DependencyIndexes: file_csi_proto_depIdxs,
+		EnumInfos:         file_csi_proto_enumTypes,
+		MessageInfos:      file_csi_proto_msgTypes,
+		ExtensionInfos:    file_csi_proto_extTypes,
+	}.Build()
+	File_csi_proto = out.File
+	file_csi_proto_rawDesc = nil
+	file_csi_proto_goTypes = nil
+	file_csi_proto_depIdxs = nil
 }
diff --git a/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi_grpc.pb.go b/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi_grpc.pb.go
new file mode 100644
index 000000000..8d7091946
--- /dev/null
+++ b/vendor/github.com/container-storage-interface/spec/lib/go/csi/csi_grpc.pb.go
@@ -0,0 +1,1487 @@
+// Code generated by make; DO NOT EDIT.
+
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc             v4.25.2
+// source: csi.proto
+
+package csi
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+	Identity_GetPluginInfo_FullMethodName         = "/csi.v1.Identity/GetPluginInfo"
+	Identity_GetPluginCapabilities_FullMethodName = "/csi.v1.Identity/GetPluginCapabilities"
+	Identity_Probe_FullMethodName                 = "/csi.v1.Identity/Probe"
+)
+
+// IdentityClient is the client API for Identity service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type IdentityClient interface {
+	GetPluginInfo(ctx context.Context, in *GetPluginInfoRequest, opts ...grpc.CallOption) (*GetPluginInfoResponse, error)
+	GetPluginCapabilities(ctx context.Context, in *GetPluginCapabilitiesRequest, opts ...grpc.CallOption) (*GetPluginCapabilitiesResponse, error)
+	Probe(ctx context.Context, in *ProbeRequest, opts ...grpc.CallOption) (*ProbeResponse, error)
+}
+
+type identityClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewIdentityClient(cc grpc.ClientConnInterface) IdentityClient {
+	return &identityClient{cc}
+}
+
+func (c *identityClient) GetPluginInfo(ctx context.Context, in *GetPluginInfoRequest, opts ...grpc.CallOption) (*GetPluginInfoResponse, error) {
+	out := new(GetPluginInfoResponse)
+	err := c.cc.Invoke(ctx, Identity_GetPluginInfo_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *identityClient) GetPluginCapabilities(ctx context.Context, in *GetPluginCapabilitiesRequest, opts ...grpc.CallOption) (*GetPluginCapabilitiesResponse, error) {
+	out := new(GetPluginCapabilitiesResponse)
+	err := c.cc.Invoke(ctx, Identity_GetPluginCapabilities_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *identityClient) Probe(ctx context.Context, in *ProbeRequest, opts ...grpc.CallOption) (*ProbeResponse, error) {
+	out := new(ProbeResponse)
+	err := c.cc.Invoke(ctx, Identity_Probe_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// IdentityServer is the server API for Identity service.
+// All implementations must embed UnimplementedIdentityServer
+// for forward compatibility
+type IdentityServer interface {
+	GetPluginInfo(context.Context, *GetPluginInfoRequest) (*GetPluginInfoResponse, error)
+	GetPluginCapabilities(context.Context, *GetPluginCapabilitiesRequest) (*GetPluginCapabilitiesResponse, error)
+	Probe(context.Context, *ProbeRequest) (*ProbeResponse, error)
+	mustEmbedUnimplementedIdentityServer()
+}
+
+// UnimplementedIdentityServer must be embedded to have forward compatible implementations.
+type UnimplementedIdentityServer struct {
+}
+
+func (UnimplementedIdentityServer) GetPluginInfo(context.Context, *GetPluginInfoRequest) (*GetPluginInfoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetPluginInfo not implemented")
+}
+func (UnimplementedIdentityServer) GetPluginCapabilities(context.Context, *GetPluginCapabilitiesRequest) (*GetPluginCapabilitiesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetPluginCapabilities not implemented")
+}
+func (UnimplementedIdentityServer) Probe(context.Context, *ProbeRequest) (*ProbeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Probe not implemented")
+}
+func (UnimplementedIdentityServer) mustEmbedUnimplementedIdentityServer() {}
+
+// UnsafeIdentityServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to IdentityServer will
+// result in compilation errors.
+type UnsafeIdentityServer interface {
+	mustEmbedUnimplementedIdentityServer()
+}
+
+func RegisterIdentityServer(s grpc.ServiceRegistrar, srv IdentityServer) {
+	s.RegisterService(&Identity_ServiceDesc, srv)
+}
+
+func _Identity_GetPluginInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetPluginInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IdentityServer).GetPluginInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Identity_GetPluginInfo_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IdentityServer).GetPluginInfo(ctx, req.(*GetPluginInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Identity_GetPluginCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetPluginCapabilitiesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IdentityServer).GetPluginCapabilities(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Identity_GetPluginCapabilities_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IdentityServer).GetPluginCapabilities(ctx, req.(*GetPluginCapabilitiesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Identity_Probe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ProbeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IdentityServer).Probe(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Identity_Probe_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IdentityServer).Probe(ctx, req.(*ProbeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Identity_ServiceDesc is the grpc.ServiceDesc for Identity service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Identity_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "csi.v1.Identity",
+	HandlerType: (*IdentityServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetPluginInfo",
+			Handler:    _Identity_GetPluginInfo_Handler,
+		},
+		{
+			MethodName: "GetPluginCapabilities",
+			Handler:    _Identity_GetPluginCapabilities_Handler,
+		},
+		{
+			MethodName: "Probe",
+			Handler:    _Identity_Probe_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "csi.proto",
+}
+
+const (
+	Controller_CreateVolume_FullMethodName               = "/csi.v1.Controller/CreateVolume"
+	Controller_DeleteVolume_FullMethodName               = "/csi.v1.Controller/DeleteVolume"
+	Controller_ControllerPublishVolume_FullMethodName    = "/csi.v1.Controller/ControllerPublishVolume"
+	Controller_ControllerUnpublishVolume_FullMethodName  = "/csi.v1.Controller/ControllerUnpublishVolume"
+	Controller_ValidateVolumeCapabilities_FullMethodName = "/csi.v1.Controller/ValidateVolumeCapabilities"
+	Controller_ListVolumes_FullMethodName                = "/csi.v1.Controller/ListVolumes"
+	Controller_GetCapacity_FullMethodName                = "/csi.v1.Controller/GetCapacity"
+	Controller_ControllerGetCapabilities_FullMethodName  = "/csi.v1.Controller/ControllerGetCapabilities"
+	Controller_CreateSnapshot_FullMethodName             = "/csi.v1.Controller/CreateSnapshot"
+	Controller_DeleteSnapshot_FullMethodName             = "/csi.v1.Controller/DeleteSnapshot"
+	Controller_ListSnapshots_FullMethodName              = "/csi.v1.Controller/ListSnapshots"
+	Controller_ControllerExpandVolume_FullMethodName     = "/csi.v1.Controller/ControllerExpandVolume"
+	Controller_ControllerGetVolume_FullMethodName        = "/csi.v1.Controller/ControllerGetVolume"
+	Controller_ControllerModifyVolume_FullMethodName     = "/csi.v1.Controller/ControllerModifyVolume"
+)
+
+// ControllerClient is the client API for Controller service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type ControllerClient interface {
+	CreateVolume(ctx context.Context, in *CreateVolumeRequest, opts ...grpc.CallOption) (*CreateVolumeResponse, error)
+	DeleteVolume(ctx context.Context, in *DeleteVolumeRequest, opts ...grpc.CallOption) (*DeleteVolumeResponse, error)
+	ControllerPublishVolume(ctx context.Context, in *ControllerPublishVolumeRequest, opts ...grpc.CallOption) (*ControllerPublishVolumeResponse, error)
+	ControllerUnpublishVolume(ctx context.Context, in *ControllerUnpublishVolumeRequest, opts ...grpc.CallOption) (*ControllerUnpublishVolumeResponse, error)
+	ValidateVolumeCapabilities(ctx context.Context, in *ValidateVolumeCapabilitiesRequest, opts ...grpc.CallOption) (*ValidateVolumeCapabilitiesResponse, error)
+	ListVolumes(ctx context.Context, in *ListVolumesRequest, opts ...grpc.CallOption) (*ListVolumesResponse, error)
+	GetCapacity(ctx context.Context, in *GetCapacityRequest, opts ...grpc.CallOption) (*GetCapacityResponse, error)
+	ControllerGetCapabilities(ctx context.Context, in *ControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*ControllerGetCapabilitiesResponse, error)
+	CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*CreateSnapshotResponse, error)
+	DeleteSnapshot(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*DeleteSnapshotResponse, error)
+	ListSnapshots(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error)
+	ControllerExpandVolume(ctx context.Context, in *ControllerExpandVolumeRequest, opts ...grpc.CallOption) (*ControllerExpandVolumeResponse, error)
+	ControllerGetVolume(ctx context.Context, in *ControllerGetVolumeRequest, opts ...grpc.CallOption) (*ControllerGetVolumeResponse, error)
+	ControllerModifyVolume(ctx context.Context, in *ControllerModifyVolumeRequest, opts ...grpc.CallOption) (*ControllerModifyVolumeResponse, error)
+}
+
+type controllerClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewControllerClient(cc grpc.ClientConnInterface) ControllerClient {
+	return &controllerClient{cc}
+}
+
+func (c *controllerClient) CreateVolume(ctx context.Context, in *CreateVolumeRequest, opts ...grpc.CallOption) (*CreateVolumeResponse, error) {
+	out := new(CreateVolumeResponse)
+	err := c.cc.Invoke(ctx, Controller_CreateVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) DeleteVolume(ctx context.Context, in *DeleteVolumeRequest, opts ...grpc.CallOption) (*DeleteVolumeResponse, error) {
+	out := new(DeleteVolumeResponse)
+	err := c.cc.Invoke(ctx, Controller_DeleteVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ControllerPublishVolume(ctx context.Context, in *ControllerPublishVolumeRequest, opts ...grpc.CallOption) (*ControllerPublishVolumeResponse, error) {
+	out := new(ControllerPublishVolumeResponse)
+	err := c.cc.Invoke(ctx, Controller_ControllerPublishVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ControllerUnpublishVolume(ctx context.Context, in *ControllerUnpublishVolumeRequest, opts ...grpc.CallOption) (*ControllerUnpublishVolumeResponse, error) {
+	out := new(ControllerUnpublishVolumeResponse)
+	err := c.cc.Invoke(ctx, Controller_ControllerUnpublishVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ValidateVolumeCapabilities(ctx context.Context, in *ValidateVolumeCapabilitiesRequest, opts ...grpc.CallOption) (*ValidateVolumeCapabilitiesResponse, error) {
+	out := new(ValidateVolumeCapabilitiesResponse)
+	err := c.cc.Invoke(ctx, Controller_ValidateVolumeCapabilities_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ListVolumes(ctx context.Context, in *ListVolumesRequest, opts ...grpc.CallOption) (*ListVolumesResponse, error) {
+	out := new(ListVolumesResponse)
+	err := c.cc.Invoke(ctx, Controller_ListVolumes_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) GetCapacity(ctx context.Context, in *GetCapacityRequest, opts ...grpc.CallOption) (*GetCapacityResponse, error) {
+	out := new(GetCapacityResponse)
+	err := c.cc.Invoke(ctx, Controller_GetCapacity_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ControllerGetCapabilities(ctx context.Context, in *ControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*ControllerGetCapabilitiesResponse, error) {
+	out := new(ControllerGetCapabilitiesResponse)
+	err := c.cc.Invoke(ctx, Controller_ControllerGetCapabilities_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*CreateSnapshotResponse, error) {
+	out := new(CreateSnapshotResponse)
+	err := c.cc.Invoke(ctx, Controller_CreateSnapshot_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) DeleteSnapshot(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*DeleteSnapshotResponse, error) {
+	out := new(DeleteSnapshotResponse)
+	err := c.cc.Invoke(ctx, Controller_DeleteSnapshot_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ListSnapshots(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error) {
+	out := new(ListSnapshotsResponse)
+	err := c.cc.Invoke(ctx, Controller_ListSnapshots_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ControllerExpandVolume(ctx context.Context, in *ControllerExpandVolumeRequest, opts ...grpc.CallOption) (*ControllerExpandVolumeResponse, error) {
+	out := new(ControllerExpandVolumeResponse)
+	err := c.cc.Invoke(ctx, Controller_ControllerExpandVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ControllerGetVolume(ctx context.Context, in *ControllerGetVolumeRequest, opts ...grpc.CallOption) (*ControllerGetVolumeResponse, error) {
+	out := new(ControllerGetVolumeResponse)
+	err := c.cc.Invoke(ctx, Controller_ControllerGetVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *controllerClient) ControllerModifyVolume(ctx context.Context, in *ControllerModifyVolumeRequest, opts ...grpc.CallOption) (*ControllerModifyVolumeResponse, error) {
+	out := new(ControllerModifyVolumeResponse)
+	err := c.cc.Invoke(ctx, Controller_ControllerModifyVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// ControllerServer is the server API for Controller service.
+// All implementations must embed UnimplementedControllerServer
+// for forward compatibility
+type ControllerServer interface {
+	CreateVolume(context.Context, *CreateVolumeRequest) (*CreateVolumeResponse, error)
+	DeleteVolume(context.Context, *DeleteVolumeRequest) (*DeleteVolumeResponse, error)
+	ControllerPublishVolume(context.Context, *ControllerPublishVolumeRequest) (*ControllerPublishVolumeResponse, error)
+	ControllerUnpublishVolume(context.Context, *ControllerUnpublishVolumeRequest) (*ControllerUnpublishVolumeResponse, error)
+	ValidateVolumeCapabilities(context.Context, *ValidateVolumeCapabilitiesRequest) (*ValidateVolumeCapabilitiesResponse, error)
+	ListVolumes(context.Context, *ListVolumesRequest) (*ListVolumesResponse, error)
+	GetCapacity(context.Context, *GetCapacityRequest) (*GetCapacityResponse, error)
+	ControllerGetCapabilities(context.Context, *ControllerGetCapabilitiesRequest) (*ControllerGetCapabilitiesResponse, error)
+	CreateSnapshot(context.Context, *CreateSnapshotRequest) (*CreateSnapshotResponse, error)
+	DeleteSnapshot(context.Context, *DeleteSnapshotRequest) (*DeleteSnapshotResponse, error)
+	ListSnapshots(context.Context, *ListSnapshotsRequest) (*ListSnapshotsResponse, error)
+	ControllerExpandVolume(context.Context, *ControllerExpandVolumeRequest) (*ControllerExpandVolumeResponse, error)
+	ControllerGetVolume(context.Context, *ControllerGetVolumeRequest) (*ControllerGetVolumeResponse, error)
+	ControllerModifyVolume(context.Context, *ControllerModifyVolumeRequest) (*ControllerModifyVolumeResponse, error)
+	mustEmbedUnimplementedControllerServer()
+}
+
+// UnimplementedControllerServer must be embedded to have forward compatible implementations.
+type UnimplementedControllerServer struct {
+}
+
+func (UnimplementedControllerServer) CreateVolume(context.Context, *CreateVolumeRequest) (*CreateVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateVolume not implemented")
+}
+func (UnimplementedControllerServer) DeleteVolume(context.Context, *DeleteVolumeRequest) (*DeleteVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DeleteVolume not implemented")
+}
+func (UnimplementedControllerServer) ControllerPublishVolume(context.Context, *ControllerPublishVolumeRequest) (*ControllerPublishVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ControllerPublishVolume not implemented")
+}
+func (UnimplementedControllerServer) ControllerUnpublishVolume(context.Context, *ControllerUnpublishVolumeRequest) (*ControllerUnpublishVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ControllerUnpublishVolume not implemented")
+}
+func (UnimplementedControllerServer) ValidateVolumeCapabilities(context.Context, *ValidateVolumeCapabilitiesRequest) (*ValidateVolumeCapabilitiesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ValidateVolumeCapabilities not implemented")
+}
+func (UnimplementedControllerServer) ListVolumes(context.Context, *ListVolumesRequest) (*ListVolumesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListVolumes not implemented")
+}
+func (UnimplementedControllerServer) GetCapacity(context.Context, *GetCapacityRequest) (*GetCapacityResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetCapacity not implemented")
+}
+func (UnimplementedControllerServer) ControllerGetCapabilities(context.Context, *ControllerGetCapabilitiesRequest) (*ControllerGetCapabilitiesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ControllerGetCapabilities not implemented")
+}
+func (UnimplementedControllerServer) CreateSnapshot(context.Context, *CreateSnapshotRequest) (*CreateSnapshotResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateSnapshot not implemented")
+}
+func (UnimplementedControllerServer) DeleteSnapshot(context.Context, *DeleteSnapshotRequest) (*DeleteSnapshotResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DeleteSnapshot not implemented")
+}
+func (UnimplementedControllerServer) ListSnapshots(context.Context, *ListSnapshotsRequest) (*ListSnapshotsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListSnapshots not implemented")
+}
+func (UnimplementedControllerServer) ControllerExpandVolume(context.Context, *ControllerExpandVolumeRequest) (*ControllerExpandVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ControllerExpandVolume not implemented")
+}
+func (UnimplementedControllerServer) ControllerGetVolume(context.Context, *ControllerGetVolumeRequest) (*ControllerGetVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ControllerGetVolume not implemented")
+}
+func (UnimplementedControllerServer) ControllerModifyVolume(context.Context, *ControllerModifyVolumeRequest) (*ControllerModifyVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ControllerModifyVolume not implemented")
+}
+func (UnimplementedControllerServer) mustEmbedUnimplementedControllerServer() {}
+
+// UnsafeControllerServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to ControllerServer will
+// result in compilation errors.
+type UnsafeControllerServer interface {
+	mustEmbedUnimplementedControllerServer()
+}
+
+func RegisterControllerServer(s grpc.ServiceRegistrar, srv ControllerServer) {
+	s.RegisterService(&Controller_ServiceDesc, srv)
+}
+
+func _Controller_CreateVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).CreateVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_CreateVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).CreateVolume(ctx, req.(*CreateVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_DeleteVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).DeleteVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_DeleteVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).DeleteVolume(ctx, req.(*DeleteVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ControllerPublishVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ControllerPublishVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ControllerPublishVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ControllerPublishVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ControllerPublishVolume(ctx, req.(*ControllerPublishVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ControllerUnpublishVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ControllerUnpublishVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ControllerUnpublishVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ControllerUnpublishVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ControllerUnpublishVolume(ctx, req.(*ControllerUnpublishVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ValidateVolumeCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ValidateVolumeCapabilitiesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ValidateVolumeCapabilities(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ValidateVolumeCapabilities_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ValidateVolumeCapabilities(ctx, req.(*ValidateVolumeCapabilitiesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ListVolumes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListVolumesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ListVolumes(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ListVolumes_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ListVolumes(ctx, req.(*ListVolumesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_GetCapacity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetCapacityRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).GetCapacity(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_GetCapacity_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).GetCapacity(ctx, req.(*GetCapacityRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ControllerGetCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ControllerGetCapabilitiesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ControllerGetCapabilities(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ControllerGetCapabilities_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ControllerGetCapabilities(ctx, req.(*ControllerGetCapabilitiesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_CreateSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateSnapshotRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).CreateSnapshot(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_CreateSnapshot_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).CreateSnapshot(ctx, req.(*CreateSnapshotRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_DeleteSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteSnapshotRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).DeleteSnapshot(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_DeleteSnapshot_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).DeleteSnapshot(ctx, req.(*DeleteSnapshotRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ListSnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListSnapshotsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ListSnapshots(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ListSnapshots_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ListSnapshots(ctx, req.(*ListSnapshotsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ControllerExpandVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ControllerExpandVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ControllerExpandVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ControllerExpandVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ControllerExpandVolume(ctx, req.(*ControllerExpandVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ControllerGetVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ControllerGetVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ControllerGetVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ControllerGetVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ControllerGetVolume(ctx, req.(*ControllerGetVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Controller_ControllerModifyVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ControllerModifyVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).ControllerModifyVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Controller_ControllerModifyVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).ControllerModifyVolume(ctx, req.(*ControllerModifyVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Controller_ServiceDesc is the grpc.ServiceDesc for Controller service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Controller_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "csi.v1.Controller",
+	HandlerType: (*ControllerServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CreateVolume",
+			Handler:    _Controller_CreateVolume_Handler,
+		},
+		{
+			MethodName: "DeleteVolume",
+			Handler:    _Controller_DeleteVolume_Handler,
+		},
+		{
+			MethodName: "ControllerPublishVolume",
+			Handler:    _Controller_ControllerPublishVolume_Handler,
+		},
+		{
+			MethodName: "ControllerUnpublishVolume",
+			Handler:    _Controller_ControllerUnpublishVolume_Handler,
+		},
+		{
+			MethodName: "ValidateVolumeCapabilities",
+			Handler:    _Controller_ValidateVolumeCapabilities_Handler,
+		},
+		{
+			MethodName: "ListVolumes",
+			Handler:    _Controller_ListVolumes_Handler,
+		},
+		{
+			MethodName: "GetCapacity",
+			Handler:    _Controller_GetCapacity_Handler,
+		},
+		{
+			MethodName: "ControllerGetCapabilities",
+			Handler:    _Controller_ControllerGetCapabilities_Handler,
+		},
+		{
+			MethodName: "CreateSnapshot",
+			Handler:    _Controller_CreateSnapshot_Handler,
+		},
+		{
+			MethodName: "DeleteSnapshot",
+			Handler:    _Controller_DeleteSnapshot_Handler,
+		},
+		{
+			MethodName: "ListSnapshots",
+			Handler:    _Controller_ListSnapshots_Handler,
+		},
+		{
+			MethodName: "ControllerExpandVolume",
+			Handler:    _Controller_ControllerExpandVolume_Handler,
+		},
+		{
+			MethodName: "ControllerGetVolume",
+			Handler:    _Controller_ControllerGetVolume_Handler,
+		},
+		{
+			MethodName: "ControllerModifyVolume",
+			Handler:    _Controller_ControllerModifyVolume_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "csi.proto",
+}
+
+const (
+	GroupController_GroupControllerGetCapabilities_FullMethodName = "/csi.v1.GroupController/GroupControllerGetCapabilities"
+	GroupController_CreateVolumeGroupSnapshot_FullMethodName      = "/csi.v1.GroupController/CreateVolumeGroupSnapshot"
+	GroupController_DeleteVolumeGroupSnapshot_FullMethodName      = "/csi.v1.GroupController/DeleteVolumeGroupSnapshot"
+	GroupController_GetVolumeGroupSnapshot_FullMethodName         = "/csi.v1.GroupController/GetVolumeGroupSnapshot"
+)
+
+// GroupControllerClient is the client API for GroupController service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type GroupControllerClient interface {
+	GroupControllerGetCapabilities(ctx context.Context, in *GroupControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*GroupControllerGetCapabilitiesResponse, error)
+	CreateVolumeGroupSnapshot(ctx context.Context, in *CreateVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*CreateVolumeGroupSnapshotResponse, error)
+	DeleteVolumeGroupSnapshot(ctx context.Context, in *DeleteVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*DeleteVolumeGroupSnapshotResponse, error)
+	GetVolumeGroupSnapshot(ctx context.Context, in *GetVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*GetVolumeGroupSnapshotResponse, error)
+}
+
+type groupControllerClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewGroupControllerClient(cc grpc.ClientConnInterface) GroupControllerClient {
+	return &groupControllerClient{cc}
+}
+
+func (c *groupControllerClient) GroupControllerGetCapabilities(ctx context.Context, in *GroupControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*GroupControllerGetCapabilitiesResponse, error) {
+	out := new(GroupControllerGetCapabilitiesResponse)
+	err := c.cc.Invoke(ctx, GroupController_GroupControllerGetCapabilities_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *groupControllerClient) CreateVolumeGroupSnapshot(ctx context.Context, in *CreateVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*CreateVolumeGroupSnapshotResponse, error) {
+	out := new(CreateVolumeGroupSnapshotResponse)
+	err := c.cc.Invoke(ctx, GroupController_CreateVolumeGroupSnapshot_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *groupControllerClient) DeleteVolumeGroupSnapshot(ctx context.Context, in *DeleteVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*DeleteVolumeGroupSnapshotResponse, error) {
+	out := new(DeleteVolumeGroupSnapshotResponse)
+	err := c.cc.Invoke(ctx, GroupController_DeleteVolumeGroupSnapshot_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *groupControllerClient) GetVolumeGroupSnapshot(ctx context.Context, in *GetVolumeGroupSnapshotRequest, opts ...grpc.CallOption) (*GetVolumeGroupSnapshotResponse, error) {
+	out := new(GetVolumeGroupSnapshotResponse)
+	err := c.cc.Invoke(ctx, GroupController_GetVolumeGroupSnapshot_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// GroupControllerServer is the server API for GroupController service.
+// All implementations must embed UnimplementedGroupControllerServer
+// for forward compatibility
+type GroupControllerServer interface {
+	GroupControllerGetCapabilities(context.Context, *GroupControllerGetCapabilitiesRequest) (*GroupControllerGetCapabilitiesResponse, error)
+	CreateVolumeGroupSnapshot(context.Context, *CreateVolumeGroupSnapshotRequest) (*CreateVolumeGroupSnapshotResponse, error)
+	DeleteVolumeGroupSnapshot(context.Context, *DeleteVolumeGroupSnapshotRequest) (*DeleteVolumeGroupSnapshotResponse, error)
+	GetVolumeGroupSnapshot(context.Context, *GetVolumeGroupSnapshotRequest) (*GetVolumeGroupSnapshotResponse, error)
+	mustEmbedUnimplementedGroupControllerServer()
+}
+
+// UnimplementedGroupControllerServer must be embedded to have forward compatible implementations.
+type UnimplementedGroupControllerServer struct {
+}
+
+func (UnimplementedGroupControllerServer) GroupControllerGetCapabilities(context.Context, *GroupControllerGetCapabilitiesRequest) (*GroupControllerGetCapabilitiesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GroupControllerGetCapabilities not implemented")
+}
+func (UnimplementedGroupControllerServer) CreateVolumeGroupSnapshot(context.Context, *CreateVolumeGroupSnapshotRequest) (*CreateVolumeGroupSnapshotResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateVolumeGroupSnapshot not implemented")
+}
+func (UnimplementedGroupControllerServer) DeleteVolumeGroupSnapshot(context.Context, *DeleteVolumeGroupSnapshotRequest) (*DeleteVolumeGroupSnapshotResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DeleteVolumeGroupSnapshot not implemented")
+}
+func (UnimplementedGroupControllerServer) GetVolumeGroupSnapshot(context.Context, *GetVolumeGroupSnapshotRequest) (*GetVolumeGroupSnapshotResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetVolumeGroupSnapshot not implemented")
+}
+func (UnimplementedGroupControllerServer) mustEmbedUnimplementedGroupControllerServer() {}
+
+// UnsafeGroupControllerServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to GroupControllerServer will
+// result in compilation errors.
+type UnsafeGroupControllerServer interface {
+	mustEmbedUnimplementedGroupControllerServer()
+}
+
+func RegisterGroupControllerServer(s grpc.ServiceRegistrar, srv GroupControllerServer) {
+	s.RegisterService(&GroupController_ServiceDesc, srv)
+}
+
+func _GroupController_GroupControllerGetCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GroupControllerGetCapabilitiesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GroupControllerServer).GroupControllerGetCapabilities(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GroupController_GroupControllerGetCapabilities_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GroupControllerServer).GroupControllerGetCapabilities(ctx, req.(*GroupControllerGetCapabilitiesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _GroupController_CreateVolumeGroupSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateVolumeGroupSnapshotRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GroupControllerServer).CreateVolumeGroupSnapshot(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GroupController_CreateVolumeGroupSnapshot_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GroupControllerServer).CreateVolumeGroupSnapshot(ctx, req.(*CreateVolumeGroupSnapshotRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _GroupController_DeleteVolumeGroupSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteVolumeGroupSnapshotRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GroupControllerServer).DeleteVolumeGroupSnapshot(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GroupController_DeleteVolumeGroupSnapshot_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GroupControllerServer).DeleteVolumeGroupSnapshot(ctx, req.(*DeleteVolumeGroupSnapshotRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _GroupController_GetVolumeGroupSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetVolumeGroupSnapshotRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GroupControllerServer).GetVolumeGroupSnapshot(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: GroupController_GetVolumeGroupSnapshot_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GroupControllerServer).GetVolumeGroupSnapshot(ctx, req.(*GetVolumeGroupSnapshotRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// GroupController_ServiceDesc is the grpc.ServiceDesc for GroupController service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var GroupController_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "csi.v1.GroupController",
+	HandlerType: (*GroupControllerServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GroupControllerGetCapabilities",
+			Handler:    _GroupController_GroupControllerGetCapabilities_Handler,
+		},
+		{
+			MethodName: "CreateVolumeGroupSnapshot",
+			Handler:    _GroupController_CreateVolumeGroupSnapshot_Handler,
+		},
+		{
+			MethodName: "DeleteVolumeGroupSnapshot",
+			Handler:    _GroupController_DeleteVolumeGroupSnapshot_Handler,
+		},
+		{
+			MethodName: "GetVolumeGroupSnapshot",
+			Handler:    _GroupController_GetVolumeGroupSnapshot_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "csi.proto",
+}
+
+const (
+	SnapshotMetadata_GetMetadataAllocated_FullMethodName = "/csi.v1.SnapshotMetadata/GetMetadataAllocated"
+	SnapshotMetadata_GetMetadataDelta_FullMethodName     = "/csi.v1.SnapshotMetadata/GetMetadataDelta"
+)
+
+// SnapshotMetadataClient is the client API for SnapshotMetadata service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type SnapshotMetadataClient interface {
+	GetMetadataAllocated(ctx context.Context, in *GetMetadataAllocatedRequest, opts ...grpc.CallOption) (SnapshotMetadata_GetMetadataAllocatedClient, error)
+	GetMetadataDelta(ctx context.Context, in *GetMetadataDeltaRequest, opts ...grpc.CallOption) (SnapshotMetadata_GetMetadataDeltaClient, error)
+}
+
+type snapshotMetadataClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewSnapshotMetadataClient(cc grpc.ClientConnInterface) SnapshotMetadataClient {
+	return &snapshotMetadataClient{cc}
+}
+
+func (c *snapshotMetadataClient) GetMetadataAllocated(ctx context.Context, in *GetMetadataAllocatedRequest, opts ...grpc.CallOption) (SnapshotMetadata_GetMetadataAllocatedClient, error) {
+	stream, err := c.cc.NewStream(ctx, &SnapshotMetadata_ServiceDesc.Streams[0], SnapshotMetadata_GetMetadataAllocated_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &snapshotMetadataGetMetadataAllocatedClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type SnapshotMetadata_GetMetadataAllocatedClient interface {
+	Recv() (*GetMetadataAllocatedResponse, error)
+	grpc.ClientStream
+}
+
+type snapshotMetadataGetMetadataAllocatedClient struct {
+	grpc.ClientStream
+}
+
+func (x *snapshotMetadataGetMetadataAllocatedClient) Recv() (*GetMetadataAllocatedResponse, error) {
+	m := new(GetMetadataAllocatedResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *snapshotMetadataClient) GetMetadataDelta(ctx context.Context, in *GetMetadataDeltaRequest, opts ...grpc.CallOption) (SnapshotMetadata_GetMetadataDeltaClient, error) {
+	stream, err := c.cc.NewStream(ctx, &SnapshotMetadata_ServiceDesc.Streams[1], SnapshotMetadata_GetMetadataDelta_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &snapshotMetadataGetMetadataDeltaClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type SnapshotMetadata_GetMetadataDeltaClient interface {
+	Recv() (*GetMetadataDeltaResponse, error)
+	grpc.ClientStream
+}
+
+type snapshotMetadataGetMetadataDeltaClient struct {
+	grpc.ClientStream
+}
+
+func (x *snapshotMetadataGetMetadataDeltaClient) Recv() (*GetMetadataDeltaResponse, error) {
+	m := new(GetMetadataDeltaResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// SnapshotMetadataServer is the server API for SnapshotMetadata service.
+// All implementations must embed UnimplementedSnapshotMetadataServer
+// for forward compatibility
+type SnapshotMetadataServer interface {
+	GetMetadataAllocated(*GetMetadataAllocatedRequest, SnapshotMetadata_GetMetadataAllocatedServer) error
+	GetMetadataDelta(*GetMetadataDeltaRequest, SnapshotMetadata_GetMetadataDeltaServer) error
+	mustEmbedUnimplementedSnapshotMetadataServer()
+}
+
+// UnimplementedSnapshotMetadataServer must be embedded to have forward compatible implementations.
+type UnimplementedSnapshotMetadataServer struct {
+}
+
+func (UnimplementedSnapshotMetadataServer) GetMetadataAllocated(*GetMetadataAllocatedRequest, SnapshotMetadata_GetMetadataAllocatedServer) error {
+	return status.Errorf(codes.Unimplemented, "method GetMetadataAllocated not implemented")
+}
+func (UnimplementedSnapshotMetadataServer) GetMetadataDelta(*GetMetadataDeltaRequest, SnapshotMetadata_GetMetadataDeltaServer) error {
+	return status.Errorf(codes.Unimplemented, "method GetMetadataDelta not implemented")
+}
+func (UnimplementedSnapshotMetadataServer) mustEmbedUnimplementedSnapshotMetadataServer() {}
+
+// UnsafeSnapshotMetadataServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to SnapshotMetadataServer will
+// result in compilation errors.
+type UnsafeSnapshotMetadataServer interface {
+	mustEmbedUnimplementedSnapshotMetadataServer()
+}
+
+func RegisterSnapshotMetadataServer(s grpc.ServiceRegistrar, srv SnapshotMetadataServer) {
+	s.RegisterService(&SnapshotMetadata_ServiceDesc, srv)
+}
+
+func _SnapshotMetadata_GetMetadataAllocated_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetMetadataAllocatedRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(SnapshotMetadataServer).GetMetadataAllocated(m, &snapshotMetadataGetMetadataAllocatedServer{stream})
+}
+
+type SnapshotMetadata_GetMetadataAllocatedServer interface {
+	Send(*GetMetadataAllocatedResponse) error
+	grpc.ServerStream
+}
+
+type snapshotMetadataGetMetadataAllocatedServer struct {
+	grpc.ServerStream
+}
+
+func (x *snapshotMetadataGetMetadataAllocatedServer) Send(m *GetMetadataAllocatedResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _SnapshotMetadata_GetMetadataDelta_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetMetadataDeltaRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(SnapshotMetadataServer).GetMetadataDelta(m, &snapshotMetadataGetMetadataDeltaServer{stream})
+}
+
+type SnapshotMetadata_GetMetadataDeltaServer interface {
+	Send(*GetMetadataDeltaResponse) error
+	grpc.ServerStream
+}
+
+type snapshotMetadataGetMetadataDeltaServer struct {
+	grpc.ServerStream
+}
+
+func (x *snapshotMetadataGetMetadataDeltaServer) Send(m *GetMetadataDeltaResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+// SnapshotMetadata_ServiceDesc is the grpc.ServiceDesc for SnapshotMetadata service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var SnapshotMetadata_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "csi.v1.SnapshotMetadata",
+	HandlerType: (*SnapshotMetadataServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "GetMetadataAllocated",
+			Handler:       _SnapshotMetadata_GetMetadataAllocated_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "GetMetadataDelta",
+			Handler:       _SnapshotMetadata_GetMetadataDelta_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "csi.proto",
+}
+
+const (
+	Node_NodeStageVolume_FullMethodName     = "/csi.v1.Node/NodeStageVolume"
+	Node_NodeUnstageVolume_FullMethodName   = "/csi.v1.Node/NodeUnstageVolume"
+	Node_NodePublishVolume_FullMethodName   = "/csi.v1.Node/NodePublishVolume"
+	Node_NodeUnpublishVolume_FullMethodName = "/csi.v1.Node/NodeUnpublishVolume"
+	Node_NodeGetVolumeStats_FullMethodName  = "/csi.v1.Node/NodeGetVolumeStats"
+	Node_NodeExpandVolume_FullMethodName    = "/csi.v1.Node/NodeExpandVolume"
+	Node_NodeGetCapabilities_FullMethodName = "/csi.v1.Node/NodeGetCapabilities"
+	Node_NodeGetInfo_FullMethodName         = "/csi.v1.Node/NodeGetInfo"
+)
+
+// NodeClient is the client API for Node service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type NodeClient interface {
+	NodeStageVolume(ctx context.Context, in *NodeStageVolumeRequest, opts ...grpc.CallOption) (*NodeStageVolumeResponse, error)
+	NodeUnstageVolume(ctx context.Context, in *NodeUnstageVolumeRequest, opts ...grpc.CallOption) (*NodeUnstageVolumeResponse, error)
+	NodePublishVolume(ctx context.Context, in *NodePublishVolumeRequest, opts ...grpc.CallOption) (*NodePublishVolumeResponse, error)
+	NodeUnpublishVolume(ctx context.Context, in *NodeUnpublishVolumeRequest, opts ...grpc.CallOption) (*NodeUnpublishVolumeResponse, error)
+	NodeGetVolumeStats(ctx context.Context, in *NodeGetVolumeStatsRequest, opts ...grpc.CallOption) (*NodeGetVolumeStatsResponse, error)
+	NodeExpandVolume(ctx context.Context, in *NodeExpandVolumeRequest, opts ...grpc.CallOption) (*NodeExpandVolumeResponse, error)
+	NodeGetCapabilities(ctx context.Context, in *NodeGetCapabilitiesRequest, opts ...grpc.CallOption) (*NodeGetCapabilitiesResponse, error)
+	NodeGetInfo(ctx context.Context, in *NodeGetInfoRequest, opts ...grpc.CallOption) (*NodeGetInfoResponse, error)
+}
+
+type nodeClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewNodeClient(cc grpc.ClientConnInterface) NodeClient {
+	return &nodeClient{cc}
+}
+
+func (c *nodeClient) NodeStageVolume(ctx context.Context, in *NodeStageVolumeRequest, opts ...grpc.CallOption) (*NodeStageVolumeResponse, error) {
+	out := new(NodeStageVolumeResponse)
+	err := c.cc.Invoke(ctx, Node_NodeStageVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *nodeClient) NodeUnstageVolume(ctx context.Context, in *NodeUnstageVolumeRequest, opts ...grpc.CallOption) (*NodeUnstageVolumeResponse, error) {
+	out := new(NodeUnstageVolumeResponse)
+	err := c.cc.Invoke(ctx, Node_NodeUnstageVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *nodeClient) NodePublishVolume(ctx context.Context, in *NodePublishVolumeRequest, opts ...grpc.CallOption) (*NodePublishVolumeResponse, error) {
+	out := new(NodePublishVolumeResponse)
+	err := c.cc.Invoke(ctx, Node_NodePublishVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *nodeClient) NodeUnpublishVolume(ctx context.Context, in *NodeUnpublishVolumeRequest, opts ...grpc.CallOption) (*NodeUnpublishVolumeResponse, error) {
+	out := new(NodeUnpublishVolumeResponse)
+	err := c.cc.Invoke(ctx, Node_NodeUnpublishVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *nodeClient) NodeGetVolumeStats(ctx context.Context, in *NodeGetVolumeStatsRequest, opts ...grpc.CallOption) (*NodeGetVolumeStatsResponse, error) {
+	out := new(NodeGetVolumeStatsResponse)
+	err := c.cc.Invoke(ctx, Node_NodeGetVolumeStats_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *nodeClient) NodeExpandVolume(ctx context.Context, in *NodeExpandVolumeRequest, opts ...grpc.CallOption) (*NodeExpandVolumeResponse, error) {
+	out := new(NodeExpandVolumeResponse)
+	err := c.cc.Invoke(ctx, Node_NodeExpandVolume_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *nodeClient) NodeGetCapabilities(ctx context.Context, in *NodeGetCapabilitiesRequest, opts ...grpc.CallOption) (*NodeGetCapabilitiesResponse, error) {
+	out := new(NodeGetCapabilitiesResponse)
+	err := c.cc.Invoke(ctx, Node_NodeGetCapabilities_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *nodeClient) NodeGetInfo(ctx context.Context, in *NodeGetInfoRequest, opts ...grpc.CallOption) (*NodeGetInfoResponse, error) {
+	out := new(NodeGetInfoResponse)
+	err := c.cc.Invoke(ctx, Node_NodeGetInfo_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// NodeServer is the server API for Node service.
+// All implementations must embed UnimplementedNodeServer
+// for forward compatibility
+type NodeServer interface {
+	NodeStageVolume(context.Context, *NodeStageVolumeRequest) (*NodeStageVolumeResponse, error)
+	NodeUnstageVolume(context.Context, *NodeUnstageVolumeRequest) (*NodeUnstageVolumeResponse, error)
+	NodePublishVolume(context.Context, *NodePublishVolumeRequest) (*NodePublishVolumeResponse, error)
+	NodeUnpublishVolume(context.Context, *NodeUnpublishVolumeRequest) (*NodeUnpublishVolumeResponse, error)
+	NodeGetVolumeStats(context.Context, *NodeGetVolumeStatsRequest) (*NodeGetVolumeStatsResponse, error)
+	NodeExpandVolume(context.Context, *NodeExpandVolumeRequest) (*NodeExpandVolumeResponse, error)
+	NodeGetCapabilities(context.Context, *NodeGetCapabilitiesRequest) (*NodeGetCapabilitiesResponse, error)
+	NodeGetInfo(context.Context, *NodeGetInfoRequest) (*NodeGetInfoResponse, error)
+	mustEmbedUnimplementedNodeServer()
+}
+
+// UnimplementedNodeServer must be embedded to have forward compatible implementations.
+type UnimplementedNodeServer struct {
+}
+
+func (UnimplementedNodeServer) NodeStageVolume(context.Context, *NodeStageVolumeRequest) (*NodeStageVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NodeStageVolume not implemented")
+}
+func (UnimplementedNodeServer) NodeUnstageVolume(context.Context, *NodeUnstageVolumeRequest) (*NodeUnstageVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NodeUnstageVolume not implemented")
+}
+func (UnimplementedNodeServer) NodePublishVolume(context.Context, *NodePublishVolumeRequest) (*NodePublishVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NodePublishVolume not implemented")
+}
+func (UnimplementedNodeServer) NodeUnpublishVolume(context.Context, *NodeUnpublishVolumeRequest) (*NodeUnpublishVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NodeUnpublishVolume not implemented")
+}
+func (UnimplementedNodeServer) NodeGetVolumeStats(context.Context, *NodeGetVolumeStatsRequest) (*NodeGetVolumeStatsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NodeGetVolumeStats not implemented")
+}
+func (UnimplementedNodeServer) NodeExpandVolume(context.Context, *NodeExpandVolumeRequest) (*NodeExpandVolumeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NodeExpandVolume not implemented")
+}
+func (UnimplementedNodeServer) NodeGetCapabilities(context.Context, *NodeGetCapabilitiesRequest) (*NodeGetCapabilitiesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NodeGetCapabilities not implemented")
+}
+func (UnimplementedNodeServer) NodeGetInfo(context.Context, *NodeGetInfoRequest) (*NodeGetInfoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NodeGetInfo not implemented")
+}
+func (UnimplementedNodeServer) mustEmbedUnimplementedNodeServer() {}
+
+// UnsafeNodeServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to NodeServer will
+// result in compilation errors.
+type UnsafeNodeServer interface {
+	mustEmbedUnimplementedNodeServer()
+}
+
+func RegisterNodeServer(s grpc.ServiceRegistrar, srv NodeServer) {
+	s.RegisterService(&Node_ServiceDesc, srv)
+}
+
+func _Node_NodeStageVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodeStageVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).NodeStageVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_NodeStageVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).NodeStageVolume(ctx, req.(*NodeStageVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Node_NodeUnstageVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodeUnstageVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).NodeUnstageVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_NodeUnstageVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).NodeUnstageVolume(ctx, req.(*NodeUnstageVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Node_NodePublishVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodePublishVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).NodePublishVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_NodePublishVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).NodePublishVolume(ctx, req.(*NodePublishVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Node_NodeUnpublishVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodeUnpublishVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).NodeUnpublishVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_NodeUnpublishVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).NodeUnpublishVolume(ctx, req.(*NodeUnpublishVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Node_NodeGetVolumeStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodeGetVolumeStatsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).NodeGetVolumeStats(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_NodeGetVolumeStats_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).NodeGetVolumeStats(ctx, req.(*NodeGetVolumeStatsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Node_NodeExpandVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodeExpandVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).NodeExpandVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_NodeExpandVolume_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).NodeExpandVolume(ctx, req.(*NodeExpandVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Node_NodeGetCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodeGetCapabilitiesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).NodeGetCapabilities(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_NodeGetCapabilities_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).NodeGetCapabilities(ctx, req.(*NodeGetCapabilitiesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Node_NodeGetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodeGetInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).NodeGetInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_NodeGetInfo_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).NodeGetInfo(ctx, req.(*NodeGetInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Node_ServiceDesc is the grpc.ServiceDesc for Node service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Node_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "csi.v1.Node",
+	HandlerType: (*NodeServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "NodeStageVolume",
+			Handler:    _Node_NodeStageVolume_Handler,
+		},
+		{
+			MethodName: "NodeUnstageVolume",
+			Handler:    _Node_NodeUnstageVolume_Handler,
+		},
+		{
+			MethodName: "NodePublishVolume",
+			Handler:    _Node_NodePublishVolume_Handler,
+		},
+		{
+			MethodName: "NodeUnpublishVolume",
+			Handler:    _Node_NodeUnpublishVolume_Handler,
+		},
+		{
+			MethodName: "NodeGetVolumeStats",
+			Handler:    _Node_NodeGetVolumeStats_Handler,
+		},
+		{
+			MethodName: "NodeExpandVolume",
+			Handler:    _Node_NodeExpandVolume_Handler,
+		},
+		{
+			MethodName: "NodeGetCapabilities",
+			Handler:    _Node_NodeGetCapabilities_Handler,
+		},
+		{
+			MethodName: "NodeGetInfo",
+			Handler:    _Node_NodeGetInfo_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "csi.proto",
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go
deleted file mode 100644
index cc40f27ad..000000000
--- a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go
+++ /dev/null
@@ -1,71 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/wrappers/wrappers.proto
-
-package wrappers
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
-	reflect "reflect"
-)
-
-// Symbols defined in public import of google/protobuf/wrappers.proto.
-
-type DoubleValue = wrapperspb.DoubleValue
-type FloatValue = wrapperspb.FloatValue
-type Int64Value = wrapperspb.Int64Value
-type UInt64Value = wrapperspb.UInt64Value
-type Int32Value = wrapperspb.Int32Value
-type UInt32Value = wrapperspb.UInt32Value
-type BoolValue = wrapperspb.BoolValue
-type StringValue = wrapperspb.StringValue
-type BytesValue = wrapperspb.BytesValue
-
-var File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc = []byte{
-	0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2f, 0x77, 0x72, 0x61,
-	0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61,
-	0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x35, 0x5a, 0x33, 0x67,
-	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
-	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73,
-	0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x3b, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65,
-	0x72, 0x73, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() }
-func file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() {
-	if File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto != nil {
-		return
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   0,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes,
-		DependencyIndexes: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs,
-	}.Build()
-	File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto = out.File
-	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc = nil
-	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = nil
-	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = nil
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 91d6fa8a0..aed2a1603 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -7,7 +7,7 @@ github.com/blang/semver/v4
 # github.com/cespare/xxhash/v2 v2.3.0
 ## explicit; go 1.11
 github.com/cespare/xxhash/v2
-# github.com/container-storage-interface/spec v1.9.0
+# github.com/container-storage-interface/spec v1.10.1-0.20241022120259-f6b6d53db606
 ## explicit; go 1.18
 github.com/container-storage-interface/spec/lib/go/csi
 # github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
@@ -64,7 +64,6 @@ github.com/golang/protobuf/ptypes
 github.com/golang/protobuf/ptypes/any
 github.com/golang/protobuf/ptypes/duration
 github.com/golang/protobuf/ptypes/timestamp
-github.com/golang/protobuf/ptypes/wrappers
 # github.com/google/gnostic-models v0.6.8
 ## explicit; go 1.18
 github.com/google/gnostic-models/compiler
@@ -114,7 +113,7 @@ github.com/kubernetes-csi/csi-lib-utils/leaderelection
 github.com/kubernetes-csi/csi-lib-utils/metrics
 github.com/kubernetes-csi/csi-lib-utils/protosanitizer
 github.com/kubernetes-csi/csi-lib-utils/rpc
-# github.com/kubernetes-csi/csi-test/v5 v5.2.0
+# github.com/kubernetes-csi/csi-test/v5 v5.3.1
 ## explicit; go 1.18
 github.com/kubernetes-csi/csi-test/v5/driver
 github.com/kubernetes-csi/csi-test/v5/utils



Test patch:
diff --git a/cmd/csi-snapshotter/main_test.go b/cmd/csi-snapshotter/main_test.go
index c3ecf9d58..a366a3bb4 100644
--- a/cmd/csi-snapshotter/main_test.go
+++ b/cmd/csi-snapshotter/main_test.go
@@ -26,6 +26,7 @@ import (
 	"github.com/kubernetes-csi/csi-lib-utils/connection"
 	"github.com/kubernetes-csi/csi-lib-utils/metrics"
 	"github.com/kubernetes-csi/csi-test/v5/driver"
+	"github.com/kubernetes-csi/csi-test/v5/utils"
 
 	"google.golang.org/grpc"
 )
@@ -125,7 +126,7 @@ func Test_supportsControllerCreateSnapshot(t *testing.T) {
 		}
 
 		// Setup expectation
-		controllerServer.EXPECT().ControllerGetCapabilities(gomock.Any(), in).Return(out, injectedErr).Times(1)
+		controllerServer.EXPECT().ControllerGetCapabilities(gomock.Any(), utils.Protobuf(in)).Return(out, injectedErr).Times(1)
 
 		ok, err := supportsControllerCreateSnapshot(context.Background(), csiConn)
 		if test.expectError && err == nil {
diff --git a/pkg/snapshotter/snapshotter_test.go b/pkg/snapshotter/snapshotter_test.go
index 148848fff..314c02317 100644
--- a/pkg/snapshotter/snapshotter_test.go
+++ b/pkg/snapshotter/snapshotter_test.go
@@ -28,6 +28,7 @@ import (
 	"github.com/kubernetes-csi/csi-lib-utils/connection"
 	"github.com/kubernetes-csi/csi-lib-utils/metrics"
 	"github.com/kubernetes-csi/csi-test/v5/driver"
+	"github.com/kubernetes-csi/csi-test/v5/utils"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
@@ -210,7 +211,7 @@ func TestCreateSnapshot(t *testing.T) {
 		// Setup expectation
 		if in != nil {
 			identityServer.EXPECT().GetPluginInfo(gomock.Any(), gomock.Any()).Return(pluginInfoOutput, nil).Times(1)
-			controllerServer.EXPECT().CreateSnapshot(gomock.Any(), in).Return(out, injectedErr).Times(1)
+			controllerServer.EXPECT().CreateSnapshot(gomock.Any(), utils.Protobuf(in)).Return(out, injectedErr).Times(1)
 		}
 
 		s := NewSnapshotter(csiConn)
@@ -318,7 +319,7 @@ func TestDeleteSnapshot(t *testing.T) {
 
 		// Setup expectation
 		if in != nil {
-			controllerServer.EXPECT().DeleteSnapshot(gomock.Any(), in).Return(out, injectedErr).Times(1)
+			controllerServer.EXPECT().DeleteSnapshot(gomock.Any(), utils.Protobuf(in)).Return(out, injectedErr).Times(1)
 		}
 
 		s := NewSnapshotter(csiConn)
@@ -463,7 +464,7 @@ func TestGetSnapshotStatus(t *testing.T) {
 				Capabilities: controllerCapabilities,
 			}, nil).Times(1)
 			if test.listSnapshotsSupported {
-				controllerServer.EXPECT().ListSnapshots(gomock.Any(), in).Return(out, injectedErr).Times(1)
+				controllerServer.EXPECT().ListSnapshots(gomock.Any(), utils.Protobuf(in)).Return(out, injectedErr).Times(1)
 			}
 		}
 
diff --git a/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver-controller.go b/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver-controller.go
index 9205795a8..b40b427f1 100644
--- a/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver-controller.go
+++ b/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver-controller.go
@@ -29,8 +29,9 @@ import (
 
 // CSIDriverControllerServer is the Controller service component of the driver.
 type CSIDriverControllerServer struct {
-	Controller csi.ControllerServer
-	Identity   csi.IdentityServer
+	Controller       csi.ControllerServer
+	Identity         csi.IdentityServer
+	SnapshotMetadata csi.SnapshotMetadataServer
 }
 
 // CSIDriverController is the CSI Driver Controller backend.
@@ -76,6 +77,9 @@ func (c *CSIDriverController) Start(l net.Listener) error {
 	if c.controllerServer.Identity != nil {
 		csi.RegisterIdentityServer(c.server, c.controllerServer.Identity)
 	}
+	if c.controllerServer.SnapshotMetadata != nil {
+		csi.RegisterSnapshotMetadataServer(c.server, c.controllerServer.SnapshotMetadata)
+	}
 
 	reflection.Register(c.server)
 
diff --git a/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.go b/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.go
index 8e30fd2f9..502723d27 100644
--- a/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.go
+++ b/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-//go:generate mockgen -package=driver -destination=driver.mock.go github.com/container-storage-interface/spec/lib/go/csi IdentityServer,ControllerServer,NodeServer
+//go:generate mockgen -package=driver -destination=driver.mock.go github.com/container-storage-interface/spec/lib/go/csi IdentityServer,ControllerServer,NodeServer,SnapshotMetadataServer
 
 package driver
 
@@ -47,9 +47,10 @@ var (
 // CSIDriverServers is a unified driver component with both Controller and Node
 // services.
 type CSIDriverServers struct {
-	Controller csi.ControllerServer
-	Identity   csi.IdentityServer
-	Node       csi.NodeServer
+	Controller       csi.ControllerServer
+	Identity         csi.IdentityServer
+	Node             csi.NodeServer
+	SnapshotMetadata csi.SnapshotMetadataServer
 }
 
 // This is the key name in all the CSI secret objects.
@@ -116,6 +117,10 @@ func (c *CSIDriver) Start(l net.Listener) error {
 	if c.servers.Node != nil {
 		csi.RegisterNodeServer(c.server, c.servers.Node)
 	}
+	if c.servers.SnapshotMetadata != nil {
+		csi.RegisterSnapshotMetadataServer(c.server, c.servers.SnapshotMetadata)
+	}
+
 	reflection.Register(c.server)
 
 	// Start listening for requests
diff --git a/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.mock.go b/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.mock.go
index 40b377654..e8da0ba98 100644
--- a/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.mock.go
+++ b/vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.mock.go
@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/container-storage-interface/spec/lib/go/csi (interfaces: IdentityServer,ControllerServer,NodeServer)
+// Source: github.com/container-storage-interface/spec/lib/go/csi (interfaces: IdentityServer,ControllerServer,NodeServer,SnapshotMetadataServer)
 
 // Package driver is a generated GoMock package.
 package driver
@@ -80,6 +80,18 @@ func (mr *MockIdentityServerMockRecorder) Probe(arg0, arg1 interface{}) *gomock.
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Probe", reflect.TypeOf((*MockIdentityServer)(nil).Probe), arg0, arg1)
 }
 
+// mustEmbedUnimplementedIdentityServer mocks base method.
+func (m *MockIdentityServer) mustEmbedUnimplementedIdentityServer() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "mustEmbedUnimplementedIdentityServer")
+}
+
+// mustEmbedUnimplementedIdentityServer indicates an expected call of mustEmbedUnimplementedIdentityServer.
+func (mr *MockIdentityServerMockRecorder) mustEmbedUnimplementedIdentityServer() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedIdentityServer", reflect.TypeOf((*MockIdentityServer)(nil).mustEmbedUnimplementedIdentityServer))
+}
+
 // MockControllerServer is a mock of ControllerServer interface.
 type MockControllerServer struct {
 	ctrl     *gomock.Controller
@@ -313,6 +325,18 @@ func (mr *MockControllerServerMockRecorder) ValidateVolumeCapabilities(arg0, arg
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateVolumeCapabilities", reflect.TypeOf((*MockControllerServer)(nil).ValidateVolumeCapabilities), arg0, arg1)
 }
 
+// mustEmbedUnimplementedControllerServer mocks base method.
+func (m *MockControllerServer) mustEmbedUnimplementedControllerServer() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "mustEmbedUnimplementedControllerServer")
+}
+
+// mustEmbedUnimplementedControllerServer indicates an expected call of mustEmbedUnimplementedControllerServer.
+func (mr *MockControllerServerMockRecorder) mustEmbedUnimplementedControllerServer() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedControllerServer", reflect.TypeOf((*MockControllerServer)(nil).mustEmbedUnimplementedControllerServer))
+}
+
 // MockNodeServer is a mock of NodeServer interface.
 type MockNodeServer struct {
 	ctrl     *gomock.Controller
@@ -455,3 +479,78 @@ func (mr *MockNodeServerMockRecorder) NodeUnstageVolume(arg0, arg1 interface{})
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUnstageVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeUnstageVolume), arg0, arg1)
 }
+
+// mustEmbedUnimplementedNodeServer mocks base method.
+func (m *MockNodeServer) mustEmbedUnimplementedNodeServer() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "mustEmbedUnimplementedNodeServer")
+}
+
+// mustEmbedUnimplementedNodeServer indicates an expected call of mustEmbedUnimplementedNodeServer.
+func (mr *MockNodeServerMockRecorder) mustEmbedUnimplementedNodeServer() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedNodeServer", reflect.TypeOf((*MockNodeServer)(nil).mustEmbedUnimplementedNodeServer))
+}
+
+// MockSnapshotMetadataServer is a mock of SnapshotMetadataServer interface.
+type MockSnapshotMetadataServer struct {
+	ctrl     *gomock.Controller
+	recorder *MockSnapshotMetadataServerMockRecorder
+}
+
+// MockSnapshotMetadataServerMockRecorder is the mock recorder for MockSnapshotMetadataServer.
+type MockSnapshotMetadataServerMockRecorder struct {
+	mock *MockSnapshotMetadataServer
+}
+
+// NewMockSnapshotMetadataServer creates a new mock instance.
+func NewMockSnapshotMetadataServer(ctrl *gomock.Controller) *MockSnapshotMetadataServer {
+	mock := &MockSnapshotMetadataServer{ctrl: ctrl}
+	mock.recorder = &MockSnapshotMetadataServerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockSnapshotMetadataServer) EXPECT() *MockSnapshotMetadataServerMockRecorder {
+	return m.recorder
+}
+
+// GetMetadataAllocated mocks base method.
+func (m *MockSnapshotMetadataServer) GetMetadataAllocated(arg0 *csi.GetMetadataAllocatedRequest, arg1 csi.SnapshotMetadata_GetMetadataAllocatedServer) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMetadataAllocated", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// GetMetadataAllocated indicates an expected call of GetMetadataAllocated.
+func (mr *MockSnapshotMetadataServerMockRecorder) GetMetadataAllocated(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadataAllocated", reflect.TypeOf((*MockSnapshotMetadataServer)(nil).GetMetadataAllocated), arg0, arg1)
+}
+
+// GetMetadataDelta mocks base method.
+func (m *MockSnapshotMetadataServer) GetMetadataDelta(arg0 *csi.GetMetadataDeltaRequest, arg1 csi.SnapshotMetadata_GetMetadataDeltaServer) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMetadataDelta", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// GetMetadataDelta indicates an expected call of GetMetadataDelta.
+func (mr *MockSnapshotMetadataServerMockRecorder) GetMetadataDelta(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadataDelta", reflect.TypeOf((*MockSnapshotMetadataServer)(nil).GetMetadataDelta), arg0, arg1)
+}
+
+// mustEmbedUnimplementedSnapshotMetadataServer mocks base method.
+func (m *MockSnapshotMetadataServer) mustEmbedUnimplementedSnapshotMetadataServer() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "mustEmbedUnimplementedSnapshotMetadataServer")
+}
+
+// mustEmbedUnimplementedSnapshotMetadataServer indicates an expected call of mustEmbedUnimplementedSnapshotMetadataServer.
+func (mr *MockSnapshotMetadataServerMockRecorder) mustEmbedUnimplementedSnapshotMetadataServer() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedSnapshotMetadataServer", reflect.TypeOf((*MockSnapshotMetadataServer)(nil).mustEmbedUnimplementedSnapshotMetadataServer))
+}
diff --git a/vendor/github.com/kubernetes-csi/csi-test/v5/driver/mock.go b/vendor/github.com/kubernetes-csi/csi-test/v5/driver/mock.go
index 3863dc370..c9088542a 100644
--- a/vendor/github.com/kubernetes-csi/csi-test/v5/driver/mock.go
+++ b/vendor/github.com/kubernetes-csi/csi-test/v5/driver/mock.go
@@ -19,14 +19,17 @@ package driver
 import (
 	"net"
 
-	"github.com/kubernetes-csi/csi-test/v5/utils"
+	"github.com/container-storage-interface/spec/lib/go/csi"
 	"google.golang.org/grpc"
+
+	"github.com/kubernetes-csi/csi-test/v5/utils"
 )
 
 type MockCSIDriverServers struct {
-	Controller *MockControllerServer
-	Identity   *MockIdentityServer
-	Node       *MockNodeServer
+	Controller       *MockControllerServer
+	Identity         *MockIdentityServer
+	Node             *MockNodeServer
+	SnapshotMetadata *MockSnapshotMetadataServer
 }
 
 type MockCSIDriver struct {
@@ -38,9 +41,22 @@ func NewMockCSIDriver(servers *MockCSIDriverServers) *MockCSIDriver {
 	return &MockCSIDriver{
 		CSIDriver: CSIDriver{
 			servers: &CSIDriverServers{
-				Controller: servers.Controller,
-				Node:       servers.Node,
-				Identity:   servers.Identity,
+				Controller: struct {
+					csi.UnsafeControllerServer
+					*MockControllerServer
+				}{MockControllerServer: servers.Controller},
+				Node: struct {
+					csi.UnsafeNodeServer
+					*MockNodeServer
+				}{MockNodeServer: servers.Node},
+				Identity: struct {
+					csi.UnsafeIdentityServer
+					*MockIdentityServer
+				}{MockIdentityServer: servers.Identity},
+				SnapshotMetadata: struct {
+					csi.UnsafeSnapshotMetadataServer
+					*MockSnapshotMetadataServer
+				}{MockSnapshotMetadataServer: servers.SnapshotMetadata},
 			},
 		},
 	}
diff --git a/vendor/github.com/kubernetes-csi/csi-test/v5/utils/protobuf_matcher.go b/vendor/github.com/kubernetes-csi/csi-test/v5/utils/protobuf_matcher.go
new file mode 100644
index 000000000..5a2a70165
--- /dev/null
+++ b/vendor/github.com/kubernetes-csi/csi-test/v5/utils/protobuf_matcher.go
@@ -0,0 +1,33 @@
+package utils
+
+import (
+	"github.com/golang/mock/gomock"
+	"google.golang.org/protobuf/encoding/prototext"
+	"google.golang.org/protobuf/proto"
+)
+
+// Protobuf returns a Matcher that relies upon proto.Equal to compare Protobuf messages
+// Example usage with mocked request:
+//
+// example.EXPECT().ExampleRequest(Protobuf(requestMsg)).Return(responseMsg, nil).AnyTimes()
+func Protobuf(msg proto.Message) gomock.Matcher {
+	return &ProtobufMatcher{msg}
+}
+
+type ProtobufMatcher struct {
+	msg proto.Message
+}
+
+var _ gomock.Matcher = &ProtobufMatcher{}
+
+func (p *ProtobufMatcher) Matches(x interface{}) bool {
+	otherMsg, ok := x.(proto.Message)
+	if !ok {
+		return false
+	}
+	return proto.Equal(p.msg, otherMsg)
+}
+
+func (p *ProtobufMatcher) String() string {
+	return prototext.Format(p.msg)
+}