From 37171a0f06b6c923f768382328a9f0743efcfa92 Mon Sep 17 00:00:00 2001 From: Parthiba-Hazra Date: Wed, 11 Mar 2026 19:14:54 +0530 Subject: [PATCH 1/7] crd generation and env configmaps --- api/v1/imageanalysisresult_types.go | 219 ++++++++++++ api/v1/zz_generated.deepcopy.go | 230 +++++++++++++ .../devzero.io_imageanalysisresults.yaml | 294 +++++++++++++++++ config/manager/env_configmap.yaml | 32 ++ internal/controller/image_analysis_config.go | 311 ++++++++++++++++++ .../controller/image_analysis_config_test.go | 258 +++++++++++++++ internal/util/env.go | 6 + 7 files changed, 1350 insertions(+) create mode 100644 api/v1/imageanalysisresult_types.go create mode 100644 config/crd/bases/devzero.io_imageanalysisresults.yaml create mode 100644 internal/controller/image_analysis_config.go create mode 100644 internal/controller/image_analysis_config_test.go diff --git a/api/v1/imageanalysisresult_types.go b/api/v1/imageanalysisresult_types.go new file mode 100644 index 00000000..e58cc5be --- /dev/null +++ b/api/v1/imageanalysisresult_types.go @@ -0,0 +1,219 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// ImageAnalysisResultSpec defines the desired state of ImageAnalysisResult +type ImageAnalysisResultSpec struct { + // ImageRef is the full image reference including tag (e.g. "docker.io/library/nginx:1.25.3") + ImageRef string `json:"imageRef"` + + // ImageDigest is the image digest (e.g. "sha256:a1b2c3d4e5f6...") + ImageDigest string `json:"imageDigest"` + + // ImageSizeBytes is the total size of the image in bytes + ImageSizeBytes int64 `json:"imageSizeBytes,omitempty"` + + // ImageSource describes how the image was acquired for analysis + ImageSource ImageSourceInfo `json:"imageSource"` + + // Analysis contains the dive analysis results + Analysis ImageAnalysis `json:"analysis"` + + // WorkloadSummary is a high-level summary of workloads using this image + WorkloadSummary WorkloadSummary `json:"workloadSummary,omitempty"` + + // WorkloadReferences lists the workloads using this image (capped at 200, sorted by replica count desc) + // +optional + WorkloadReferences []WorkloadReference `json:"workloadReferences,omitempty"` +} + +// ImageSourceInfo describes how the image was acquired for analysis +type ImageSourceInfo struct { + // Type is the image acquisition method: "local-containerd" or "remote-pull" + // +kubebuilder:validation:Enum=local-containerd;remote-pull + Type string `json:"type"` + + // NodeName is the node where the analysis job ran + NodeName string `json:"nodeName"` + + // ExportDurationMs is how long it took to export/pull the image in milliseconds + ExportDurationMs int64 `json:"exportDurationMs,omitempty"` + + // BatchJobName is the name of the batch job that analyzed this image + BatchJobName string `json:"batchJobName,omitempty"` +} + +// ImageAnalysis contains the dive analysis results +type ImageAnalysis struct { + // Efficiency is the image efficiency ratio as a string (e.g. "0.9516") + // Stored as string for cross-language CRD compatibility. Range: "0.0" to "1.0". + Efficiency string `json:"efficiency"` + + // WastedBytes is the total wasted space in bytes + WastedBytes int64 `json:"wastedBytes"` + + // UserWastedPercent is the percentage of user image space that is wasted as a string (e.g. "0.016") + // Stored as string for cross-language CRD compatibility. Range: "0.0" to "1.0". + UserWastedPercent string `json:"userWastedPercent"` + + // Passed indicates whether the image meets the configured efficiency thresholds + Passed bool `json:"passed"` + + // LayerCount is the total number of layers in the image + LayerCount int `json:"layerCount"` + + // Layers contains details for each image layer + // +optional + Layers []LayerInfo `json:"layers,omitempty"` + + // FileAnalysis contains aggregate file statistics across all layers + // +optional + FileAnalysis *FileAnalysis `json:"fileAnalysis,omitempty"` + + // WastedFiles lists the top files contributing to wasted space (capped at 50) + // +optional + WastedFiles []WastedFile `json:"wastedFiles,omitempty"` +} + +// LayerInfo contains details about a single image layer +type LayerInfo struct { + // Index is the layer position (0 = base layer) + Index int `json:"index"` + + // Digest is the layer digest + Digest string `json:"digest,omitempty"` + + // SizeBytes is the layer size in bytes + SizeBytes int64 `json:"sizeBytes"` + + // Command is the Dockerfile instruction that created this layer (truncated to 200 chars) + Command string `json:"command,omitempty"` +} + +// FileAnalysis contains aggregate file statistics +type FileAnalysis struct { + // TotalFiles is the total number of files in the image + TotalFiles int `json:"totalFiles,omitempty"` + + // ModifiedFiles is the count of files modified across layers + ModifiedFiles int `json:"modifiedFiles,omitempty"` + + // AddedFiles is the count of files added across layers + AddedFiles int `json:"addedFiles,omitempty"` + + // RemovedFiles is the count of files removed across layers + RemovedFiles int `json:"removedFiles,omitempty"` +} + +// WastedFile identifies a file or directory contributing to wasted space +type WastedFile struct { + // Path is the file or directory path + Path string `json:"path"` + + // SizeBytes is the wasted space from this file in bytes + SizeBytes int64 `json:"sizeBytes"` +} + +// WorkloadSummary provides a high-level summary of workloads using this image +type WorkloadSummary struct { + // TotalContainers is the total number of container instances using this image across the cluster + TotalContainers int `json:"totalContainers,omitempty"` + + // TotalWorkloads is the count of unique workloads (Deployments, StatefulSets, etc.) using this image + TotalWorkloads int `json:"totalWorkloads,omitempty"` + + // NodesRunningImage is the count of nodes that have containers running this image + NodesRunningImage int `json:"nodesRunningImage,omitempty"` + + // Namespaces lists the namespaces where this image is used + Namespaces []string `json:"namespaces,omitempty"` +} + +// WorkloadReference identifies a workload that uses this image +type WorkloadReference struct { + // Namespace is the workload's namespace + Namespace string `json:"namespace"` + + // WorkloadType is the kind of workload (e.g. "Deployment", "StatefulSet", "DaemonSet", "Job", "CronJob") + WorkloadType string `json:"workloadType"` + + // WorkloadName is the name of the workload + WorkloadName string `json:"workloadName"` + + // WorkloadUID is the UID of the workload + WorkloadUID string `json:"workloadUID"` + + // ContainerNames lists the container names within the workload that use this image + ContainerNames []string `json:"containerNames,omitempty"` + + // Replicas is the current replica count of the workload + Replicas int32 `json:"replicas,omitempty"` +} + +// ImageAnalysisResultStatus defines the observed state of ImageAnalysisResult +type ImageAnalysisResultStatus struct { + // Phase is the current state of the analysis + // +kubebuilder:validation:Enum=Pending;Analyzing;Completed;Failed + Phase string `json:"phase,omitempty"` + + // AnalyzedAt is when the image was analyzed + AnalyzedAt metav1.Time `json:"analyzedAt,omitempty"` + + // AnalysisDurationSeconds is how long the dive analysis took + AnalysisDurationSeconds int `json:"analysisDurationSeconds,omitempty"` + + // Message contains additional information about the current phase (e.g. error details) + Message string `json:"message,omitempty"` +} + +//+kubebuilder:object:root=true +//+kubebuilder:subresource:status +//+kubebuilder:resource:scope=Cluster +//+kubebuilder:printcolumn:name="Image",type="string",JSONPath=".spec.imageRef",priority=0 +//+kubebuilder:printcolumn:name="Efficiency",type="string",JSONPath=".spec.analysis.efficiency",priority=0 +//+kubebuilder:printcolumn:name="Passed",type="boolean",JSONPath=".spec.analysis.passed",priority=0 +//+kubebuilder:printcolumn:name="Source",type="string",JSONPath=".spec.imageSource.type",priority=1 +//+kubebuilder:printcolumn:name="Phase",type="string",JSONPath=".status.phase",priority=0 +//+kubebuilder:printcolumn:name="Analyzed At",type="date",JSONPath=".status.analyzedAt",priority=0 + +// ImageAnalysisResult is the Schema for the imageanalysisresults API. +// It stores dive analysis results for a container image including efficiency metrics, +// layer breakdown, wasted space details, and references to workloads using the image. +type ImageAnalysisResult struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + Spec ImageAnalysisResultSpec `json:"spec,omitempty"` + Status ImageAnalysisResultStatus `json:"status,omitempty"` +} + +//+kubebuilder:object:root=true + +// ImageAnalysisResultList contains a list of ImageAnalysisResult +type ImageAnalysisResultList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []ImageAnalysisResult `json:"items"` +} + +func init() { + SchemeBuilder.Register(&ImageAnalysisResult{}, &ImageAnalysisResultList{}) +} diff --git a/api/v1/zz_generated.deepcopy.go b/api/v1/zz_generated.deepcopy.go index 110630df..c8c6a384 100644 --- a/api/v1/zz_generated.deepcopy.go +++ b/api/v1/zz_generated.deepcopy.go @@ -853,6 +853,181 @@ func (in *Exclusions) DeepCopy() *Exclusions { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FileAnalysis) DeepCopyInto(out *FileAnalysis) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FileAnalysis. +func (in *FileAnalysis) DeepCopy() *FileAnalysis { + if in == nil { + return nil + } + out := new(FileAnalysis) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageAnalysis) DeepCopyInto(out *ImageAnalysis) { + *out = *in + if in.Layers != nil { + in, out := &in.Layers, &out.Layers + *out = make([]LayerInfo, len(*in)) + copy(*out, *in) + } + if in.FileAnalysis != nil { + in, out := &in.FileAnalysis, &out.FileAnalysis + *out = new(FileAnalysis) + **out = **in + } + if in.WastedFiles != nil { + in, out := &in.WastedFiles, &out.WastedFiles + *out = make([]WastedFile, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageAnalysis. +func (in *ImageAnalysis) DeepCopy() *ImageAnalysis { + if in == nil { + return nil + } + out := new(ImageAnalysis) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageAnalysisResult) DeepCopyInto(out *ImageAnalysisResult) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageAnalysisResult. +func (in *ImageAnalysisResult) DeepCopy() *ImageAnalysisResult { + if in == nil { + return nil + } + out := new(ImageAnalysisResult) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ImageAnalysisResult) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageAnalysisResultList) DeepCopyInto(out *ImageAnalysisResultList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ImageAnalysisResult, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageAnalysisResultList. +func (in *ImageAnalysisResultList) DeepCopy() *ImageAnalysisResultList { + if in == nil { + return nil + } + out := new(ImageAnalysisResultList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ImageAnalysisResultList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageAnalysisResultSpec) DeepCopyInto(out *ImageAnalysisResultSpec) { + *out = *in + out.ImageSource = in.ImageSource + in.Analysis.DeepCopyInto(&out.Analysis) + in.WorkloadSummary.DeepCopyInto(&out.WorkloadSummary) + if in.WorkloadReferences != nil { + in, out := &in.WorkloadReferences, &out.WorkloadReferences + *out = make([]WorkloadReference, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageAnalysisResultSpec. +func (in *ImageAnalysisResultSpec) DeepCopy() *ImageAnalysisResultSpec { + if in == nil { + return nil + } + out := new(ImageAnalysisResultSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageAnalysisResultStatus) DeepCopyInto(out *ImageAnalysisResultStatus) { + *out = *in + in.AnalyzedAt.DeepCopyInto(&out.AnalyzedAt) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageAnalysisResultStatus. +func (in *ImageAnalysisResultStatus) DeepCopy() *ImageAnalysisResultStatus { + if in == nil { + return nil + } + out := new(ImageAnalysisResultStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageSourceInfo) DeepCopyInto(out *ImageSourceInfo) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageSourceInfo. +func (in *ImageSourceInfo) DeepCopy() *ImageSourceInfo { + if in == nil { + return nil + } + out := new(ImageSourceInfo) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *LayerInfo) DeepCopyInto(out *LayerInfo) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LayerInfo. +func (in *LayerInfo) DeepCopy() *LayerInfo { + if in == nil { + return nil + } + out := new(LayerInfo) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *NamespacedResource) DeepCopyInto(out *NamespacedResource) { *out = *in @@ -924,3 +1099,58 @@ func (in *TargetSelector) DeepCopy() *TargetSelector { in.DeepCopyInto(out) return out } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WastedFile) DeepCopyInto(out *WastedFile) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WastedFile. +func (in *WastedFile) DeepCopy() *WastedFile { + if in == nil { + return nil + } + out := new(WastedFile) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WorkloadReference) DeepCopyInto(out *WorkloadReference) { + *out = *in + if in.ContainerNames != nil { + in, out := &in.ContainerNames, &out.ContainerNames + *out = make([]string, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadReference. +func (in *WorkloadReference) DeepCopy() *WorkloadReference { + if in == nil { + return nil + } + out := new(WorkloadReference) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WorkloadSummary) DeepCopyInto(out *WorkloadSummary) { + *out = *in + if in.Namespaces != nil { + in, out := &in.Namespaces, &out.Namespaces + *out = make([]string, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadSummary. +func (in *WorkloadSummary) DeepCopy() *WorkloadSummary { + if in == nil { + return nil + } + out := new(WorkloadSummary) + in.DeepCopyInto(out) + return out +} diff --git a/config/crd/bases/devzero.io_imageanalysisresults.yaml b/config/crd/bases/devzero.io_imageanalysisresults.yaml new file mode 100644 index 00000000..cfc182f0 --- /dev/null +++ b/config/crd/bases/devzero.io_imageanalysisresults.yaml @@ -0,0 +1,294 @@ +--- +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.5 + name: imageanalysisresults.devzero.io +spec: + group: devzero.io + names: + kind: ImageAnalysisResult + listKind: ImageAnalysisResultList + plural: imageanalysisresults + singular: imageanalysisresult + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .spec.imageRef + name: Image + type: string + - jsonPath: .spec.analysis.efficiency + name: Efficiency + type: string + - jsonPath: .spec.analysis.passed + name: Passed + type: boolean + - jsonPath: .spec.imageSource.type + name: Source + priority: 1 + type: string + - jsonPath: .status.phase + name: Phase + type: string + - jsonPath: .status.analyzedAt + name: Analyzed At + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + ImageAnalysisResult is the Schema for the imageanalysisresults API. + It stores dive analysis results for a container image including efficiency metrics, + layer breakdown, wasted space details, and references to workloads using the image. + properties: + apiVersion: + description: |- + APIVersion defines the versioned schema of this representation of an object. + Servers should convert recognized schemas to the latest internal value, and + may reject unrecognized values. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources + type: string + kind: + description: |- + Kind is a string value representing the REST resource this object represents. + Servers may infer this from the endpoint the client submits requests to. + Cannot be updated. + In CamelCase. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + metadata: + type: object + spec: + description: ImageAnalysisResultSpec defines the desired state of ImageAnalysisResult + properties: + analysis: + description: Analysis contains the dive analysis results + properties: + efficiency: + description: |- + Efficiency is the image efficiency ratio as a string (e.g. "0.9516") + Stored as string for cross-language CRD compatibility. Range: "0.0" to "1.0". + type: string + fileAnalysis: + description: FileAnalysis contains aggregate file statistics across + all layers + properties: + addedFiles: + description: AddedFiles is the count of files added across + layers + type: integer + modifiedFiles: + description: ModifiedFiles is the count of files modified + across layers + type: integer + removedFiles: + description: RemovedFiles is the count of files removed across + layers + type: integer + totalFiles: + description: TotalFiles is the total number of files in the + image + type: integer + type: object + layerCount: + description: LayerCount is the total number of layers in the image + type: integer + layers: + description: Layers contains details for each image layer + items: + description: LayerInfo contains details about a single image + layer + properties: + command: + description: Command is the Dockerfile instruction that + created this layer (truncated to 200 chars) + type: string + digest: + description: Digest is the layer digest + type: string + index: + description: Index is the layer position (0 = base layer) + type: integer + sizeBytes: + description: SizeBytes is the layer size in bytes + format: int64 + type: integer + required: + - index + - sizeBytes + type: object + type: array + passed: + description: Passed indicates whether the image meets the configured + efficiency thresholds + type: boolean + userWastedPercent: + description: |- + UserWastedPercent is the percentage of user image space that is wasted as a string (e.g. "0.016") + Stored as string for cross-language CRD compatibility. Range: "0.0" to "1.0". + type: string + wastedBytes: + description: WastedBytes is the total wasted space in bytes + format: int64 + type: integer + wastedFiles: + description: WastedFiles lists the top files contributing to wasted + space (capped at 50) + items: + description: WastedFile identifies a file or directory contributing + to wasted space + properties: + path: + description: Path is the file or directory path + type: string + sizeBytes: + description: SizeBytes is the wasted space from this file + in bytes + format: int64 + type: integer + required: + - path + - sizeBytes + type: object + type: array + required: + - efficiency + - layerCount + - passed + - userWastedPercent + - wastedBytes + type: object + imageDigest: + description: ImageDigest is the image digest (e.g. "sha256:a1b2c3d4e5f6...") + type: string + imageRef: + description: ImageRef is the full image reference including tag (e.g. + "docker.io/library/nginx:1.25.3") + type: string + imageSizeBytes: + description: ImageSizeBytes is the total size of the image in bytes + format: int64 + type: integer + imageSource: + description: ImageSource describes how the image was acquired for + analysis + properties: + batchJobName: + description: BatchJobName is the name of the batch job that analyzed + this image + type: string + exportDurationMs: + description: ExportDurationMs is how long it took to export/pull + the image in milliseconds + format: int64 + type: integer + nodeName: + description: NodeName is the node where the analysis job ran + type: string + type: + description: 'Type is the image acquisition method: "local-containerd" + or "remote-pull"' + enum: + - local-containerd + - remote-pull + type: string + required: + - nodeName + - type + type: object + workloadReferences: + description: WorkloadReferences lists the workloads using this image + (capped at 200, sorted by replica count desc) + items: + description: WorkloadReference identifies a workload that uses this + image + properties: + containerNames: + description: ContainerNames lists the container names within + the workload that use this image + items: + type: string + type: array + namespace: + description: Namespace is the workload's namespace + type: string + replicas: + description: Replicas is the current replica count of the workload + format: int32 + type: integer + workloadName: + description: WorkloadName is the name of the workload + type: string + workloadType: + description: WorkloadType is the kind of workload (e.g. "Deployment", + "StatefulSet", "DaemonSet", "Job", "CronJob") + type: string + workloadUID: + description: WorkloadUID is the UID of the workload + type: string + required: + - namespace + - workloadName + - workloadType + - workloadUID + type: object + type: array + workloadSummary: + description: WorkloadSummary is a high-level summary of workloads + using this image + properties: + namespaces: + description: Namespaces lists the namespaces where this image + is used + items: + type: string + type: array + nodesRunningImage: + description: NodesRunningImage is the count of nodes that have + containers running this image + type: integer + totalContainers: + description: TotalContainers is the total number of container + instances using this image across the cluster + type: integer + totalWorkloads: + description: TotalWorkloads is the count of unique workloads (Deployments, + StatefulSets, etc.) using this image + type: integer + type: object + required: + - analysis + - imageDigest + - imageRef + - imageSource + type: object + status: + description: ImageAnalysisResultStatus defines the observed state of ImageAnalysisResult + properties: + analysisDurationSeconds: + description: AnalysisDurationSeconds is how long the dive analysis + took + type: integer + analyzedAt: + description: AnalyzedAt is when the image was analyzed + format: date-time + type: string + message: + description: Message contains additional information about the current + phase (e.g. error details) + type: string + phase: + description: Phase is the current state of the analysis + enum: + - Pending + - Analyzing + - Completed + - Failed + type: string + type: object + type: object + served: true + storage: true + subresources: + status: {} diff --git a/config/manager/env_configmap.yaml b/config/manager/env_configmap.yaml index dff80c03..af2f80a4 100644 --- a/config/manager/env_configmap.yaml +++ b/config/manager/env_configmap.yaml @@ -56,3 +56,35 @@ data: TOKEN_SECRET_NAME: "devzero-zxporter-token" # Deprecated, use TOKEN_RUNTIME_SECRET_NAME TOKEN_CONFIGMAP_NAME: "devzero-zxporter-env-config" USE_SECRET_FOR_TOKEN: "false" + # === Image Analysis Configuration === + IMAGE_ANALYSIS_ENABLED: "true" + IMAGE_ANALYSIS_INTERVAL_DAYS: "7" + IMAGE_ANALYSIS_CRON_EXPRESSION: "" + IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS: "10" + IMAGE_ANALYSIS_MAX_JOBS_PER_NODE: "1" + IMAGE_ANALYSIS_BATCH_SIZE: "10" + IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES: "30" + IMAGE_ANALYSIS_MAX_RETRIES: "2" + IMAGE_ANALYSIS_JOB_NAMESPACE: "devzero-zxporter" + IMAGE_ANALYSIS_ANALYZER_IMAGE: "devzeroinc/image-analyzer:v1" + IMAGE_ANALYSIS_JOB_CPU_REQUEST: "500m" + IMAGE_ANALYSIS_JOB_CPU_LIMIT: "1" + IMAGE_ANALYSIS_JOB_MEMORY_REQUEST: "1Gi" + IMAGE_ANALYSIS_JOB_MEMORY_LIMIT: "4Gi" + IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT: "10Gi" + IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE: "30" + IMAGE_ANALYSIS_JOB_TOLERATIONS: "[]" + IMAGE_ANALYSIS_PREFER_LOCAL: "true" + IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH: "/run/containerd/containerd.sock" + IMAGE_ANALYSIS_CONTAINERD_NAMESPACE: "k8s.io" + IMAGE_ANALYSIS_FALLBACK_TO_REMOTE: "true" + IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT: "5m" + IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET: "" + IMAGE_ANALYSIS_TARGET_NAMESPACES: "" + IMAGE_ANALYSIS_EXCLUDED_NAMESPACES: "kube-system,kube-public" + IMAGE_ANALYSIS_EXCLUDED_IMAGES: "registry.k8s.io/pause:*" + IMAGE_ANALYSIS_INCLUDED_IMAGES: "" + IMAGE_ANALYSIS_LOWEST_EFFICIENCY: "0.90" + IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES: "50MB" + IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT: "0.20" + IMAGE_ANALYSIS_RESULT_RETENTION_DAYS: "30" diff --git a/internal/controller/image_analysis_config.go b/internal/controller/image_analysis_config.go new file mode 100644 index 00000000..37964466 --- /dev/null +++ b/internal/controller/image_analysis_config.go @@ -0,0 +1,311 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "encoding/json" + "fmt" + "strconv" + "strings" + + corev1 "k8s.io/api/core/v1" + + "github.com/devzero-inc/zxporter/internal/util" +) + +// Environment variable keys for image analysis configuration. +const ( + // Enable/Disable + _ENV_IMAGE_ANALYSIS_ENABLED = "IMAGE_ANALYSIS_ENABLED" + + // Schedule + _ENV_IMAGE_ANALYSIS_INTERVAL_DAYS = "IMAGE_ANALYSIS_INTERVAL_DAYS" + _ENV_IMAGE_ANALYSIS_CRON_EXPRESSION = "IMAGE_ANALYSIS_CRON_EXPRESSION" + + // Job execution tuning + _ENV_IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS = "IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS" + _ENV_IMAGE_ANALYSIS_MAX_JOBS_PER_NODE = "IMAGE_ANALYSIS_MAX_JOBS_PER_NODE" + _ENV_IMAGE_ANALYSIS_BATCH_SIZE = "IMAGE_ANALYSIS_BATCH_SIZE" + _ENV_IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES = "IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES" + _ENV_IMAGE_ANALYSIS_MAX_RETRIES = "IMAGE_ANALYSIS_MAX_RETRIES" + _ENV_IMAGE_ANALYSIS_JOB_NAMESPACE = "IMAGE_ANALYSIS_JOB_NAMESPACE" + _ENV_IMAGE_ANALYSIS_ANALYZER_IMAGE = "IMAGE_ANALYSIS_ANALYZER_IMAGE" + _ENV_IMAGE_ANALYSIS_JOB_CPU_REQUEST = "IMAGE_ANALYSIS_JOB_CPU_REQUEST" + _ENV_IMAGE_ANALYSIS_JOB_CPU_LIMIT = "IMAGE_ANALYSIS_JOB_CPU_LIMIT" + _ENV_IMAGE_ANALYSIS_JOB_MEMORY_REQUEST = "IMAGE_ANALYSIS_JOB_MEMORY_REQUEST" + _ENV_IMAGE_ANALYSIS_JOB_MEMORY_LIMIT = "IMAGE_ANALYSIS_JOB_MEMORY_LIMIT" + _ENV_IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT = "IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT" + _ENV_IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE = "IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE" + + // Job tolerations + _ENV_IMAGE_ANALYSIS_JOB_TOLERATIONS = "IMAGE_ANALYSIS_JOB_TOLERATIONS" + + // Image source preferences + _ENV_IMAGE_ANALYSIS_PREFER_LOCAL = "IMAGE_ANALYSIS_PREFER_LOCAL" + _ENV_IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH = "IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH" + _ENV_IMAGE_ANALYSIS_CONTAINERD_NAMESPACE = "IMAGE_ANALYSIS_CONTAINERD_NAMESPACE" + _ENV_IMAGE_ANALYSIS_FALLBACK_TO_REMOTE = "IMAGE_ANALYSIS_FALLBACK_TO_REMOTE" + _ENV_IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT = "IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT" + _ENV_IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET = "IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET" + + // Targeting + _ENV_IMAGE_ANALYSIS_TARGET_NAMESPACES = "IMAGE_ANALYSIS_TARGET_NAMESPACES" + _ENV_IMAGE_ANALYSIS_EXCLUDED_NAMESPACES = "IMAGE_ANALYSIS_EXCLUDED_NAMESPACES" + _ENV_IMAGE_ANALYSIS_EXCLUDED_IMAGES = "IMAGE_ANALYSIS_EXCLUDED_IMAGES" + _ENV_IMAGE_ANALYSIS_INCLUDED_IMAGES = "IMAGE_ANALYSIS_INCLUDED_IMAGES" + + // Thresholds + _ENV_IMAGE_ANALYSIS_LOWEST_EFFICIENCY = "IMAGE_ANALYSIS_LOWEST_EFFICIENCY" + _ENV_IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES = "IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES" + _ENV_IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT = "IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT" + + // Cleanup + _ENV_IMAGE_ANALYSIS_RESULT_RETENTION_DAYS = "IMAGE_ANALYSIS_RESULT_RETENTION_DAYS" +) + +// ImageAnalysisConfig holds all configuration for the image analysis controller. +type ImageAnalysisConfig struct { + // Enable/Disable + Enabled bool + + // Schedule + IntervalDays int + CronExpression string + + // Job execution tuning + MaxConcurrentJobs int + MaxJobsPerNode int + BatchSize int + JobTimeoutMinutes int + MaxRetries int + JobNamespace string + AnalyzerImage string + JobCPURequest string + JobCPULimit string + JobMemoryRequest string + JobMemoryLimit string + WorkspaceSizeLimit string + RegistryPullRatePerMinute int + JobTolerations []corev1.Toleration + + // Image source preferences + PreferLocal bool + ContainerdSocketPath string + ContainerdNamespace string + FallbackToRemote bool + RemotePullTimeout string + RegistryAuthSecret string + + // Targeting + TargetNamespaces []string + ExcludedNamespaces []string + ExcludedImages []string + IncludedImages []string + + // Thresholds + LowestEfficiency float64 + HighestWastedBytes string + HighestUserWastedPercent float64 + + // Cleanup + ResultRetentionDays int +} + +// DefaultImageAnalysisConfig returns the config with all defaults applied. +func DefaultImageAnalysisConfig() ImageAnalysisConfig { + return ImageAnalysisConfig{ + Enabled: true, + IntervalDays: 7, + MaxConcurrentJobs: 10, + MaxJobsPerNode: 1, + BatchSize: 10, + JobTimeoutMinutes: 30, + MaxRetries: 2, + JobNamespace: "devzero-zxporter", + AnalyzerImage: "devzeroinc/image-analyzer:v1", + JobCPURequest: "500m", + JobCPULimit: "1", + JobMemoryRequest: "1Gi", + JobMemoryLimit: "4Gi", + WorkspaceSizeLimit: "10Gi", + RegistryPullRatePerMinute: 30, + PreferLocal: true, + ContainerdSocketPath: "/run/containerd/containerd.sock", + ContainerdNamespace: "k8s.io", + FallbackToRemote: true, + RemotePullTimeout: "5m", + ExcludedNamespaces: []string{"kube-system", "kube-public"}, + ExcludedImages: []string{"registry.k8s.io/pause:*"}, + LowestEfficiency: 0.90, + HighestWastedBytes: "50MB", + HighestUserWastedPercent: 0.20, + ResultRetentionDays: 30, + } +} + +// LoadImageAnalysisConfigFromEnv loads image analysis configuration from environment +// variables with fallback to /etc/zxporter/config/ files. Unset values use defaults. +func LoadImageAnalysisConfigFromEnv() (ImageAnalysisConfig, error) { + cfg := DefaultImageAnalysisConfig() + + // Helper to split comma-separated lists + splitCSV := func(envKey string) []string { + if raw := util.GetEnv(envKey); raw != "" { + parts := strings.Split(raw, ",") + for i := range parts { + parts[i] = strings.TrimSpace(parts[i]) + } + return parts + } + return nil + } + + // Helper to parse int with default + parseInt := func(envKey string, defaultVal int) (int, error) { + if raw := util.GetEnv(envKey); raw != "" { + v, err := strconv.Atoi(raw) + if err != nil { + return 0, fmt.Errorf("invalid integer for %s: %w", envKey, err) + } + return v, nil + } + return defaultVal, nil + } + + // Helper to parse bool with default + parseBool := func(envKey string, defaultVal bool) (bool, error) { + if raw := util.GetEnv(envKey); raw != "" { + v, err := strconv.ParseBool(raw) + if err != nil { + return false, fmt.Errorf("invalid boolean for %s: %w", envKey, err) + } + return v, nil + } + return defaultVal, nil + } + + // Helper to parse float64 with default + parseFloat := func(envKey string, defaultVal float64) (float64, error) { + if raw := util.GetEnv(envKey); raw != "" { + v, err := strconv.ParseFloat(raw, 64) + if err != nil { + return 0, fmt.Errorf("invalid float for %s: %w", envKey, err) + } + return v, nil + } + return defaultVal, nil + } + + // Helper to read string with default + readString := func(envKey string, defaultVal string) string { + if raw := util.GetEnv(envKey); raw != "" { + return raw + } + return defaultVal + } + + var err error + + // === Enable/Disable === + if cfg.Enabled, err = parseBool(_ENV_IMAGE_ANALYSIS_ENABLED, cfg.Enabled); err != nil { + return cfg, err + } + + // === Schedule === + if cfg.IntervalDays, err = parseInt(_ENV_IMAGE_ANALYSIS_INTERVAL_DAYS, cfg.IntervalDays); err != nil { + return cfg, err + } + cfg.CronExpression = readString(_ENV_IMAGE_ANALYSIS_CRON_EXPRESSION, cfg.CronExpression) + + // === Job execution tuning === + if cfg.MaxConcurrentJobs, err = parseInt(_ENV_IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS, cfg.MaxConcurrentJobs); err != nil { + return cfg, err + } + if cfg.MaxJobsPerNode, err = parseInt(_ENV_IMAGE_ANALYSIS_MAX_JOBS_PER_NODE, cfg.MaxJobsPerNode); err != nil { + return cfg, err + } + if cfg.BatchSize, err = parseInt(_ENV_IMAGE_ANALYSIS_BATCH_SIZE, cfg.BatchSize); err != nil { + return cfg, err + } + if cfg.JobTimeoutMinutes, err = parseInt(_ENV_IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES, cfg.JobTimeoutMinutes); err != nil { + return cfg, err + } + if cfg.MaxRetries, err = parseInt(_ENV_IMAGE_ANALYSIS_MAX_RETRIES, cfg.MaxRetries); err != nil { + return cfg, err + } + cfg.JobNamespace = readString(_ENV_IMAGE_ANALYSIS_JOB_NAMESPACE, cfg.JobNamespace) + cfg.AnalyzerImage = readString(_ENV_IMAGE_ANALYSIS_ANALYZER_IMAGE, cfg.AnalyzerImage) + cfg.JobCPURequest = readString(_ENV_IMAGE_ANALYSIS_JOB_CPU_REQUEST, cfg.JobCPURequest) + cfg.JobCPULimit = readString(_ENV_IMAGE_ANALYSIS_JOB_CPU_LIMIT, cfg.JobCPULimit) + cfg.JobMemoryRequest = readString(_ENV_IMAGE_ANALYSIS_JOB_MEMORY_REQUEST, cfg.JobMemoryRequest) + cfg.JobMemoryLimit = readString(_ENV_IMAGE_ANALYSIS_JOB_MEMORY_LIMIT, cfg.JobMemoryLimit) + cfg.WorkspaceSizeLimit = readString(_ENV_IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT, cfg.WorkspaceSizeLimit) + if cfg.RegistryPullRatePerMinute, err = parseInt(_ENV_IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE, cfg.RegistryPullRatePerMinute); err != nil { + return cfg, err + } + + // === Job tolerations (JSON array) === + if raw := util.GetEnv(_ENV_IMAGE_ANALYSIS_JOB_TOLERATIONS); raw != "" { + var tolerations []corev1.Toleration + if err := json.Unmarshal([]byte(raw), &tolerations); err != nil { + return cfg, fmt.Errorf("invalid JSON for %s: %w", _ENV_IMAGE_ANALYSIS_JOB_TOLERATIONS, err) + } + cfg.JobTolerations = tolerations + } + + // === Image source preferences === + if cfg.PreferLocal, err = parseBool(_ENV_IMAGE_ANALYSIS_PREFER_LOCAL, cfg.PreferLocal); err != nil { + return cfg, err + } + cfg.ContainerdSocketPath = readString(_ENV_IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH, cfg.ContainerdSocketPath) + cfg.ContainerdNamespace = readString(_ENV_IMAGE_ANALYSIS_CONTAINERD_NAMESPACE, cfg.ContainerdNamespace) + if cfg.FallbackToRemote, err = parseBool(_ENV_IMAGE_ANALYSIS_FALLBACK_TO_REMOTE, cfg.FallbackToRemote); err != nil { + return cfg, err + } + cfg.RemotePullTimeout = readString(_ENV_IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT, cfg.RemotePullTimeout) + cfg.RegistryAuthSecret = readString(_ENV_IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET, cfg.RegistryAuthSecret) + + // === Targeting === + if ns := splitCSV(_ENV_IMAGE_ANALYSIS_TARGET_NAMESPACES); ns != nil { + cfg.TargetNamespaces = ns + } + if ns := splitCSV(_ENV_IMAGE_ANALYSIS_EXCLUDED_NAMESPACES); ns != nil { + cfg.ExcludedNamespaces = ns + } + if imgs := splitCSV(_ENV_IMAGE_ANALYSIS_EXCLUDED_IMAGES); imgs != nil { + cfg.ExcludedImages = imgs + } + if imgs := splitCSV(_ENV_IMAGE_ANALYSIS_INCLUDED_IMAGES); imgs != nil { + cfg.IncludedImages = imgs + } + + // === Thresholds === + if cfg.LowestEfficiency, err = parseFloat(_ENV_IMAGE_ANALYSIS_LOWEST_EFFICIENCY, cfg.LowestEfficiency); err != nil { + return cfg, err + } + cfg.HighestWastedBytes = readString(_ENV_IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES, cfg.HighestWastedBytes) + if cfg.HighestUserWastedPercent, err = parseFloat(_ENV_IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT, cfg.HighestUserWastedPercent); err != nil { + return cfg, err + } + + // === Cleanup === + if cfg.ResultRetentionDays, err = parseInt(_ENV_IMAGE_ANALYSIS_RESULT_RETENTION_DAYS, cfg.ResultRetentionDays); err != nil { + return cfg, err + } + + return cfg, nil +} diff --git a/internal/controller/image_analysis_config_test.go b/internal/controller/image_analysis_config_test.go new file mode 100644 index 00000000..a8b048f6 --- /dev/null +++ b/internal/controller/image_analysis_config_test.go @@ -0,0 +1,258 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "os" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func clearImageAnalysisEnvVars(t *testing.T) { + t.Helper() + envVars := []string{ + _ENV_IMAGE_ANALYSIS_ENABLED, + _ENV_IMAGE_ANALYSIS_INTERVAL_DAYS, + _ENV_IMAGE_ANALYSIS_CRON_EXPRESSION, + _ENV_IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS, + _ENV_IMAGE_ANALYSIS_MAX_JOBS_PER_NODE, + _ENV_IMAGE_ANALYSIS_BATCH_SIZE, + _ENV_IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES, + _ENV_IMAGE_ANALYSIS_MAX_RETRIES, + _ENV_IMAGE_ANALYSIS_JOB_NAMESPACE, + _ENV_IMAGE_ANALYSIS_ANALYZER_IMAGE, + _ENV_IMAGE_ANALYSIS_JOB_CPU_REQUEST, + _ENV_IMAGE_ANALYSIS_JOB_CPU_LIMIT, + _ENV_IMAGE_ANALYSIS_JOB_MEMORY_REQUEST, + _ENV_IMAGE_ANALYSIS_JOB_MEMORY_LIMIT, + _ENV_IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT, + _ENV_IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE, + _ENV_IMAGE_ANALYSIS_JOB_TOLERATIONS, + _ENV_IMAGE_ANALYSIS_PREFER_LOCAL, + _ENV_IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH, + _ENV_IMAGE_ANALYSIS_CONTAINERD_NAMESPACE, + _ENV_IMAGE_ANALYSIS_FALLBACK_TO_REMOTE, + _ENV_IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT, + _ENV_IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET, + _ENV_IMAGE_ANALYSIS_TARGET_NAMESPACES, + _ENV_IMAGE_ANALYSIS_EXCLUDED_NAMESPACES, + _ENV_IMAGE_ANALYSIS_EXCLUDED_IMAGES, + _ENV_IMAGE_ANALYSIS_INCLUDED_IMAGES, + _ENV_IMAGE_ANALYSIS_LOWEST_EFFICIENCY, + _ENV_IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES, + _ENV_IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT, + _ENV_IMAGE_ANALYSIS_RESULT_RETENTION_DAYS, + } + for _, v := range envVars { + os.Unsetenv(v) + } +} + +func TestDefaultImageAnalysisConfig(t *testing.T) { + cfg := DefaultImageAnalysisConfig() + + assert.True(t, cfg.Enabled) + assert.Equal(t, 7, cfg.IntervalDays) + assert.Equal(t, "", cfg.CronExpression) + assert.Equal(t, 10, cfg.MaxConcurrentJobs) + assert.Equal(t, 1, cfg.MaxJobsPerNode) + assert.Equal(t, 10, cfg.BatchSize) + assert.Equal(t, 30, cfg.JobTimeoutMinutes) + assert.Equal(t, 2, cfg.MaxRetries) + assert.Equal(t, "devzero-zxporter", cfg.JobNamespace) + assert.Equal(t, "devzeroinc/image-analyzer:v1", cfg.AnalyzerImage) + assert.Equal(t, "500m", cfg.JobCPURequest) + assert.Equal(t, "1", cfg.JobCPULimit) + assert.Equal(t, "1Gi", cfg.JobMemoryRequest) + assert.Equal(t, "4Gi", cfg.JobMemoryLimit) + assert.Equal(t, "10Gi", cfg.WorkspaceSizeLimit) + assert.Equal(t, 30, cfg.RegistryPullRatePerMinute) + assert.Nil(t, cfg.JobTolerations) + assert.True(t, cfg.PreferLocal) + assert.Equal(t, "/run/containerd/containerd.sock", cfg.ContainerdSocketPath) + assert.Equal(t, "k8s.io", cfg.ContainerdNamespace) + assert.True(t, cfg.FallbackToRemote) + assert.Equal(t, "5m", cfg.RemotePullTimeout) + assert.Equal(t, "", cfg.RegistryAuthSecret) + assert.Nil(t, cfg.TargetNamespaces) + assert.Equal(t, []string{"kube-system", "kube-public"}, cfg.ExcludedNamespaces) + assert.Equal(t, []string{"registry.k8s.io/pause:*"}, cfg.ExcludedImages) + assert.Nil(t, cfg.IncludedImages) + assert.Equal(t, 0.90, cfg.LowestEfficiency) + assert.Equal(t, "50MB", cfg.HighestWastedBytes) + assert.Equal(t, 0.20, cfg.HighestUserWastedPercent) + assert.Equal(t, 30, cfg.ResultRetentionDays) +} + +func TestLoadImageAnalysisConfigFromEnv_Defaults(t *testing.T) { + clearImageAnalysisEnvVars(t) + + cfg, err := LoadImageAnalysisConfigFromEnv() + require.NoError(t, err) + + expected := DefaultImageAnalysisConfig() + assert.Equal(t, expected.Enabled, cfg.Enabled) + assert.Equal(t, expected.IntervalDays, cfg.IntervalDays) + assert.Equal(t, expected.BatchSize, cfg.BatchSize) + assert.Equal(t, expected.JobNamespace, cfg.JobNamespace) + assert.Equal(t, expected.ExcludedNamespaces, cfg.ExcludedNamespaces) + assert.Equal(t, expected.LowestEfficiency, cfg.LowestEfficiency) +} + +func TestLoadImageAnalysisConfigFromEnv_CustomValues(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_ENABLED, "false") + t.Setenv(_ENV_IMAGE_ANALYSIS_INTERVAL_DAYS, "14") + t.Setenv(_ENV_IMAGE_ANALYSIS_CRON_EXPRESSION, "0 2 * * 0") + t.Setenv(_ENV_IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS, "20") + t.Setenv(_ENV_IMAGE_ANALYSIS_MAX_JOBS_PER_NODE, "2") + t.Setenv(_ENV_IMAGE_ANALYSIS_BATCH_SIZE, "5") + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES, "60") + t.Setenv(_ENV_IMAGE_ANALYSIS_MAX_RETRIES, "3") + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_NAMESPACE, "custom-ns") + t.Setenv(_ENV_IMAGE_ANALYSIS_ANALYZER_IMAGE, "myregistry/analyzer:v2") + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_CPU_REQUEST, "250m") + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_CPU_LIMIT, "2") + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_MEMORY_REQUEST, "512Mi") + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_MEMORY_LIMIT, "2Gi") + t.Setenv(_ENV_IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT, "20Gi") + t.Setenv(_ENV_IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE, "60") + t.Setenv(_ENV_IMAGE_ANALYSIS_PREFER_LOCAL, "false") + t.Setenv(_ENV_IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH, "/custom/containerd.sock") + t.Setenv(_ENV_IMAGE_ANALYSIS_CONTAINERD_NAMESPACE, "custom.ns") + t.Setenv(_ENV_IMAGE_ANALYSIS_FALLBACK_TO_REMOTE, "false") + t.Setenv(_ENV_IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT, "10m") + t.Setenv(_ENV_IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET, "my-registry-secret") + t.Setenv(_ENV_IMAGE_ANALYSIS_TARGET_NAMESPACES, "ns1, ns2, ns3") + t.Setenv(_ENV_IMAGE_ANALYSIS_EXCLUDED_NAMESPACES, "test-ns") + t.Setenv(_ENV_IMAGE_ANALYSIS_EXCLUDED_IMAGES, "pause:*,debug:*") + t.Setenv(_ENV_IMAGE_ANALYSIS_INCLUDED_IMAGES, "nginx:*,redis:*") + t.Setenv(_ENV_IMAGE_ANALYSIS_LOWEST_EFFICIENCY, "0.95") + t.Setenv(_ENV_IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES, "100MB") + t.Setenv(_ENV_IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT, "0.10") + t.Setenv(_ENV_IMAGE_ANALYSIS_RESULT_RETENTION_DAYS, "60") + + cfg, err := LoadImageAnalysisConfigFromEnv() + require.NoError(t, err) + + assert.False(t, cfg.Enabled) + assert.Equal(t, 14, cfg.IntervalDays) + assert.Equal(t, "0 2 * * 0", cfg.CronExpression) + assert.Equal(t, 20, cfg.MaxConcurrentJobs) + assert.Equal(t, 2, cfg.MaxJobsPerNode) + assert.Equal(t, 5, cfg.BatchSize) + assert.Equal(t, 60, cfg.JobTimeoutMinutes) + assert.Equal(t, 3, cfg.MaxRetries) + assert.Equal(t, "custom-ns", cfg.JobNamespace) + assert.Equal(t, "myregistry/analyzer:v2", cfg.AnalyzerImage) + assert.Equal(t, "250m", cfg.JobCPURequest) + assert.Equal(t, "2", cfg.JobCPULimit) + assert.Equal(t, "512Mi", cfg.JobMemoryRequest) + assert.Equal(t, "2Gi", cfg.JobMemoryLimit) + assert.Equal(t, "20Gi", cfg.WorkspaceSizeLimit) + assert.Equal(t, 60, cfg.RegistryPullRatePerMinute) + assert.False(t, cfg.PreferLocal) + assert.Equal(t, "/custom/containerd.sock", cfg.ContainerdSocketPath) + assert.Equal(t, "custom.ns", cfg.ContainerdNamespace) + assert.False(t, cfg.FallbackToRemote) + assert.Equal(t, "10m", cfg.RemotePullTimeout) + assert.Equal(t, "my-registry-secret", cfg.RegistryAuthSecret) + assert.Equal(t, []string{"ns1", "ns2", "ns3"}, cfg.TargetNamespaces) + assert.Equal(t, []string{"test-ns"}, cfg.ExcludedNamespaces) + assert.Equal(t, []string{"pause:*", "debug:*"}, cfg.ExcludedImages) + assert.Equal(t, []string{"nginx:*", "redis:*"}, cfg.IncludedImages) + assert.Equal(t, 0.95, cfg.LowestEfficiency) + assert.Equal(t, "100MB", cfg.HighestWastedBytes) + assert.Equal(t, 0.10, cfg.HighestUserWastedPercent) + assert.Equal(t, 60, cfg.ResultRetentionDays) +} + +func TestLoadImageAnalysisConfigFromEnv_Tolerations(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_TOLERATIONS, `[{"key":"dedicated","operator":"Exists","effect":"NoSchedule"}]`) + + cfg, err := LoadImageAnalysisConfigFromEnv() + require.NoError(t, err) + require.Len(t, cfg.JobTolerations, 1) + assert.Equal(t, "dedicated", cfg.JobTolerations[0].Key) + assert.Equal(t, "Exists", string(cfg.JobTolerations[0].Operator)) + assert.Equal(t, "NoSchedule", string(cfg.JobTolerations[0].Effect)) +} + +func TestLoadImageAnalysisConfigFromEnv_InvalidInt(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_INTERVAL_DAYS, "not-a-number") + + _, err := LoadImageAnalysisConfigFromEnv() + assert.Error(t, err) + assert.Contains(t, err.Error(), "invalid integer for IMAGE_ANALYSIS_INTERVAL_DAYS") +} + +func TestLoadImageAnalysisConfigFromEnv_InvalidBool(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_ENABLED, "not-a-bool") + + _, err := LoadImageAnalysisConfigFromEnv() + assert.Error(t, err) + assert.Contains(t, err.Error(), "invalid boolean for IMAGE_ANALYSIS_ENABLED") +} + +func TestLoadImageAnalysisConfigFromEnv_InvalidFloat(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_LOWEST_EFFICIENCY, "abc") + + _, err := LoadImageAnalysisConfigFromEnv() + assert.Error(t, err) + assert.Contains(t, err.Error(), "invalid float for IMAGE_ANALYSIS_LOWEST_EFFICIENCY") +} + +func TestLoadImageAnalysisConfigFromEnv_InvalidTolerationJSON(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_TOLERATIONS, "not-json") + + _, err := LoadImageAnalysisConfigFromEnv() + assert.Error(t, err) + assert.Contains(t, err.Error(), "invalid JSON for IMAGE_ANALYSIS_JOB_TOLERATIONS") +} + +func TestLoadImageAnalysisConfigFromEnv_EmptyTolerationsArray(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_TOLERATIONS, "[]") + + cfg, err := LoadImageAnalysisConfigFromEnv() + require.NoError(t, err) + assert.Empty(t, cfg.JobTolerations) +} + +func TestLoadImageAnalysisConfigFromEnv_CSVTrimming(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_TARGET_NAMESPACES, " ns1 , ns2 , ns3 ") + + cfg, err := LoadImageAnalysisConfigFromEnv() + require.NoError(t, err) + assert.Equal(t, []string{"ns1", "ns2", "ns3"}, cfg.TargetNamespaces) +} diff --git a/internal/util/env.go b/internal/util/env.go index f07a2961..cb65e928 100644 --- a/internal/util/env.go +++ b/internal/util/env.go @@ -259,6 +259,12 @@ const ( const configVolumeMountPath = "/etc/zxporter/config" +// GetEnv reads a configuration value by key, first checking environment variables, +// then falling back to a file at /etc/zxporter/config/. +func GetEnv(key string) string { + return getEnv(key) +} + func getEnv(key string) string { if data := os.Getenv(key); data != "" { return data From 229b2cf7816f46aab35742df77164310e8841d28 Mon Sep 17 00:00:00 2001 From: Parthiba-Hazra Date: Fri, 13 Mar 2026 20:08:42 +0530 Subject: [PATCH 2/7] first iteration of image analyzer with some refactors --- Makefile | 11 + api/v1/imageanalysisresult_types.go | 4 +- cmd/main.go | 31 + .../devzero.io_imageanalysisresults.yaml | 5 +- .../crds/devzero.io_imageanalysisresults.yaml | 295 ++++++ helm-chart/zxporter/templates/configmap.yaml | 36 + .../templates/image-analysis-rbac.yaml | 13 + .../zxporter/templates/zxporter-rbac.yaml | 55 ++ helm-chart/zxporter/values.yaml | 49 +- internal/analyzer/Dockerfile | 33 + internal/analyzer/analyze-batch.sh | 180 ++++ internal/controller/image_analysis_config.go | 16 + .../controller/image_analysis_config_test.go | 20 + .../controller/image_analysis_controller.go | 609 ++++++++++++ .../image_analysis_controller_test.go | 258 +++++ internal/controller/image_discovery.go | 396 ++++++++ internal/controller/image_discovery_test.go | 767 ++++++++++++++ internal/controller/image_job_manager.go | 553 +++++++++++ internal/controller/image_job_manager_test.go | 784 +++++++++++++++ internal/controller/image_result_collector.go | 788 +++++++++++++++ .../controller/image_result_collector_test.go | 934 ++++++++++++++++++ 21 files changed, 5829 insertions(+), 8 deletions(-) create mode 100644 helm-chart/zxporter/crds/devzero.io_imageanalysisresults.yaml create mode 100644 helm-chart/zxporter/templates/image-analysis-rbac.yaml create mode 100644 internal/analyzer/Dockerfile create mode 100644 internal/analyzer/analyze-batch.sh create mode 100644 internal/controller/image_analysis_controller.go create mode 100644 internal/controller/image_analysis_controller_test.go create mode 100644 internal/controller/image_discovery.go create mode 100644 internal/controller/image_discovery_test.go create mode 100644 internal/controller/image_job_manager.go create mode 100644 internal/controller/image_job_manager_test.go create mode 100644 internal/controller/image_result_collector.go create mode 100644 internal/controller/image_result_collector_test.go diff --git a/Makefile b/Makefile index 17d479e4..b988bd39 100644 --- a/Makefile +++ b/Makefile @@ -250,6 +250,17 @@ stress-docker-build: ## Build docker image for the stress test. stress-docker-push: ## Push docker image for the stress test. $(CONTAINER_TOOL) push ${STRESS_IMG} +# Image analyzer for dive batch analysis +IMG_ANALYZER ?= ttl.sh/zxporter-image-analyzer:latest + +.PHONY: docker-build-analyzer +docker-build-analyzer: ## Build docker image for the image analyzer + $(CONTAINER_TOOL) build -t ${IMG_ANALYZER} -f internal/analyzer/Dockerfile internal/analyzer/ + +.PHONY: docker-push-analyzer +docker-push-analyzer: ## Push docker image for the image analyzer + $(CONTAINER_TOOL) push ${IMG_ANALYZER} + # zxporter-netmon images IMG_NETMON ?= ttl.sh/zxporter-netmon:latest diff --git a/api/v1/imageanalysisresult_types.go b/api/v1/imageanalysisresult_types.go index e58cc5be..6bdc5a81 100644 --- a/api/v1/imageanalysisresult_types.go +++ b/api/v1/imageanalysisresult_types.go @@ -47,8 +47,8 @@ type ImageAnalysisResultSpec struct { // ImageSourceInfo describes how the image was acquired for analysis type ImageSourceInfo struct { - // Type is the image acquisition method: "local-containerd" or "remote-pull" - // +kubebuilder:validation:Enum=local-containerd;remote-pull + // Type is the image acquisition method: "local-containerd", "remote-pull", or "failed" + // +kubebuilder:validation:Enum=local-containerd;remote-pull;failed Type string `json:"type"` // NodeName is the node where the analysis job ran diff --git a/cmd/main.go b/cmd/main.go index 7128e310..cfa8c328 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -29,6 +29,7 @@ import ( _ "k8s.io/client-go/plugin/pkg/client/auth" "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/kubernetes" utilruntime "k8s.io/apimachinery/pkg/util/runtime" clientgoscheme "k8s.io/client-go/kubernetes/scheme" ctrl "sigs.k8s.io/controller-runtime" @@ -190,6 +191,36 @@ func main() { os.Exit(1) } + // Setup image analysis controller (if enabled). + imageAnalysisConfig, err := controller.LoadImageAnalysisConfigFromEnv() + if err != nil { + setupLog.Error(err, "failed to load image analysis config, feature disabled") + } else if imageAnalysisConfig.Enabled { + k8sClient, err := kubernetes.NewForConfig(mgr.GetConfig()) + if err != nil { + setupLog.Error(err, "failed to create kubernetes client for image analysis") + os.Exit(1) + } + + imageAnalysisController := controller.NewImageAnalysisController( + k8sClient, + mgr.GetClient(), + ctrl.Log.WithName("image-analysis"), + imageAnalysisConfig, + ) + + if err := mgr.Add(imageAnalysisController); err != nil { + setupLog.Error(err, "unable to add image analysis controller to manager") + os.Exit(1) + } + setupLog.Info("image analysis controller registered", + "intervalDays", imageAnalysisConfig.IntervalDays, + "batchSize", imageAnalysisConfig.BatchSize, + ) + } else { + setupLog.Info("image analysis controller disabled") + } + setupLog.Info("starting manager") if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil { setupLog.Error(err, "problem running manager") diff --git a/config/crd/bases/devzero.io_imageanalysisresults.yaml b/config/crd/bases/devzero.io_imageanalysisresults.yaml index cfc182f0..d5763844 100644 --- a/config/crd/bases/devzero.io_imageanalysisresults.yaml +++ b/config/crd/bases/devzero.io_imageanalysisresults.yaml @@ -187,11 +187,12 @@ spec: description: NodeName is the node where the analysis job ran type: string type: - description: 'Type is the image acquisition method: "local-containerd" - or "remote-pull"' + description: 'Type is the image acquisition method: "local-containerd", + "remote-pull", or "failed"' enum: - local-containerd - remote-pull + - failed type: string required: - nodeName diff --git a/helm-chart/zxporter/crds/devzero.io_imageanalysisresults.yaml b/helm-chart/zxporter/crds/devzero.io_imageanalysisresults.yaml new file mode 100644 index 00000000..d5763844 --- /dev/null +++ b/helm-chart/zxporter/crds/devzero.io_imageanalysisresults.yaml @@ -0,0 +1,295 @@ +--- +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.5 + name: imageanalysisresults.devzero.io +spec: + group: devzero.io + names: + kind: ImageAnalysisResult + listKind: ImageAnalysisResultList + plural: imageanalysisresults + singular: imageanalysisresult + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .spec.imageRef + name: Image + type: string + - jsonPath: .spec.analysis.efficiency + name: Efficiency + type: string + - jsonPath: .spec.analysis.passed + name: Passed + type: boolean + - jsonPath: .spec.imageSource.type + name: Source + priority: 1 + type: string + - jsonPath: .status.phase + name: Phase + type: string + - jsonPath: .status.analyzedAt + name: Analyzed At + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + ImageAnalysisResult is the Schema for the imageanalysisresults API. + It stores dive analysis results for a container image including efficiency metrics, + layer breakdown, wasted space details, and references to workloads using the image. + properties: + apiVersion: + description: |- + APIVersion defines the versioned schema of this representation of an object. + Servers should convert recognized schemas to the latest internal value, and + may reject unrecognized values. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources + type: string + kind: + description: |- + Kind is a string value representing the REST resource this object represents. + Servers may infer this from the endpoint the client submits requests to. + Cannot be updated. + In CamelCase. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + metadata: + type: object + spec: + description: ImageAnalysisResultSpec defines the desired state of ImageAnalysisResult + properties: + analysis: + description: Analysis contains the dive analysis results + properties: + efficiency: + description: |- + Efficiency is the image efficiency ratio as a string (e.g. "0.9516") + Stored as string for cross-language CRD compatibility. Range: "0.0" to "1.0". + type: string + fileAnalysis: + description: FileAnalysis contains aggregate file statistics across + all layers + properties: + addedFiles: + description: AddedFiles is the count of files added across + layers + type: integer + modifiedFiles: + description: ModifiedFiles is the count of files modified + across layers + type: integer + removedFiles: + description: RemovedFiles is the count of files removed across + layers + type: integer + totalFiles: + description: TotalFiles is the total number of files in the + image + type: integer + type: object + layerCount: + description: LayerCount is the total number of layers in the image + type: integer + layers: + description: Layers contains details for each image layer + items: + description: LayerInfo contains details about a single image + layer + properties: + command: + description: Command is the Dockerfile instruction that + created this layer (truncated to 200 chars) + type: string + digest: + description: Digest is the layer digest + type: string + index: + description: Index is the layer position (0 = base layer) + type: integer + sizeBytes: + description: SizeBytes is the layer size in bytes + format: int64 + type: integer + required: + - index + - sizeBytes + type: object + type: array + passed: + description: Passed indicates whether the image meets the configured + efficiency thresholds + type: boolean + userWastedPercent: + description: |- + UserWastedPercent is the percentage of user image space that is wasted as a string (e.g. "0.016") + Stored as string for cross-language CRD compatibility. Range: "0.0" to "1.0". + type: string + wastedBytes: + description: WastedBytes is the total wasted space in bytes + format: int64 + type: integer + wastedFiles: + description: WastedFiles lists the top files contributing to wasted + space (capped at 50) + items: + description: WastedFile identifies a file or directory contributing + to wasted space + properties: + path: + description: Path is the file or directory path + type: string + sizeBytes: + description: SizeBytes is the wasted space from this file + in bytes + format: int64 + type: integer + required: + - path + - sizeBytes + type: object + type: array + required: + - efficiency + - layerCount + - passed + - userWastedPercent + - wastedBytes + type: object + imageDigest: + description: ImageDigest is the image digest (e.g. "sha256:a1b2c3d4e5f6...") + type: string + imageRef: + description: ImageRef is the full image reference including tag (e.g. + "docker.io/library/nginx:1.25.3") + type: string + imageSizeBytes: + description: ImageSizeBytes is the total size of the image in bytes + format: int64 + type: integer + imageSource: + description: ImageSource describes how the image was acquired for + analysis + properties: + batchJobName: + description: BatchJobName is the name of the batch job that analyzed + this image + type: string + exportDurationMs: + description: ExportDurationMs is how long it took to export/pull + the image in milliseconds + format: int64 + type: integer + nodeName: + description: NodeName is the node where the analysis job ran + type: string + type: + description: 'Type is the image acquisition method: "local-containerd", + "remote-pull", or "failed"' + enum: + - local-containerd + - remote-pull + - failed + type: string + required: + - nodeName + - type + type: object + workloadReferences: + description: WorkloadReferences lists the workloads using this image + (capped at 200, sorted by replica count desc) + items: + description: WorkloadReference identifies a workload that uses this + image + properties: + containerNames: + description: ContainerNames lists the container names within + the workload that use this image + items: + type: string + type: array + namespace: + description: Namespace is the workload's namespace + type: string + replicas: + description: Replicas is the current replica count of the workload + format: int32 + type: integer + workloadName: + description: WorkloadName is the name of the workload + type: string + workloadType: + description: WorkloadType is the kind of workload (e.g. "Deployment", + "StatefulSet", "DaemonSet", "Job", "CronJob") + type: string + workloadUID: + description: WorkloadUID is the UID of the workload + type: string + required: + - namespace + - workloadName + - workloadType + - workloadUID + type: object + type: array + workloadSummary: + description: WorkloadSummary is a high-level summary of workloads + using this image + properties: + namespaces: + description: Namespaces lists the namespaces where this image + is used + items: + type: string + type: array + nodesRunningImage: + description: NodesRunningImage is the count of nodes that have + containers running this image + type: integer + totalContainers: + description: TotalContainers is the total number of container + instances using this image across the cluster + type: integer + totalWorkloads: + description: TotalWorkloads is the count of unique workloads (Deployments, + StatefulSets, etc.) using this image + type: integer + type: object + required: + - analysis + - imageDigest + - imageRef + - imageSource + type: object + status: + description: ImageAnalysisResultStatus defines the observed state of ImageAnalysisResult + properties: + analysisDurationSeconds: + description: AnalysisDurationSeconds is how long the dive analysis + took + type: integer + analyzedAt: + description: AnalyzedAt is when the image was analyzed + format: date-time + type: string + message: + description: Message contains additional information about the current + phase (e.g. error details) + type: string + phase: + description: Phase is the current state of the analysis + enum: + - Pending + - Analyzing + - Completed + - Failed + type: string + type: object + type: object + served: true + storage: true + subresources: + status: {} diff --git a/helm-chart/zxporter/templates/configmap.yaml b/helm-chart/zxporter/templates/configmap.yaml index 217a9114..19928ef4 100644 --- a/helm-chart/zxporter/templates/configmap.yaml +++ b/helm-chart/zxporter/templates/configmap.yaml @@ -53,6 +53,42 @@ data: TOKEN_SECRET_NAME: "{{ .Values.zxporter.tokenSecretName }}" USE_SECRET_FOR_TOKEN: "{{ .Values.zxporter.useSecretForToken }}" WATCHED_CRDS: "" + # === Image Analysis Configuration === + {{- if .Values.imageAnalysis.enabled }} + IMAGE_ANALYSIS_ENABLED: "true" + IMAGE_ANALYSIS_INTERVAL_DAYS: "{{ .Values.imageAnalysis.intervalDays }}" + IMAGE_ANALYSIS_CRON_EXPRESSION: "" + IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS: "{{ .Values.imageAnalysis.maxConcurrentJobs }}" + IMAGE_ANALYSIS_MAX_JOBS_PER_NODE: "{{ .Values.imageAnalysis.maxJobsPerNode }}" + IMAGE_ANALYSIS_BATCH_SIZE: "{{ .Values.imageAnalysis.batchSize }}" + IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES: "{{ .Values.imageAnalysis.jobTimeoutMinutes }}" + IMAGE_ANALYSIS_MAX_RETRIES: "{{ .Values.imageAnalysis.maxRetries }}" + IMAGE_ANALYSIS_JOB_NAMESPACE: "{{ .Values.namespace }}" + IMAGE_ANALYSIS_ANALYZER_IMAGE: "{{ .Values.imageAnalysis.analyzerImage.repository }}:{{ .Values.imageAnalysis.analyzerImage.tag }}" + IMAGE_ANALYSIS_JOB_CPU_REQUEST: "{{ .Values.imageAnalysis.jobResources.requests.cpu }}" + IMAGE_ANALYSIS_JOB_CPU_LIMIT: "{{ .Values.imageAnalysis.jobResources.limits.cpu }}" + IMAGE_ANALYSIS_JOB_MEMORY_REQUEST: "{{ .Values.imageAnalysis.jobResources.requests.memory }}" + IMAGE_ANALYSIS_JOB_MEMORY_LIMIT: "{{ .Values.imageAnalysis.jobResources.limits.memory }}" + IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT: "{{ .Values.imageAnalysis.workspaceSizeLimit }}" + IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE: "30" + IMAGE_ANALYSIS_JOB_TOLERATIONS: "{{ .Values.imageAnalysis.jobTolerations | toJson }}" + IMAGE_ANALYSIS_PREFER_LOCAL: "{{ .Values.imageAnalysis.imageSource.preferLocal }}" + IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH: "{{ .Values.imageAnalysis.imageSource.containerdSocketPath }}" + IMAGE_ANALYSIS_CONTAINERD_NAMESPACE: "{{ .Values.imageAnalysis.imageSource.containerdNamespace }}" + IMAGE_ANALYSIS_FALLBACK_TO_REMOTE: "{{ .Values.imageAnalysis.imageSource.fallbackToRemote }}" + IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT: "{{ .Values.imageAnalysis.imageSource.remotePullTimeout }}" + IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET: "{{ .Values.imageAnalysis.registryAuthSecret }}" + IMAGE_ANALYSIS_TARGET_NAMESPACES: "" + IMAGE_ANALYSIS_EXCLUDED_NAMESPACES: "{{ join "," .Values.imageAnalysis.excludedNamespaces }}" + IMAGE_ANALYSIS_EXCLUDED_IMAGES: "{{ join "," .Values.imageAnalysis.excludedImages }}" + IMAGE_ANALYSIS_INCLUDED_IMAGES: "" + IMAGE_ANALYSIS_LOWEST_EFFICIENCY: "{{ .Values.imageAnalysis.thresholds.lowestEfficiency }}" + IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES: "{{ .Values.imageAnalysis.thresholds.highestWastedBytes }}" + IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT: "{{ .Values.imageAnalysis.thresholds.highestUserWastedPercent }}" + IMAGE_ANALYSIS_RESULT_RETENTION_DAYS: "{{ .Values.imageAnalysis.resultRetentionDays }}" + {{- else }} + IMAGE_ANALYSIS_ENABLED: "false" + {{- end }} kind: ConfigMap metadata: name: {{ .Values.zxporter.tokenConfigMapName }} diff --git a/helm-chart/zxporter/templates/image-analysis-rbac.yaml b/helm-chart/zxporter/templates/image-analysis-rbac.yaml new file mode 100644 index 00000000..13ba79d9 --- /dev/null +++ b/helm-chart/zxporter/templates/image-analysis-rbac.yaml @@ -0,0 +1,13 @@ +{{- if .Values.imageAnalysis.enabled }} +# ServiceAccount for image analysis batch jobs. +# Jobs don't access the K8s API — this SA is only for imagePullSecrets +# to pull the analyzer image itself from private registries if needed. +apiVersion: v1 +kind: ServiceAccount +metadata: + name: image-analyzer + namespace: {{ .Values.namespace }} + labels: + app.kubernetes.io/name: devzero-zxporter + app.kubernetes.io/component: image-analysis +{{- end }} diff --git a/helm-chart/zxporter/templates/zxporter-rbac.yaml b/helm-chart/zxporter/templates/zxporter-rbac.yaml index 73d07a9c..370acd14 100644 --- a/helm-chart/zxporter/templates/zxporter-rbac.yaml +++ b/helm-chart/zxporter/templates/zxporter-rbac.yaml @@ -337,11 +337,23 @@ rules: - batch resources: - cronjobs + verbs: + - get + - list + - watch +# Jobs: read-only for monitoring, plus create/delete for image analysis batch jobs +- apiGroups: + - batch + resources: - jobs verbs: - get - list - watch +{{- if .Values.imageAnalysis.enabled }} + - create + - delete +{{- end }} - apiGroups: - batch.volcano.sh resources: @@ -393,6 +405,49 @@ rules: - get - patch - update +{{- if .Values.imageAnalysis.enabled }} +# ========================================== +# IMAGE ANALYSIS PERMISSIONS +# ========================================== +# ImageAnalysisResult CRD CRUD (cluster-scoped) +- apiGroups: + - devzero.io + resources: + - imageanalysisresults + verbs: + - create + - delete + - get + - list + - update + - watch +# ImageAnalysisResult status subresource +- apiGroups: + - devzero.io + resources: + - imageanalysisresults/status + verbs: + - get + - update +# Pod log access for reading batch job output +- apiGroups: + - "" + resources: + - pods/log + verbs: + - get +{{- if .Values.imageAnalysis.registryAuthSecret }} +# Registry auth secret access for private image pulls +- apiGroups: + - "" + resourceNames: + - {{ .Values.imageAnalysis.registryAuthSecret }} + resources: + - secrets + verbs: + - get +{{- end }} +{{- end }} # ========================================== # OPTIONAL THIRD-PARTY RESOURCES # ========================================== diff --git a/helm-chart/zxporter/values.yaml b/helm-chart/zxporter/values.yaml index a6b7214b..1e14551c 100644 --- a/helm-chart/zxporter/values.yaml +++ b/helm-chart/zxporter/values.yaml @@ -17,7 +17,7 @@ image: # ZXPorter configuration zxporter: - dakrUrl: "https://dakr.devzero.io" + dakrUrl: "https://dakr.devzero.dev" prometheusUrl: "http://prometheus-dz-prometheus-server.devzero-zxporter.svc.cluster.local:80" targetNamespaces: "" # Cluster token for authentication with the DevZero platform @@ -29,7 +29,7 @@ zxporter: # automatically exchange the PAT for a cluster token on startup # This is the recommended approach for production deployments # Example: "dzu-aKAAyJgsrblR0dFmgnoB_sQjiVNs-I3Y4gI7jJnePgs=" - patToken: "" + patToken: "dzu-O1EGgVcRumuXPU1aiGrpZUu9Yqk71yZcuXBc1ssj8M8=" # Kubernetes context name to identify this cluster # Required: Must be set to a unique identifier for your cluster @@ -39,12 +39,12 @@ zxporter: # - AKS: "my-aks-cluster" # - OCI: "ocid1.cluster.oc1.iad.aaaaaaaa..." # - Other: "production-cluster" or "staging-cluster" - kubeContextName: "" + kubeContextName: "test-eks-3" # Kubernetes provider type # Required: Must be one of: "aws", "gcp", "azure", "oci", "other" # This helps optimize collection for specific cloud providers - k8sProvider: "" + k8sProvider: "aws" # Set to true to store CLUSTER_TOKEN and PAT_TOKEN in Kubernetes Secrets instead of ConfigMap # Default is false for backward compatibility useSecretForToken: false @@ -86,6 +86,47 @@ highAvailability: mpaServer: port: 50051 +# Image Analysis Configuration +# Runs dive analysis on container images to evaluate efficiency, wasted space, etc. +imageAnalysis: + enabled: false + intervalDays: 7 + analyzerImage: + repository: docker.io/devzeroinc/image-analyzer + tag: "v1" + batchSize: 10 + maxConcurrentJobs: 10 + maxJobsPerNode: 1 + jobTimeoutMinutes: 30 + maxRetries: 2 + imageSource: + preferLocal: true + containerdSocketPath: "/run/containerd/containerd.sock" + containerdNamespace: "k8s.io" + fallbackToRemote: true + remotePullTimeout: "5m" + # Secret name containing .dockerconfigjson for private registry access (optional) + registryAuthSecret: "" + thresholds: + lowestEfficiency: 0.90 + highestWastedBytes: "50MB" + highestUserWastedPercent: 0.20 + excludedNamespaces: + - kube-system + - kube-public + excludedImages: + - "registry.k8s.io/pause:*" + jobResources: + requests: + cpu: "500m" + memory: "1Gi" + limits: + cpu: "1" + memory: "4Gi" + jobTolerations: [] + workspaceSizeLimit: "10Gi" + resultRetentionDays: 30 + # Priority Class for critical workloads priorityClass: enabled: true diff --git a/internal/analyzer/Dockerfile b/internal/analyzer/Dockerfile new file mode 100644 index 00000000..2952f859 --- /dev/null +++ b/internal/analyzer/Dockerfile @@ -0,0 +1,33 @@ +# Image Analyzer — Containerd-First Batch Analysis +# +# This image contains dive, crane, ctr (containerd CLI), and jq for +# running batch image analysis on Kubernetes nodes. +# +# Security model: +# - Runs as root (runAsUser: 0) for containerd socket access +# - Security enforced via Job securityContext: +# * allowPrivilegeEscalation: false +# * Containerd socket mounted read-only +# * No additional capabilities + +FROM alpine:3.21 AS base + +RUN apk add --no-cache bash jq coreutils + +# crane — for remote registry pulls when containerd export fails +COPY --from=gcr.io/go-containerregistry/crane:latest /ko-app/crane /usr/local/bin/crane + +# dive — the core image analysis tool +COPY --from=wagoodman/dive:latest /usr/local/bin/dive /usr/local/bin/dive + +# ctr — containerd CLI for local image export +COPY --from=docker.io/rancher/k3s:v1.31.4-k3s1 /bin/ctr /usr/local/bin/ctr + +COPY analyze-batch.sh /analyze-batch.sh +RUN chmod +x /analyze-batch.sh + +# NOTE: No USER directive — job runs as root (runAsUser: 0) for containerd socket access. +# Security is enforced via: allowPrivilegeEscalation=false, read-only socket mount, +# and no additional capabilities. + +ENTRYPOINT ["/analyze-batch.sh"] diff --git a/internal/analyzer/analyze-batch.sh b/internal/analyzer/analyze-batch.sh new file mode 100644 index 00000000..ffc6871b --- /dev/null +++ b/internal/analyzer/analyze-batch.sh @@ -0,0 +1,180 @@ +#!/bin/bash +set -uo pipefail +# NOTE: intentionally no `set -e` — we handle errors per-image to avoid +# killing the entire batch when a single image analysis fails. + +# ============================================================================ +# Image Analyzer Batch Script +# +# Input: IMAGES_JSON env var — JSON array of {digest, ref} objects +# e.g. [{"digest":"sha256:abc...","ref":"docker.io/nginx:1.25"},...] +# +# Output: One NDJSON line per image to stdout: +# {"digest":"...","ref":"...","source":"local-containerd|remote-pull|failed", +# "durationMs":N,"error":"","result":{...}} +# +# The script always exits 0. Per-image failures are encoded in the NDJSON +# output (source="failed" or error field set), never as exit codes. +# ============================================================================ + +WORKSPACE="${WORKSPACE:-/tmp/workspace}" +CONTAINERD_SOCK="${CONTAINERD_SOCK:-/run/containerd/containerd.sock}" +CONTAINERD_NS="${CONTAINERD_NS:-k8s.io}" +PREFER_LOCAL="${PREFER_LOCAL:-true}" +FALLBACK_REMOTE="${FALLBACK_REMOTE:-true}" +REMOTE_PULL_TIMEOUT="${REMOTE_PULL_TIMEOUT:-300}" + +# Ensure workspace exists. +mkdir -p "$WORKSPACE" + +# Read IMAGES_JSON from env var, or fall back to file. +IMAGES_JSON="${IMAGES_JSON:-}" +if [ -z "$IMAGES_JSON" ] && [ -f "${WORKSPACE}/images.json" ]; then + IMAGES_JSON="$(cat "${WORKSPACE}/images.json")" +fi + +if [ -z "$IMAGES_JSON" ]; then + echo '{"digest":"","ref":"","source":"failed","durationMs":0,"error":"IMAGES_JSON is empty and no fallback file found","result":null}' + exit 0 +fi + +# Validate IMAGES_JSON is parseable. +if ! echo "$IMAGES_JSON" | jq -e 'type == "array"' >/dev/null 2>&1; then + echo '{"digest":"","ref":"","source":"failed","durationMs":0,"error":"IMAGES_JSON is not a valid JSON array","result":null}' + exit 0 +fi + +# emit_json safely outputs a JSON line, escaping the error string. +# Usage: emit_json "$digest" "$ref" "$source" "$duration_ms" "$error" ["$result_file_path"] +# If result_file_path is provided and exists, reads dive result from file +# to avoid ARG_MAX limits with large JSON payloads. +emit_json() { + local digest="$1" + local ref="$2" + local source="$3" + local duration_ms="$4" + local error_msg="$5" + local result_file="${6:-}" + + if [ -n "$result_file" ] && [ -f "$result_file" ]; then + # Read result from file using --slurpfile to avoid ARG_MAX limits. + jq -cn \ + --arg digest "$digest" \ + --arg ref "$ref" \ + --arg source "$source" \ + --argjson durationMs "$duration_ms" \ + --arg error "$error_msg" \ + --slurpfile result "$result_file" \ + '{digest: $digest, ref: $ref, source: $source, durationMs: $durationMs, error: $error, result: $result[0]}' + else + # No result file — emit with null result. + jq -cn \ + --arg digest "$digest" \ + --arg ref "$ref" \ + --arg source "$source" \ + --argjson durationMs "$duration_ms" \ + --arg error "$error_msg" \ + '{digest: $digest, ref: $ref, source: $source, durationMs: $durationMs, error: $error, result: null}' + fi +} + +# get_time_ms returns current time in milliseconds. +get_time_ms() { + # date +%s%N gives nanoseconds; divide by 1000000 for ms. + echo $(( $(date +%s%N) / 1000000 )) +} + +analyze_image() { + local digest="$1" + local ref="$2" + local tar_path="${WORKSPACE}/image.tar" + local result_path="${WORKSPACE}/result.json" + local source="unknown" + local start_ms + start_ms=$(get_time_ms) + + # Clean any leftover files from previous iteration. + rm -f "$tar_path" "$result_path" + + # ---- Strategy 1: Containerd local export ---- + # Uses image ref (not digest) because `ctr images export` needs the tag. + if [ "$PREFER_LOCAL" = "true" ] && [ -S "$CONTAINERD_SOCK" ]; then + if ctr -a "$CONTAINERD_SOCK" -n "$CONTAINERD_NS" images export \ + "$tar_path" "$ref" --platform linux/amd64 2>/dev/null; then + source="local-containerd" + else + # ctr may leave behind a partial/corrupt tar on failure. + # Remove it so the crane fallback can trigger. + rm -f "$tar_path" + fi + fi + + # ---- Strategy 2: Remote pull via crane ---- + # crane reads auth from /root/.docker/config.json (mounted from Secret). + if [ ! -f "$tar_path" ] && [ "$FALLBACK_REMOTE" = "true" ]; then + if timeout "$REMOTE_PULL_TIMEOUT" \ + crane pull "$ref" "$tar_path" --platform=linux/amd64 2>/dev/null; then + source="remote-pull" + fi + fi + + # ---- If neither worked, emit error ---- + if [ ! -f "$tar_path" ]; then + local end_ms + end_ms=$(get_time_ms) + local duration_ms=$(( end_ms - start_ms )) + emit_json "$digest" "$ref" "failed" "$duration_ms" "image acquisition failed: containerd export and remote pull both failed" + return 0 + fi + + # ---- Run dive analysis ---- + if CI=true dive --source docker-archive "$tar_path" --json "$result_path" 2>/dev/null; then + local end_ms + end_ms=$(get_time_ms) + local duration_ms=$(( end_ms - start_ms )) + + if [ -f "$result_path" ] && [ -s "$result_path" ]; then + # Validate the dive output is valid JSON before embedding. + if jq -e . "$result_path" >/dev/null 2>&1; then + # Pass file path to emit_json; it reads via --slurpfile + # to avoid ARG_MAX limits with large dive results. + emit_json "$digest" "$ref" "$source" "$duration_ms" "" "$result_path" + else + emit_json "$digest" "$ref" "$source" "$duration_ms" "dive produced invalid JSON output" + fi + else + emit_json "$digest" "$ref" "$source" "$duration_ms" "dive produced empty result file" + fi + else + local exit_code=$? + local end_ms + end_ms=$(get_time_ms) + local duration_ms=$(( end_ms - start_ms )) + emit_json "$digest" "$ref" "$source" "$duration_ms" "dive analysis failed with exit code $exit_code" + fi + + # Cleanup tar + result immediately to free disk for the next image. + rm -f "$tar_path" "$result_path" + return 0 # always succeed at batch level +} + +# ============================================================================ +# Main: Process each image in the batch sequentially. +# ============================================================================ + +image_count=$(echo "$IMAGES_JSON" | jq 'length') +echo "Starting batch analysis of $image_count images" >&2 + +# Use process substitution instead of pipe to avoid subshell variable scope issues. +index=0 +while IFS= read -r img; do + digest=$(echo "$img" | jq -r '.digest') + ref=$(echo "$img" | jq -r '.ref') + + echo "[$((index + 1))/$image_count] Analyzing: $ref (digest: ${digest:0:24}...)" >&2 + analyze_image "$digest" "$ref" + index=$((index + 1)) +done < <(echo "$IMAGES_JSON" | jq -c '.[]') + +echo "Batch analysis complete" >&2 +exit 0 # batch always exits 0; per-image errors are in NDJSON output diff --git a/internal/controller/image_analysis_config.go b/internal/controller/image_analysis_config.go index 37964466..ae6b28ec 100644 --- a/internal/controller/image_analysis_config.go +++ b/internal/controller/image_analysis_config.go @@ -23,6 +23,7 @@ import ( "strings" corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" "github.com/devzero-inc/zxporter/internal/util" ) @@ -307,5 +308,20 @@ func LoadImageAnalysisConfigFromEnv() (ImageAnalysisConfig, error) { return cfg, err } + // === Validate resource quantities to catch bad values at load time (not at Job creation) === + for _, check := range []struct { + name, value string + }{ + {"JobCPURequest", cfg.JobCPURequest}, + {"JobCPULimit", cfg.JobCPULimit}, + {"JobMemoryRequest", cfg.JobMemoryRequest}, + {"JobMemoryLimit", cfg.JobMemoryLimit}, + {"WorkspaceSizeLimit", cfg.WorkspaceSizeLimit}, + } { + if _, err := resource.ParseQuantity(check.value); err != nil { + return cfg, fmt.Errorf("invalid resource quantity for %s (%q): %w", check.name, check.value, err) + } + } + return cfg, nil } diff --git a/internal/controller/image_analysis_config_test.go b/internal/controller/image_analysis_config_test.go index a8b048f6..301e9b4a 100644 --- a/internal/controller/image_analysis_config_test.go +++ b/internal/controller/image_analysis_config_test.go @@ -247,6 +247,26 @@ func TestLoadImageAnalysisConfigFromEnv_EmptyTolerationsArray(t *testing.T) { assert.Empty(t, cfg.JobTolerations) } +func TestLoadImageAnalysisConfigFromEnv_InvalidResourceQuantity(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_CPU_REQUEST, "not-a-resource") + + _, err := LoadImageAnalysisConfigFromEnv() + assert.Error(t, err) + assert.Contains(t, err.Error(), "invalid resource quantity for JobCPURequest") +} + +func TestLoadImageAnalysisConfigFromEnv_InvalidMemoryQuantity(t *testing.T) { + clearImageAnalysisEnvVars(t) + + t.Setenv(_ENV_IMAGE_ANALYSIS_JOB_MEMORY_LIMIT, "xyz") + + _, err := LoadImageAnalysisConfigFromEnv() + assert.Error(t, err) + assert.Contains(t, err.Error(), "invalid resource quantity for JobMemoryLimit") +} + func TestLoadImageAnalysisConfigFromEnv_CSVTrimming(t *testing.T) { clearImageAnalysisEnvVars(t) diff --git a/internal/controller/image_analysis_controller.go b/internal/controller/image_analysis_controller.go new file mode 100644 index 00000000..595bdff7 --- /dev/null +++ b/internal/controller/image_analysis_controller.go @@ -0,0 +1,609 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "context" + "fmt" + "sync" + "time" + + "github.com/go-logr/logr" + "k8s.io/apimachinery/pkg/types" + "k8s.io/client-go/kubernetes" + "sigs.k8s.io/controller-runtime/pkg/client" + + v1 "github.com/devzero-inc/zxporter/api/v1" +) + +// ScanPhase represents the current phase of a scan cycle. +type ScanPhase string + +const ( + ScanPhaseIdle ScanPhase = "Idle" + ScanPhaseDiscovering ScanPhase = "Discovering" + ScanPhaseAnalyzing ScanPhase = "Analyzing" + ScanPhaseCollecting ScanPhase = "Collecting" + ScanPhaseCompleted ScanPhase = "Completed" + ScanPhaseFailed ScanPhase = "Failed" + + // jobPollInterval is how often to check job statuses during the analysis phase. + jobPollInterval = 30 * time.Second +) + +// ImageSourceStats tracks how images were acquired during a scan. +type ImageSourceStats struct { + LocalContainerd int + RemotePull int + AcquisitionFailed int +} + +// ScanState holds the in-memory state for a single scan cycle. +type ScanState struct { + mu sync.RWMutex + + Phase ScanPhase + ScanID string + StartAt time.Time + + // Discovery stats. + TotalUniqueImages int + TotalNodes int + TotalBatches int + + // Progress counters. + ImagesCompleted int + ImagesFailed int + BatchesTotal int + BatchesComplete int + BatchesFailed int + + // Source stats. + SourceStats ImageSourceStats + + // Error from the scan. + Error string +} + +// GetPhase returns the current scan phase (thread-safe). +func (s *ScanState) GetPhase() ScanPhase { + s.mu.RLock() + defer s.mu.RUnlock() + return s.Phase +} + +// setPhase updates the scan phase (thread-safe). +func (s *ScanState) setPhase(phase ScanPhase) { + s.mu.Lock() + defer s.mu.Unlock() + s.Phase = phase +} + +// recordBatchResult updates counters from a single batch collection. +func (s *ScanState) recordBatchResult(cr *CollectionResult) { + s.mu.Lock() + defer s.mu.Unlock() + s.BatchesComplete++ + s.ImagesCompleted += len(cr.Succeeded) + s.ImagesFailed += len(cr.Failed) + cr.ParseErrors + s.SourceStats.LocalContainerd += cr.LocalContainerd + s.SourceStats.RemotePull += cr.RemotePull + s.SourceStats.AcquisitionFailed += cr.AcquisitionFailed +} + +// recordBatchFailed records a batch that failed entirely (couldn't read logs, etc.). +func (s *ScanState) recordBatchFailed() { + s.mu.Lock() + defer s.mu.Unlock() + s.BatchesFailed++ +} + +// ImageAnalysisController runs periodic image analysis scans. +// It implements manager.Runnable so it can be added via mgr.Add(). +type ImageAnalysisController struct { + k8sClient kubernetes.Interface + crdClient client.Client + log logr.Logger + config ImageAnalysisConfig + state *ScanState +} + +// NewImageAnalysisController creates a new image analysis controller. +func NewImageAnalysisController( + k8sClient kubernetes.Interface, + crdClient client.Client, + log logr.Logger, + config ImageAnalysisConfig, +) *ImageAnalysisController { + return &ImageAnalysisController{ + k8sClient: k8sClient, + crdClient: crdClient, + log: log.WithName("image-analysis"), + config: config, + state: &ScanState{ + Phase: ScanPhaseIdle, + }, + } +} + +// NeedLeaderElection returns true — only the leader should run image analysis. +func (c *ImageAnalysisController) NeedLeaderElection() bool { + return true +} + +// Start implements manager.Runnable. It runs an initial scan attempt on resume, +// then enters the periodic scan loop. +func (c *ImageAnalysisController) Start(ctx context.Context) error { + c.log.Info("image analysis controller starting", + "interval", fmt.Sprintf("%dd", c.config.IntervalDays), + "batchSize", c.config.BatchSize, + "maxConcurrentJobs", c.config.MaxConcurrentJobs, + "analyzerImage", c.config.AnalyzerImage, + ) + + // Check if there's an in-progress scan from a previous controller instance. + if resumed := c.tryResumeScan(ctx); resumed { + c.log.Info("resumed in-progress scan from previous instance") + } + + // Run the periodic scan loop. + interval := time.Duration(c.config.IntervalDays) * 24 * time.Hour + ticker := time.NewTicker(interval) + defer ticker.Stop() + + // Run first scan immediately if we didn't resume one. + if c.state.GetPhase() == ScanPhaseIdle { + c.runScan(ctx) + } + + for { + select { + case <-ticker.C: + // Re-read config each cycle to pick up ConfigMap changes. + newConfig, err := LoadImageAnalysisConfigFromEnv() + if err != nil { + c.log.Error(err, "failed to reload config, using previous") + } else { + c.config = newConfig + if !c.config.Enabled { + c.log.Info("image analysis disabled via config, skipping scan") + continue + } + } + c.runScan(ctx) + case <-ctx.Done(): + c.log.Info("image analysis controller stopping") + return nil + } + } +} + +// GetState returns the current scan state (for health reporting). +func (c *ImageAnalysisController) GetState() *ScanState { + return c.state +} + +// tryResumeScan checks for in-progress jobs from a previous controller instance. +// Returns true if a scan was resumed. +func (c *ImageAnalysisController) tryResumeScan(ctx context.Context) bool { + jm := NewJobManager(c.k8sClient, c.config, c.log) + + // List all image-analysis jobs. + jobList, err := jm.ListScanJobs(ctx, "") + if err != nil { + c.log.V(1).Info("could not list existing jobs for resume check", "error", err) + return false + } + + if len(jobList.Items) == 0 { + return false + } + + // Find the most recent scan ID. + latestScanID := "" + var latestTime time.Time + for i := range jobList.Items { + scanID := jobList.Items[i].Labels[LabelScanID] + if jobList.Items[i].CreationTimestamp.After(latestTime) { + latestTime = jobList.Items[i].CreationTimestamp.Time + latestScanID = scanID + } + } + + if latestScanID == "" { + return false + } + + // Check if any jobs from this scan are still active (not completed/failed). + hasActive := false + for i := range jobList.Items { + if jobList.Items[i].Labels[LabelScanID] != latestScanID { + continue + } + if jobList.Items[i].Status.Succeeded == 0 && !isJobFailed(&jobList.Items[i]) { + hasActive = true + break + } + } + + if !hasActive { + // All jobs from the latest scan are done. Collect any uncollected results. + c.log.Info("found completed scan from previous instance, collecting results", + "scanID", latestScanID) + c.collectRemainingResults(ctx, latestScanID, nil) + return true + } + + // There are still active jobs — monitor them. + c.log.Info("resuming active scan from previous instance", "scanID", latestScanID) + c.state.ScanID = latestScanID + c.state.setPhase(ScanPhaseAnalyzing) + c.monitorAndCollect(ctx, latestScanID, nil) + return true +} + +// runScan executes a full scan cycle: discover → plan → submit → monitor → collect → prune. +func (c *ImageAnalysisController) runScan(ctx context.Context) { + c.state = &ScanState{ + Phase: ScanPhaseDiscovering, + StartAt: time.Now(), + } + + c.log.Info("starting image analysis scan") + + // Phase 1: Discover images. + discoverer := NewImageDiscoverer(c.k8sClient, c.config, c.log) + discoveryResult, err := discoverer.Discover(ctx) + if err != nil { + c.log.Error(err, "image discovery failed") + c.state.setPhase(ScanPhaseFailed) + c.state.Error = fmt.Sprintf("discovery failed: %v", err) + return + } + + totalImages := 0 + for _, batch := range discoveryResult.NodeImages { + totalImages += len(batch.Images) + } + c.log.Info("discovery complete", + "uniqueImages", totalImages, + "nodes", len(discoveryResult.NodeImages), + ) + + if totalImages == 0 { + c.log.Info("no images to analyze, scan complete") + c.state.setPhase(ScanPhaseCompleted) + return + } + + c.state.TotalUniqueImages = totalImages + c.state.TotalNodes = len(discoveryResult.NodeImages) + + // Phase 2: Smart diff — skip images already analyzed in this scan window. + filteredNodeImages := c.smartDiff(ctx, discoveryResult.NodeImages) + filteredTotal := 0 + for _, batch := range filteredNodeImages { + filteredTotal += len(batch.Images) + } + + if filteredTotal == 0 { + c.log.Info("all images already analyzed within scan window, skipping") + c.state.setPhase(ScanPhaseCompleted) + return + } + + c.log.Info("after smart diff", "toAnalyze", filteredTotal, "skipped", totalImages-filteredTotal) + + // Phase 3: Plan and submit batch jobs. + c.state.setPhase(ScanPhaseAnalyzing) + jm := NewJobManager(c.k8sClient, c.config, c.log) + scanID := GenerateScanID() + c.state.ScanID = scanID + + batches := jm.PlanBatchJobs(filteredNodeImages, scanID) + c.state.TotalBatches = len(batches) + c.state.BatchesTotal = len(batches) + + c.log.Info("planned batch jobs", "batches", len(batches), "scanID", scanID) + + createdJobs, err := jm.SubmitBatches(ctx, batches) + if err != nil { + c.log.Error(err, "batch submission failed", "submitted", len(createdJobs)) + // Continue — some batches may have been submitted. + } + + if len(createdJobs) == 0 { + c.log.Error(nil, "no batches could be submitted") + c.state.setPhase(ScanPhaseFailed) + c.state.Error = "no batches submitted" + return + } + + c.log.Info("submitted batch jobs", "submitted", len(createdJobs), "total", len(batches)) + + // Phase 4: Monitor jobs and collect results. + c.monitorAndCollect(ctx, scanID, discoveryResult.WorkloadRefs) + + // Phase 5: Prune stale results. + c.pruneStaleResults(ctx, discoveryResult) + + // Phase 6: Clean up old scan jobs. + if _, err := jm.CleanupOldScanJobs(ctx, scanID); err != nil { + c.log.Error(err, "failed to cleanup old scan jobs") + } + + c.state.setPhase(ScanPhaseCompleted) + c.log.Info("scan complete", + "scanID", scanID, + "imagesCompleted", c.state.ImagesCompleted, + "imagesFailed", c.state.ImagesFailed, + "localContainerd", c.state.SourceStats.LocalContainerd, + "remotePull", c.state.SourceStats.RemotePull, + "acquisitionFailed", c.state.SourceStats.AcquisitionFailed, + "duration", time.Since(c.state.StartAt).Round(time.Second), + ) +} + +// smartDiff filters out images that already have a recent ImageAnalysisResult. +func (c *ImageAnalysisController) smartDiff(ctx context.Context, nodeImages NodeImageMap) NodeImageMap { + // List all existing ImageAnalysisResults. + existingList := &v1.ImageAnalysisResultList{} + if err := c.crdClient.List(ctx, existingList); err != nil { + c.log.Error(err, "failed to list existing ImageAnalysisResults, analyzing all images") + return nodeImages + } + + // Build a set of recently analyzed digests. + scanWindow := time.Duration(c.config.IntervalDays) * 24 * time.Hour + cutoff := time.Now().Add(-scanWindow) + recentlyAnalyzed := make(map[string]bool) + + for i := range existingList.Items { + item := &existingList.Items[i] + if item.Status.Phase == "Completed" && item.Status.AnalyzedAt.After(cutoff) { + recentlyAnalyzed[item.Spec.ImageDigest] = true + } + } + + if len(recentlyAnalyzed) == 0 { + return nodeImages + } + + // Filter node images. + filtered := make(NodeImageMap) + for nodeName, batch := range nodeImages { + var kept []ImageInfo + for _, img := range batch.Images { + if !recentlyAnalyzed[img.Digest] { + kept = append(kept, img) + } + } + if len(kept) > 0 { + filtered[nodeName] = &NodeBatch{ + NodeName: nodeName, + Images: kept, + } + } + } + + return filtered +} + +// monitorAndCollect polls job statuses and collects results as jobs complete. +func (c *ImageAnalysisController) monitorAndCollect( + ctx context.Context, + scanID string, + workloadRefs WorkloadRefMap, +) { + c.state.setPhase(ScanPhaseCollecting) + jm := NewJobManager(c.k8sClient, c.config, c.log) + collector := NewResultCollector(c.k8sClient, c.crdClient, c.config, c.log) + + // Track which jobs we've already collected. + collected := make(map[string]bool) + timeout := time.Duration(c.config.JobTimeoutMinutes*2) * time.Minute + deadline := time.Now().Add(timeout) + + for { + select { + case <-ctx.Done(): + return + default: + } + + if time.Now().After(deadline) { + c.log.Error(nil, "scan deadline reached, stopping collection", "scanID", scanID) + c.state.Error = "scan deadline reached" + return + } + + jobList, err := jm.ListScanJobs(ctx, scanID) + if err != nil { + c.log.Error(err, "failed to list scan jobs") + time.Sleep(jobPollInterval) + continue + } + + allDone := true + for i := range jobList.Items { + job := &jobList.Items[i] + + if collected[job.Name] { + continue + } + + if job.Status.Succeeded > 0 { + // Job completed — collect results. + cr, err := collector.CollectFromJob(ctx, job) + if err != nil { + c.log.Error(err, "failed to collect results from job", "job", job.Name) + c.state.recordBatchFailed() + } else { + c.processCollectionResult(ctx, collector, cr, workloadRefs) + c.state.recordBatchResult(cr) + } + collected[job.Name] = true + } else if isJobFailed(job) { + // Job failed entirely. + c.log.Error(nil, "batch job failed", "job", job.Name, + "node", job.Labels[LabelAnalysisNode]) + // Still try to collect partial results from failed jobs. + cr, err := collector.CollectFromJob(ctx, job) + if err != nil { + c.log.V(1).Info("no results from failed job", "job", job.Name, "error", err) + c.state.recordBatchFailed() + } else { + c.processCollectionResult(ctx, collector, cr, workloadRefs) + c.state.recordBatchResult(cr) + } + collected[job.Name] = true + } else { + // Still running. + allDone = false + } + } + + if allDone && len(collected) > 0 { + c.log.Info("all batch jobs complete", "collected", len(collected)) + return + } + + if len(jobList.Items) == 0 { + c.log.Info("no jobs found for scan, may have been cleaned up", "scanID", scanID) + return + } + + time.Sleep(jobPollInterval) + } +} + +// processCollectionResult saves individual image results from a batch to CRDs. +func (c *ImageAnalysisController) processCollectionResult( + ctx context.Context, + collector *ResultCollector, + cr *CollectionResult, + workloadRefs WorkloadRefMap, +) { + // Save successful results. + for _, img := range cr.Succeeded { + if err := collector.ProcessAndSave(ctx, img, cr.JobName, cr.NodeName, cr.ScanID, workloadRefs); err != nil { + c.log.Error(err, "failed to save result", "image", img.Ref) + } + } + + // Save failed results. + for _, img := range cr.Failed { + if err := collector.SaveFailedResult(ctx, img, cr.JobName, cr.NodeName, cr.ScanID); err != nil { + c.log.Error(err, "failed to save failed result", "image", img.Ref) + } + } +} + +// collectRemainingResults collects results from completed jobs that haven't been processed yet. +func (c *ImageAnalysisController) collectRemainingResults( + ctx context.Context, + scanID string, + workloadRefs WorkloadRefMap, +) { + jm := NewJobManager(c.k8sClient, c.config, c.log) + collector := NewResultCollector(c.k8sClient, c.crdClient, c.config, c.log) + + jobList, err := jm.ListScanJobs(ctx, scanID) + if err != nil { + c.log.Error(err, "failed to list jobs for result collection", "scanID", scanID) + return + } + + for i := range jobList.Items { + job := &jobList.Items[i] + if job.Status.Succeeded == 0 && !isJobFailed(job) { + continue // still running + } + + // Check if CRDs already exist for this job's images. + // We do best-effort collection — if CRD already exists, ProcessAndSave will update it. + cr, err := collector.CollectFromJob(ctx, job) + if err != nil { + c.log.V(1).Info("could not collect from job", "job", job.Name, "error", err) + continue + } + + c.processCollectionResult(ctx, collector, cr, workloadRefs) + } +} + +// pruneStaleResults removes ImageAnalysisResult CRDs for images no longer running in the cluster. +func (c *ImageAnalysisController) pruneStaleResults(ctx context.Context, discovery *DiscoveryResult) { + if c.config.ResultRetentionDays <= 0 { + return + } + + existingList := &v1.ImageAnalysisResultList{} + if err := c.crdClient.List(ctx, existingList); err != nil { + c.log.Error(err, "failed to list ImageAnalysisResults for pruning") + return + } + + // Build set of currently discovered image digests. + currentDigests := make(map[string]bool) + for _, batch := range discovery.NodeImages { + for _, img := range batch.Images { + currentDigests[img.Digest] = true + } + } + + retentionCutoff := time.Now().Add(-time.Duration(c.config.ResultRetentionDays) * 24 * time.Hour) + pruned := 0 + + for i := range existingList.Items { + item := &existingList.Items[i] + // Only prune if the image is no longer discovered AND the result is older than retention. + if !currentDigests[item.Spec.ImageDigest] && item.Status.AnalyzedAt.Time.Before(retentionCutoff) { + if err := c.crdClient.Delete(ctx, item); err != nil { + c.log.Error(err, "failed to prune stale result", "name", item.Name) + } else { + pruned++ + } + } + } + + if pruned > 0 { + c.log.Info("pruned stale ImageAnalysisResults", "count", pruned) + } +} + +// updateWorkloadRefs updates workload references for existing CRDs without re-analyzing. +// Used when an image is still running but workload refs may have changed. +func (c *ImageAnalysisController) updateWorkloadRefs( + ctx context.Context, + digest string, + workloadRefs WorkloadRefMap, +) { + crdName := generateCRDName(digest) + existing := &v1.ImageAnalysisResult{} + if err := c.crdClient.Get(ctx, types.NamespacedName{Name: crdName}, existing); err != nil { + return // not found, nothing to update + } + + newRefs, newSummary := buildWorkloadData(digest, workloadRefs) + existing.Spec.WorkloadReferences = newRefs + existing.Spec.WorkloadSummary = newSummary + + if err := c.crdClient.Update(ctx, existing); err != nil { + c.log.V(1).Info("failed to update workload refs", "name", crdName, "error", err) + } +} diff --git a/internal/controller/image_analysis_controller_test.go b/internal/controller/image_analysis_controller_test.go new file mode 100644 index 00000000..faef9138 --- /dev/null +++ b/internal/controller/image_analysis_controller_test.go @@ -0,0 +1,258 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "testing" + "time" + + v1 "github.com/devzero-inc/zxporter/api/v1" + "github.com/go-logr/logr" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// ============================================================================= +// Unit Tests: ScanState +// ============================================================================= + +func TestScanState_InitialPhase(t *testing.T) { + state := &ScanState{Phase: ScanPhaseIdle} + if state.GetPhase() != ScanPhaseIdle { + t.Errorf("expected Idle, got %s", state.GetPhase()) + } +} + +func TestScanState_SetPhase(t *testing.T) { + state := &ScanState{Phase: ScanPhaseIdle} + state.setPhase(ScanPhaseDiscovering) + if state.GetPhase() != ScanPhaseDiscovering { + t.Errorf("expected Discovering, got %s", state.GetPhase()) + } +} + +func TestScanState_RecordBatchResult(t *testing.T) { + state := &ScanState{} + cr := &CollectionResult{ + Succeeded: make([]BatchImageResult, 3), + Failed: make([]BatchImageResult, 1), + ParseErrors: 1, + LocalContainerd: 2, + RemotePull: 1, + AcquisitionFailed: 0, + } + + state.recordBatchResult(cr) + + if state.BatchesComplete != 1 { + t.Errorf("expected 1 batch complete, got %d", state.BatchesComplete) + } + if state.ImagesCompleted != 3 { + t.Errorf("expected 3 images completed, got %d", state.ImagesCompleted) + } + if state.ImagesFailed != 2 { // 1 failed + 1 parse error + t.Errorf("expected 2 images failed, got %d", state.ImagesFailed) + } + if state.SourceStats.LocalContainerd != 2 { + t.Errorf("expected 2 local containerd, got %d", state.SourceStats.LocalContainerd) + } + if state.SourceStats.RemotePull != 1 { + t.Errorf("expected 1 remote pull, got %d", state.SourceStats.RemotePull) + } +} + +func TestScanState_RecordMultipleBatches(t *testing.T) { + state := &ScanState{} + + state.recordBatchResult(&CollectionResult{ + Succeeded: make([]BatchImageResult, 5), + LocalContainerd: 3, + RemotePull: 2, + }) + state.recordBatchResult(&CollectionResult{ + Succeeded: make([]BatchImageResult, 3), + Failed: make([]BatchImageResult, 2), + AcquisitionFailed: 2, + }) + + if state.BatchesComplete != 2 { + t.Errorf("expected 2 batches complete, got %d", state.BatchesComplete) + } + if state.ImagesCompleted != 8 { + t.Errorf("expected 8 images completed, got %d", state.ImagesCompleted) + } + if state.ImagesFailed != 2 { + t.Errorf("expected 2 images failed, got %d", state.ImagesFailed) + } + if state.SourceStats.LocalContainerd != 3 { + t.Errorf("expected 3 local, got %d", state.SourceStats.LocalContainerd) + } + if state.SourceStats.AcquisitionFailed != 2 { + t.Errorf("expected 2 acq failed, got %d", state.SourceStats.AcquisitionFailed) + } +} + +func TestScanState_RecordBatchFailed(t *testing.T) { + state := &ScanState{} + state.recordBatchFailed() + state.recordBatchFailed() + if state.BatchesFailed != 2 { + t.Errorf("expected 2 batches failed, got %d", state.BatchesFailed) + } +} + +// ============================================================================= +// Unit Tests: smartDiff (via simulated existing results) +// ============================================================================= + +func TestSmartDiff_NoExistingResults(t *testing.T) { + nodeImages := NodeImageMap{ + "node-1": &NodeBatch{ + NodeName: "node-1", + Images: []ImageInfo{ + {Digest: "sha256:aaa", Ref: "nginx:latest"}, + {Digest: "sha256:bbb", Ref: "redis:latest"}, + }, + }, + } + + // smartDiff depends on crdClient.List which we can't mock easily here. + // Instead test that the NodeImageMap filtering logic works by calling + // the filter function directly (inline in smartDiff). + // For now, verify that the structure is correct. + if len(nodeImages) != 1 { + t.Errorf("expected 1 node, got %d", len(nodeImages)) + } + if len(nodeImages["node-1"].Images) != 2 { + t.Errorf("expected 2 images, got %d", len(nodeImages["node-1"].Images)) + } +} + +// ============================================================================= +// Unit Tests: NewImageAnalysisController +// ============================================================================= + +func TestNewImageAnalysisController(t *testing.T) { + config := DefaultImageAnalysisConfig() + // We can't use nil for k8sClient/crdClient in production, but for construction test it's fine. + ctrl := NewImageAnalysisController(nil, nil, testLogger(), config) + + if ctrl == nil { + t.Fatal("expected non-nil controller") + } + if ctrl.state.GetPhase() != ScanPhaseIdle { + t.Errorf("expected initial phase Idle, got %s", ctrl.state.GetPhase()) + } + if !ctrl.NeedLeaderElection() { + t.Error("expected NeedLeaderElection=true") + } +} + +// ============================================================================= +// Unit Tests: pruneStaleResults logic +// ============================================================================= + +func TestPruneLogic_ShouldPrune(t *testing.T) { + // Test the pruning criteria: not in current digests AND older than retention. + retentionDays := 30 + retentionCutoff := time.Now().Add(-time.Duration(retentionDays) * 24 * time.Hour) + + currentDigests := map[string]bool{ + "sha256:active1": true, + "sha256:active2": true, + } + + tests := []struct { + name string + digest string + analyzedAt time.Time + shouldPrune bool + }{ + { + name: "active image recent", + digest: "sha256:active1", + analyzedAt: time.Now().Add(-24 * time.Hour), + shouldPrune: false, + }, + { + name: "active image old", + digest: "sha256:active2", + analyzedAt: time.Now().Add(-60 * 24 * time.Hour), + shouldPrune: false, // still active, don't prune + }, + { + name: "inactive image recent", + digest: "sha256:gone1", + analyzedAt: time.Now().Add(-24 * time.Hour), + shouldPrune: false, // within retention + }, + { + name: "inactive image old", + digest: "sha256:gone2", + analyzedAt: time.Now().Add(-60 * 24 * time.Hour), + shouldPrune: true, // not active AND older than retention + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + item := &v1.ImageAnalysisResult{ + Spec: v1.ImageAnalysisResultSpec{ + ImageDigest: tt.digest, + }, + Status: v1.ImageAnalysisResultStatus{ + AnalyzedAt: metav1.NewTime(tt.analyzedAt), + }, + } + + shouldPrune := !currentDigests[item.Spec.ImageDigest] && + item.Status.AnalyzedAt.Time.Before(retentionCutoff) + + if shouldPrune != tt.shouldPrune { + t.Errorf("shouldPrune = %v, want %v", shouldPrune, tt.shouldPrune) + } + }) + } +} + +// ============================================================================= +// Unit Tests: Phase transitions +// ============================================================================= + +func TestScanPhaseConstants(t *testing.T) { + // Ensure phase constants are distinct. + phases := []ScanPhase{ + ScanPhaseIdle, + ScanPhaseDiscovering, + ScanPhaseAnalyzing, + ScanPhaseCollecting, + ScanPhaseCompleted, + ScanPhaseFailed, + } + + seen := make(map[ScanPhase]bool) + for _, p := range phases { + if seen[p] { + t.Errorf("duplicate phase: %s", p) + } + seen[p] = true + } +} + +// testLogger returns a no-op logger for tests. +func testLogger() logr.Logger { + return logr.Discard() +} diff --git a/internal/controller/image_discovery.go b/internal/controller/image_discovery.go new file mode 100644 index 00000000..32f7990b --- /dev/null +++ b/internal/controller/image_discovery.go @@ -0,0 +1,396 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "context" + "fmt" + "path" + "strings" + + "github.com/go-logr/logr" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes" +) + +const ( + // podListPageSize is the number of pods fetched per paginated LIST call. + podListPageSize = 500 +) + +// NodeImageMap maps nodeName → *NodeBatch. +type NodeImageMap = map[string]*NodeBatch + +// WorkloadRefMap maps image digest → list of workload references discovered from pods. +type WorkloadRefMap = map[string][]DiscoveredWorkloadRef + +// NodeBatch groups all unique images assigned to a single node for analysis. +type NodeBatch struct { + NodeName string + Images []ImageInfo +} + +// ImageInfo represents a unique container image discovered in the cluster. +type ImageInfo struct { + // Digest is the image ID from container status (e.g. "docker.io/library/nginx@sha256:abc123...") + Digest string + + // Ref is the full image reference with tag (e.g. "docker.io/library/nginx:1.25.3") + Ref string + + // ContainerCount tracks how many running containers use this image. + ContainerCount int +} + +// DiscoveredWorkloadRef is the workload reference gathered during discovery. +// It maps to the CRD's WorkloadReference type but is a discovery-time struct +// so we can accumulate container names before writing to the CRD. +type DiscoveredWorkloadRef struct { + Namespace string + WorkloadType string + WorkloadName string + WorkloadUID string + ContainerNames map[string]struct{} // set of container names (deduplicated) +} + +// DiscoveryResult holds the complete output of the image discovery phase. +type DiscoveryResult struct { + // NodeImages maps nodeName → batch of unique images to analyze on that node. + NodeImages NodeImageMap + + // WorkloadRefs maps image digest → workload references from all pods (global). + WorkloadRefs WorkloadRefMap + + // TotalPodsScanned is the number of running pods processed. + TotalPodsScanned int + + // TotalImagesFound is the number of unique images (after dedup). + TotalImagesFound int + + // TotalContainersSeen is the count of container statuses processed. + TotalContainersSeen int +} + +// ImageDiscoverer lists running pods and builds a node-grouped, deduplicated image map. +type ImageDiscoverer struct { + client kubernetes.Interface + config ImageAnalysisConfig + log logr.Logger +} + +// NewImageDiscoverer creates a new ImageDiscoverer. +func NewImageDiscoverer(client kubernetes.Interface, config ImageAnalysisConfig, log logr.Logger) *ImageDiscoverer { + return &ImageDiscoverer{ + client: client, + config: config, + log: log.WithName("image-discovery"), + } +} + +// Discover lists all running pods (paginated), extracts container images, +// deduplicates globally by digest, groups by node, and collects workload references. +func (d *ImageDiscoverer) Discover(ctx context.Context) (*DiscoveryResult, error) { + result := &DiscoveryResult{ + NodeImages: make(NodeImageMap), + WorkloadRefs: make(WorkloadRefMap), + } + + // globalDedup tracks which digests have already been assigned to a node. + globalDedup := make(map[string]bool) + + // containerCountByDigest tracks total container count per digest. + containerCountByDigest := make(map[string]int) + + namespaceFilter := d.buildNamespaceFilter() + + continueToken := "" + for { + podList, err := d.client.CoreV1().Pods("").List(ctx, metav1.ListOptions{ + Limit: podListPageSize, + Continue: continueToken, + FieldSelector: "status.phase=Running", + }) + if err != nil { + return nil, fmt.Errorf("listing pods: %w", err) + } + + for i := range podList.Items { + pod := &podList.Items[i] + + // Skip unscheduled pods. + if pod.Spec.NodeName == "" { + continue + } + + // Apply namespace filter. + if !namespaceFilter(pod.Namespace) { + continue + } + + result.TotalPodsScanned++ + + // Process both regular and init container statuses. + d.processContainerStatuses(pod, pod.Status.ContainerStatuses, false, + result, globalDedup, containerCountByDigest) + d.processContainerStatuses(pod, pod.Status.InitContainerStatuses, true, + result, globalDedup, containerCountByDigest) + } + + if podList.Continue == "" { + break + } + continueToken = podList.Continue + } + + // Update container counts on ImageInfo (they were accumulated in containerCountByDigest). + for _, batch := range result.NodeImages { + for i := range batch.Images { + batch.Images[i].ContainerCount = containerCountByDigest[batch.Images[i].Digest] + } + } + + d.log.Info("discovery complete", + "totalPodsScanned", result.TotalPodsScanned, + "totalContainersSeen", result.TotalContainersSeen, + "uniqueImages", result.TotalImagesFound, + "nodes", len(result.NodeImages), + ) + + return result, nil +} + +// processContainerStatuses handles a slice of container statuses from a pod. +func (d *ImageDiscoverer) processContainerStatuses( + pod *corev1.Pod, + statuses []corev1.ContainerStatus, + isInit bool, + result *DiscoveryResult, + globalDedup map[string]bool, + containerCountByDigest map[string]int, +) { + nodeName := pod.Spec.NodeName + + for _, cs := range statuses { + digest := normalizeDigest(cs.ImageID) + if digest == "" { + continue + } + + imageRef := cs.Image + if imageRef == "" { + continue + } + + // Apply image pattern filter. + if !d.matchesImageFilter(imageRef) { + continue + } + + result.TotalContainersSeen++ + containerCountByDigest[digest]++ + + // Always collect workload refs globally, even if this image is already deduped. + d.addWorkloadRef(result.WorkloadRefs, digest, pod, cs.Name) + + // Assign image to first node discovered (global dedup). + if globalDedup[digest] { + continue + } + globalDedup[digest] = true + result.TotalImagesFound++ + + batch, ok := result.NodeImages[nodeName] + if !ok { + batch = &NodeBatch{NodeName: nodeName} + result.NodeImages[nodeName] = batch + } + batch.Images = append(batch.Images, ImageInfo{ + Digest: digest, + Ref: imageRef, + }) + } +} + +// addWorkloadRef adds or updates a workload reference for the given image digest. +func (d *ImageDiscoverer) addWorkloadRef(refs WorkloadRefMap, digest string, pod *corev1.Pod, containerName string) { + workloadName, workloadType, workloadUID := resolveWorkloadOwner(pod) + + // Dedup by namespace/type/name — if same workload already tracked, just add the container name. + existing := refs[digest] + for i := range existing { + if existing[i].Namespace == pod.Namespace && + existing[i].WorkloadType == workloadType && + existing[i].WorkloadName == workloadName { + existing[i].ContainerNames[containerName] = struct{}{} + return + } + } + + refs[digest] = append(refs[digest], DiscoveredWorkloadRef{ + Namespace: pod.Namespace, + WorkloadType: workloadType, + WorkloadName: workloadName, + WorkloadUID: workloadUID, + ContainerNames: map[string]struct{}{containerName: {}}, + }) +} + +// resolveWorkloadOwner walks the owner reference chain to find the top-level workload. +// Pod → ReplicaSet → Deployment, Pod → Job → CronJob, etc. +func resolveWorkloadOwner(pod *corev1.Pod) (name, kind, uid string) { + if len(pod.OwnerReferences) == 0 { + return pod.Name, "Pod", string(pod.UID) + } + + owner := pod.OwnerReferences[0] + switch owner.Kind { + case "ReplicaSet": + // ReplicaSets created by Deployments have names like "-" + // The hash is a 10-char pod-template-hash. Strip it to get the Deployment name. + rsName := owner.Name + if idx := strings.LastIndex(rsName, "-"); idx > 0 { + // This is a Deployment-owned ReplicaSet. + return rsName[:idx], "Deployment", string(owner.UID) + } + // Standalone ReplicaSet (no Deployment owner). + return rsName, "ReplicaSet", string(owner.UID) + + case "Job": + // Jobs created by CronJobs have names like "-" + // The timestamp suffix is 10 digits. If the name has a numeric suffix, assume CronJob. + jobName := owner.Name + if idx := strings.LastIndex(jobName, "-"); idx > 0 { + suffix := jobName[idx+1:] + if isNumeric(suffix) && len(suffix) >= 8 { + return jobName[:idx], "CronJob", string(owner.UID) + } + } + return jobName, "Job", string(owner.UID) + + case "StatefulSet": + return owner.Name, "StatefulSet", string(owner.UID) + + case "DaemonSet": + return owner.Name, "DaemonSet", string(owner.UID) + + default: + // Custom CRDs or other controllers. + return owner.Name, owner.Kind, string(owner.UID) + } +} + +// isNumeric returns true if s consists entirely of digits. +func isNumeric(s string) bool { + if s == "" { + return false + } + for _, c := range s { + if c < '0' || c > '9' { + return false + } + } + return true +} + +// normalizeDigest extracts a consistent digest string from a container status ImageID. +// ImageID can be in formats: +// - "docker.io/library/nginx@sha256:abc123..." +// - "sha256:abc123..." +// - "docker-pullable://docker.io/library/nginx@sha256:abc123..." +// +// We normalize to the full "repo@sha256:..." form when possible, or just the "sha256:..." part. +func normalizeDigest(imageID string) string { + if imageID == "" { + return "" + } + + // Strip "docker-pullable://" prefix if present (older Docker). + imageID = strings.TrimPrefix(imageID, "docker-pullable://") + + // If it contains "@sha256:", it's already in repo@digest form — use as-is. + if strings.Contains(imageID, "@sha256:") { + return imageID + } + + // If it starts with "sha256:", it's just the digest — use as-is. + if strings.HasPrefix(imageID, "sha256:") { + return imageID + } + + // Unexpected format — return as-is but log. + return imageID +} + +// buildNamespaceFilter returns a function that checks if a namespace should be included. +func (d *ImageDiscoverer) buildNamespaceFilter() func(string) bool { + targetSet := make(map[string]bool, len(d.config.TargetNamespaces)) + for _, ns := range d.config.TargetNamespaces { + targetSet[ns] = true + } + + excludeSet := make(map[string]bool, len(d.config.ExcludedNamespaces)) + for _, ns := range d.config.ExcludedNamespaces { + excludeSet[ns] = true + } + + return func(namespace string) bool { + // If target namespaces are specified, only include those. + if len(targetSet) > 0 { + return targetSet[namespace] + } + // Otherwise, exclude the excluded namespaces. + return !excludeSet[namespace] + } +} + +// matchesImageFilter checks if an image reference passes the include/exclude glob filters. +func (d *ImageDiscoverer) matchesImageFilter(imageRef string) bool { + // If included images are specified, the image must match at least one. + if len(d.config.IncludedImages) > 0 { + for _, pattern := range d.config.IncludedImages { + if matched, _ := path.Match(pattern, imageRef); matched { + return true + } + // Also try matching just the image:tag part (without registry prefix). + if matched, _ := path.Match(pattern, shortImageRef(imageRef)); matched { + return true + } + } + return false + } + + // Check excluded images. + for _, pattern := range d.config.ExcludedImages { + if matched, _ := path.Match(pattern, imageRef); matched { + return false + } + if matched, _ := path.Match(pattern, shortImageRef(imageRef)); matched { + return false + } + } + + return true +} + +// shortImageRef strips the registry prefix from an image reference. +// "docker.io/library/nginx:1.25.3" → "nginx:1.25.3" +// "registry.k8s.io/pause:3.9" → "pause:3.9" +func shortImageRef(ref string) string { + parts := strings.Split(ref, "/") + return parts[len(parts)-1] +} diff --git a/internal/controller/image_discovery_test.go b/internal/controller/image_discovery_test.go new file mode 100644 index 00000000..8ff5b53f --- /dev/null +++ b/internal/controller/image_discovery_test.go @@ -0,0 +1,767 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "context" + "fmt" + "testing" + + "github.com/go-logr/logr" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/client-go/kubernetes/fake" +) + +// Helper to build a running pod with container statuses. +func makePod(name, namespace, nodeName string, ownerRefs []metav1.OwnerReference, containers []corev1.ContainerStatus, initContainers []corev1.ContainerStatus) *corev1.Pod { + return &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: name, + Namespace: namespace, + UID: types.UID(name + "-uid"), + OwnerReferences: ownerRefs, + }, + Spec: corev1.PodSpec{ + NodeName: nodeName, + }, + Status: corev1.PodStatus{ + Phase: corev1.PodRunning, + ContainerStatuses: containers, + InitContainerStatuses: initContainers, + }, + } +} + +func makeContainerStatus(name, image, imageID string) corev1.ContainerStatus { + return corev1.ContainerStatus{ + Name: name, + Image: image, + ImageID: imageID, + } +} + +func deploymentOwnerRef(name string) []metav1.OwnerReference { + return []metav1.OwnerReference{ + {Kind: "ReplicaSet", Name: name + "-7f9d8c6b5f", UID: types.UID(name + "-rs-uid")}, + } +} + +func statefulsetOwnerRef(name string) []metav1.OwnerReference { + return []metav1.OwnerReference{ + {Kind: "StatefulSet", Name: name, UID: types.UID(name + "-sts-uid")}, + } +} + +func daemonsetOwnerRef(name string) []metav1.OwnerReference { + return []metav1.OwnerReference{ + {Kind: "DaemonSet", Name: name, UID: types.UID(name + "-ds-uid")}, + } +} + +func jobOwnerRef(name string) []metav1.OwnerReference { + return []metav1.OwnerReference{ + {Kind: "Job", Name: name, UID: types.UID(name + "-job-uid")}, + } +} + +func cronjobJobOwnerRef(cronJobName string) []metav1.OwnerReference { + return []metav1.OwnerReference{ + {Kind: "Job", Name: cronJobName + "-1709420400", UID: types.UID(cronJobName + "-cj-uid")}, + } +} + +func defaultConfig() ImageAnalysisConfig { + cfg := DefaultImageAnalysisConfig() + // Clear excluded namespaces/images for most tests so they don't interfere. + cfg.ExcludedNamespaces = nil + cfg.ExcludedImages = nil + return cfg +} + +func TestDiscover_BasicSingleNode(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + deploymentOwnerRef("nginx-deploy"), + []corev1.ContainerStatus{ + makeContainerStatus("nginx", "docker.io/library/nginx:1.25.3", "docker.io/library/nginx@sha256:aaa111"), + }, + nil, + ), + *makePod("pod-2", "default", "node-1", + deploymentOwnerRef("redis-deploy"), + []corev1.ContainerStatus{ + makeContainerStatus("redis", "docker.io/library/redis:7.2", "docker.io/library/redis@sha256:bbb222"), + }, + nil, + ), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 2, result.TotalPodsScanned) + assert.Equal(t, 2, result.TotalImagesFound) + assert.Equal(t, 2, result.TotalContainersSeen) + assert.Len(t, result.NodeImages, 1) + + batch := result.NodeImages["node-1"] + require.NotNil(t, batch) + assert.Len(t, batch.Images, 2) + + // Verify workload refs. + nginxRefs := result.WorkloadRefs["docker.io/library/nginx@sha256:aaa111"] + require.Len(t, nginxRefs, 1) + assert.Equal(t, "Deployment", nginxRefs[0].WorkloadType) + assert.Equal(t, "nginx-deploy", nginxRefs[0].WorkloadName) + assert.Contains(t, nginxRefs[0].ContainerNames, "nginx") +} + +func TestDiscover_GlobalDedup_MultiNode(t *testing.T) { + // Same image on two different nodes — should only be assigned to the first node. + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + deploymentOwnerRef("nginx"), + []corev1.ContainerStatus{ + makeContainerStatus("nginx", "docker.io/library/nginx:1.25.3", "docker.io/library/nginx@sha256:aaa111"), + }, + nil, + ), + *makePod("pod-2", "default", "node-2", + deploymentOwnerRef("nginx"), + []corev1.ContainerStatus{ + makeContainerStatus("nginx", "docker.io/library/nginx:1.25.3", "docker.io/library/nginx@sha256:aaa111"), + }, + nil, + ), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + // Image deduped — only 1 unique image. + assert.Equal(t, 1, result.TotalImagesFound) + // But container count is 2. + assert.Equal(t, 2, result.TotalContainersSeen) + + // Image should be assigned to exactly one node. + totalImages := 0 + for _, batch := range result.NodeImages { + totalImages += len(batch.Images) + } + assert.Equal(t, 1, totalImages) + + // Workload refs should have entries from BOTH nodes. + refs := result.WorkloadRefs["docker.io/library/nginx@sha256:aaa111"] + require.Len(t, refs, 1) // Same workload on both nodes, should be 1 ref with the container name. +} + +func TestDiscover_WorkloadRefsGlobal(t *testing.T) { + // Same image used by different workloads on different nodes. + pods := []corev1.Pod{ + *makePod("pod-1", "ns-a", "node-1", + deploymentOwnerRef("web"), + []corev1.ContainerStatus{ + makeContainerStatus("app", "nginx:1.25", "nginx@sha256:aaa111"), + }, + nil, + ), + *makePod("pod-2", "ns-b", "node-2", + statefulsetOwnerRef("cache"), + []corev1.ContainerStatus{ + makeContainerStatus("sidecar", "nginx:1.25", "nginx@sha256:aaa111"), + }, + nil, + ), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + refs := result.WorkloadRefs["nginx@sha256:aaa111"] + require.Len(t, refs, 2, "two different workloads should be tracked") + + types := map[string]bool{} + for _, ref := range refs { + types[ref.WorkloadType] = true + } + assert.True(t, types["Deployment"]) + assert.True(t, types["StatefulSet"]) +} + +func TestDiscover_InitContainers(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + deploymentOwnerRef("app"), + []corev1.ContainerStatus{ + makeContainerStatus("app", "myapp:v1", "myapp@sha256:app111"), + }, + []corev1.ContainerStatus{ + makeContainerStatus("init-db", "flyway:9", "flyway@sha256:init222"), + }, + ), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 2, result.TotalImagesFound, "both regular and init container images should be found") + assert.Equal(t, 2, result.TotalContainersSeen) + + batch := result.NodeImages["node-1"] + require.NotNil(t, batch) + assert.Len(t, batch.Images, 2) +} + +func TestDiscover_SkipUnscheduledPods(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-pending", "default", "", // empty NodeName = unscheduled + nil, + []corev1.ContainerStatus{ + makeContainerStatus("app", "myapp:v1", "myapp@sha256:aaa111"), + }, + nil, + ), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 0, result.TotalPodsScanned) + assert.Equal(t, 0, result.TotalImagesFound) +} + +func TestDiscover_SkipEmptyImageID(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + nil, + []corev1.ContainerStatus{ + makeContainerStatus("app", "myapp:v1", ""), // empty ImageID + }, + nil, + ), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 1, result.TotalPodsScanned) + assert.Equal(t, 0, result.TotalImagesFound) +} + +func TestDiscover_NamespaceFiltering_TargetNamespaces(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "production", "node-1", nil, + []corev1.ContainerStatus{makeContainerStatus("app", "app:v1", "app@sha256:aaa")}, nil), + *makePod("pod-2", "staging", "node-1", nil, + []corev1.ContainerStatus{makeContainerStatus("app", "app:v2", "app@sha256:bbb")}, nil), + *makePod("pod-3", "kube-system", "node-1", nil, + []corev1.ContainerStatus{makeContainerStatus("kube", "kube:v1", "kube@sha256:ccc")}, nil), + } + + cfg := defaultConfig() + cfg.TargetNamespaces = []string{"production"} + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, cfg, logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 1, result.TotalPodsScanned) + assert.Equal(t, 1, result.TotalImagesFound) +} + +func TestDiscover_NamespaceFiltering_ExcludedNamespaces(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", nil, + []corev1.ContainerStatus{makeContainerStatus("app", "app:v1", "app@sha256:aaa")}, nil), + *makePod("pod-2", "kube-system", "node-1", nil, + []corev1.ContainerStatus{makeContainerStatus("kube", "kube:v1", "kube@sha256:bbb")}, nil), + *makePod("pod-3", "kube-public", "node-1", nil, + []corev1.ContainerStatus{makeContainerStatus("pub", "pub:v1", "pub@sha256:ccc")}, nil), + } + + cfg := defaultConfig() + cfg.ExcludedNamespaces = []string{"kube-system", "kube-public"} + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, cfg, logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 1, result.TotalPodsScanned) + assert.Equal(t, 1, result.TotalImagesFound) +} + +func TestDiscover_ImageFiltering_Excluded(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", nil, + []corev1.ContainerStatus{ + makeContainerStatus("app", "myapp:v1", "myapp@sha256:aaa"), + makeContainerStatus("pause", "registry.k8s.io/pause:3.9", "registry.k8s.io/pause@sha256:bbb"), + }, nil), + } + + cfg := defaultConfig() + cfg.ExcludedImages = []string{"registry.k8s.io/pause:*"} + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, cfg, logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 1, result.TotalImagesFound) + batch := result.NodeImages["node-1"] + require.NotNil(t, batch) + assert.Equal(t, "myapp@sha256:aaa", batch.Images[0].Digest) +} + +func TestDiscover_ImageFiltering_Included(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", nil, + []corev1.ContainerStatus{ + makeContainerStatus("nginx", "nginx:1.25", "nginx@sha256:aaa"), + makeContainerStatus("redis", "redis:7.2", "redis@sha256:bbb"), + makeContainerStatus("app", "myapp:v1", "myapp@sha256:ccc"), + }, nil), + } + + cfg := defaultConfig() + cfg.IncludedImages = []string{"nginx:*"} + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, cfg, logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 1, result.TotalImagesFound) +} + +func TestDiscover_OwnerResolution_Deployment(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + deploymentOwnerRef("web-server"), + []corev1.ContainerStatus{makeContainerStatus("web", "nginx:1.25", "nginx@sha256:aaa")}, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + refs := result.WorkloadRefs["nginx@sha256:aaa"] + require.Len(t, refs, 1) + assert.Equal(t, "Deployment", refs[0].WorkloadType) + assert.Equal(t, "web-server", refs[0].WorkloadName) +} + +func TestDiscover_OwnerResolution_StatefulSet(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + statefulsetOwnerRef("postgres"), + []corev1.ContainerStatus{makeContainerStatus("db", "postgres:15", "postgres@sha256:aaa")}, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + refs := result.WorkloadRefs["postgres@sha256:aaa"] + require.Len(t, refs, 1) + assert.Equal(t, "StatefulSet", refs[0].WorkloadType) + assert.Equal(t, "postgres", refs[0].WorkloadName) +} + +func TestDiscover_OwnerResolution_DaemonSet(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + daemonsetOwnerRef("fluentd"), + []corev1.ContainerStatus{makeContainerStatus("log", "fluentd:1.16", "fluentd@sha256:aaa")}, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + refs := result.WorkloadRefs["fluentd@sha256:aaa"] + require.Len(t, refs, 1) + assert.Equal(t, "DaemonSet", refs[0].WorkloadType) + assert.Equal(t, "fluentd", refs[0].WorkloadName) +} + +func TestDiscover_OwnerResolution_Job(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + jobOwnerRef("migration-v3"), + []corev1.ContainerStatus{makeContainerStatus("migrate", "flyway:9", "flyway@sha256:aaa")}, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + refs := result.WorkloadRefs["flyway@sha256:aaa"] + require.Len(t, refs, 1) + assert.Equal(t, "Job", refs[0].WorkloadType) + assert.Equal(t, "migration-v3", refs[0].WorkloadName) +} + +func TestDiscover_OwnerResolution_CronJob(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + cronjobJobOwnerRef("nightly-backup"), + []corev1.ContainerStatus{makeContainerStatus("backup", "backup:v1", "backup@sha256:aaa")}, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + refs := result.WorkloadRefs["backup@sha256:aaa"] + require.Len(t, refs, 1) + assert.Equal(t, "CronJob", refs[0].WorkloadType) + assert.Equal(t, "nightly-backup", refs[0].WorkloadName) +} + +func TestDiscover_OwnerResolution_NakedPod(t *testing.T) { + pods := []corev1.Pod{ + *makePod("standalone-pod", "default", "node-1", + nil, // no owner references + []corev1.ContainerStatus{makeContainerStatus("app", "app:v1", "app@sha256:aaa")}, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + refs := result.WorkloadRefs["app@sha256:aaa"] + require.Len(t, refs, 1) + assert.Equal(t, "Pod", refs[0].WorkloadType) + assert.Equal(t, "standalone-pod", refs[0].WorkloadName) +} + +func TestDiscover_ContainerCount(t *testing.T) { + // Same image used by 3 containers across 2 pods on 2 nodes. + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + deploymentOwnerRef("app"), + []corev1.ContainerStatus{ + makeContainerStatus("app", "myapp:v1", "myapp@sha256:aaa"), + makeContainerStatus("sidecar", "myapp:v1", "myapp@sha256:aaa"), + }, nil), + *makePod("pod-2", "default", "node-2", + deploymentOwnerRef("app"), + []corev1.ContainerStatus{ + makeContainerStatus("app", "myapp:v1", "myapp@sha256:aaa"), + }, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 1, result.TotalImagesFound) + assert.Equal(t, 3, result.TotalContainersSeen) + + // Find the image in whichever node it was assigned to. + var img *ImageInfo + for _, batch := range result.NodeImages { + for i := range batch.Images { + if batch.Images[i].Digest == "myapp@sha256:aaa" { + img = &batch.Images[i] + } + } + } + require.NotNil(t, img) + assert.Equal(t, 3, img.ContainerCount) +} + +func TestDiscover_MultipleContainersPerPod_DifferentImages(t *testing.T) { + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + deploymentOwnerRef("app"), + []corev1.ContainerStatus{ + makeContainerStatus("app", "myapp:v1", "myapp@sha256:aaa"), + makeContainerStatus("sidecar", "envoy:1.28", "envoy@sha256:bbb"), + }, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 2, result.TotalImagesFound) + + // Both images should have workload refs pointing to the same deployment. + appRefs := result.WorkloadRefs["myapp@sha256:aaa"] + require.Len(t, appRefs, 1) + assert.Equal(t, "app", appRefs[0].WorkloadName) + assert.Contains(t, appRefs[0].ContainerNames, "app") + + envoyRefs := result.WorkloadRefs["envoy@sha256:bbb"] + require.Len(t, envoyRefs, 1) + assert.Equal(t, "app", envoyRefs[0].WorkloadName) + assert.Contains(t, envoyRefs[0].ContainerNames, "sidecar") +} + +func TestDiscover_WorkloadRefDedup_SameWorkloadMultiplePods(t *testing.T) { + // Two pods from the same deployment, same image — workload ref should appear once + // but with all container names collected. + pods := []corev1.Pod{ + *makePod("pod-1", "default", "node-1", + deploymentOwnerRef("web"), + []corev1.ContainerStatus{ + makeContainerStatus("nginx", "nginx:1.25", "nginx@sha256:aaa"), + }, nil), + *makePod("pod-2", "default", "node-1", + deploymentOwnerRef("web"), + []corev1.ContainerStatus{ + makeContainerStatus("nginx", "nginx:1.25", "nginx@sha256:aaa"), + }, nil), + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + refs := result.WorkloadRefs["nginx@sha256:aaa"] + require.Len(t, refs, 1, "same workload should only appear once") + assert.Equal(t, "web", refs[0].WorkloadName) + assert.Contains(t, refs[0].ContainerNames, "nginx") +} + +func TestDiscover_EmptyCluster(t *testing.T) { + client := fake.NewSimpleClientset() + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 0, result.TotalPodsScanned) + assert.Equal(t, 0, result.TotalImagesFound) + assert.Empty(t, result.NodeImages) +} + +func TestNormalizeDigest(t *testing.T) { + tests := []struct { + input string + expected string + }{ + {"", ""}, + {"sha256:abc123", "sha256:abc123"}, + {"docker.io/library/nginx@sha256:abc123", "docker.io/library/nginx@sha256:abc123"}, + {"docker-pullable://docker.io/library/nginx@sha256:abc123", "docker.io/library/nginx@sha256:abc123"}, + {"some-other-format", "some-other-format"}, + } + + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + assert.Equal(t, tt.expected, normalizeDigest(tt.input)) + }) + } +} + +func TestResolveWorkloadOwner(t *testing.T) { + tests := []struct { + name string + ownerRefs []metav1.OwnerReference + expectedName string + expectedKind string + }{ + { + name: "no owner", + ownerRefs: nil, + expectedName: "my-pod", + expectedKind: "Pod", + }, + { + name: "deployment via replicaset", + ownerRefs: []metav1.OwnerReference{ + {Kind: "ReplicaSet", Name: "web-server-7f9d8c6b5f", UID: "rs-uid"}, + }, + expectedName: "web-server", + expectedKind: "Deployment", + }, + { + name: "standalone replicaset (no dash)", + ownerRefs: []metav1.OwnerReference{ + {Kind: "ReplicaSet", Name: "standalone", UID: "rs-uid"}, + }, + expectedName: "standalone", + expectedKind: "ReplicaSet", + }, + { + name: "statefulset", + ownerRefs: []metav1.OwnerReference{ + {Kind: "StatefulSet", Name: "postgres", UID: "sts-uid"}, + }, + expectedName: "postgres", + expectedKind: "StatefulSet", + }, + { + name: "daemonset", + ownerRefs: []metav1.OwnerReference{ + {Kind: "DaemonSet", Name: "fluentd", UID: "ds-uid"}, + }, + expectedName: "fluentd", + expectedKind: "DaemonSet", + }, + { + name: "plain job", + ownerRefs: []metav1.OwnerReference{ + {Kind: "Job", Name: "migration-v3", UID: "job-uid"}, + }, + expectedName: "migration-v3", + expectedKind: "Job", + }, + { + name: "cronjob job", + ownerRefs: []metav1.OwnerReference{ + {Kind: "Job", Name: "nightly-backup-1709420400", UID: "cj-uid"}, + }, + expectedName: "nightly-backup", + expectedKind: "CronJob", + }, + { + name: "custom CRD", + ownerRefs: []metav1.OwnerReference{ + {Kind: "ArgoRollout", Name: "canary-deploy", UID: "argo-uid"}, + }, + expectedName: "canary-deploy", + expectedKind: "ArgoRollout", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + pod := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "my-pod", + UID: "pod-uid", + OwnerReferences: tt.ownerRefs, + }, + } + name, kind, _ := resolveWorkloadOwner(pod) + assert.Equal(t, tt.expectedName, name) + assert.Equal(t, tt.expectedKind, kind) + }) + } +} + +func TestIsNumeric(t *testing.T) { + assert.True(t, isNumeric("12345678")) + assert.True(t, isNumeric("1709420400")) + assert.False(t, isNumeric("")) + assert.False(t, isNumeric("abc")) + assert.False(t, isNumeric("123abc")) + assert.False(t, isNumeric("7f9d8c6b5f")) +} + +func TestShortImageRef(t *testing.T) { + assert.Equal(t, "nginx:1.25.3", shortImageRef("docker.io/library/nginx:1.25.3")) + assert.Equal(t, "pause:3.9", shortImageRef("registry.k8s.io/pause:3.9")) + assert.Equal(t, "myapp:v1", shortImageRef("myapp:v1")) + assert.Equal(t, "image", shortImageRef("gcr.io/project/image")) +} + +func TestDiscover_LargeScale(t *testing.T) { + // Simulate 100 pods across 10 nodes, each with 3 containers (some sharing images). + var pods []corev1.Pod + for i := 0; i < 100; i++ { + nodeName := fmt.Sprintf("node-%d", i%10) + namespace := fmt.Sprintf("ns-%d", i%5) + // Each pod has 3 containers. Images repeat across pods (10 unique images total). + imgIdx := i % 10 + pods = append(pods, *makePod( + fmt.Sprintf("pod-%d", i), namespace, nodeName, + deploymentOwnerRef(fmt.Sprintf("deploy-%d", imgIdx)), + []corev1.ContainerStatus{ + makeContainerStatus("main", + fmt.Sprintf("app-%d:v1", imgIdx), + fmt.Sprintf("app-%d@sha256:digest%d", imgIdx, imgIdx)), + makeContainerStatus("sidecar", + fmt.Sprintf("sidecar-%d:v1", imgIdx), + fmt.Sprintf("sidecar-%d@sha256:sdigest%d", imgIdx, imgIdx)), + makeContainerStatus("monitor", "monitor:v1", "monitor@sha256:mon000"), + }, nil)) + } + + client := fake.NewSimpleClientset(&corev1.PodList{Items: pods}) + discoverer := NewImageDiscoverer(client, defaultConfig(), logr.Discard()) + + result, err := discoverer.Discover(context.Background()) + require.NoError(t, err) + + // 10 unique app images + 10 unique sidecar images + 1 monitor image = 21 unique images. + assert.Equal(t, 21, result.TotalImagesFound) + assert.Equal(t, 100, result.TotalPodsScanned) + assert.Equal(t, 300, result.TotalContainersSeen) // 100 pods * 3 containers + + // Monitor image appears in 100 containers. + var monitorImg *ImageInfo + for _, batch := range result.NodeImages { + for i := range batch.Images { + if batch.Images[i].Digest == "monitor@sha256:mon000" { + monitorImg = &batch.Images[i] + } + } + } + require.NotNil(t, monitorImg) + assert.Equal(t, 100, monitorImg.ContainerCount) +} diff --git a/internal/controller/image_job_manager.go b/internal/controller/image_job_manager.go new file mode 100644 index 00000000..8bffb959 --- /dev/null +++ b/internal/controller/image_job_manager.go @@ -0,0 +1,553 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "context" + "encoding/json" + "fmt" + "regexp" + "sort" + "strconv" + "strings" + "time" + + "github.com/go-logr/logr" + batchv1 "k8s.io/api/batch/v1" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes" +) + +const ( + // Label keys used on batch analysis Jobs. + LabelComponent = "devzero.io/component" + LabelAnalysisNode = "devzero.io/analysis-node" + LabelBatchIndex = "devzero.io/batch-index" + LabelScanID = "devzero.io/scan-id" + + // LabelComponentValue is the value for the component label on analysis jobs. + LabelComponentValue = "image-analysis" + + // jobNamePrefix is used in all analysis job names. + jobNamePrefix = "dive" + + // maxJobNameLength is the K8s resource name limit. + maxJobNameLength = 63 + + // ttlSecondsAfterFinished controls Job auto-cleanup after completion. + ttlSecondsAfterFinished = 3600 // 1 hour +) + +// BatchJobSpec describes a single batch job to be created. +type BatchJobSpec struct { + JobName string + NodeName string + BatchIndex int + ScanID string + Images []ImageInfo +} + +// JobManager creates and monitors batch analysis Jobs. +type JobManager struct { + client kubernetes.Interface + config ImageAnalysisConfig + log logr.Logger +} + +// NewJobManager creates a new JobManager. +func NewJobManager(client kubernetes.Interface, config ImageAnalysisConfig, log logr.Logger) *JobManager { + return &JobManager{ + client: client, + config: config, + log: log.WithName("job-manager"), + } +} + +// GenerateScanID returns a unique scan identifier based on current Unix timestamp. +func GenerateScanID() string { + return strconv.FormatInt(time.Now().Unix(), 10) +} + +// PlanBatchJobs takes a NodeImageMap and splits each node's images into batches, +// returning a prioritized list of BatchJobSpecs (busiest nodes first). +func (m *JobManager) PlanBatchJobs(nodeImages NodeImageMap, scanID string) []BatchJobSpec { + // Build sorted node list (descending by image count for priority). + type nodeEntry struct { + nodeName string + batch *NodeBatch + } + nodes := make([]nodeEntry, 0, len(nodeImages)) + for name, batch := range nodeImages { + nodes = append(nodes, nodeEntry{nodeName: name, batch: batch}) + } + sort.Slice(nodes, func(i, j int) bool { + return len(nodes[i].batch.Images) > len(nodes[j].batch.Images) + }) + + var specs []BatchJobSpec + batchSize := m.config.BatchSize + if batchSize <= 0 { + batchSize = 10 + } + + for _, entry := range nodes { + images := entry.batch.Images + for i := 0; i < len(images); i += batchSize { + end := i + batchSize + if end > len(images) { + end = len(images) + } + batchIndex := i / batchSize + jobName := generateJobName(entry.nodeName, batchIndex, scanID) + + specs = append(specs, BatchJobSpec{ + JobName: jobName, + NodeName: entry.nodeName, + BatchIndex: batchIndex, + ScanID: scanID, + Images: images[i:end], + }) + } + } + + return specs +} + +// CreateJob creates a single batch analysis Job in the cluster. +func (m *JobManager) CreateJob(ctx context.Context, spec BatchJobSpec) (*batchv1.Job, error) { + job, err := m.buildJobObject(spec) + if err != nil { + return nil, fmt.Errorf("building job object for %s: %w", spec.JobName, err) + } + + created, err := m.client.BatchV1().Jobs(m.config.JobNamespace).Create(ctx, job, metav1.CreateOptions{}) + if err != nil { + return nil, fmt.Errorf("creating job %s: %w", spec.JobName, err) + } + + m.log.Info("created batch job", + "job", created.Name, + "node", spec.NodeName, + "batchIndex", spec.BatchIndex, + "imageCount", len(spec.Images), + "scanID", spec.ScanID, + ) + + return created, nil +} + +// SubmitBatches creates Jobs respecting cluster-level and per-node concurrency limits. +// It returns the list of Jobs that were successfully created, and any error. +// It does NOT block waiting for Jobs to complete — the caller should watch for completion. +func (m *JobManager) SubmitBatches(ctx context.Context, specs []BatchJobSpec) ([]*batchv1.Job, error) { + if len(specs) == 0 { + return nil, nil + } + + scanID := specs[0].ScanID + + // Count currently active jobs for this scan. + activeJobs, activePerNode, err := m.countActiveJobs(ctx, scanID) + if err != nil { + return nil, fmt.Errorf("counting active jobs: %w", err) + } + + maxCluster := m.config.MaxConcurrentJobs + if maxCluster <= 0 { + maxCluster = 10 + } + maxPerNode := m.config.MaxJobsPerNode + if maxPerNode <= 0 { + maxPerNode = 1 + } + + var created []*batchv1.Job + + for _, spec := range specs { + // Check cluster-level concurrency. + if activeJobs >= maxCluster { + m.log.V(1).Info("cluster concurrency limit reached", + "active", activeJobs, "max", maxCluster, + "remaining", len(specs)-len(created)) + break + } + + // Check per-node concurrency. + nodeActive := activePerNode[spec.NodeName] + if nodeActive >= maxPerNode { + m.log.V(1).Info("node concurrency limit reached", + "node", spec.NodeName, "active", nodeActive, "max", maxPerNode) + continue + } + + job, err := m.CreateJob(ctx, spec) + if err != nil { + m.log.Error(err, "failed to create batch job", "job", spec.JobName) + continue + } + + created = append(created, job) + activeJobs++ + activePerNode[spec.NodeName]++ + } + + m.log.Info("batch submission complete", + "planned", len(specs), + "submitted", len(created), + "activeTotal", activeJobs, + ) + + return created, nil +} + +// ListScanJobs lists all Jobs for a given scan ID. +func (m *JobManager) ListScanJobs(ctx context.Context, scanID string) (*batchv1.JobList, error) { + // If scanID is empty, list ALL image-analysis jobs (used for resume detection). + labelSelector := fmt.Sprintf("%s=%s", LabelComponent, LabelComponentValue) + if scanID != "" { + labelSelector = fmt.Sprintf("%s,%s=%s", labelSelector, LabelScanID, scanID) + } + + return m.client.BatchV1().Jobs(m.config.JobNamespace).List(ctx, metav1.ListOptions{ + LabelSelector: labelSelector, + }) +} + +// GetJobStatus returns summary counts of jobs in various states for a scan. +func (m *JobManager) GetJobStatus(ctx context.Context, scanID string) (active, succeeded, failed int, err error) { + jobList, err := m.ListScanJobs(ctx, scanID) + if err != nil { + return 0, 0, 0, err + } + + for i := range jobList.Items { + job := &jobList.Items[i] + switch { + case job.Status.Succeeded > 0: + succeeded++ + case isJobFailed(job): + failed++ + default: + active++ + } + } + + return active, succeeded, failed, nil +} + +// CleanupOldScanJobs deletes completed/failed Jobs from previous scans (not the current scanID). +func (m *JobManager) CleanupOldScanJobs(ctx context.Context, currentScanID string) (int, error) { + labelSelector := fmt.Sprintf("%s=%s", LabelComponent, LabelComponentValue) + + jobList, err := m.client.BatchV1().Jobs(m.config.JobNamespace).List(ctx, metav1.ListOptions{ + LabelSelector: labelSelector, + }) + if err != nil { + return 0, fmt.Errorf("listing old scan jobs: %w", err) + } + + deleted := 0 + propagation := metav1.DeletePropagationBackground + for i := range jobList.Items { + job := &jobList.Items[i] + jobScanID := job.Labels[LabelScanID] + if jobScanID == currentScanID { + continue + } + + // Only delete completed or failed jobs. + if job.Status.Succeeded == 0 && !isJobFailed(job) { + continue + } + + if err := m.client.BatchV1().Jobs(m.config.JobNamespace).Delete( + ctx, job.Name, metav1.DeleteOptions{PropagationPolicy: &propagation}, + ); err != nil { + m.log.Error(err, "failed to delete old job", "job", job.Name, "scanID", jobScanID) + continue + } + deleted++ + } + + if deleted > 0 { + m.log.Info("cleaned up old scan jobs", "deleted", deleted) + } + + return deleted, nil +} + +// buildJobObject constructs the batchv1.Job K8s object for a batch spec. +func (m *JobManager) buildJobObject(spec BatchJobSpec) (*batchv1.Job, error) { + // Serialize images list to JSON for the IMAGES_JSON env var. + type imageEntry struct { + Digest string `json:"digest"` + Ref string `json:"ref"` + } + entries := make([]imageEntry, len(spec.Images)) + for i, img := range spec.Images { + entries[i] = imageEntry{Digest: img.Digest, Ref: img.Ref} + } + imagesJSON, err := json.Marshal(entries) + if err != nil { + return nil, fmt.Errorf("marshaling images JSON: %w", err) + } + + // Parse resource quantities (validated at config load time, safe to use MustParse here). + cpuRequest := resource.MustParse(m.config.JobCPURequest) + cpuLimit := resource.MustParse(m.config.JobCPULimit) + memRequest := resource.MustParse(m.config.JobMemoryRequest) + memLimit := resource.MustParse(m.config.JobMemoryLimit) + workspaceSize := resource.MustParse(m.config.WorkspaceSizeLimit) + + // Compute activeDeadlineSeconds from config. + activeDeadlineSeconds := int64(m.config.JobTimeoutMinutes * 60) + + // backoffLimit from config. + backoffLimit := int32(m.config.MaxRetries) + + ttl := int32(ttlSecondsAfterFinished) + + // Parse remote pull timeout to seconds for the env var. + remotePullTimeoutSec := parseDurationToSeconds(m.config.RemotePullTimeout) + + // Build env vars. + envVars := []corev1.EnvVar{ + {Name: "IMAGES_JSON", Value: string(imagesJSON)}, + {Name: "PREFER_LOCAL", Value: strconv.FormatBool(m.config.PreferLocal)}, + {Name: "FALLBACK_REMOTE", Value: strconv.FormatBool(m.config.FallbackToRemote)}, + {Name: "CONTAINERD_SOCK", Value: m.config.ContainerdSocketPath}, + {Name: "CONTAINERD_NS", Value: m.config.ContainerdNamespace}, + {Name: "REMOTE_PULL_TIMEOUT", Value: strconv.Itoa(remotePullTimeoutSec)}, + } + + // Build volumes and mounts. + volumes := []corev1.Volume{ + { + Name: "containerd-sock", + VolumeSource: corev1.VolumeSource{ + HostPath: &corev1.HostPathVolumeSource{ + Path: m.config.ContainerdSocketPath, + Type: hostPathTypePtr(corev1.HostPathSocket), + }, + }, + }, + { + Name: "workspace", + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{ + SizeLimit: &workspaceSize, + }, + }, + }, + } + + volumeMounts := []corev1.VolumeMount{ + { + Name: "containerd-sock", + MountPath: "/run/containerd/containerd.sock", + ReadOnly: true, + }, + { + Name: "workspace", + MountPath: "/tmp/workspace", + }, + } + + // Optionally mount registry auth secret. + if m.config.RegistryAuthSecret != "" { + volumes = append(volumes, corev1.Volume{ + Name: "registry-auth", + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ + SecretName: m.config.RegistryAuthSecret, + Optional: boolPtr(true), + }, + }, + }) + volumeMounts = append(volumeMounts, corev1.VolumeMount{ + Name: "registry-auth", + MountPath: "/root/.docker", + ReadOnly: true, + }) + } + + // Build labels. + labels := map[string]string{ + LabelComponent: LabelComponentValue, + LabelAnalysisNode: sanitizeLabelValue(spec.NodeName), + LabelBatchIndex: strconv.Itoa(spec.BatchIndex), + LabelScanID: spec.ScanID, + } + + var runAsUser int64 = 0 + allowPrivEsc := false + + job := &batchv1.Job{ + ObjectMeta: metav1.ObjectMeta{ + Name: spec.JobName, + Namespace: m.config.JobNamespace, + Labels: labels, + }, + Spec: batchv1.JobSpec{ + BackoffLimit: &backoffLimit, + ActiveDeadlineSeconds: &activeDeadlineSeconds, + TTLSecondsAfterFinished: &ttl, + Template: corev1.PodTemplateSpec{ + ObjectMeta: metav1.ObjectMeta{ + Labels: labels, + }, + Spec: corev1.PodSpec{ + RestartPolicy: corev1.RestartPolicyNever, + ServiceAccountName: "image-analyzer", + NodeName: spec.NodeName, + Tolerations: m.config.JobTolerations, + Containers: []corev1.Container{ + { + Name: "analyzer", + Image: m.config.AnalyzerImage, + Env: envVars, + Resources: corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceCPU: cpuRequest, + corev1.ResourceMemory: memRequest, + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: cpuLimit, + corev1.ResourceMemory: memLimit, + }, + }, + VolumeMounts: volumeMounts, + SecurityContext: &corev1.SecurityContext{ + RunAsUser: &runAsUser, + AllowPrivilegeEscalation: &allowPrivEsc, + }, + }, + }, + Volumes: volumes, + }, + }, + }, + } + + return job, nil +} + +// countActiveJobs returns the number of currently running (not completed/failed) jobs +// for the given scan ID, both total and per-node. +func (m *JobManager) countActiveJobs(ctx context.Context, scanID string) (int, map[string]int, error) { + jobList, err := m.ListScanJobs(ctx, scanID) + if err != nil { + return 0, nil, err + } + + total := 0 + perNode := make(map[string]int) + + for i := range jobList.Items { + job := &jobList.Items[i] + // Skip completed/failed jobs. + if job.Status.Succeeded > 0 || isJobFailed(job) { + continue + } + total++ + nodeName := job.Labels[LabelAnalysisNode] + perNode[nodeName]++ + } + + return total, perNode, nil +} + +// isJobFailed checks if a Job has a "Failed" condition. +func isJobFailed(job *batchv1.Job) bool { + for _, cond := range job.Status.Conditions { + if cond.Type == batchv1.JobFailed && cond.Status == corev1.ConditionTrue { + return true + } + } + return false +} + +// generateJobName creates a DNS-safe Job name within the 63-char K8s limit. +// Format: dive--b- +func generateJobName(nodeName string, batchIndex int, scanID string) string { + sanitized := sanitizeDNSName(nodeName) + + suffix := fmt.Sprintf("-b%d-%s", batchIndex, scanID) + + // Reserve space for prefix "dive-" (5 chars) and suffix. + maxNodeLen := maxJobNameLength - len(jobNamePrefix) - 1 - len(suffix) + if maxNodeLen < 1 { + maxNodeLen = 1 + } + if len(sanitized) > maxNodeLen { + sanitized = sanitized[:maxNodeLen] + } + + // Trim trailing hyphens after truncation. + sanitized = strings.TrimRight(sanitized, "-") + + return fmt.Sprintf("%s-%s%s", jobNamePrefix, sanitized, suffix) +} + +// dnsNameRegex matches characters NOT allowed in DNS subdomain names. +var dnsNameRegex = regexp.MustCompile(`[^a-z0-9-]`) + +// sanitizeDNSName converts a string into a valid DNS subdomain label. +func sanitizeDNSName(name string) string { + name = strings.ToLower(name) + name = dnsNameRegex.ReplaceAllString(name, "-") + + // Collapse multiple hyphens. + for strings.Contains(name, "--") { + name = strings.ReplaceAll(name, "--", "-") + } + + // Trim leading/trailing hyphens. + name = strings.Trim(name, "-") + + return name +} + +// sanitizeLabelValue ensures a label value is valid (≤63 chars, alphanumeric start/end). +func sanitizeLabelValue(value string) string { + value = sanitizeDNSName(value) + if len(value) > 63 { + value = value[:63] + } + value = strings.Trim(value, "-") + return value +} + +// parseDurationToSeconds parses a Go-style duration string (e.g. "5m", "300s") +// and returns the value in seconds. Falls back to 300 if parsing fails. +func parseDurationToSeconds(s string) int { + d, err := time.ParseDuration(s) + if err != nil { + return 300 + } + return int(d.Seconds()) +} + +func boolPtr(b bool) *bool { + return &b +} + +func hostPathTypePtr(t corev1.HostPathType) *corev1.HostPathType { + return &t +} diff --git a/internal/controller/image_job_manager_test.go b/internal/controller/image_job_manager_test.go new file mode 100644 index 00000000..361d9a60 --- /dev/null +++ b/internal/controller/image_job_manager_test.go @@ -0,0 +1,784 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "context" + "encoding/json" + "fmt" + "strconv" + "strings" + "testing" + + "github.com/go-logr/logr" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + batchv1 "k8s.io/api/batch/v1" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/fake" +) + +func jobManagerConfig() ImageAnalysisConfig { + cfg := DefaultImageAnalysisConfig() + cfg.ExcludedNamespaces = nil + cfg.ExcludedImages = nil + return cfg +} + +func makeNodeImageMap(nodes map[string]int) NodeImageMap { + nim := make(NodeImageMap) + for nodeName, imageCount := range nodes { + batch := &NodeBatch{NodeName: nodeName} + for i := 0; i < imageCount; i++ { + batch.Images = append(batch.Images, ImageInfo{ + Digest: fmt.Sprintf("%s-img-%d@sha256:digest%d", nodeName, i, i), + Ref: fmt.Sprintf("registry.example.com/%s-img-%d:v1", nodeName, i), + }) + } + nim[nodeName] = batch + } + return nim +} + +// --- GenerateScanID --- + +func TestGenerateScanID(t *testing.T) { + id := GenerateScanID() + assert.NotEmpty(t, id) + + // Should be a valid Unix timestamp (all digits). + _, err := strconv.ParseInt(id, 10, 64) + assert.NoError(t, err) + + // Should be reasonably recent (after 2020). + ts, _ := strconv.ParseInt(id, 10, 64) + assert.Greater(t, ts, int64(1577836800)) // 2020-01-01 +} + +// --- PlanBatchJobs --- + +func TestPlanBatchJobs_BasicSplitting(t *testing.T) { + cfg := jobManagerConfig() + cfg.BatchSize = 10 + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + nim := makeNodeImageMap(map[string]int{ + "node-1": 25, + }) + scanID := "1709420400" + + specs := mgr.PlanBatchJobs(nim, scanID) + + // 25 images / 10 per batch = 3 batches + assert.Len(t, specs, 3) + + assert.Equal(t, 0, specs[0].BatchIndex) + assert.Len(t, specs[0].Images, 10) + + assert.Equal(t, 1, specs[1].BatchIndex) + assert.Len(t, specs[1].Images, 10) + + assert.Equal(t, 2, specs[2].BatchIndex) + assert.Len(t, specs[2].Images, 5) + + // All specs should reference the same node and scan ID. + for _, s := range specs { + assert.Equal(t, "node-1", s.NodeName) + assert.Equal(t, scanID, s.ScanID) + } +} + +func TestPlanBatchJobs_MultipleNodes_SortedByImageCount(t *testing.T) { + cfg := jobManagerConfig() + cfg.BatchSize = 5 + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + nim := makeNodeImageMap(map[string]int{ + "small-node": 3, + "big-node": 12, + "mid-node": 7, + }) + scanID := "1709420400" + + specs := mgr.PlanBatchJobs(nim, scanID) + + // big-node: 12/5 = 3 batches, mid-node: 7/5 = 2 batches, small-node: 3/5 = 1 batch + assert.Len(t, specs, 6) + + // First specs should be from the biggest node. + assert.Equal(t, "big-node", specs[0].NodeName) + assert.Equal(t, "big-node", specs[1].NodeName) + assert.Equal(t, "big-node", specs[2].NodeName) + + // Then mid-node. + assert.Equal(t, "mid-node", specs[3].NodeName) + assert.Equal(t, "mid-node", specs[4].NodeName) + + // Then small-node. + assert.Equal(t, "small-node", specs[5].NodeName) +} + +func TestPlanBatchJobs_SingleImagePerBatch(t *testing.T) { + cfg := jobManagerConfig() + cfg.BatchSize = 1 + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + nim := makeNodeImageMap(map[string]int{"node-1": 3}) + + specs := mgr.PlanBatchJobs(nim, "123") + assert.Len(t, specs, 3) + for _, s := range specs { + assert.Len(t, s.Images, 1) + } +} + +func TestPlanBatchJobs_ExactBatchSize(t *testing.T) { + cfg := jobManagerConfig() + cfg.BatchSize = 10 + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + nim := makeNodeImageMap(map[string]int{"node-1": 10}) + + specs := mgr.PlanBatchJobs(nim, "123") + assert.Len(t, specs, 1) + assert.Len(t, specs[0].Images, 10) +} + +func TestPlanBatchJobs_EmptyNodeMap(t *testing.T) { + cfg := jobManagerConfig() + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + specs := mgr.PlanBatchJobs(NodeImageMap{}, "123") + assert.Empty(t, specs) +} + +// --- generateJobName --- + +func TestGenerateJobName_Basic(t *testing.T) { + name := generateJobName("worker-01", 3, "1709420400") + assert.Equal(t, "dive-worker-01-b3-1709420400", name) + assert.LessOrEqual(t, len(name), maxJobNameLength) +} + +func TestGenerateJobName_LongNodeName(t *testing.T) { + longNode := strings.Repeat("a", 100) + name := generateJobName(longNode, 0, "1709420400") + assert.LessOrEqual(t, len(name), maxJobNameLength) + assert.True(t, strings.HasPrefix(name, "dive-")) + assert.True(t, strings.HasSuffix(name, "-b0-1709420400")) +} + +func TestGenerateJobName_SpecialChars(t *testing.T) { + name := generateJobName("ip-10-0-1-5.ec2.internal", 2, "12345") + assert.Equal(t, "dive-ip-10-0-1-5-ec2-internal-b2-12345", name) + assert.LessOrEqual(t, len(name), maxJobNameLength) +} + +func TestGenerateJobName_UpperCase(t *testing.T) { + name := generateJobName("Worker-Node-01", 0, "100") + assert.Equal(t, "dive-worker-node-01-b0-100", name) +} + +// --- sanitizeDNSName --- + +func TestSanitizeDNSName(t *testing.T) { + tests := []struct { + input string + expected string + }{ + {"worker-01", "worker-01"}, + {"Worker_Node.01", "worker-node-01"}, + {"ip-10-0-1-5.ec2.internal", "ip-10-0-1-5-ec2-internal"}, + {"-leading-", "leading"}, + {"UPPERCASE", "uppercase"}, + {"a--b---c", "a-b-c"}, + } + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + assert.Equal(t, tt.expected, sanitizeDNSName(tt.input)) + }) + } +} + +// --- sanitizeLabelValue --- + +func TestSanitizeLabelValue_Long(t *testing.T) { + long := strings.Repeat("x", 100) + result := sanitizeLabelValue(long) + assert.LessOrEqual(t, len(result), 63) +} + +// --- parseDurationToSeconds --- + +func TestParseDurationToSeconds(t *testing.T) { + assert.Equal(t, 300, parseDurationToSeconds("5m")) + assert.Equal(t, 60, parseDurationToSeconds("1m")) + assert.Equal(t, 600, parseDurationToSeconds("10m")) + assert.Equal(t, 30, parseDurationToSeconds("30s")) + assert.Equal(t, 300, parseDurationToSeconds("invalid")) // fallback + assert.Equal(t, 300, parseDurationToSeconds("")) // fallback + assert.Equal(t, 3600, parseDurationToSeconds("1h")) +} + +// --- buildJobObject --- + +func TestBuildJobObject_Structure(t *testing.T) { + cfg := jobManagerConfig() + cfg.RegistryAuthSecret = "my-registry-secret" + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + spec := BatchJobSpec{ + JobName: "dive-node1-b0-123", + NodeName: "node-1", + BatchIndex: 0, + ScanID: "123", + Images: []ImageInfo{ + {Digest: "nginx@sha256:aaa", Ref: "nginx:1.25"}, + {Digest: "redis@sha256:bbb", Ref: "redis:7.2"}, + }, + } + + job, err := mgr.buildJobObject(spec) + require.NoError(t, err) + + // Metadata. + assert.Equal(t, "dive-node1-b0-123", job.Name) + assert.Equal(t, "devzero-zxporter", job.Namespace) + assert.Equal(t, LabelComponentValue, job.Labels[LabelComponent]) + assert.Equal(t, "123", job.Labels[LabelScanID]) + assert.Equal(t, "0", job.Labels[LabelBatchIndex]) + + // Spec. + assert.Equal(t, int32(2), *job.Spec.BackoffLimit) // MaxRetries default + assert.Equal(t, int64(1800), *job.Spec.ActiveDeadlineSeconds) // 30 min + assert.Equal(t, int32(3600), *job.Spec.TTLSecondsAfterFinished) + + // Pod spec. + podSpec := job.Spec.Template.Spec + assert.Equal(t, corev1.RestartPolicyNever, podSpec.RestartPolicy) + assert.Equal(t, "image-analyzer", podSpec.ServiceAccountName) + assert.Equal(t, "node-1", podSpec.NodeName) + + // Container. + require.Len(t, podSpec.Containers, 1) + container := podSpec.Containers[0] + assert.Equal(t, "analyzer", container.Name) + assert.Equal(t, cfg.AnalyzerImage, container.Image) + + // Env vars. + envMap := make(map[string]string) + for _, e := range container.Env { + envMap[e.Name] = e.Value + } + assert.Contains(t, envMap, "IMAGES_JSON") + assert.Equal(t, "true", envMap["PREFER_LOCAL"]) + assert.Equal(t, "true", envMap["FALLBACK_REMOTE"]) + assert.Equal(t, "/run/containerd/containerd.sock", envMap["CONTAINERD_SOCK"]) + assert.Equal(t, "k8s.io", envMap["CONTAINERD_NS"]) + assert.Equal(t, "300", envMap["REMOTE_PULL_TIMEOUT"]) + + // Verify IMAGES_JSON is valid JSON with correct images. + var images []struct { + Digest string `json:"digest"` + Ref string `json:"ref"` + } + err = json.Unmarshal([]byte(envMap["IMAGES_JSON"]), &images) + require.NoError(t, err) + assert.Len(t, images, 2) + assert.Equal(t, "nginx@sha256:aaa", images[0].Digest) + assert.Equal(t, "redis:7.2", images[1].Ref) + + // Resources. + assert.Equal(t, "500m", container.Resources.Requests.Cpu().String()) + assert.Equal(t, "1", container.Resources.Limits.Cpu().String()) + assert.Equal(t, "1Gi", container.Resources.Requests.Memory().String()) + assert.Equal(t, "4Gi", container.Resources.Limits.Memory().String()) + + // Security context. + require.NotNil(t, container.SecurityContext) + assert.Equal(t, int64(0), *container.SecurityContext.RunAsUser) + assert.False(t, *container.SecurityContext.AllowPrivilegeEscalation) + + // Volumes — should have 3 (containerd-sock, workspace, registry-auth). + assert.Len(t, podSpec.Volumes, 3) + assert.Len(t, container.VolumeMounts, 3) + + // Verify containerd socket volume. + var sockVol *corev1.Volume + for i := range podSpec.Volumes { + if podSpec.Volumes[i].Name == "containerd-sock" { + sockVol = &podSpec.Volumes[i] + } + } + require.NotNil(t, sockVol) + assert.Equal(t, "/run/containerd/containerd.sock", sockVol.HostPath.Path) + assert.Equal(t, corev1.HostPathSocket, *sockVol.HostPath.Type) + + // Verify workspace volume. + var wsVol *corev1.Volume + for i := range podSpec.Volumes { + if podSpec.Volumes[i].Name == "workspace" { + wsVol = &podSpec.Volumes[i] + } + } + require.NotNil(t, wsVol) + assert.Equal(t, "10Gi", wsVol.EmptyDir.SizeLimit.String()) + + // Verify registry auth volume. + var authVol *corev1.Volume + for i := range podSpec.Volumes { + if podSpec.Volumes[i].Name == "registry-auth" { + authVol = &podSpec.Volumes[i] + } + } + require.NotNil(t, authVol) + assert.Equal(t, "my-registry-secret", authVol.Secret.SecretName) + assert.True(t, *authVol.Secret.Optional) +} + +func TestBuildJobObject_NoRegistrySecret(t *testing.T) { + cfg := jobManagerConfig() + cfg.RegistryAuthSecret = "" // no secret + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + spec := BatchJobSpec{ + JobName: "dive-test-b0-1", NodeName: "node-1", + Images: []ImageInfo{{Digest: "a@sha256:x", Ref: "a:v1"}}, + } + + job, err := mgr.buildJobObject(spec) + require.NoError(t, err) + + // Should only have 2 volumes (no registry-auth). + assert.Len(t, job.Spec.Template.Spec.Volumes, 2) + assert.Len(t, job.Spec.Template.Spec.Containers[0].VolumeMounts, 2) +} + +func TestBuildJobObject_WithTolerations(t *testing.T) { + cfg := jobManagerConfig() + cfg.JobTolerations = []corev1.Toleration{ + {Key: "dedicated", Operator: corev1.TolerationOpExists, Effect: corev1.TaintEffectNoSchedule}, + } + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + spec := BatchJobSpec{ + JobName: "dive-test-b0-1", NodeName: "node-1", + Images: []ImageInfo{{Digest: "a@sha256:x", Ref: "a:v1"}}, + } + + job, err := mgr.buildJobObject(spec) + require.NoError(t, err) + + require.Len(t, job.Spec.Template.Spec.Tolerations, 1) + assert.Equal(t, "dedicated", job.Spec.Template.Spec.Tolerations[0].Key) +} + +// --- CreateJob --- + +func TestCreateJob_Success(t *testing.T) { + cfg := jobManagerConfig() + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + spec := BatchJobSpec{ + JobName: "dive-node1-b0-123", + NodeName: "node-1", + BatchIndex: 0, + ScanID: "123", + Images: []ImageInfo{ + {Digest: "nginx@sha256:aaa", Ref: "nginx:1.25"}, + }, + } + + job, err := mgr.CreateJob(context.Background(), spec) + require.NoError(t, err) + assert.Equal(t, "dive-node1-b0-123", job.Name) + + // Verify it exists in the fake client. + fetched, err := client.BatchV1().Jobs(cfg.JobNamespace).Get( + context.Background(), "dive-node1-b0-123", metav1.GetOptions{}) + require.NoError(t, err) + assert.Equal(t, "dive-node1-b0-123", fetched.Name) +} + +// --- SubmitBatches --- + +func TestSubmitBatches_RespectsClusterLimit(t *testing.T) { + cfg := jobManagerConfig() + cfg.MaxConcurrentJobs = 3 + cfg.MaxJobsPerNode = 10 // high per-node limit so it doesn't interfere + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + // Create 5 specs all on different nodes. + specs := make([]BatchJobSpec, 5) + for i := 0; i < 5; i++ { + specs[i] = BatchJobSpec{ + JobName: fmt.Sprintf("dive-node%d-b0-123", i), + NodeName: fmt.Sprintf("node-%d", i), + BatchIndex: 0, + ScanID: "123", + Images: []ImageInfo{{Digest: fmt.Sprintf("img%d@sha256:x", i), Ref: fmt.Sprintf("img%d:v1", i)}}, + } + } + + created, err := mgr.SubmitBatches(context.Background(), specs) + require.NoError(t, err) + + // Only 3 should be created (cluster limit). + assert.Len(t, created, 3) +} + +func TestSubmitBatches_RespectsPerNodeLimit(t *testing.T) { + cfg := jobManagerConfig() + cfg.MaxConcurrentJobs = 100 // high cluster limit + cfg.MaxJobsPerNode = 1 + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + // 3 specs on the same node. + specs := make([]BatchJobSpec, 3) + for i := 0; i < 3; i++ { + specs[i] = BatchJobSpec{ + JobName: fmt.Sprintf("dive-node1-b%d-123", i), + NodeName: "node-1", + BatchIndex: i, + ScanID: "123", + Images: []ImageInfo{{Digest: fmt.Sprintf("img%d@sha256:x", i), Ref: fmt.Sprintf("img%d:v1", i)}}, + } + } + + created, err := mgr.SubmitBatches(context.Background(), specs) + require.NoError(t, err) + + // Only 1 should be created (per-node limit). + assert.Len(t, created, 1) +} + +func TestSubmitBatches_MixedNodes(t *testing.T) { + cfg := jobManagerConfig() + cfg.MaxConcurrentJobs = 5 + cfg.MaxJobsPerNode = 1 + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + // 2 batches on node-1, 2 on node-2, 1 on node-3. + specs := []BatchJobSpec{ + {JobName: "dive-n1-b0-1", NodeName: "node-1", ScanID: "1", Images: []ImageInfo{{Digest: "a@sha256:1", Ref: "a:1"}}}, + {JobName: "dive-n1-b1-1", NodeName: "node-1", ScanID: "1", Images: []ImageInfo{{Digest: "b@sha256:2", Ref: "b:1"}}}, + {JobName: "dive-n2-b0-1", NodeName: "node-2", ScanID: "1", Images: []ImageInfo{{Digest: "c@sha256:3", Ref: "c:1"}}}, + {JobName: "dive-n2-b1-1", NodeName: "node-2", ScanID: "1", Images: []ImageInfo{{Digest: "d@sha256:4", Ref: "d:1"}}}, + {JobName: "dive-n3-b0-1", NodeName: "node-3", ScanID: "1", Images: []ImageInfo{{Digest: "e@sha256:5", Ref: "e:1"}}}, + } + + created, err := mgr.SubmitBatches(context.Background(), specs) + require.NoError(t, err) + + // Per-node=1: node-1 gets 1, node-2 gets 1, node-3 gets 1 = 3 total. + assert.Len(t, created, 3) + + nodesSeen := map[string]int{} + for _, j := range created { + nodesSeen[j.Spec.Template.Spec.NodeName]++ + } + assert.Equal(t, 1, nodesSeen["node-1"]) + assert.Equal(t, 1, nodesSeen["node-2"]) + assert.Equal(t, 1, nodesSeen["node-3"]) +} + +func TestSubmitBatches_Empty(t *testing.T) { + cfg := jobManagerConfig() + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + created, err := mgr.SubmitBatches(context.Background(), nil) + require.NoError(t, err) + assert.Nil(t, created) +} + +func TestSubmitBatches_AccountsForExistingActiveJobs(t *testing.T) { + cfg := jobManagerConfig() + cfg.MaxConcurrentJobs = 3 + cfg.MaxJobsPerNode = 2 + + // Pre-create 2 active Jobs for this scan. + existingJob1 := &batchv1.Job{ + ObjectMeta: metav1.ObjectMeta{ + Name: "dive-node1-b0-123", + Namespace: cfg.JobNamespace, + Labels: map[string]string{ + LabelComponent: LabelComponentValue, + LabelScanID: "123", + LabelAnalysisNode: "node-1", + }, + }, + Status: batchv1.JobStatus{Active: 1}, // still running + } + existingJob2 := &batchv1.Job{ + ObjectMeta: metav1.ObjectMeta{ + Name: "dive-node2-b0-123", + Namespace: cfg.JobNamespace, + Labels: map[string]string{ + LabelComponent: LabelComponentValue, + LabelScanID: "123", + LabelAnalysisNode: "node-2", + }, + }, + Status: batchv1.JobStatus{Active: 1}, // still running + } + + client := fake.NewSimpleClientset(existingJob1, existingJob2) + mgr := NewJobManager(client, cfg, logr.Discard()) + + // Try to submit 3 more. + specs := []BatchJobSpec{ + {JobName: "dive-node3-b0-123", NodeName: "node-3", ScanID: "123", Images: []ImageInfo{{Digest: "a@sha256:1", Ref: "a:1"}}}, + {JobName: "dive-node4-b0-123", NodeName: "node-4", ScanID: "123", Images: []ImageInfo{{Digest: "b@sha256:2", Ref: "b:1"}}}, + {JobName: "dive-node5-b0-123", NodeName: "node-5", ScanID: "123", Images: []ImageInfo{{Digest: "c@sha256:3", Ref: "c:1"}}}, + } + + created, err := mgr.SubmitBatches(context.Background(), specs) + require.NoError(t, err) + + // 2 existing active + max 3 = only 1 slot available. + assert.Len(t, created, 1) +} + +// --- GetJobStatus --- + +func TestGetJobStatus(t *testing.T) { + cfg := jobManagerConfig() + + jobs := []batchv1.Job{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "job-active", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "100"}, + }, + Status: batchv1.JobStatus{Active: 1}, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "job-succeeded", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "100"}, + }, + Status: batchv1.JobStatus{Succeeded: 1}, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "job-failed", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "100"}, + }, + Status: batchv1.JobStatus{ + Conditions: []batchv1.JobCondition{ + {Type: batchv1.JobFailed, Status: corev1.ConditionTrue}, + }, + }, + }, + { + // Different scan — should not be counted. + ObjectMeta: metav1.ObjectMeta{ + Name: "job-other-scan", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "999"}, + }, + Status: batchv1.JobStatus{Active: 1}, + }, + } + + jobList := &batchv1.JobList{Items: jobs} + client := fake.NewSimpleClientset(jobList) + mgr := NewJobManager(client, cfg, logr.Discard()) + + active, succeeded, failed, err := mgr.GetJobStatus(context.Background(), "100") + require.NoError(t, err) + assert.Equal(t, 1, active) + assert.Equal(t, 1, succeeded) + assert.Equal(t, 1, failed) +} + +// --- CleanupOldScanJobs --- + +func TestCleanupOldScanJobs(t *testing.T) { + cfg := jobManagerConfig() + + jobs := []batchv1.Job{ + { + // Old scan, completed — should be deleted. + ObjectMeta: metav1.ObjectMeta{ + Name: "old-completed", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "old"}, + }, + Status: batchv1.JobStatus{Succeeded: 1}, + }, + { + // Old scan, failed — should be deleted. + ObjectMeta: metav1.ObjectMeta{ + Name: "old-failed", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "old"}, + }, + Status: batchv1.JobStatus{ + Conditions: []batchv1.JobCondition{ + {Type: batchv1.JobFailed, Status: corev1.ConditionTrue}, + }, + }, + }, + { + // Old scan, still active — should NOT be deleted. + ObjectMeta: metav1.ObjectMeta{ + Name: "old-active", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "old"}, + }, + Status: batchv1.JobStatus{Active: 1}, + }, + { + // Current scan — should NOT be deleted. + ObjectMeta: metav1.ObjectMeta{ + Name: "current-job", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "current"}, + }, + Status: batchv1.JobStatus{Succeeded: 1}, + }, + } + + jobList := &batchv1.JobList{Items: jobs} + client := fake.NewSimpleClientset(jobList) + mgr := NewJobManager(client, cfg, logr.Discard()) + + deleted, err := mgr.CleanupOldScanJobs(context.Background(), "current") + require.NoError(t, err) + assert.Equal(t, 2, deleted) // old-completed + old-failed + + // Verify what remains. + remaining, err := client.BatchV1().Jobs(cfg.JobNamespace).List(context.Background(), metav1.ListOptions{}) + require.NoError(t, err) + + names := make(map[string]bool) + for _, j := range remaining.Items { + names[j.Name] = true + } + assert.True(t, names["old-active"], "active old job should remain") + assert.True(t, names["current-job"], "current scan job should remain") + assert.False(t, names["old-completed"], "old completed should be deleted") + assert.False(t, names["old-failed"], "old failed should be deleted") +} + +// --- isJobFailed --- + +func TestIsJobFailed(t *testing.T) { + assert.False(t, isJobFailed(&batchv1.Job{})) + assert.False(t, isJobFailed(&batchv1.Job{ + Status: batchv1.JobStatus{Active: 1}, + })) + assert.True(t, isJobFailed(&batchv1.Job{ + Status: batchv1.JobStatus{ + Conditions: []batchv1.JobCondition{ + {Type: batchv1.JobFailed, Status: corev1.ConditionTrue}, + }, + }, + })) + assert.False(t, isJobFailed(&batchv1.Job{ + Status: batchv1.JobStatus{ + Conditions: []batchv1.JobCondition{ + {Type: batchv1.JobFailed, Status: corev1.ConditionFalse}, + }, + }, + })) +} + +// --- ListScanJobs --- + +func TestListScanJobs(t *testing.T) { + cfg := jobManagerConfig() + + jobs := []batchv1.Job{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "scan-a-j1", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "a"}, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "scan-a-j2", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "a"}, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "scan-b-j1", Namespace: cfg.JobNamespace, + Labels: map[string]string{LabelComponent: LabelComponentValue, LabelScanID: "b"}, + }, + }, + } + + client := fake.NewSimpleClientset(&batchv1.JobList{Items: jobs}) + mgr := NewJobManager(client, cfg, logr.Discard()) + + list, err := mgr.ListScanJobs(context.Background(), "a") + require.NoError(t, err) + assert.Len(t, list.Items, 2) +} + +// --- End-to-end: Plan → Submit --- + +func TestPlanAndSubmit_EndToEnd(t *testing.T) { + cfg := jobManagerConfig() + cfg.BatchSize = 3 + cfg.MaxConcurrentJobs = 5 + cfg.MaxJobsPerNode = 1 + client := fake.NewSimpleClientset() + mgr := NewJobManager(client, cfg, logr.Discard()) + + nim := makeNodeImageMap(map[string]int{ + "node-a": 7, // → 3 batches + "node-b": 2, // → 1 batch + }) + scanID := "1700000000" + + specs := mgr.PlanBatchJobs(nim, scanID) + // node-a: 3 batches (7/3 = 3), node-b: 1 batch (2/3 = 1) = 4 total + assert.Len(t, specs, 4) + + // Submit — per-node=1 means only 1 per node = 2 jobs submitted. + created, err := mgr.SubmitBatches(context.Background(), specs) + require.NoError(t, err) + assert.Len(t, created, 2) + + // Verify created jobs in cluster. + allJobs, err := client.BatchV1().Jobs(cfg.JobNamespace).List(context.Background(), metav1.ListOptions{}) + require.NoError(t, err) + assert.Len(t, allJobs.Items, 2) + + // Verify one per node. + nodesSeen := map[string]bool{} + for _, j := range allJobs.Items { + nodesSeen[j.Spec.Template.Spec.NodeName] = true + assert.Equal(t, scanID, j.Labels[LabelScanID]) + assert.Equal(t, LabelComponentValue, j.Labels[LabelComponent]) + } + assert.True(t, nodesSeen["node-a"]) + assert.True(t, nodesSeen["node-b"]) +} diff --git a/internal/controller/image_result_collector.go b/internal/controller/image_result_collector.go new file mode 100644 index 00000000..f0493a5d --- /dev/null +++ b/internal/controller/image_result_collector.go @@ -0,0 +1,788 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "bufio" + "context" + "encoding/json" + "fmt" + "sort" + "strconv" + "strings" + "time" + "unicode" + + "github.com/go-logr/logr" + batchv1 "k8s.io/api/batch/v1" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/client-go/kubernetes" + "sigs.k8s.io/controller-runtime/pkg/client" + + v1 "github.com/devzero-inc/zxporter/api/v1" +) + +const ( + // maxCommandLength is the max length for a layer command string stored in the CRD. + maxCommandLength = 200 + + // maxWastedFiles is the max number of wasted file entries stored per image. + maxWastedFiles = 50 + + // maxWorkloadRefs is the max number of workload references stored per image. + maxWorkloadRefs = 200 + + // CRD label keys for ImageAnalysisResult. + LabelImageRegistry = "devzero.io/image-registry" + LabelImageRepo = "devzero.io/image-repo" + LabelScanPassed = "devzero.io/scan-passed" + LabelAnalyzedNode = "devzero.io/analyzed-node" + // LabelScanID is reused from image_job_manager.go + + // Annotation keys. + AnnotationFullImageRef = "devzero.io/full-image-ref" +) + +// --- Dive JSON types (matches dive's export format) --- + +// BatchImageResult is a single NDJSON line from the batch analyzer script. +type BatchImageResult struct { + Digest string `json:"digest"` + Ref string `json:"ref"` + Source string `json:"source"` // "local-containerd", "remote-pull", "failed" + DurationMs int64 `json:"durationMs"` + Error string `json:"error"` + Result *DiveResult `json:"result"` // null if failed +} + +// DiveResult is dive's top-level JSON export structure. +type DiveResult struct { + Image DiveImage `json:"image"` + Layer []DiveLayer `json:"layer"` +} + +// DiveImage contains the image-level metrics from dive. +type DiveImage struct { + SizeBytes uint64 `json:"sizeBytes"` + InefficientBytes uint64 `json:"inefficientBytes"` + EfficiencyScore float64 `json:"efficiencyScore"` + FileReference []DiveFileRef `json:"fileReference"` +} + +// DiveFileRef is a file contributing to wasted space in the image. +type DiveFileRef struct { + Count int `json:"count"` + SizeBytes uint64 `json:"sizeBytes"` + File string `json:"file"` +} + +// DiveLayer contains per-layer details from dive. +type DiveLayer struct { + Index int `json:"index"` + ID string `json:"id"` + DigestID string `json:"digestId"` + SizeBytes uint64 `json:"sizeBytes"` + Command string `json:"command"` + FileList []DiveFile `json:"fileList"` +} + +// DiveFile is a file entry in a dive layer's file list. +type DiveFile struct { + Path string `json:"path"` + Size uint64 `json:"size"` + TypeFlag int `json:"typeFlag"` + IsDir bool `json:"isDir"` +} + +// --- Collection result types --- + +// CollectionResult holds the outcome of collecting results from a single batch Job. +type CollectionResult struct { + JobName string + NodeName string + ScanID string + Succeeded []BatchImageResult // images that were analyzed successfully + Failed []BatchImageResult // images that failed (source="failed" or error!="") + ParseErrors int // count of NDJSON lines that couldn't be parsed + TotalLines int // total NDJSON lines parsed + LocalContainerd int // count of images acquired via containerd + RemotePull int // count of images acquired via remote pull + AcquisitionFailed int // count of images where acquisition failed +} + +// --- ResultCollector --- + +// ResultCollector reads Job pod logs, parses NDJSON output, maps to CRDs, and persists them. +type ResultCollector struct { + k8sClient kubernetes.Interface + crdClient client.Client + config ImageAnalysisConfig + log logr.Logger +} + +// NewResultCollector creates a new ResultCollector. +func NewResultCollector( + k8sClient kubernetes.Interface, + crdClient client.Client, + config ImageAnalysisConfig, + log logr.Logger, +) *ResultCollector { + return &ResultCollector{ + k8sClient: k8sClient, + crdClient: crdClient, + config: config, + log: log.WithName("result-collector"), + } +} + +// CollectFromJob reads pod logs from a completed batch Job and parses the NDJSON output. +func (rc *ResultCollector) CollectFromJob(ctx context.Context, job *batchv1.Job) (*CollectionResult, error) { + result := &CollectionResult{ + JobName: job.Name, + NodeName: job.Labels[LabelAnalysisNode], + ScanID: job.Labels[LabelScanID], + } + + // Find the pod(s) for this Job. + podList, err := rc.k8sClient.CoreV1().Pods(job.Namespace).List(ctx, metav1.ListOptions{ + LabelSelector: fmt.Sprintf("job-name=%s", job.Name), + }) + if err != nil { + return nil, fmt.Errorf("listing pods for job %s: %w", job.Name, err) + } + + if len(podList.Items) == 0 { + return nil, fmt.Errorf("no pods found for job %s", job.Name) + } + + // Use the most recently created pod (in case of retries, this is the last attempt). + pod := findLatestPod(podList.Items) + + // Read pod logs. + logStream, err := rc.k8sClient.CoreV1().Pods(job.Namespace).GetLogs(pod.Name, &corev1.PodLogOptions{ + Container: "analyzer", + }).Stream(ctx) + if err != nil { + return nil, fmt.Errorf("reading logs from pod %s: %w", pod.Name, err) + } + defer logStream.Close() + + // Parse NDJSON lines. + scanner := bufio.NewScanner(logStream) + // Allow up to 10MB per line (dive JSON can be large). + scanner.Buffer(make([]byte, 0, 64*1024), 10*1024*1024) + + for scanner.Scan() { + line := strings.TrimSpace(scanner.Text()) + if line == "" { + continue + } + + // Skip non-JSON lines (progress messages go to stderr, but just in case). + if !strings.HasPrefix(line, "{") { + continue + } + + result.TotalLines++ + + var imgResult BatchImageResult + if err := json.Unmarshal([]byte(line), &imgResult); err != nil { + rc.log.V(1).Info("failed to parse NDJSON line", "job", job.Name, "error", err) + result.ParseErrors++ + continue + } + + // Classify the result. + switch { + case imgResult.Source == "failed" || imgResult.Error != "": + result.Failed = append(result.Failed, imgResult) + result.AcquisitionFailed++ + case imgResult.Source == "local-containerd": + result.Succeeded = append(result.Succeeded, imgResult) + result.LocalContainerd++ + case imgResult.Source == "remote-pull": + result.Succeeded = append(result.Succeeded, imgResult) + result.RemotePull++ + default: + result.Succeeded = append(result.Succeeded, imgResult) + } + } + + if err := scanner.Err(); err != nil { + return result, fmt.Errorf("scanning logs from pod %s: %w", pod.Name, err) + } + + rc.log.Info("collected batch results", + "job", job.Name, + "succeeded", len(result.Succeeded), + "failed", len(result.Failed), + "parseErrors", result.ParseErrors, + ) + + return result, nil +} + +// ProcessAndSave maps a successful BatchImageResult to an ImageAnalysisResult CRD and persists it. +// workloadRefs comes from the discovery phase (global workload reference map). +func (rc *ResultCollector) ProcessAndSave( + ctx context.Context, + imgResult BatchImageResult, + jobName string, + nodeName string, + scanID string, + workloadRefs WorkloadRefMap, +) error { + crdName := generateCRDName(imgResult.Digest) + + // Build the CRD spec. + spec, err := rc.buildSpec(imgResult, jobName, nodeName, workloadRefs) + if err != nil { + return fmt.Errorf("building spec for %s: %w", imgResult.Ref, err) + } + + // Build status. + status := v1.ImageAnalysisResultStatus{ + Phase: "Completed", + AnalyzedAt: metav1.NewTime(time.Now()), + } + if imgResult.DurationMs > 0 { + // Round up so sub-second durations don't show as 0. + status.AnalysisDurationSeconds = int((imgResult.DurationMs + 999) / 1000) + } + + // Build labels and annotations. + registry, repo := parseImageRegistryAndRepo(imgResult.Ref) + labels := map[string]string{ + LabelImageRegistry: sanitizeLabelValue(registry), + LabelImageRepo: sanitizeLabelValue(repo), + LabelScanPassed: strconv.FormatBool(spec.Analysis.Passed), + LabelAnalyzedNode: sanitizeLabelValue(nodeName), + LabelScanID: scanID, + } + annotations := map[string]string{ + AnnotationFullImageRef: imgResult.Ref, + } + + // Try to get existing CRD. + existing := &v1.ImageAnalysisResult{} + err = rc.crdClient.Get(ctx, types.NamespacedName{Name: crdName}, existing) + + if errors.IsNotFound(err) { + // Create new CRD. + crd := &v1.ImageAnalysisResult{ + ObjectMeta: metav1.ObjectMeta{ + Name: crdName, + Labels: labels, + Annotations: annotations, + }, + Spec: spec, + } + if err := rc.crdClient.Create(ctx, crd); err != nil { + return fmt.Errorf("creating ImageAnalysisResult %s: %w", crdName, err) + } + + // Update status subresource. + crd.Status = status + if err := rc.crdClient.Status().Update(ctx, crd); err != nil { + rc.log.Error(err, "failed to update status after create", "name", crdName) + } + + rc.log.V(1).Info("created ImageAnalysisResult", "name", crdName, "image", imgResult.Ref) + return nil + } else if err != nil { + return fmt.Errorf("getting existing ImageAnalysisResult %s: %w", crdName, err) + } + + // Update existing CRD. + existing.Labels = labels + existing.Annotations = annotations + existing.Spec = spec + if err := rc.crdClient.Update(ctx, existing); err != nil { + return fmt.Errorf("updating ImageAnalysisResult %s: %w", crdName, err) + } + + // Update status subresource. + existing.Status = status + if err := rc.crdClient.Status().Update(ctx, existing); err != nil { + rc.log.Error(err, "failed to update status", "name", crdName) + } + + rc.log.V(1).Info("updated ImageAnalysisResult", "name", crdName, "image", imgResult.Ref) + return nil +} + +// SaveFailedResult creates/updates a CRD with Failed status for an image that couldn't be analyzed. +func (rc *ResultCollector) SaveFailedResult( + ctx context.Context, + imgResult BatchImageResult, + jobName string, + nodeName string, + scanID string, +) error { + crdName := generateCRDName(imgResult.Digest) + + labels := map[string]string{ + LabelScanPassed: "false", + LabelAnalyzedNode: sanitizeLabelValue(nodeName), + LabelScanID: scanID, + } + + status := v1.ImageAnalysisResultStatus{ + Phase: "Failed", + AnalyzedAt: metav1.NewTime(time.Now()), + Message: imgResult.Error, + } + + existing := &v1.ImageAnalysisResult{} + err := rc.crdClient.Get(ctx, types.NamespacedName{Name: crdName}, existing) + + if errors.IsNotFound(err) { + crd := &v1.ImageAnalysisResult{ + ObjectMeta: metav1.ObjectMeta{ + Name: crdName, + Labels: labels, + }, + Spec: v1.ImageAnalysisResultSpec{ + ImageRef: imgResult.Ref, + ImageDigest: imgResult.Digest, + ImageSource: v1.ImageSourceInfo{ + Type: imgResult.Source, + NodeName: nodeName, + BatchJobName: jobName, + }, + Analysis: v1.ImageAnalysis{ + Efficiency: "0", + WastedBytes: 0, + UserWastedPercent: "0", + Passed: false, + LayerCount: 0, + }, + }, + } + if err := rc.crdClient.Create(ctx, crd); err != nil { + return fmt.Errorf("creating failed ImageAnalysisResult %s: %w", crdName, err) + } + crd.Status = status + if err := rc.crdClient.Status().Update(ctx, crd); err != nil { + rc.log.Error(err, "failed to update failed status after create", "name", crdName) + } + return nil + } else if err != nil { + return fmt.Errorf("getting existing ImageAnalysisResult %s: %w", crdName, err) + } + + // Update existing with failed spec and status. + existing.Labels = labels + existing.Spec.ImageRef = imgResult.Ref + existing.Spec.ImageDigest = imgResult.Digest + existing.Spec.ImageSource = v1.ImageSourceInfo{ + Type: imgResult.Source, + NodeName: nodeName, + BatchJobName: jobName, + } + existing.Spec.Analysis.Passed = false + if err := rc.crdClient.Update(ctx, existing); err != nil { + return fmt.Errorf("updating failed ImageAnalysisResult %s: %w", crdName, err) + } + + existing.Status = status + if err := rc.crdClient.Status().Update(ctx, existing); err != nil { + return fmt.Errorf("updating failed status for %s: %w", crdName, err) + } + return nil +} + +// buildSpec constructs the ImageAnalysisResultSpec from a BatchImageResult. +func (rc *ResultCollector) buildSpec( + imgResult BatchImageResult, + jobName string, + nodeName string, + workloadRefs WorkloadRefMap, +) (v1.ImageAnalysisResultSpec, error) { + spec := v1.ImageAnalysisResultSpec{ + ImageRef: imgResult.Ref, + ImageDigest: imgResult.Digest, + ImageSource: v1.ImageSourceInfo{ + Type: imgResult.Source, + NodeName: nodeName, + ExportDurationMs: imgResult.DurationMs, + BatchJobName: jobName, + }, + } + + if imgResult.Result == nil { + return spec, fmt.Errorf("nil dive result for %s", imgResult.Ref) + } + + dive := imgResult.Result + + // Image size. + spec.ImageSizeBytes = int64(dive.Image.SizeBytes) + + // Analysis metrics. + spec.Analysis = v1.ImageAnalysis{ + Efficiency: formatFloat(dive.Image.EfficiencyScore), + WastedBytes: int64(dive.Image.InefficientBytes), + UserWastedPercent: computeUserWastedPercent(dive.Image.InefficientBytes, dive.Image.SizeBytes), + LayerCount: len(dive.Layer), + } + + // Evaluate pass/fail against thresholds. + spec.Analysis.Passed = rc.evaluateThresholds(spec.Analysis) + + // Map layers (command truncated to 200 chars). + spec.Analysis.Layers = make([]v1.LayerInfo, 0, len(dive.Layer)) + for _, layer := range dive.Layer { + spec.Analysis.Layers = append(spec.Analysis.Layers, v1.LayerInfo{ + Index: layer.Index, + Digest: layer.DigestID, + SizeBytes: int64(layer.SizeBytes), + Command: truncateString(layer.Command, maxCommandLength), + }) + } + + // Map wasted files (capped at 50, sorted by size desc). + if len(dive.Image.FileReference) > 0 { + // Sort by size descending. + refs := make([]DiveFileRef, len(dive.Image.FileReference)) + copy(refs, dive.Image.FileReference) + sort.Slice(refs, func(i, j int) bool { + return refs[i].SizeBytes > refs[j].SizeBytes + }) + + cap := maxWastedFiles + if len(refs) < cap { + cap = len(refs) + } + spec.Analysis.WastedFiles = make([]v1.WastedFile, 0, cap) + for _, ref := range refs[:cap] { + spec.Analysis.WastedFiles = append(spec.Analysis.WastedFiles, v1.WastedFile{ + Path: ref.File, + SizeBytes: int64(ref.SizeBytes), + }) + } + } + + // Compute file analysis from layer file lists (if available). + spec.Analysis.FileAnalysis = computeFileAnalysis(dive.Layer) + + // Map workload references. + spec.WorkloadReferences, spec.WorkloadSummary = buildWorkloadData( + imgResult.Digest, workloadRefs, + ) + + return spec, nil +} + +// evaluateThresholds checks if analysis metrics pass the configured thresholds. +func (rc *ResultCollector) evaluateThresholds(analysis v1.ImageAnalysis) bool { + // Check efficiency >= lowestEfficiency. + efficiency, err := strconv.ParseFloat(analysis.Efficiency, 64) + if err == nil && efficiency < rc.config.LowestEfficiency { + return false + } + + // Check wastedBytes <= highestWastedBytes. + maxWastedBytes := parseByteSize(rc.config.HighestWastedBytes) + if maxWastedBytes > 0 && analysis.WastedBytes > maxWastedBytes { + return false + } + + // Check userWastedPercent <= highestUserWastedPercent. + userWasted, err := strconv.ParseFloat(analysis.UserWastedPercent, 64) + if err == nil && userWasted > rc.config.HighestUserWastedPercent { + return false + } + + return true +} + +// --- Helper functions --- + +// findLatestPod returns the most recently created pod from a list. +func findLatestPod(pods []corev1.Pod) *corev1.Pod { + if len(pods) == 0 { + return nil + } + latest := &pods[0] + for i := 1; i < len(pods); i++ { + if pods[i].CreationTimestamp.After(latest.CreationTimestamp.Time) { + latest = &pods[i] + } + } + return latest +} + +// generateCRDName creates a deterministic CRD name from an image digest. +// Input: "docker.io/library/nginx@sha256:a1b2c3d4e5f6..." or "sha256:a1b2c3d4e5f6..." +// Output: "sha-a1b2c3d4e5f6" +func generateCRDName(digest string) string { + // Extract hex portion after "sha256:". + hex := digest + if idx := strings.LastIndex(digest, "sha256:"); idx >= 0 { + hex = digest[idx+len("sha256:"):] + } + + // Take first 12 hex chars. + if len(hex) > 12 { + hex = hex[:12] + } + + // Ensure only hex characters. + cleaned := strings.Map(func(r rune) rune { + if (r >= '0' && r <= '9') || (r >= 'a' && r <= 'f') { + return r + } + return -1 + }, strings.ToLower(hex)) + + if cleaned == "" { + // Fallback: hash the whole digest string. + cleaned = sanitizeDNSName(digest) + if len(cleaned) > 12 { + cleaned = cleaned[:12] + } + } + + return "sha-" + cleaned +} + +// parseImageRegistryAndRepo extracts the registry and repository from an image reference. +// "docker.io/library/nginx:1.25.3" → ("docker.io", "library-nginx") +// "gcr.io/myproject/myapp:v1" → ("gcr.io", "myproject-myapp") +func parseImageRegistryAndRepo(ref string) (registry, repo string) { + // Strip tag or digest. + if idx := strings.LastIndex(ref, ":"); idx > 0 { + // Make sure this isn't a port number. + afterColon := ref[idx+1:] + if !strings.Contains(afterColon, "/") { + ref = ref[:idx] + } + } + if idx := strings.Index(ref, "@"); idx > 0 { + ref = ref[:idx] + } + + parts := strings.SplitN(ref, "/", 2) + if len(parts) == 1 { + // No registry prefix (e.g., "nginx"). + return "docker.io", parts[0] + } + + // Check if first part looks like a registry (contains a dot or colon). + if strings.Contains(parts[0], ".") || strings.Contains(parts[0], ":") { + registry = parts[0] + repo = strings.ReplaceAll(parts[1], "/", "-") + } else { + // No registry (e.g., "library/nginx"). + registry = "docker.io" + repo = strings.ReplaceAll(ref, "/", "-") + } + + return registry, repo +} + +// computeUserWastedPercent calculates the ratio of wasted bytes to total image size. +func computeUserWastedPercent(inefficientBytes, sizeBytes uint64) string { + if sizeBytes == 0 { + return "0" + } + ratio := float64(inefficientBytes) / float64(sizeBytes) + return formatFloat(ratio) +} + +// computeFileAnalysis aggregates file statistics from dive layer file lists. +func computeFileAnalysis(layers []DiveLayer) *v1.FileAnalysis { + if len(layers) == 0 { + return nil + } + + // Check if any layer has file list data. + hasFileData := false + for _, l := range layers { + if len(l.FileList) > 0 { + hasFileData = true + break + } + } + if !hasFileData { + return nil + } + + // Track files across layers: path → first layer index seen. + seenFiles := make(map[string]int) + fa := &v1.FileAnalysis{} + + for _, layer := range layers { + for _, file := range layer.FileList { + if file.IsDir { + continue + } + + if _, seen := seenFiles[file.Path]; !seen { + // First time seeing this file → added. + seenFiles[file.Path] = layer.Index + fa.AddedFiles++ + } else { + // Seen before → modified (or removed and re-added). + fa.ModifiedFiles++ + } + } + } + + fa.TotalFiles = len(seenFiles) + // Note: removedFiles requires whiteout detection (typeFlag analysis). + // For now, we leave it as 0 since dive's fileList doesn't clearly distinguish removals. + + return fa +} + +// buildWorkloadData constructs WorkloadReferences and WorkloadSummary from discovery data. +func buildWorkloadData(digest string, workloadRefs WorkloadRefMap) ([]v1.WorkloadReference, v1.WorkloadSummary) { + discoveredRefs := workloadRefs[digest] + if len(discoveredRefs) == 0 { + return nil, v1.WorkloadSummary{} + } + + // Convert DiscoveredWorkloadRef → v1.WorkloadReference. + refs := make([]v1.WorkloadReference, 0, len(discoveredRefs)) + namespaceSet := make(map[string]struct{}) + totalContainers := 0 + + for _, dRef := range discoveredRefs { + containerNames := make([]string, 0, len(dRef.ContainerNames)) + for name := range dRef.ContainerNames { + containerNames = append(containerNames, name) + } + sort.Strings(containerNames) + + refs = append(refs, v1.WorkloadReference{ + Namespace: dRef.Namespace, + WorkloadType: dRef.WorkloadType, + WorkloadName: dRef.WorkloadName, + WorkloadUID: dRef.WorkloadUID, + ContainerNames: containerNames, + // Note: Replicas is not available from discovery (would require querying each workload). + }) + + namespaceSet[dRef.Namespace] = struct{}{} + totalContainers += len(containerNames) + } + + // Sort by replica count desc (since we don't have replicas, sort by container count desc). + sort.Slice(refs, func(i, j int) bool { + return len(refs[i].ContainerNames) > len(refs[j].ContainerNames) + }) + + // Cap at maxWorkloadRefs. + if len(refs) > maxWorkloadRefs { + refs = refs[:maxWorkloadRefs] + } + + // Build namespace list. + namespaces := make([]string, 0, len(namespaceSet)) + for ns := range namespaceSet { + namespaces = append(namespaces, ns) + } + sort.Strings(namespaces) + + summary := v1.WorkloadSummary{ + TotalContainers: totalContainers, + TotalWorkloads: len(discoveredRefs), + Namespaces: namespaces, + // NodesRunningImage is not available from discovery (would require cross-referencing). + } + + return refs, summary +} + +// formatFloat formats a float64 to a string with up to 4 decimal places, trimming trailing zeros. +func formatFloat(f float64) string { + s := strconv.FormatFloat(f, 'f', 4, 64) + // Trim trailing zeros after decimal point. + if strings.Contains(s, ".") { + s = strings.TrimRight(s, "0") + s = strings.TrimRight(s, ".") + } + if s == "" { + return "0" + } + return s +} + +// truncateString truncates a string to maxLen characters. +func truncateString(s string, maxLen int) string { + if len(s) <= maxLen { + return s + } + return s[:maxLen] +} + +// parseByteSize parses a human-readable byte size string (e.g., "50MB", "1GB", "100KB") to bytes. +// Returns 0 if the string can't be parsed. +func parseByteSize(s string) int64 { + s = strings.TrimSpace(s) + if s == "" { + return 0 + } + + // Split into numeric part and unit suffix. + i := 0 + for i < len(s) && (s[i] == '.' || (s[i] >= '0' && s[i] <= '9')) { + i++ + } + + numStr := s[:i] + unit := strings.TrimSpace(s[i:]) + + num, err := strconv.ParseFloat(numStr, 64) + if err != nil { + return 0 + } + + // Normalize unit to uppercase, trimmed. + unit = strings.ToUpper(strings.TrimFunc(unit, func(r rune) bool { + return unicode.IsSpace(r) + })) + + var multiplier float64 + switch unit { + case "B", "": + multiplier = 1 + case "KB", "K": + multiplier = 1000 + case "MB", "M": + multiplier = 1000 * 1000 + case "GB", "G": + multiplier = 1000 * 1000 * 1000 + case "TB", "T": + multiplier = 1000 * 1000 * 1000 * 1000 + case "KIB", "KI": + multiplier = 1024 + case "MIB", "MI": + multiplier = 1024 * 1024 + case "GIB", "GI": + multiplier = 1024 * 1024 * 1024 + default: + return 0 + } + + return int64(num * multiplier) +} diff --git a/internal/controller/image_result_collector_test.go b/internal/controller/image_result_collector_test.go new file mode 100644 index 00000000..8fd44b25 --- /dev/null +++ b/internal/controller/image_result_collector_test.go @@ -0,0 +1,934 @@ +/* +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controller + +import ( + "encoding/json" + "fmt" + "testing" + + v1 "github.com/devzero-inc/zxporter/api/v1" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// ============================================================================= +// Unit Tests: generateCRDName +// ============================================================================= + +func TestGenerateCRDName_BasicSha256(t *testing.T) { + name := generateCRDName("sha256:a1b2c3d4e5f6a7b8c9d0e1f2") + if name != "sha-a1b2c3d4e5f6" { + t.Errorf("expected sha-a1b2c3d4e5f6, got %s", name) + } +} + +func TestGenerateCRDName_WithRegistryPrefix(t *testing.T) { + name := generateCRDName("docker.io/library/nginx@sha256:abcdef123456789abcdef") + if name != "sha-abcdef123456" { + t.Errorf("expected sha-abcdef123456, got %s", name) + } +} + +func TestGenerateCRDName_ShortHex(t *testing.T) { + name := generateCRDName("sha256:abc") + if name != "sha-abc" { + t.Errorf("expected sha-abc, got %s", name) + } +} + +func TestGenerateCRDName_UppercaseHex(t *testing.T) { + name := generateCRDName("sha256:AABBCCDDEE11") + if name != "sha-aabbccddee11" { + t.Errorf("expected sha-aabbccddee11, got %s", name) + } +} + +func TestGenerateCRDName_NoSha256Prefix(t *testing.T) { + // Falls through to cleaned hex logic — no sha256: prefix, so it tries to use the whole string as hex. + name := generateCRDName("notahexstring") + // Should fall back to sanitizeDNSName since no valid hex chars after filtering. + if name == "" { + t.Error("expected non-empty name") + } + if len(name) < 4 { // at minimum "sha-" + t.Errorf("expected name starting with sha-, got %s", name) + } +} + +func TestGenerateCRDName_EmptyDigest(t *testing.T) { + // Empty digest has no hex chars and sanitizeDNSName("") returns "", so we get "sha-". + // This is an edge case that shouldn't happen in practice (digest is always non-empty). + name := generateCRDName("") + if name == "" { + t.Error("expected non-empty name") + } +} + +// ============================================================================= +// Unit Tests: parseImageRegistryAndRepo +// ============================================================================= + +func TestParseImageRegistryAndRepo(t *testing.T) { + tests := []struct { + ref string + wantRegistry string + wantRepo string + }{ + {"docker.io/library/nginx:1.25.3", "docker.io", "library-nginx"}, + {"gcr.io/myproject/myapp:v1", "gcr.io", "myproject-myapp"}, + {"nginx:latest", "docker.io", "nginx"}, + {"nginx", "docker.io", "nginx"}, + {"registry.example.com:5000/repo/image:tag", "registry.example.com:5000", "repo-image"}, + {"quay.io/prometheus/node-exporter:v1.6.0", "quay.io", "prometheus-node-exporter"}, + {"docker.io/library/nginx@sha256:abc123", "docker.io", "library-nginx"}, + {"library/nginx", "docker.io", "library-nginx"}, + } + + for _, tt := range tests { + t.Run(tt.ref, func(t *testing.T) { + reg, repo := parseImageRegistryAndRepo(tt.ref) + if reg != tt.wantRegistry { + t.Errorf("registry: got %q, want %q", reg, tt.wantRegistry) + } + if repo != tt.wantRepo { + t.Errorf("repo: got %q, want %q", repo, tt.wantRepo) + } + }) + } +} + +// ============================================================================= +// Unit Tests: computeUserWastedPercent +// ============================================================================= + +func TestComputeUserWastedPercent(t *testing.T) { + tests := []struct { + name string + inefficient uint64 + size uint64 + want string + }{ + {"zero size", 100, 0, "0"}, + {"no waste", 0, 1000000, "0"}, + {"10% waste", 100000, 1000000, "0.1"}, + {"50% waste", 500000, 1000000, "0.5"}, + {"100% waste", 1000000, 1000000, "1"}, + {"tiny fraction", 1, 1000000, "0"}, // formatFloat uses 4 decimal places, 0.000001 rounds to "0" + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := computeUserWastedPercent(tt.inefficient, tt.size) + if got != tt.want { + t.Errorf("got %q, want %q", got, tt.want) + } + }) + } +} + +// ============================================================================= +// Unit Tests: formatFloat +// ============================================================================= + +func TestFormatFloat(t *testing.T) { + tests := []struct { + input float64 + want string + }{ + {0.0, "0"}, + {1.0, "1"}, + {0.95, "0.95"}, + {0.9516, "0.9516"}, + {0.12340, "0.1234"}, + {0.10, "0.1"}, + {0.001, "0.001"}, + {99.99, "99.99"}, + } + + for _, tt := range tests { + t.Run(tt.want, func(t *testing.T) { + got := formatFloat(tt.input) + if got != tt.want { + t.Errorf("formatFloat(%v) = %q, want %q", tt.input, got, tt.want) + } + }) + } +} + +// ============================================================================= +// Unit Tests: truncateString +// ============================================================================= + +func TestTruncateString(t *testing.T) { + if got := truncateString("hello", 10); got != "hello" { + t.Errorf("expected hello, got %s", got) + } + if got := truncateString("hello world", 5); got != "hello" { + t.Errorf("expected hello, got %s", got) + } + if got := truncateString("", 5); got != "" { + t.Errorf("expected empty, got %s", got) + } + if got := truncateString("exact", 5); got != "exact" { + t.Errorf("expected exact, got %s", got) + } +} + +// ============================================================================= +// Unit Tests: parseByteSize +// ============================================================================= + +func TestParseByteSize(t *testing.T) { + tests := []struct { + input string + want int64 + }{ + {"", 0}, + {"0", 0}, + {"100B", 100}, + {"100", 100}, + {"1KB", 1000}, + {"1K", 1000}, + {"50MB", 50000000}, + {"50M", 50000000}, + {"1GB", 1000000000}, + {"1G", 1000000000}, + {"1TB", 1000000000000}, + {"1KiB", 1024}, + {"1MiB", 1048576}, + {"1GiB", 1073741824}, + {"1.5GB", 1500000000}, + {"0.5MB", 500000}, + {"invalid", 0}, + {"MB", 0}, + {" 50MB ", 50000000}, + } + + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + got := parseByteSize(tt.input) + if got != tt.want { + t.Errorf("parseByteSize(%q) = %d, want %d", tt.input, got, tt.want) + } + }) + } +} + +// ============================================================================= +// Unit Tests: computeFileAnalysis +// ============================================================================= + +func TestComputeFileAnalysis_EmptyLayers(t *testing.T) { + result := computeFileAnalysis(nil) + if result != nil { + t.Error("expected nil for empty layers") + } +} + +func TestComputeFileAnalysis_NoFileData(t *testing.T) { + layers := []DiveLayer{ + {Index: 0, Command: "FROM alpine"}, + {Index: 1, Command: "RUN apk add bash"}, + } + result := computeFileAnalysis(layers) + if result != nil { + t.Error("expected nil when no layers have file lists") + } +} + +func TestComputeFileAnalysis_WithFiles(t *testing.T) { + layers := []DiveLayer{ + { + Index: 0, + Command: "FROM alpine", + FileList: []DiveFile{ + {Path: "/bin/sh", Size: 100, IsDir: false}, + {Path: "/etc/passwd", Size: 200, IsDir: false}, + {Path: "/usr", Size: 0, IsDir: true}, // dirs should be skipped + }, + }, + { + Index: 1, + Command: "RUN apk add bash", + FileList: []DiveFile{ + {Path: "/bin/bash", Size: 500, IsDir: false}, // new file → added + {Path: "/etc/passwd", Size: 250, IsDir: false}, // already seen → modified + }, + }, + } + + result := computeFileAnalysis(layers) + if result == nil { + t.Fatal("expected non-nil result") + } + + // /bin/sh added in layer 0, /etc/passwd added in layer 0, /bin/bash added in layer 1 + if result.AddedFiles != 3 { + t.Errorf("AddedFiles: got %d, want 3", result.AddedFiles) + } + // /etc/passwd modified in layer 1 + if result.ModifiedFiles != 1 { + t.Errorf("ModifiedFiles: got %d, want 1", result.ModifiedFiles) + } + // Unique files: /bin/sh, /etc/passwd, /bin/bash + if result.TotalFiles != 3 { + t.Errorf("TotalFiles: got %d, want 3", result.TotalFiles) + } +} + +// ============================================================================= +// Unit Tests: buildWorkloadData +// ============================================================================= + +func TestBuildWorkloadData_EmptyRefs(t *testing.T) { + refs, summary := buildWorkloadData("sha256:abc123", WorkloadRefMap{}) + if refs != nil { + t.Error("expected nil refs for empty map") + } + if summary.TotalWorkloads != 0 { + t.Error("expected zero total workloads") + } +} + +func TestBuildWorkloadData_SingleRef(t *testing.T) { + workloadRefs := WorkloadRefMap{ + "sha256:abc123": { + { + Namespace: "default", + WorkloadType: "Deployment", + WorkloadName: "nginx", + WorkloadUID: "uid-123", + ContainerNames: map[string]struct{}{"web": {}, "sidecar": {}}, + }, + }, + } + + refs, summary := buildWorkloadData("sha256:abc123", workloadRefs) + + if len(refs) != 1 { + t.Fatalf("expected 1 ref, got %d", len(refs)) + } + if refs[0].Namespace != "default" { + t.Errorf("namespace: got %q", refs[0].Namespace) + } + if refs[0].WorkloadType != "Deployment" { + t.Errorf("workloadType: got %q", refs[0].WorkloadType) + } + if len(refs[0].ContainerNames) != 2 { + t.Errorf("containerNames: got %d, want 2", len(refs[0].ContainerNames)) + } + if summary.TotalContainers != 2 { + t.Errorf("totalContainers: got %d, want 2", summary.TotalContainers) + } + if summary.TotalWorkloads != 1 { + t.Errorf("totalWorkloads: got %d, want 1", summary.TotalWorkloads) + } + if len(summary.Namespaces) != 1 || summary.Namespaces[0] != "default" { + t.Errorf("namespaces: got %v", summary.Namespaces) + } +} + +func TestBuildWorkloadData_MultipleNamespaces(t *testing.T) { + workloadRefs := WorkloadRefMap{ + "sha256:abc123": { + { + Namespace: "prod", + WorkloadType: "Deployment", + WorkloadName: "app", + WorkloadUID: "uid-1", + ContainerNames: map[string]struct{}{"main": {}}, + }, + { + Namespace: "staging", + WorkloadType: "Deployment", + WorkloadName: "app", + WorkloadUID: "uid-2", + ContainerNames: map[string]struct{}{"main": {}}, + }, + { + Namespace: "prod", + WorkloadType: "DaemonSet", + WorkloadName: "monitor", + WorkloadUID: "uid-3", + ContainerNames: map[string]struct{}{"agent": {}, "sidecar": {}, "exporter": {}}, + }, + }, + } + + refs, summary := buildWorkloadData("sha256:abc123", workloadRefs) + + if len(refs) != 3 { + t.Fatalf("expected 3 refs, got %d", len(refs)) + } + + // Should be sorted by container count desc → DaemonSet (3) first. + if refs[0].WorkloadName != "monitor" { + t.Errorf("first ref should be monitor (3 containers), got %s (%d containers)", + refs[0].WorkloadName, len(refs[0].ContainerNames)) + } + + if summary.TotalWorkloads != 3 { + t.Errorf("totalWorkloads: got %d, want 3", summary.TotalWorkloads) + } + if summary.TotalContainers != 5 { + t.Errorf("totalContainers: got %d, want 5", summary.TotalContainers) + } + + // Namespaces should be sorted. + if len(summary.Namespaces) != 2 { + t.Fatalf("expected 2 namespaces, got %d", len(summary.Namespaces)) + } + if summary.Namespaces[0] != "prod" || summary.Namespaces[1] != "staging" { + t.Errorf("namespaces: got %v, want [prod staging]", summary.Namespaces) + } +} + +func TestBuildWorkloadData_WrongDigest(t *testing.T) { + workloadRefs := WorkloadRefMap{ + "sha256:abc123": { + { + Namespace: "default", + WorkloadType: "Deployment", + WorkloadName: "nginx", + WorkloadUID: "uid-123", + ContainerNames: map[string]struct{}{"web": {}}, + }, + }, + } + + refs, summary := buildWorkloadData("sha256:different", workloadRefs) + if refs != nil { + t.Error("expected nil refs for non-matching digest") + } + if summary.TotalWorkloads != 0 { + t.Error("expected zero total workloads") + } +} + +func TestBuildWorkloadData_ContainerNamesSorted(t *testing.T) { + workloadRefs := WorkloadRefMap{ + "sha256:abc123": { + { + Namespace: "default", + WorkloadType: "Deployment", + WorkloadName: "app", + WorkloadUID: "uid-1", + ContainerNames: map[string]struct{}{"zebra": {}, "alpha": {}, "mid": {}}, + }, + }, + } + + refs, _ := buildWorkloadData("sha256:abc123", workloadRefs) + if len(refs) != 1 { + t.Fatal("expected 1 ref") + } + + names := refs[0].ContainerNames + if len(names) != 3 { + t.Fatalf("expected 3 names, got %d", len(names)) + } + if names[0] != "alpha" || names[1] != "mid" || names[2] != "zebra" { + t.Errorf("expected [alpha mid zebra], got %v", names) + } +} + +// ============================================================================= +// Unit Tests: evaluateThresholds +// ============================================================================= + +func TestEvaluateThresholds_AllPass(t *testing.T) { + rc := &ResultCollector{ + config: ImageAnalysisConfig{ + LowestEfficiency: 0.9, + HighestWastedBytes: "50MB", + HighestUserWastedPercent: 0.1, + }, + } + + analysis := v1.ImageAnalysis{ + Efficiency: "0.95", + WastedBytes: 1000000, // 1MB < 50MB + UserWastedPercent: "0.01", // 1% < 10% + } + + if !rc.evaluateThresholds(analysis) { + t.Error("expected pass") + } +} + +func TestEvaluateThresholds_FailEfficiency(t *testing.T) { + rc := &ResultCollector{ + config: ImageAnalysisConfig{ + LowestEfficiency: 0.9, + HighestWastedBytes: "50MB", + HighestUserWastedPercent: 0.1, + }, + } + + analysis := v1.ImageAnalysis{ + Efficiency: "0.85", // Below 0.9 + WastedBytes: 1000000, + UserWastedPercent: "0.01", + } + + if rc.evaluateThresholds(analysis) { + t.Error("expected fail due to low efficiency") + } +} + +func TestEvaluateThresholds_FailWastedBytes(t *testing.T) { + rc := &ResultCollector{ + config: ImageAnalysisConfig{ + LowestEfficiency: 0.9, + HighestWastedBytes: "50MB", + HighestUserWastedPercent: 0.1, + }, + } + + analysis := v1.ImageAnalysis{ + Efficiency: "0.95", + WastedBytes: 60000000, // 60MB > 50MB + UserWastedPercent: "0.01", + } + + if rc.evaluateThresholds(analysis) { + t.Error("expected fail due to high wasted bytes") + } +} + +func TestEvaluateThresholds_FailUserWastedPercent(t *testing.T) { + rc := &ResultCollector{ + config: ImageAnalysisConfig{ + LowestEfficiency: 0.9, + HighestWastedBytes: "50MB", + HighestUserWastedPercent: 0.1, + }, + } + + analysis := v1.ImageAnalysis{ + Efficiency: "0.95", + WastedBytes: 1000000, + UserWastedPercent: "0.15", // 15% > 10% + } + + if rc.evaluateThresholds(analysis) { + t.Error("expected fail due to high user wasted percent") + } +} + +func TestEvaluateThresholds_ZeroThresholds(t *testing.T) { + // Zero thresholds: maxWastedBytes=0 means no check. + rc := &ResultCollector{ + config: ImageAnalysisConfig{ + LowestEfficiency: 0.0, + HighestWastedBytes: "", + HighestUserWastedPercent: 0.0, + }, + } + + analysis := v1.ImageAnalysis{ + Efficiency: "0.5", + WastedBytes: 999999999, + UserWastedPercent: "0", + } + + // Everything >= 0 for efficiency, no wasted bytes check, userWasted=0 is not > 0. + if !rc.evaluateThresholds(analysis) { + t.Error("expected pass with zero thresholds") + } +} + +// ============================================================================= +// Unit Tests: findLatestPod +// ============================================================================= + +func TestFindLatestPod_Empty(t *testing.T) { + pod := findLatestPod(nil) + if pod != nil { + t.Error("expected nil for empty slice") + } +} + +func TestFindLatestPod_Single(t *testing.T) { + pods := []corev1.Pod{ + {ObjectMeta: metav1.ObjectMeta{Name: "pod-1"}}, + } + pod := findLatestPod(pods) + if pod.Name != "pod-1" { + t.Errorf("expected pod-1, got %s", pod.Name) + } +} + +func TestFindLatestPod_Multiple(t *testing.T) { + now := metav1.Now() + earlier := metav1.NewTime(now.Add(-60 * 1e9)) + pods := []corev1.Pod{ + {ObjectMeta: metav1.ObjectMeta{Name: "pod-old", CreationTimestamp: earlier}}, + {ObjectMeta: metav1.ObjectMeta{Name: "pod-new", CreationTimestamp: now}}, + } + pod := findLatestPod(pods) + if pod.Name != "pod-new" { + t.Errorf("expected pod-new, got %s", pod.Name) + } +} + +// ============================================================================= +// Unit Tests: Dive JSON types (marshal/unmarshal) +// ============================================================================= + +func TestBatchImageResult_Unmarshal(t *testing.T) { + jsonLine := `{"digest":"sha256:abc123","ref":"docker.io/nginx:1.25","source":"local-containerd","durationMs":5000,"error":"","result":{"image":{"sizeBytes":50000000,"inefficientBytes":500000,"efficiencyScore":0.99,"fileReference":[{"count":2,"sizeBytes":1024,"file":"/tmp/cache"}]},"layer":[{"index":0,"id":"layer0","digestId":"sha256:layer0","sizeBytes":30000000,"command":"FROM alpine","fileList":[]}]}}` + + var result BatchImageResult + if err := json.Unmarshal([]byte(jsonLine), &result); err != nil { + t.Fatalf("unmarshal failed: %v", err) + } + + if result.Digest != "sha256:abc123" { + t.Errorf("digest: got %q", result.Digest) + } + if result.Source != "local-containerd" { + t.Errorf("source: got %q", result.Source) + } + if result.DurationMs != 5000 { + t.Errorf("durationMs: got %d", result.DurationMs) + } + if result.Result == nil { + t.Fatal("result should not be nil") + } + if result.Result.Image.SizeBytes != 50000000 { + t.Errorf("sizeBytes: got %d", result.Result.Image.SizeBytes) + } + if result.Result.Image.EfficiencyScore != 0.99 { + t.Errorf("efficiencyScore: got %f", result.Result.Image.EfficiencyScore) + } + if len(result.Result.Image.FileReference) != 1 { + t.Fatalf("fileReference count: got %d", len(result.Result.Image.FileReference)) + } + if result.Result.Image.FileReference[0].File != "/tmp/cache" { + t.Errorf("fileRef file: got %q", result.Result.Image.FileReference[0].File) + } + if len(result.Result.Layer) != 1 { + t.Fatalf("layer count: got %d", len(result.Result.Layer)) + } + if result.Result.Layer[0].Command != "FROM alpine" { + t.Errorf("layer command: got %q", result.Result.Layer[0].Command) + } +} + +func TestBatchImageResult_FailedImage(t *testing.T) { + jsonLine := `{"digest":"sha256:def456","ref":"private.registry/app:v1","source":"failed","durationMs":1000,"error":"image acquisition failed","result":null}` + + var result BatchImageResult + if err := json.Unmarshal([]byte(jsonLine), &result); err != nil { + t.Fatalf("unmarshal failed: %v", err) + } + + if result.Source != "failed" { + t.Errorf("source: got %q", result.Source) + } + if result.Error != "image acquisition failed" { + t.Errorf("error: got %q", result.Error) + } + if result.Result != nil { + t.Error("result should be nil for failed image") + } +} + +// ============================================================================= +// Unit Tests: buildSpec +// ============================================================================= + +func TestBuildSpec_FullResult(t *testing.T) { + rc := &ResultCollector{ + config: ImageAnalysisConfig{ + LowestEfficiency: 0.9, + HighestWastedBytes: "50MB", + HighestUserWastedPercent: 0.1, + }, + } + + imgResult := BatchImageResult{ + Digest: "sha256:abc123def456", + Ref: "docker.io/library/nginx:1.25", + Source: "local-containerd", + DurationMs: 3000, + Result: &DiveResult{ + Image: DiveImage{ + SizeBytes: 100000000, + InefficientBytes: 5000000, + EfficiencyScore: 0.95, + FileReference: []DiveFileRef{ + {Count: 2, SizeBytes: 2000000, File: "/var/cache/apt"}, + {Count: 1, SizeBytes: 1000000, File: "/tmp/build"}, + {Count: 3, SizeBytes: 3000000, File: "/root/.cache"}, + }, + }, + Layer: []DiveLayer{ + {Index: 0, DigestID: "sha256:base", SizeBytes: 50000000, Command: "FROM alpine:3.21"}, + {Index: 1, DigestID: "sha256:layer1", SizeBytes: 30000000, Command: "RUN apk add --no-cache bash jq coreutils"}, + {Index: 2, DigestID: "sha256:layer2", SizeBytes: 20000000, Command: "COPY --from=gcr.io/go-containerregistry/crane:latest /ko-app/crane /usr/local/bin/crane"}, + }, + }, + } + + workloadRefs := WorkloadRefMap{ + "sha256:abc123def456": { + { + Namespace: "production", + WorkloadType: "Deployment", + WorkloadName: "web-server", + WorkloadUID: "uid-web", + ContainerNames: map[string]struct{}{"nginx": {}}, + }, + }, + } + + spec, err := rc.buildSpec(imgResult, "analyze-job-1", "node-1", workloadRefs) + if err != nil { + t.Fatalf("buildSpec error: %v", err) + } + + // Basic fields. + if spec.ImageRef != "docker.io/library/nginx:1.25" { + t.Errorf("imageRef: got %q", spec.ImageRef) + } + if spec.ImageDigest != "sha256:abc123def456" { + t.Errorf("imageDigest: got %q", spec.ImageDigest) + } + if spec.ImageSizeBytes != 100000000 { + t.Errorf("imageSizeBytes: got %d", spec.ImageSizeBytes) + } + + // Source info. + if spec.ImageSource.Type != "local-containerd" { + t.Errorf("source type: got %q", spec.ImageSource.Type) + } + if spec.ImageSource.NodeName != "node-1" { + t.Errorf("source node: got %q", spec.ImageSource.NodeName) + } + if spec.ImageSource.BatchJobName != "analyze-job-1" { + t.Errorf("source job: got %q", spec.ImageSource.BatchJobName) + } + + // Analysis. + if spec.Analysis.Efficiency != "0.95" { + t.Errorf("efficiency: got %q", spec.Analysis.Efficiency) + } + if spec.Analysis.WastedBytes != 5000000 { + t.Errorf("wastedBytes: got %d", spec.Analysis.WastedBytes) + } + if spec.Analysis.UserWastedPercent != "0.05" { + t.Errorf("userWastedPercent: got %q", spec.Analysis.UserWastedPercent) + } + if spec.Analysis.LayerCount != 3 { + t.Errorf("layerCount: got %d", spec.Analysis.LayerCount) + } + if !spec.Analysis.Passed { + t.Error("expected passed=true (efficiency 0.95 >= 0.9, wasted 5MB < 50MB, userWasted 5% < 10%)") + } + + // Layers. + if len(spec.Analysis.Layers) != 3 { + t.Fatalf("layers count: got %d", len(spec.Analysis.Layers)) + } + if spec.Analysis.Layers[0].Digest != "sha256:base" { + t.Errorf("layer 0 digest: got %q", spec.Analysis.Layers[0].Digest) + } + + // Wasted files: sorted by size desc, so /root/.cache (3MB) first. + if len(spec.Analysis.WastedFiles) != 3 { + t.Fatalf("wastedFiles count: got %d", len(spec.Analysis.WastedFiles)) + } + if spec.Analysis.WastedFiles[0].Path != "/root/.cache" { + t.Errorf("first wasted file: got %q", spec.Analysis.WastedFiles[0].Path) + } + if spec.Analysis.WastedFiles[0].SizeBytes != 3000000 { + t.Errorf("first wasted file size: got %d", spec.Analysis.WastedFiles[0].SizeBytes) + } + + // Workload references. + if len(spec.WorkloadReferences) != 1 { + t.Fatalf("workloadRefs count: got %d", len(spec.WorkloadReferences)) + } + if spec.WorkloadReferences[0].WorkloadName != "web-server" { + t.Errorf("workload name: got %q", spec.WorkloadReferences[0].WorkloadName) + } + if spec.WorkloadSummary.TotalWorkloads != 1 { + t.Errorf("total workloads: got %d", spec.WorkloadSummary.TotalWorkloads) + } +} + +func TestBuildSpec_NilResult(t *testing.T) { + rc := &ResultCollector{ + config: DefaultImageAnalysisConfig(), + } + + imgResult := BatchImageResult{ + Digest: "sha256:abc123", + Ref: "nginx:latest", + Result: nil, + } + + _, err := rc.buildSpec(imgResult, "job-1", "node-1", WorkloadRefMap{}) + if err == nil { + t.Error("expected error for nil result") + } +} + +func TestBuildSpec_LayerCommandTruncation(t *testing.T) { + rc := &ResultCollector{ + config: DefaultImageAnalysisConfig(), + } + + // Create a very long command. + longCommand := "" + for i := 0; i < 300; i++ { + longCommand += "x" + } + + imgResult := BatchImageResult{ + Digest: "sha256:abc123", + Ref: "nginx:latest", + Source: "local-containerd", + Result: &DiveResult{ + Image: DiveImage{SizeBytes: 100, EfficiencyScore: 1.0}, + Layer: []DiveLayer{ + {Index: 0, Command: longCommand, SizeBytes: 100}, + }, + }, + } + + spec, err := rc.buildSpec(imgResult, "job-1", "node-1", WorkloadRefMap{}) + if err != nil { + t.Fatalf("buildSpec error: %v", err) + } + + if len(spec.Analysis.Layers[0].Command) != maxCommandLength { + t.Errorf("command length: got %d, want %d", len(spec.Analysis.Layers[0].Command), maxCommandLength) + } +} + +func TestBuildSpec_WastedFilesCapped(t *testing.T) { + rc := &ResultCollector{ + config: DefaultImageAnalysisConfig(), + } + + // Create more than maxWastedFiles file references. + fileRefs := make([]DiveFileRef, 100) + for i := 0; i < 100; i++ { + fileRefs[i] = DiveFileRef{ + Count: 1, + SizeBytes: uint64(100 - i), // descending to test sort + File: fmt.Sprintf("/file-%d", i), + } + } + + imgResult := BatchImageResult{ + Digest: "sha256:abc123", + Ref: "nginx:latest", + Source: "local-containerd", + Result: &DiveResult{ + Image: DiveImage{ + SizeBytes: 100000, + EfficiencyScore: 0.95, + FileReference: fileRefs, + }, + Layer: []DiveLayer{{Index: 0, SizeBytes: 100000}}, + }, + } + + spec, err := rc.buildSpec(imgResult, "job-1", "node-1", WorkloadRefMap{}) + if err != nil { + t.Fatalf("buildSpec error: %v", err) + } + + if len(spec.Analysis.WastedFiles) != maxWastedFiles { + t.Errorf("wasted files count: got %d, want %d", len(spec.Analysis.WastedFiles), maxWastedFiles) + } + + // Verify sorted by size desc — first should be the largest. + if spec.Analysis.WastedFiles[0].SizeBytes != 100 { + t.Errorf("first wasted file size: got %d, want 100", spec.Analysis.WastedFiles[0].SizeBytes) + } +} + +// ============================================================================= +// Unit Tests: NDJSON parsing edge cases (via classification logic) +// ============================================================================= + +func TestCollectionResult_Classification(t *testing.T) { + // Simulate the classification logic from CollectFromJob. + tests := []struct { + name string + result BatchImageResult + wantCat string // "succeeded" or "failed" + }{ + { + name: "local-containerd success", + result: BatchImageResult{Source: "local-containerd", Error: ""}, + wantCat: "succeeded", + }, + { + name: "remote-pull success", + result: BatchImageResult{Source: "remote-pull", Error: ""}, + wantCat: "succeeded", + }, + { + name: "failed source", + result: BatchImageResult{Source: "failed", Error: "acquisition failed"}, + wantCat: "failed", + }, + { + name: "success source with error", + result: BatchImageResult{Source: "local-containerd", Error: "dive failed"}, + wantCat: "failed", + }, + { + name: "unknown source no error", + result: BatchImageResult{Source: "unknown", Error: ""}, + wantCat: "succeeded", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cr := &CollectionResult{} + + switch { + case tt.result.Source == "failed" || tt.result.Error != "": + cr.Failed = append(cr.Failed, tt.result) + case tt.result.Source == "local-containerd": + cr.Succeeded = append(cr.Succeeded, tt.result) + cr.LocalContainerd++ + case tt.result.Source == "remote-pull": + cr.Succeeded = append(cr.Succeeded, tt.result) + cr.RemotePull++ + default: + cr.Succeeded = append(cr.Succeeded, tt.result) + } + + if tt.wantCat == "succeeded" && len(cr.Succeeded) != 1 { + t.Errorf("expected 1 succeeded, got %d", len(cr.Succeeded)) + } + if tt.wantCat == "failed" && len(cr.Failed) != 1 { + t.Errorf("expected 1 failed, got %d", len(cr.Failed)) + } + }) + } +} From 5c4e13934350e67d6c60cb1337ef9f88ff69b1c8 Mon Sep 17 00:00:00 2001 From: Parthiba-Hazra Date: Mon, 30 Mar 2026 19:09:36 +0530 Subject: [PATCH 3/7] send image analysis result to control plane --- gen/api/v1/apiv1connect/k8s.connect.go | 204 +- .../apiv1connect/operator_health.connect.go | 56 +- gen/api/v1/common.pb.go | 8592 ++++++++++------- gen/api/v1/k8s.pb.go | 5429 ++++++----- gen/api/v1/k8s_grpc.pb.go | 244 +- gen/api/v1/metrics_collector.pb.go | 137 +- gen/api/v1/operator_health.pb.go | 734 +- gen/api/v1/operator_health_grpc.pb.go | 106 +- .../image_analysis_result_collector.go | 281 + .../collector/image_analysis_wire_format.go | 233 + internal/collector/interface.go | 4 + .../controller/collectionpolicy_controller.go | 11 + internal/transport/dakr_client.go | 35 + proto/dakr_proto_descriptor.bin | Bin 344150 -> 354973 bytes 14 files changed, 9032 insertions(+), 7034 deletions(-) create mode 100644 internal/collector/image_analysis_result_collector.go create mode 100644 internal/collector/image_analysis_wire_format.go diff --git a/gen/api/v1/apiv1connect/k8s.connect.go b/gen/api/v1/apiv1connect/k8s.connect.go index 5b14f2c0..db12a286 100644 --- a/gen/api/v1/apiv1connect/k8s.connect.go +++ b/gen/api/v1/apiv1connect/k8s.connect.go @@ -55,6 +55,9 @@ const ( // K8SServiceSearchNamespacesByClusterProcedure is the fully-qualified name of the K8SService's // SearchNamespacesByCluster RPC. K8SServiceSearchNamespacesByClusterProcedure = "/api.v1.K8SService/SearchNamespacesByCluster" + // K8SServiceListNamespacesByClusterProcedure is the fully-qualified name of the K8SService's + // ListNamespacesByCluster RPC. + K8SServiceListNamespacesByClusterProcedure = "/api.v1.K8SService/ListNamespacesByCluster" // K8SServiceGetAllWorkloadNamesProcedure is the fully-qualified name of the K8SService's // GetAllWorkloadNames RPC. K8SServiceGetAllWorkloadNamesProcedure = "/api.v1.K8SService/GetAllWorkloadNames" @@ -84,6 +87,15 @@ const ( K8SServiceGetWorkloadsProcedure = "/api.v1.K8SService/GetWorkloads" // K8SServiceGetWorkloadProcedure is the fully-qualified name of the K8SService's GetWorkload RPC. K8SServiceGetWorkloadProcedure = "/api.v1.K8SService/GetWorkload" + // K8SServiceGetWorkloadContainerPercentilesProcedure is the fully-qualified name of the + // K8SService's GetWorkloadContainerPercentiles RPC. + K8SServiceGetWorkloadContainerPercentilesProcedure = "/api.v1.K8SService/GetWorkloadContainerPercentiles" + // K8SServiceGetWorkloadContainerFsPercentilesProcedure is the fully-qualified name of the + // K8SService's GetWorkloadContainerFsPercentiles RPC. + K8SServiceGetWorkloadContainerFsPercentilesProcedure = "/api.v1.K8SService/GetWorkloadContainerFsPercentiles" + // K8SServiceGetLatestContainerRequestLimitsProcedure is the fully-qualified name of the + // K8SService's GetLatestContainerRequestLimits RPC. + K8SServiceGetLatestContainerRequestLimitsProcedure = "/api.v1.K8SService/GetLatestContainerRequestLimits" // K8SServiceGetForecastWorkloadsProcedure is the fully-qualified name of the K8SService's // GetForecastWorkloads RPC. K8SServiceGetForecastWorkloadsProcedure = "/api.v1.K8SService/GetForecastWorkloads" @@ -189,6 +201,8 @@ type K8SServiceClient interface { GetAllNamespaces(context.Context, *connect.Request[v1.GetAllNamespacesRequest]) (*connect.Response[v1.GetAllNamespacesResponse], error) // SearchNamespacesByCluster searches namespaces by name within a single cluster. SearchNamespacesByCluster(context.Context, *connect.Request[v1.SearchNamespacesByClusterRequest]) (*connect.Response[v1.SearchNamespacesByClusterResponse], error) + // ListNamespacesByCluster lists namespaces (id and name) within a single cluster. + ListNamespacesByCluster(context.Context, *connect.Request[v1.ListNamespacesByClusterRequest]) (*connect.Response[v1.ListNamespacesByClusterResponse], error) // GetAllWorkloadNames returns a list of all workload names for a team ID; if cluster list is empty, returns all. GetAllWorkloadNames(context.Context, *connect.Request[v1.GetAllWorkloadNamesRequest]) (*connect.Response[v1.GetAllWorkloadNamesResponse], error) // GetAllWorkloadLabels returns all workload labels for a team ID; if cluster list is empty, returns all. @@ -210,6 +224,16 @@ type K8SServiceClient interface { GetWorkloads(context.Context, *connect.Request[v1.GetWorkloadsRequest]) (*connect.Response[v1.GetWorkloadsResponse], error) // GetWorkload retrieves detailed information for a specific workload. GetWorkload(context.Context, *connect.Request[v1.GetWorkloadRequest]) (*connect.Response[v1.GetWorkloadResponse], error) + // GetWorkloadContainerPercentiles retrieves per-container percentile metrics for a workload. + // + // Note: fs_* and current_* fields in the response are no longer populated. + // Prefer GetWorkloadContainerFsPercentiles and GetLatestContainerRequestLimits + // for progressive loading. + GetWorkloadContainerPercentiles(context.Context, *connect.Request[v1.GetWorkloadContainerPercentilesRequest]) (*connect.Response[v1.GetWorkloadContainerPercentilesResponse], error) + // GetWorkloadContainerFsPercentiles retrieves per-container filesystem I/O percentiles for a workload. + GetWorkloadContainerFsPercentiles(context.Context, *connect.Request[v1.GetWorkloadContainerFsPercentilesRequest]) (*connect.Response[v1.GetWorkloadContainerFsPercentilesResponse], error) + // GetLatestContainerRequestLimits retrieves the most recent request/limit values per container for a workload. + GetLatestContainerRequestLimits(context.Context, *connect.Request[v1.GetLatestContainerRequestLimitsRequest]) (*connect.Response[v1.GetLatestContainerRequestLimitsResponse], error) // GetForecastWorkloads retrieves all workloads for a specific cluster. // // Deprecated: do not use. @@ -296,6 +320,11 @@ func NewK8SServiceClient(httpClient connect.HTTPClient, baseURL string, opts ... baseURL+K8SServiceSearchNamespacesByClusterProcedure, opts..., ), + listNamespacesByCluster: connect.NewClient[v1.ListNamespacesByClusterRequest, v1.ListNamespacesByClusterResponse]( + httpClient, + baseURL+K8SServiceListNamespacesByClusterProcedure, + opts..., + ), getAllWorkloadNames: connect.NewClient[v1.GetAllWorkloadNamesRequest, v1.GetAllWorkloadNamesResponse]( httpClient, baseURL+K8SServiceGetAllWorkloadNamesProcedure, @@ -351,6 +380,21 @@ func NewK8SServiceClient(httpClient connect.HTTPClient, baseURL string, opts ... baseURL+K8SServiceGetWorkloadProcedure, opts..., ), + getWorkloadContainerPercentiles: connect.NewClient[v1.GetWorkloadContainerPercentilesRequest, v1.GetWorkloadContainerPercentilesResponse]( + httpClient, + baseURL+K8SServiceGetWorkloadContainerPercentilesProcedure, + opts..., + ), + getWorkloadContainerFsPercentiles: connect.NewClient[v1.GetWorkloadContainerFsPercentilesRequest, v1.GetWorkloadContainerFsPercentilesResponse]( + httpClient, + baseURL+K8SServiceGetWorkloadContainerFsPercentilesProcedure, + opts..., + ), + getLatestContainerRequestLimits: connect.NewClient[v1.GetLatestContainerRequestLimitsRequest, v1.GetLatestContainerRequestLimitsResponse]( + httpClient, + baseURL+K8SServiceGetLatestContainerRequestLimitsProcedure, + opts..., + ), getForecastWorkloads: connect.NewClient[v1.GetForecastWorkloadsRequest, v1.GetForecastWorkloadsResponse]( httpClient, baseURL+K8SServiceGetForecastWorkloadsProcedure, @@ -466,46 +510,50 @@ func NewK8SServiceClient(httpClient connect.HTTPClient, baseURL string, opts ... // k8SServiceClient implements K8SServiceClient. type k8SServiceClient struct { - getWorkloadsStats *connect.Client[v1.GetWorkloadsStatsRequest, v1.GetWorkloadsStatsResponse] - getClusters *connect.Client[v1.GetClustersRequest, v1.GetClustersResponse] - listClusters *connect.Client[v1.ListClustersRequest, v1.ListClustersResponse] - getCluster *connect.Client[v1.GetClusterRequest, v1.GetClusterResponse] - getClusterMetadata *connect.Client[v1.GetClusterMetadataRequest, v1.GetClusterMetadataResponse] - getAllNamespaces *connect.Client[v1.GetAllNamespacesRequest, v1.GetAllNamespacesResponse] - searchNamespacesByCluster *connect.Client[v1.SearchNamespacesByClusterRequest, v1.SearchNamespacesByClusterResponse] - getAllWorkloadNames *connect.Client[v1.GetAllWorkloadNamesRequest, v1.GetAllWorkloadNamesResponse] - getAllWorkloadLabels *connect.Client[v1.GetAllWorkloadLabelsRequest, v1.GetAllWorkloadLabelsResponse] - getAllNodeGroupNames *connect.Client[v1.GetAllNodeGroupNamesRequest, v1.GetAllNodeGroupNamesResponse] - metadataForWorkloads *connect.Client[v1.MetadataForWorkloadsRequest, v1.MetadataForWorkloadsResponse] - getNodeGroups *connect.Client[v1.GetNodeGroupsRequest, v1.GetNodeGroupsResponse] - getAllNodeGroups *connect.Client[v1.GetAllNodeGroupsRequest, v1.GetAllNodeGroupsResponse] - getNodeGroupsUtilization *connect.Client[v1.GetNodeGroupsUtilizationRequest, v1.GetNodeGroupsUtilizationResponse] - getNodeGroup *connect.Client[v1.GetNodeGroupRequest, v1.GetNodeGroupResponse] - getNode *connect.Client[v1.GetNodeRequest, v1.GetNodeResponse] - getWorkloads *connect.Client[v1.GetWorkloadsRequest, v1.GetWorkloadsResponse] - getWorkload *connect.Client[v1.GetWorkloadRequest, v1.GetWorkloadResponse] - getForecastWorkloads *connect.Client[v1.GetForecastWorkloadsRequest, v1.GetForecastWorkloadsResponse] - getForecastWorkload *connect.Client[v1.GetForecastWorkloadRequest, v1.GetForecastWorkloadResponse] - getResources *connect.Client[v1.GetResourcesRequest, v1.GetResourcesResponse] - getPods *connect.Client[v1.GetPodsRequest, v1.GetPodsResponse] - getLatestOperatorVersion *connect.Client[v1.GetLatestOperatorVersionRequest, v1.GetLatestOperatorVersionResponse] - galaxyGetClusterPerspective *connect.Client[v1.GalaxyGetClusterPerspectiveRequest, v1.GalaxyGetClusterPerspectiveResponse] - galaxyGetNodePerspective *connect.Client[v1.GalaxyGetNodePerspectiveRequest, v1.GalaxyGetNodePerspectiveResponse] - galaxyGetWorkloadPerspective *connect.Client[v1.GalaxyGetWorkloadPerspectiveRequest, v1.GalaxyGetWorkloadPerspectiveResponse] - listAuditLogs *connect.Client[v1.ListAuditLogsRequest, v1.ListAuditLogsResponse] - listAuditLogOriginators *connect.Client[v1.ListAuditLogOriginatorsRequest, v1.ListAuditLogOriginatorsResponse] - sendWorkloadEmail *connect.Client[v1.SendWorkloadEmailRequest, v1.SendWorkloadEmailResponse] - sendWeeklySummaryEmail *connect.Client[v1.SendWeeklySummaryEmailRequest, v1.SendWeeklySummaryEmailResponse] - getClustersNodeInfo *connect.Client[v1.GetClustersNodeInfoRequest, v1.GetClustersNodeInfoResponse] - searchK8SResources *connect.Client[v1.SearchK8SResourcesRequest, v1.SearchK8SResourcesResponse] - searchK8SWorkloads *connect.Client[v1.SearchK8SWorkloadsRequest, v1.SearchK8SWorkloadsResponse] - getClusterType *connect.Client[v1.GetClusterTypeRequest, v1.GetClusterTypeResponse] - getRelationsForKind *connect.Client[v1.GetRelatedResourcesRequest, v1.GetRelatedResourcesResponse] - lookupNodeInstance *connect.Client[v1.LookupNodeInstanceRequest, v1.LookupNodeInstanceResponse] - getWorkloadPodHistory *connect.Client[v1.GetWorkloadPodHistoryRequest, v1.GetWorkloadPodHistoryResponse] - addClusterTags *connect.Client[v1.AddClusterTagsRequest, v1.AddClusterTagsResponse] - removeClusterTags *connect.Client[v1.RemoveClusterTagsRequest, v1.RemoveClusterTagsResponse] - listTags *connect.Client[v1.ListTagsRequest, v1.ListTagsResponse] + getWorkloadsStats *connect.Client[v1.GetWorkloadsStatsRequest, v1.GetWorkloadsStatsResponse] + getClusters *connect.Client[v1.GetClustersRequest, v1.GetClustersResponse] + listClusters *connect.Client[v1.ListClustersRequest, v1.ListClustersResponse] + getCluster *connect.Client[v1.GetClusterRequest, v1.GetClusterResponse] + getClusterMetadata *connect.Client[v1.GetClusterMetadataRequest, v1.GetClusterMetadataResponse] + getAllNamespaces *connect.Client[v1.GetAllNamespacesRequest, v1.GetAllNamespacesResponse] + searchNamespacesByCluster *connect.Client[v1.SearchNamespacesByClusterRequest, v1.SearchNamespacesByClusterResponse] + listNamespacesByCluster *connect.Client[v1.ListNamespacesByClusterRequest, v1.ListNamespacesByClusterResponse] + getAllWorkloadNames *connect.Client[v1.GetAllWorkloadNamesRequest, v1.GetAllWorkloadNamesResponse] + getAllWorkloadLabels *connect.Client[v1.GetAllWorkloadLabelsRequest, v1.GetAllWorkloadLabelsResponse] + getAllNodeGroupNames *connect.Client[v1.GetAllNodeGroupNamesRequest, v1.GetAllNodeGroupNamesResponse] + metadataForWorkloads *connect.Client[v1.MetadataForWorkloadsRequest, v1.MetadataForWorkloadsResponse] + getNodeGroups *connect.Client[v1.GetNodeGroupsRequest, v1.GetNodeGroupsResponse] + getAllNodeGroups *connect.Client[v1.GetAllNodeGroupsRequest, v1.GetAllNodeGroupsResponse] + getNodeGroupsUtilization *connect.Client[v1.GetNodeGroupsUtilizationRequest, v1.GetNodeGroupsUtilizationResponse] + getNodeGroup *connect.Client[v1.GetNodeGroupRequest, v1.GetNodeGroupResponse] + getNode *connect.Client[v1.GetNodeRequest, v1.GetNodeResponse] + getWorkloads *connect.Client[v1.GetWorkloadsRequest, v1.GetWorkloadsResponse] + getWorkload *connect.Client[v1.GetWorkloadRequest, v1.GetWorkloadResponse] + getWorkloadContainerPercentiles *connect.Client[v1.GetWorkloadContainerPercentilesRequest, v1.GetWorkloadContainerPercentilesResponse] + getWorkloadContainerFsPercentiles *connect.Client[v1.GetWorkloadContainerFsPercentilesRequest, v1.GetWorkloadContainerFsPercentilesResponse] + getLatestContainerRequestLimits *connect.Client[v1.GetLatestContainerRequestLimitsRequest, v1.GetLatestContainerRequestLimitsResponse] + getForecastWorkloads *connect.Client[v1.GetForecastWorkloadsRequest, v1.GetForecastWorkloadsResponse] + getForecastWorkload *connect.Client[v1.GetForecastWorkloadRequest, v1.GetForecastWorkloadResponse] + getResources *connect.Client[v1.GetResourcesRequest, v1.GetResourcesResponse] + getPods *connect.Client[v1.GetPodsRequest, v1.GetPodsResponse] + getLatestOperatorVersion *connect.Client[v1.GetLatestOperatorVersionRequest, v1.GetLatestOperatorVersionResponse] + galaxyGetClusterPerspective *connect.Client[v1.GalaxyGetClusterPerspectiveRequest, v1.GalaxyGetClusterPerspectiveResponse] + galaxyGetNodePerspective *connect.Client[v1.GalaxyGetNodePerspectiveRequest, v1.GalaxyGetNodePerspectiveResponse] + galaxyGetWorkloadPerspective *connect.Client[v1.GalaxyGetWorkloadPerspectiveRequest, v1.GalaxyGetWorkloadPerspectiveResponse] + listAuditLogs *connect.Client[v1.ListAuditLogsRequest, v1.ListAuditLogsResponse] + listAuditLogOriginators *connect.Client[v1.ListAuditLogOriginatorsRequest, v1.ListAuditLogOriginatorsResponse] + sendWorkloadEmail *connect.Client[v1.SendWorkloadEmailRequest, v1.SendWorkloadEmailResponse] + sendWeeklySummaryEmail *connect.Client[v1.SendWeeklySummaryEmailRequest, v1.SendWeeklySummaryEmailResponse] + getClustersNodeInfo *connect.Client[v1.GetClustersNodeInfoRequest, v1.GetClustersNodeInfoResponse] + searchK8SResources *connect.Client[v1.SearchK8SResourcesRequest, v1.SearchK8SResourcesResponse] + searchK8SWorkloads *connect.Client[v1.SearchK8SWorkloadsRequest, v1.SearchK8SWorkloadsResponse] + getClusterType *connect.Client[v1.GetClusterTypeRequest, v1.GetClusterTypeResponse] + getRelationsForKind *connect.Client[v1.GetRelatedResourcesRequest, v1.GetRelatedResourcesResponse] + lookupNodeInstance *connect.Client[v1.LookupNodeInstanceRequest, v1.LookupNodeInstanceResponse] + getWorkloadPodHistory *connect.Client[v1.GetWorkloadPodHistoryRequest, v1.GetWorkloadPodHistoryResponse] + addClusterTags *connect.Client[v1.AddClusterTagsRequest, v1.AddClusterTagsResponse] + removeClusterTags *connect.Client[v1.RemoveClusterTagsRequest, v1.RemoveClusterTagsResponse] + listTags *connect.Client[v1.ListTagsRequest, v1.ListTagsResponse] } // GetWorkloadsStats calls api.v1.K8SService.GetWorkloadsStats. @@ -545,6 +593,11 @@ func (c *k8SServiceClient) SearchNamespacesByCluster(ctx context.Context, req *c return c.searchNamespacesByCluster.CallUnary(ctx, req) } +// ListNamespacesByCluster calls api.v1.K8SService.ListNamespacesByCluster. +func (c *k8SServiceClient) ListNamespacesByCluster(ctx context.Context, req *connect.Request[v1.ListNamespacesByClusterRequest]) (*connect.Response[v1.ListNamespacesByClusterResponse], error) { + return c.listNamespacesByCluster.CallUnary(ctx, req) +} + // GetAllWorkloadNames calls api.v1.K8SService.GetAllWorkloadNames. func (c *k8SServiceClient) GetAllWorkloadNames(ctx context.Context, req *connect.Request[v1.GetAllWorkloadNamesRequest]) (*connect.Response[v1.GetAllWorkloadNamesResponse], error) { return c.getAllWorkloadNames.CallUnary(ctx, req) @@ -600,6 +653,21 @@ func (c *k8SServiceClient) GetWorkload(ctx context.Context, req *connect.Request return c.getWorkload.CallUnary(ctx, req) } +// GetWorkloadContainerPercentiles calls api.v1.K8SService.GetWorkloadContainerPercentiles. +func (c *k8SServiceClient) GetWorkloadContainerPercentiles(ctx context.Context, req *connect.Request[v1.GetWorkloadContainerPercentilesRequest]) (*connect.Response[v1.GetWorkloadContainerPercentilesResponse], error) { + return c.getWorkloadContainerPercentiles.CallUnary(ctx, req) +} + +// GetWorkloadContainerFsPercentiles calls api.v1.K8SService.GetWorkloadContainerFsPercentiles. +func (c *k8SServiceClient) GetWorkloadContainerFsPercentiles(ctx context.Context, req *connect.Request[v1.GetWorkloadContainerFsPercentilesRequest]) (*connect.Response[v1.GetWorkloadContainerFsPercentilesResponse], error) { + return c.getWorkloadContainerFsPercentiles.CallUnary(ctx, req) +} + +// GetLatestContainerRequestLimits calls api.v1.K8SService.GetLatestContainerRequestLimits. +func (c *k8SServiceClient) GetLatestContainerRequestLimits(ctx context.Context, req *connect.Request[v1.GetLatestContainerRequestLimitsRequest]) (*connect.Response[v1.GetLatestContainerRequestLimitsResponse], error) { + return c.getLatestContainerRequestLimits.CallUnary(ctx, req) +} + // GetForecastWorkloads calls api.v1.K8SService.GetForecastWorkloads. // // Deprecated: do not use. @@ -733,6 +801,8 @@ type K8SServiceHandler interface { GetAllNamespaces(context.Context, *connect.Request[v1.GetAllNamespacesRequest]) (*connect.Response[v1.GetAllNamespacesResponse], error) // SearchNamespacesByCluster searches namespaces by name within a single cluster. SearchNamespacesByCluster(context.Context, *connect.Request[v1.SearchNamespacesByClusterRequest]) (*connect.Response[v1.SearchNamespacesByClusterResponse], error) + // ListNamespacesByCluster lists namespaces (id and name) within a single cluster. + ListNamespacesByCluster(context.Context, *connect.Request[v1.ListNamespacesByClusterRequest]) (*connect.Response[v1.ListNamespacesByClusterResponse], error) // GetAllWorkloadNames returns a list of all workload names for a team ID; if cluster list is empty, returns all. GetAllWorkloadNames(context.Context, *connect.Request[v1.GetAllWorkloadNamesRequest]) (*connect.Response[v1.GetAllWorkloadNamesResponse], error) // GetAllWorkloadLabels returns all workload labels for a team ID; if cluster list is empty, returns all. @@ -754,6 +824,16 @@ type K8SServiceHandler interface { GetWorkloads(context.Context, *connect.Request[v1.GetWorkloadsRequest]) (*connect.Response[v1.GetWorkloadsResponse], error) // GetWorkload retrieves detailed information for a specific workload. GetWorkload(context.Context, *connect.Request[v1.GetWorkloadRequest]) (*connect.Response[v1.GetWorkloadResponse], error) + // GetWorkloadContainerPercentiles retrieves per-container percentile metrics for a workload. + // + // Note: fs_* and current_* fields in the response are no longer populated. + // Prefer GetWorkloadContainerFsPercentiles and GetLatestContainerRequestLimits + // for progressive loading. + GetWorkloadContainerPercentiles(context.Context, *connect.Request[v1.GetWorkloadContainerPercentilesRequest]) (*connect.Response[v1.GetWorkloadContainerPercentilesResponse], error) + // GetWorkloadContainerFsPercentiles retrieves per-container filesystem I/O percentiles for a workload. + GetWorkloadContainerFsPercentiles(context.Context, *connect.Request[v1.GetWorkloadContainerFsPercentilesRequest]) (*connect.Response[v1.GetWorkloadContainerFsPercentilesResponse], error) + // GetLatestContainerRequestLimits retrieves the most recent request/limit values per container for a workload. + GetLatestContainerRequestLimits(context.Context, *connect.Request[v1.GetLatestContainerRequestLimitsRequest]) (*connect.Response[v1.GetLatestContainerRequestLimitsResponse], error) // GetForecastWorkloads retrieves all workloads for a specific cluster. // // Deprecated: do not use. @@ -836,6 +916,11 @@ func NewK8SServiceHandler(svc K8SServiceHandler, opts ...connect.HandlerOption) svc.SearchNamespacesByCluster, opts..., ) + k8SServiceListNamespacesByClusterHandler := connect.NewUnaryHandler( + K8SServiceListNamespacesByClusterProcedure, + svc.ListNamespacesByCluster, + opts..., + ) k8SServiceGetAllWorkloadNamesHandler := connect.NewUnaryHandler( K8SServiceGetAllWorkloadNamesProcedure, svc.GetAllWorkloadNames, @@ -891,6 +976,21 @@ func NewK8SServiceHandler(svc K8SServiceHandler, opts ...connect.HandlerOption) svc.GetWorkload, opts..., ) + k8SServiceGetWorkloadContainerPercentilesHandler := connect.NewUnaryHandler( + K8SServiceGetWorkloadContainerPercentilesProcedure, + svc.GetWorkloadContainerPercentiles, + opts..., + ) + k8SServiceGetWorkloadContainerFsPercentilesHandler := connect.NewUnaryHandler( + K8SServiceGetWorkloadContainerFsPercentilesProcedure, + svc.GetWorkloadContainerFsPercentiles, + opts..., + ) + k8SServiceGetLatestContainerRequestLimitsHandler := connect.NewUnaryHandler( + K8SServiceGetLatestContainerRequestLimitsProcedure, + svc.GetLatestContainerRequestLimits, + opts..., + ) k8SServiceGetForecastWorkloadsHandler := connect.NewUnaryHandler( K8SServiceGetForecastWorkloadsProcedure, svc.GetForecastWorkloads, @@ -1017,6 +1117,8 @@ func NewK8SServiceHandler(svc K8SServiceHandler, opts ...connect.HandlerOption) k8SServiceGetAllNamespacesHandler.ServeHTTP(w, r) case K8SServiceSearchNamespacesByClusterProcedure: k8SServiceSearchNamespacesByClusterHandler.ServeHTTP(w, r) + case K8SServiceListNamespacesByClusterProcedure: + k8SServiceListNamespacesByClusterHandler.ServeHTTP(w, r) case K8SServiceGetAllWorkloadNamesProcedure: k8SServiceGetAllWorkloadNamesHandler.ServeHTTP(w, r) case K8SServiceGetAllWorkloadLabelsProcedure: @@ -1039,6 +1141,12 @@ func NewK8SServiceHandler(svc K8SServiceHandler, opts ...connect.HandlerOption) k8SServiceGetWorkloadsHandler.ServeHTTP(w, r) case K8SServiceGetWorkloadProcedure: k8SServiceGetWorkloadHandler.ServeHTTP(w, r) + case K8SServiceGetWorkloadContainerPercentilesProcedure: + k8SServiceGetWorkloadContainerPercentilesHandler.ServeHTTP(w, r) + case K8SServiceGetWorkloadContainerFsPercentilesProcedure: + k8SServiceGetWorkloadContainerFsPercentilesHandler.ServeHTTP(w, r) + case K8SServiceGetLatestContainerRequestLimitsProcedure: + k8SServiceGetLatestContainerRequestLimitsHandler.ServeHTTP(w, r) case K8SServiceGetForecastWorkloadsProcedure: k8SServiceGetForecastWorkloadsHandler.ServeHTTP(w, r) case K8SServiceGetForecastWorkloadProcedure: @@ -1120,6 +1228,10 @@ func (UnimplementedK8SServiceHandler) SearchNamespacesByCluster(context.Context, return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.K8SService.SearchNamespacesByCluster is not implemented")) } +func (UnimplementedK8SServiceHandler) ListNamespacesByCluster(context.Context, *connect.Request[v1.ListNamespacesByClusterRequest]) (*connect.Response[v1.ListNamespacesByClusterResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.K8SService.ListNamespacesByCluster is not implemented")) +} + func (UnimplementedK8SServiceHandler) GetAllWorkloadNames(context.Context, *connect.Request[v1.GetAllWorkloadNamesRequest]) (*connect.Response[v1.GetAllWorkloadNamesResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.K8SService.GetAllWorkloadNames is not implemented")) } @@ -1164,6 +1276,18 @@ func (UnimplementedK8SServiceHandler) GetWorkload(context.Context, *connect.Requ return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.K8SService.GetWorkload is not implemented")) } +func (UnimplementedK8SServiceHandler) GetWorkloadContainerPercentiles(context.Context, *connect.Request[v1.GetWorkloadContainerPercentilesRequest]) (*connect.Response[v1.GetWorkloadContainerPercentilesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.K8SService.GetWorkloadContainerPercentiles is not implemented")) +} + +func (UnimplementedK8SServiceHandler) GetWorkloadContainerFsPercentiles(context.Context, *connect.Request[v1.GetWorkloadContainerFsPercentilesRequest]) (*connect.Response[v1.GetWorkloadContainerFsPercentilesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.K8SService.GetWorkloadContainerFsPercentiles is not implemented")) +} + +func (UnimplementedK8SServiceHandler) GetLatestContainerRequestLimits(context.Context, *connect.Request[v1.GetLatestContainerRequestLimitsRequest]) (*connect.Response[v1.GetLatestContainerRequestLimitsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.K8SService.GetLatestContainerRequestLimits is not implemented")) +} + func (UnimplementedK8SServiceHandler) GetForecastWorkloads(context.Context, *connect.Request[v1.GetForecastWorkloadsRequest]) (*connect.Response[v1.GetForecastWorkloadsResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.K8SService.GetForecastWorkloads is not implemented")) } diff --git a/gen/api/v1/apiv1connect/operator_health.connect.go b/gen/api/v1/apiv1connect/operator_health.connect.go index 35b3bcb4..f5f71ed0 100644 --- a/gen/api/v1/apiv1connect/operator_health.connect.go +++ b/gen/api/v1/apiv1connect/operator_health.connect.go @@ -36,19 +36,11 @@ const ( // OperatorHealthServiceReportHealthProcedure is the fully-qualified name of the // OperatorHealthService's ReportHealth RPC. OperatorHealthServiceReportHealthProcedure = "/api.v1.OperatorHealthService/ReportHealth" - // OperatorHealthServiceGetClusterOperatorHealthProcedure is the fully-qualified name of the - // OperatorHealthService's GetClusterOperatorHealth RPC. - OperatorHealthServiceGetClusterOperatorHealthProcedure = "/api.v1.OperatorHealthService/GetClusterOperatorHealth" - // OperatorHealthServiceWatchClusterLifecycleProcedure is the fully-qualified name of the - // OperatorHealthService's WatchClusterLifecycle RPC. - OperatorHealthServiceWatchClusterLifecycleProcedure = "/api.v1.OperatorHealthService/WatchClusterLifecycle" ) // OperatorHealthServiceClient is a client for the api.v1.OperatorHealthService service. type OperatorHealthServiceClient interface { ReportHealth(context.Context, *connect.Request[v1.ReportHealthRequest]) (*connect.Response[v1.ReportHealthResponse], error) - GetClusterOperatorHealth(context.Context, *connect.Request[v1.GetClusterOperatorHealthRequest]) (*connect.Response[v1.GetClusterOperatorHealthResponse], error) - WatchClusterLifecycle(context.Context, *connect.Request[v1.WatchClusterLifecycleRequest]) (*connect.ServerStreamForClient[v1.WatchClusterLifecycleResponse], error) } // NewOperatorHealthServiceClient constructs a client for the api.v1.OperatorHealthService service. @@ -66,24 +58,12 @@ func NewOperatorHealthServiceClient(httpClient connect.HTTPClient, baseURL strin baseURL+OperatorHealthServiceReportHealthProcedure, opts..., ), - getClusterOperatorHealth: connect.NewClient[v1.GetClusterOperatorHealthRequest, v1.GetClusterOperatorHealthResponse]( - httpClient, - baseURL+OperatorHealthServiceGetClusterOperatorHealthProcedure, - opts..., - ), - watchClusterLifecycle: connect.NewClient[v1.WatchClusterLifecycleRequest, v1.WatchClusterLifecycleResponse]( - httpClient, - baseURL+OperatorHealthServiceWatchClusterLifecycleProcedure, - opts..., - ), } } // operatorHealthServiceClient implements OperatorHealthServiceClient. type operatorHealthServiceClient struct { - reportHealth *connect.Client[v1.ReportHealthRequest, v1.ReportHealthResponse] - getClusterOperatorHealth *connect.Client[v1.GetClusterOperatorHealthRequest, v1.GetClusterOperatorHealthResponse] - watchClusterLifecycle *connect.Client[v1.WatchClusterLifecycleRequest, v1.WatchClusterLifecycleResponse] + reportHealth *connect.Client[v1.ReportHealthRequest, v1.ReportHealthResponse] } // ReportHealth calls api.v1.OperatorHealthService.ReportHealth. @@ -91,21 +71,9 @@ func (c *operatorHealthServiceClient) ReportHealth(ctx context.Context, req *con return c.reportHealth.CallUnary(ctx, req) } -// GetClusterOperatorHealth calls api.v1.OperatorHealthService.GetClusterOperatorHealth. -func (c *operatorHealthServiceClient) GetClusterOperatorHealth(ctx context.Context, req *connect.Request[v1.GetClusterOperatorHealthRequest]) (*connect.Response[v1.GetClusterOperatorHealthResponse], error) { - return c.getClusterOperatorHealth.CallUnary(ctx, req) -} - -// WatchClusterLifecycle calls api.v1.OperatorHealthService.WatchClusterLifecycle. -func (c *operatorHealthServiceClient) WatchClusterLifecycle(ctx context.Context, req *connect.Request[v1.WatchClusterLifecycleRequest]) (*connect.ServerStreamForClient[v1.WatchClusterLifecycleResponse], error) { - return c.watchClusterLifecycle.CallServerStream(ctx, req) -} - // OperatorHealthServiceHandler is an implementation of the api.v1.OperatorHealthService service. type OperatorHealthServiceHandler interface { ReportHealth(context.Context, *connect.Request[v1.ReportHealthRequest]) (*connect.Response[v1.ReportHealthResponse], error) - GetClusterOperatorHealth(context.Context, *connect.Request[v1.GetClusterOperatorHealthRequest]) (*connect.Response[v1.GetClusterOperatorHealthResponse], error) - WatchClusterLifecycle(context.Context, *connect.Request[v1.WatchClusterLifecycleRequest], *connect.ServerStream[v1.WatchClusterLifecycleResponse]) error } // NewOperatorHealthServiceHandler builds an HTTP handler from the service implementation. It @@ -119,24 +87,10 @@ func NewOperatorHealthServiceHandler(svc OperatorHealthServiceHandler, opts ...c svc.ReportHealth, opts..., ) - operatorHealthServiceGetClusterOperatorHealthHandler := connect.NewUnaryHandler( - OperatorHealthServiceGetClusterOperatorHealthProcedure, - svc.GetClusterOperatorHealth, - opts..., - ) - operatorHealthServiceWatchClusterLifecycleHandler := connect.NewServerStreamHandler( - OperatorHealthServiceWatchClusterLifecycleProcedure, - svc.WatchClusterLifecycle, - opts..., - ) return "/api.v1.OperatorHealthService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.URL.Path { case OperatorHealthServiceReportHealthProcedure: operatorHealthServiceReportHealthHandler.ServeHTTP(w, r) - case OperatorHealthServiceGetClusterOperatorHealthProcedure: - operatorHealthServiceGetClusterOperatorHealthHandler.ServeHTTP(w, r) - case OperatorHealthServiceWatchClusterLifecycleProcedure: - operatorHealthServiceWatchClusterLifecycleHandler.ServeHTTP(w, r) default: http.NotFound(w, r) } @@ -149,11 +103,3 @@ type UnimplementedOperatorHealthServiceHandler struct{} func (UnimplementedOperatorHealthServiceHandler) ReportHealth(context.Context, *connect.Request[v1.ReportHealthRequest]) (*connect.Response[v1.ReportHealthResponse], error) { return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.OperatorHealthService.ReportHealth is not implemented")) } - -func (UnimplementedOperatorHealthServiceHandler) GetClusterOperatorHealth(context.Context, *connect.Request[v1.GetClusterOperatorHealthRequest]) (*connect.Response[v1.GetClusterOperatorHealthResponse], error) { - return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.OperatorHealthService.GetClusterOperatorHealth is not implemented")) -} - -func (UnimplementedOperatorHealthServiceHandler) WatchClusterLifecycle(context.Context, *connect.Request[v1.WatchClusterLifecycleRequest], *connect.ServerStream[v1.WatchClusterLifecycleResponse]) error { - return connect.NewError(connect.CodeUnimplemented, errors.New("api.v1.OperatorHealthService.WatchClusterLifecycle is not implemented")) -} diff --git a/gen/api/v1/common.pb.go b/gen/api/v1/common.pb.go index fd28ee89..77235842 100644 --- a/gen/api/v1/common.pb.go +++ b/gen/api/v1/common.pb.go @@ -1518,48 +1518,44 @@ func (x *ResourceMetrics) GetPodCount() int32 { return 0 } -// ForecastResourceMetrics encapsulates Forecasted CPU and memory capacity, usage, and utilization for nodes and containers. -type ForecastResourceMetrics struct { +// MetricPercentiles contains percentile statistics for a single metric. +type MetricPercentiles struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Timestamp *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Forecast timestamp. - ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` // Cluster id of the container. - ApplicationId string `protobuf:"bytes,3,opt,name=application_id,json=applicationId,proto3" json:"application_id,omitempty"` // Application id of the container. - ApplicationKind string `protobuf:"bytes,4,opt,name=application_kind,json=applicationKind,proto3" json:"application_kind,omitempty"` // Application kind of the container. - Model string `protobuf:"bytes,5,opt,name=model,proto3" json:"model,omitempty"` // Model used for the forecast - NodeCpuCapacity float64 `protobuf:"fixed64,6,opt,name=node_cpu_capacity,json=nodeCpuCapacity,proto3" json:"node_cpu_capacity,omitempty"` // Total CPU capacity of nodes. - NodeMemoryCapacity float64 `protobuf:"fixed64,7,opt,name=node_memory_capacity,json=nodeMemoryCapacity,proto3" json:"node_memory_capacity,omitempty"` // Total memory capacity of nodes. - NodeCpuUsage float64 `protobuf:"fixed64,8,opt,name=node_cpu_usage,json=nodeCpuUsage,proto3" json:"node_cpu_usage,omitempty"` // Current CPU usage of nodes. - NodeMemoryUsage float64 `protobuf:"fixed64,9,opt,name=node_memory_usage,json=nodeMemoryUsage,proto3" json:"node_memory_usage,omitempty"` // Current memory usage of nodes. - NodeCpuUtilization float64 `protobuf:"fixed64,10,opt,name=node_cpu_utilization,json=nodeCpuUtilization,proto3" json:"node_cpu_utilization,omitempty"` // CPU utilization percentage of nodes. - NodeMemoryUtilization float64 `protobuf:"fixed64,11,opt,name=node_memory_utilization,json=nodeMemoryUtilization,proto3" json:"node_memory_utilization,omitempty"` // Memory utilization percentage of nodes. - ContainerCpuUsage float64 `protobuf:"fixed64,12,opt,name=container_cpu_usage,json=containerCpuUsage,proto3" json:"container_cpu_usage,omitempty"` // Current CPU usage of containers. - ContainerMemoryUsage float64 `protobuf:"fixed64,13,opt,name=container_memory_usage,json=containerMemoryUsage,proto3" json:"container_memory_usage,omitempty"` // Current memory usage of containers. - ContainerCpuUtilization float64 `protobuf:"fixed64,14,opt,name=container_cpu_utilization,json=containerCpuUtilization,proto3" json:"container_cpu_utilization,omitempty"` // CPU utilization percentage of containers. - ContainerMemoryUtilization float64 `protobuf:"fixed64,15,opt,name=container_memory_utilization,json=containerMemoryUtilization,proto3" json:"container_memory_utilization,omitempty"` // Memory utilization percentage of containers. - ContainerCpuRequested float64 `protobuf:"fixed64,16,opt,name=container_cpu_requested,json=containerCpuRequested,proto3" json:"container_cpu_requested,omitempty"` // CPU requested by containers. - ContainerMemoryRequested float64 `protobuf:"fixed64,17,opt,name=container_memory_requested,json=containerMemoryRequested,proto3" json:"container_memory_requested,omitempty"` // Memory requested by containers. - ContainerCpuLimits float64 `protobuf:"fixed64,18,opt,name=container_cpu_limits,json=containerCpuLimits,proto3" json:"container_cpu_limits,omitempty"` // CPU limits of containers. - ContainerMemoryLimits float64 `protobuf:"fixed64,19,opt,name=container_memory_limits,json=containerMemoryLimits,proto3" json:"container_memory_limits,omitempty"` // Memory limits of containers. - ContainerGpuUsage float64 `protobuf:"fixed64,20,opt,name=container_gpu_usage,json=containerGpuUsage,proto3" json:"container_gpu_usage,omitempty"` // GPU usage of containers. - ContainerGpuRequested float64 `protobuf:"fixed64,21,opt,name=container_gpu_requested,json=containerGpuRequested,proto3" json:"container_gpu_requested,omitempty"` // GPU requests of containers. - ContainerGpuLimits float64 `protobuf:"fixed64,22,opt,name=container_gpu_limits,json=containerGpuLimits,proto3" json:"container_gpu_limits,omitempty"` // GPU limits of containers. - ContainerGpuUtilization float64 `protobuf:"fixed64,23,opt,name=container_gpu_utilization,json=containerGpuUtilization,proto3" json:"container_gpu_utilization,omitempty"` // GPU utilization of containers. - NodeGpuCapacity float64 `protobuf:"fixed64,24,opt,name=node_gpu_capacity,json=nodeGpuCapacity,proto3" json:"node_gpu_capacity,omitempty"` // GPU capcity of nodes. - NodeGpuUsage float64 `protobuf:"fixed64,25,opt,name=node_gpu_usage,json=nodeGpuUsage,proto3" json:"node_gpu_usage,omitempty"` // GPU usage of nodes. - NodeGpuUtilization float64 `protobuf:"fixed64,26,opt,name=node_gpu_utilization,json=nodeGpuUtilization,proto3" json:"node_gpu_utilization,omitempty"` // GPU utilization of nodes. - NodeGpuVramUsage float64 `protobuf:"fixed64,27,opt,name=node_gpu_vram_usage,json=nodeGpuVramUsage,proto3" json:"node_gpu_vram_usage,omitempty"` // GPU VRAM usage of nodes. - ContainerGpuVramUsage float64 `protobuf:"fixed64,28,opt,name=container_gpu_vram_usage,json=containerGpuVramUsage,proto3" json:"container_gpu_vram_usage,omitempty"` // GPU VRAM usage of containers. - NodeGpuVramCapacity float64 `protobuf:"fixed64,29,opt,name=node_gpu_vram_capacity,json=nodeGpuVramCapacity,proto3" json:"node_gpu_vram_capacity,omitempty"` // GPU VRAM capacity of nodes. - NodeGpuVramUtilization float64 `protobuf:"fixed64,30,opt,name=node_gpu_vram_utilization,json=nodeGpuVramUtilization,proto3" json:"node_gpu_vram_utilization,omitempty"` // GPU VRAM utilization of nodes. - NormalizedNodeMemoryCapacity float64 `protobuf:"fixed64,31,opt,name=normalized_node_memory_capacity,json=normalizedNodeMemoryCapacity,proto3" json:"normalized_node_memory_capacity,omitempty"` // Total memory capacity of nodes, normalized to cover for missing bytes. - NormalizedGpuVramCapacity float64 `protobuf:"fixed64,32,opt,name=normalized_gpu_vram_capacity,json=normalizedGpuVramCapacity,proto3" json:"normalized_gpu_vram_capacity,omitempty"` // Normalized GPU VRAM capacity of nodes. -} - -func (x *ForecastResourceMetrics) Reset() { - *x = ForecastResourceMetrics{} + Min float64 `protobuf:"fixed64,1,opt,name=min,proto3" json:"min,omitempty"` + Avg float64 `protobuf:"fixed64,2,opt,name=avg,proto3" json:"avg,omitempty"` + Max float64 `protobuf:"fixed64,3,opt,name=max,proto3" json:"max,omitempty"` + P50 float64 `protobuf:"fixed64,4,opt,name=p50,proto3" json:"p50,omitempty"` + P95 float64 `protobuf:"fixed64,5,opt,name=p95,proto3" json:"p95,omitempty"` + P99 float64 `protobuf:"fixed64,6,opt,name=p99,proto3" json:"p99,omitempty"` + P100 float64 `protobuf:"fixed64,7,opt,name=p100,proto3" json:"p100,omitempty"` + P10 float64 `protobuf:"fixed64,8,opt,name=p10,proto3" json:"p10,omitempty"` + P25 float64 `protobuf:"fixed64,9,opt,name=p25,proto3" json:"p25,omitempty"` + P75 float64 `protobuf:"fixed64,10,opt,name=p75,proto3" json:"p75,omitempty"` + P90 float64 `protobuf:"fixed64,11,opt,name=p90,proto3" json:"p90,omitempty"` + P999 float64 `protobuf:"fixed64,12,opt,name=p999,proto3" json:"p999,omitempty"` + // Dense percentiles for smooth distribution visualization + P1 float64 `protobuf:"fixed64,13,opt,name=p1,proto3" json:"p1,omitempty"` + P5 float64 `protobuf:"fixed64,14,opt,name=p5,proto3" json:"p5,omitempty"` + P15 float64 `protobuf:"fixed64,15,opt,name=p15,proto3" json:"p15,omitempty"` + P20 float64 `protobuf:"fixed64,16,opt,name=p20,proto3" json:"p20,omitempty"` + P30 float64 `protobuf:"fixed64,17,opt,name=p30,proto3" json:"p30,omitempty"` + P35 float64 `protobuf:"fixed64,18,opt,name=p35,proto3" json:"p35,omitempty"` + P40 float64 `protobuf:"fixed64,19,opt,name=p40,proto3" json:"p40,omitempty"` + P45 float64 `protobuf:"fixed64,20,opt,name=p45,proto3" json:"p45,omitempty"` + P55 float64 `protobuf:"fixed64,21,opt,name=p55,proto3" json:"p55,omitempty"` + P60 float64 `protobuf:"fixed64,22,opt,name=p60,proto3" json:"p60,omitempty"` + P65 float64 `protobuf:"fixed64,23,opt,name=p65,proto3" json:"p65,omitempty"` + P70 float64 `protobuf:"fixed64,24,opt,name=p70,proto3" json:"p70,omitempty"` + P80 float64 `protobuf:"fixed64,25,opt,name=p80,proto3" json:"p80,omitempty"` + P85 float64 `protobuf:"fixed64,26,opt,name=p85,proto3" json:"p85,omitempty"` + P97 float64 `protobuf:"fixed64,27,opt,name=p97,proto3" json:"p97,omitempty"` +} + +func (x *MetricPercentiles) Reset() { + *x = MetricPercentiles{} if protoimpl.UnsafeEnabled { mi := &file_api_v1_common_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -1567,13 +1563,13 @@ func (x *ForecastResourceMetrics) Reset() { } } -func (x *ForecastResourceMetrics) String() string { +func (x *MetricPercentiles) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ForecastResourceMetrics) ProtoMessage() {} +func (*MetricPercentiles) ProtoMessage() {} -func (x *ForecastResourceMetrics) ProtoReflect() protoreflect.Message { +func (x *MetricPercentiles) ProtoReflect() protoreflect.Message { mi := &file_api_v1_common_proto_msgTypes[4] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -1585,260 +1581,237 @@ func (x *ForecastResourceMetrics) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ForecastResourceMetrics.ProtoReflect.Descriptor instead. -func (*ForecastResourceMetrics) Descriptor() ([]byte, []int) { +// Deprecated: Use MetricPercentiles.ProtoReflect.Descriptor instead. +func (*MetricPercentiles) Descriptor() ([]byte, []int) { return file_api_v1_common_proto_rawDescGZIP(), []int{4} } -func (x *ForecastResourceMetrics) GetTimestamp() *timestamppb.Timestamp { - if x != nil { - return x.Timestamp - } - return nil -} - -func (x *ForecastResourceMetrics) GetClusterId() string { - if x != nil { - return x.ClusterId - } - return "" -} - -func (x *ForecastResourceMetrics) GetApplicationId() string { - if x != nil { - return x.ApplicationId - } - return "" -} - -func (x *ForecastResourceMetrics) GetApplicationKind() string { - if x != nil { - return x.ApplicationKind - } - return "" -} - -func (x *ForecastResourceMetrics) GetModel() string { +func (x *MetricPercentiles) GetMin() float64 { if x != nil { - return x.Model - } - return "" -} - -func (x *ForecastResourceMetrics) GetNodeCpuCapacity() float64 { - if x != nil { - return x.NodeCpuCapacity + return x.Min } return 0 } -func (x *ForecastResourceMetrics) GetNodeMemoryCapacity() float64 { +func (x *MetricPercentiles) GetAvg() float64 { if x != nil { - return x.NodeMemoryCapacity + return x.Avg } return 0 } -func (x *ForecastResourceMetrics) GetNodeCpuUsage() float64 { +func (x *MetricPercentiles) GetMax() float64 { if x != nil { - return x.NodeCpuUsage + return x.Max } return 0 } -func (x *ForecastResourceMetrics) GetNodeMemoryUsage() float64 { +func (x *MetricPercentiles) GetP50() float64 { if x != nil { - return x.NodeMemoryUsage + return x.P50 } return 0 } -func (x *ForecastResourceMetrics) GetNodeCpuUtilization() float64 { +func (x *MetricPercentiles) GetP95() float64 { if x != nil { - return x.NodeCpuUtilization + return x.P95 } return 0 } -func (x *ForecastResourceMetrics) GetNodeMemoryUtilization() float64 { +func (x *MetricPercentiles) GetP99() float64 { if x != nil { - return x.NodeMemoryUtilization + return x.P99 } return 0 } -func (x *ForecastResourceMetrics) GetContainerCpuUsage() float64 { +func (x *MetricPercentiles) GetP100() float64 { if x != nil { - return x.ContainerCpuUsage + return x.P100 } return 0 } -func (x *ForecastResourceMetrics) GetContainerMemoryUsage() float64 { +func (x *MetricPercentiles) GetP10() float64 { if x != nil { - return x.ContainerMemoryUsage + return x.P10 } return 0 } -func (x *ForecastResourceMetrics) GetContainerCpuUtilization() float64 { +func (x *MetricPercentiles) GetP25() float64 { if x != nil { - return x.ContainerCpuUtilization + return x.P25 } return 0 } -func (x *ForecastResourceMetrics) GetContainerMemoryUtilization() float64 { +func (x *MetricPercentiles) GetP75() float64 { if x != nil { - return x.ContainerMemoryUtilization + return x.P75 } return 0 } -func (x *ForecastResourceMetrics) GetContainerCpuRequested() float64 { +func (x *MetricPercentiles) GetP90() float64 { if x != nil { - return x.ContainerCpuRequested + return x.P90 } return 0 } -func (x *ForecastResourceMetrics) GetContainerMemoryRequested() float64 { +func (x *MetricPercentiles) GetP999() float64 { if x != nil { - return x.ContainerMemoryRequested + return x.P999 } return 0 } -func (x *ForecastResourceMetrics) GetContainerCpuLimits() float64 { +func (x *MetricPercentiles) GetP1() float64 { if x != nil { - return x.ContainerCpuLimits + return x.P1 } return 0 } -func (x *ForecastResourceMetrics) GetContainerMemoryLimits() float64 { +func (x *MetricPercentiles) GetP5() float64 { if x != nil { - return x.ContainerMemoryLimits + return x.P5 } return 0 } -func (x *ForecastResourceMetrics) GetContainerGpuUsage() float64 { +func (x *MetricPercentiles) GetP15() float64 { if x != nil { - return x.ContainerGpuUsage + return x.P15 } return 0 } -func (x *ForecastResourceMetrics) GetContainerGpuRequested() float64 { +func (x *MetricPercentiles) GetP20() float64 { if x != nil { - return x.ContainerGpuRequested + return x.P20 } return 0 } -func (x *ForecastResourceMetrics) GetContainerGpuLimits() float64 { +func (x *MetricPercentiles) GetP30() float64 { if x != nil { - return x.ContainerGpuLimits + return x.P30 } return 0 } -func (x *ForecastResourceMetrics) GetContainerGpuUtilization() float64 { +func (x *MetricPercentiles) GetP35() float64 { if x != nil { - return x.ContainerGpuUtilization + return x.P35 } return 0 } -func (x *ForecastResourceMetrics) GetNodeGpuCapacity() float64 { +func (x *MetricPercentiles) GetP40() float64 { if x != nil { - return x.NodeGpuCapacity + return x.P40 } return 0 } -func (x *ForecastResourceMetrics) GetNodeGpuUsage() float64 { +func (x *MetricPercentiles) GetP45() float64 { if x != nil { - return x.NodeGpuUsage + return x.P45 } return 0 } -func (x *ForecastResourceMetrics) GetNodeGpuUtilization() float64 { +func (x *MetricPercentiles) GetP55() float64 { if x != nil { - return x.NodeGpuUtilization + return x.P55 } return 0 } -func (x *ForecastResourceMetrics) GetNodeGpuVramUsage() float64 { +func (x *MetricPercentiles) GetP60() float64 { if x != nil { - return x.NodeGpuVramUsage + return x.P60 } return 0 } -func (x *ForecastResourceMetrics) GetContainerGpuVramUsage() float64 { +func (x *MetricPercentiles) GetP65() float64 { if x != nil { - return x.ContainerGpuVramUsage + return x.P65 } return 0 } -func (x *ForecastResourceMetrics) GetNodeGpuVramCapacity() float64 { +func (x *MetricPercentiles) GetP70() float64 { if x != nil { - return x.NodeGpuVramCapacity + return x.P70 } return 0 } -func (x *ForecastResourceMetrics) GetNodeGpuVramUtilization() float64 { +func (x *MetricPercentiles) GetP80() float64 { if x != nil { - return x.NodeGpuVramUtilization + return x.P80 } return 0 } -func (x *ForecastResourceMetrics) GetNormalizedNodeMemoryCapacity() float64 { +func (x *MetricPercentiles) GetP85() float64 { if x != nil { - return x.NormalizedNodeMemoryCapacity + return x.P85 } return 0 } -func (x *ForecastResourceMetrics) GetNormalizedGpuVramCapacity() float64 { +func (x *MetricPercentiles) GetP97() float64 { if x != nil { - return x.NormalizedGpuVramCapacity + return x.P97 } return 0 } -// ResourceSummary provides aggregated resource counts and pod status counts for a cluster or workload. -type ResourceSummary struct { +// ContainerPercentileSummary contains percentile statistics for a single container. +type ContainerPercentileSummary struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - DeploymentCount int32 `protobuf:"varint,1,opt,name=deployment_count,json=deploymentCount,proto3" json:"deployment_count,omitempty"` // Number of Deployments. - StatefulSetCount int32 `protobuf:"varint,2,opt,name=stateful_set_count,json=statefulSetCount,proto3" json:"stateful_set_count,omitempty"` // Number of StatefulSets. - DaemonSetCount int32 `protobuf:"varint,3,opt,name=daemon_set_count,json=daemonSetCount,proto3" json:"daemon_set_count,omitempty"` // Number of DaemonSets. - JobCount int32 `protobuf:"varint,4,opt,name=job_count,json=jobCount,proto3" json:"job_count,omitempty"` // Number of Jobs. - CronJobCount int32 `protobuf:"varint,5,opt,name=cron_job_count,json=cronJobCount,proto3" json:"cron_job_count,omitempty"` // Number of CronJobs. - ReplicaSetCount int32 `protobuf:"varint,6,opt,name=replica_set_count,json=replicaSetCount,proto3" json:"replica_set_count,omitempty"` // Number of ReplicaSets. - PodCount int32 `protobuf:"varint,7,opt,name=pod_count,json=podCount,proto3" json:"pod_count,omitempty"` // Number of Pods. - ContainerCount int32 `protobuf:"varint,8,opt,name=container_count,json=containerCount,proto3" json:"container_count,omitempty"` // Number of Containers. - PendingPods int32 `protobuf:"varint,9,opt,name=pending_pods,json=pendingPods,proto3" json:"pending_pods,omitempty"` // Number of Pods in Pending state. - RunningPods int32 `protobuf:"varint,10,opt,name=running_pods,json=runningPods,proto3" json:"running_pods,omitempty"` // Number of Pods in Running state. - SucceededPods int32 `protobuf:"varint,11,opt,name=succeeded_pods,json=succeededPods,proto3" json:"succeeded_pods,omitempty"` // Number of Pods in Succeeded state. - FailedPods int32 `protobuf:"varint,12,opt,name=failed_pods,json=failedPods,proto3" json:"failed_pods,omitempty"` // Number of Pods in Failed state. - UnknownPods int32 `protobuf:"varint,13,opt,name=unknown_pods,json=unknownPods,proto3" json:"unknown_pods,omitempty"` // Number of Pods in Unknown state. - UnderProvisionedCount int32 `protobuf:"varint,14,opt,name=under_provisioned_count,json=underProvisionedCount,proto3" json:"under_provisioned_count,omitempty"` // Number of resources under-provisioned. - OverProvisionedCount int32 `protobuf:"varint,15,opt,name=over_provisioned_count,json=overProvisionedCount,proto3" json:"over_provisioned_count,omitempty"` // Number of resources over-provisioned. + ContainerName string `protobuf:"bytes,1,opt,name=container_name,json=containerName,proto3" json:"container_name,omitempty"` + CpuUsage *MetricPercentiles `protobuf:"bytes,2,opt,name=cpu_usage,json=cpuUsage,proto3" json:"cpu_usage,omitempty"` + MemoryUsage *MetricPercentiles `protobuf:"bytes,3,opt,name=memory_usage,json=memoryUsage,proto3" json:"memory_usage,omitempty"` + CpuRequest *MetricPercentiles `protobuf:"bytes,4,opt,name=cpu_request,json=cpuRequest,proto3" json:"cpu_request,omitempty"` + MemoryRequest *MetricPercentiles `protobuf:"bytes,5,opt,name=memory_request,json=memoryRequest,proto3" json:"memory_request,omitempty"` + CpuLimit *MetricPercentiles `protobuf:"bytes,6,opt,name=cpu_limit,json=cpuLimit,proto3" json:"cpu_limit,omitempty"` + MemoryLimit *MetricPercentiles `protobuf:"bytes,7,opt,name=memory_limit,json=memoryLimit,proto3" json:"memory_limit,omitempty"` + GpuUsage *MetricPercentiles `protobuf:"bytes,8,opt,name=gpu_usage,json=gpuUsage,proto3" json:"gpu_usage,omitempty"` + GpuVramUsage *MetricPercentiles `protobuf:"bytes,9,opt,name=gpu_vram_usage,json=gpuVramUsage,proto3" json:"gpu_vram_usage,omitempty"` + // Deprecated: Use GetLatestContainerRequestLimits RPC instead. + // + // Deprecated: Marked as deprecated in api/v1/common.proto. + CurrentCpuRequest float64 `protobuf:"fixed64,10,opt,name=current_cpu_request,json=currentCpuRequest,proto3" json:"current_cpu_request,omitempty"` + // Deprecated: Marked as deprecated in api/v1/common.proto. + CurrentMemoryRequest float64 `protobuf:"fixed64,11,opt,name=current_memory_request,json=currentMemoryRequest,proto3" json:"current_memory_request,omitempty"` + // Deprecated: Marked as deprecated in api/v1/common.proto. + CurrentCpuLimit float64 `protobuf:"fixed64,12,opt,name=current_cpu_limit,json=currentCpuLimit,proto3" json:"current_cpu_limit,omitempty"` + // Deprecated: Marked as deprecated in api/v1/common.proto. + CurrentMemoryLimit float64 `protobuf:"fixed64,13,opt,name=current_memory_limit,json=currentMemoryLimit,proto3" json:"current_memory_limit,omitempty"` + NetworkReceiveBytes *MetricPercentiles `protobuf:"bytes,14,opt,name=network_receive_bytes,json=networkReceiveBytes,proto3" json:"network_receive_bytes,omitempty"` + NetworkTransmitBytes *MetricPercentiles `protobuf:"bytes,15,opt,name=network_transmit_bytes,json=networkTransmitBytes,proto3" json:"network_transmit_bytes,omitempty"` + // Deprecated: Use GetWorkloadContainerFsPercentiles RPC instead. + // + // Deprecated: Marked as deprecated in api/v1/common.proto. + FsReadBytes *MetricPercentiles `protobuf:"bytes,16,opt,name=fs_read_bytes,json=fsReadBytes,proto3" json:"fs_read_bytes,omitempty"` + // Deprecated: Marked as deprecated in api/v1/common.proto. + FsWriteBytes *MetricPercentiles `protobuf:"bytes,17,opt,name=fs_write_bytes,json=fsWriteBytes,proto3" json:"fs_write_bytes,omitempty"` } -func (x *ResourceSummary) Reset() { - *x = ResourceSummary{} +func (x *ContainerPercentileSummary) Reset() { + *x = ContainerPercentileSummary{} if protoimpl.UnsafeEnabled { mi := &file_api_v1_common_proto_msgTypes[5] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -1846,13 +1819,13 @@ func (x *ResourceSummary) Reset() { } } -func (x *ResourceSummary) String() string { +func (x *ContainerPercentileSummary) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResourceSummary) ProtoMessage() {} +func (*ContainerPercentileSummary) ProtoMessage() {} -func (x *ResourceSummary) ProtoReflect() protoreflect.Message { +func (x *ContainerPercentileSummary) ProtoReflect() protoreflect.Message { mi := &file_api_v1_common_proto_msgTypes[5] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -1864,141 +1837,761 @@ func (x *ResourceSummary) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ResourceSummary.ProtoReflect.Descriptor instead. -func (*ResourceSummary) Descriptor() ([]byte, []int) { +// Deprecated: Use ContainerPercentileSummary.ProtoReflect.Descriptor instead. +func (*ContainerPercentileSummary) Descriptor() ([]byte, []int) { return file_api_v1_common_proto_rawDescGZIP(), []int{5} } -func (x *ResourceSummary) GetDeploymentCount() int32 { +func (x *ContainerPercentileSummary) GetContainerName() string { if x != nil { - return x.DeploymentCount + return x.ContainerName } - return 0 + return "" } -func (x *ResourceSummary) GetStatefulSetCount() int32 { +func (x *ContainerPercentileSummary) GetCpuUsage() *MetricPercentiles { if x != nil { - return x.StatefulSetCount + return x.CpuUsage } - return 0 + return nil } -func (x *ResourceSummary) GetDaemonSetCount() int32 { +func (x *ContainerPercentileSummary) GetMemoryUsage() *MetricPercentiles { if x != nil { - return x.DaemonSetCount + return x.MemoryUsage } - return 0 + return nil } -func (x *ResourceSummary) GetJobCount() int32 { +func (x *ContainerPercentileSummary) GetCpuRequest() *MetricPercentiles { if x != nil { - return x.JobCount + return x.CpuRequest } - return 0 + return nil } -func (x *ResourceSummary) GetCronJobCount() int32 { +func (x *ContainerPercentileSummary) GetMemoryRequest() *MetricPercentiles { if x != nil { - return x.CronJobCount + return x.MemoryRequest } - return 0 + return nil } -func (x *ResourceSummary) GetReplicaSetCount() int32 { +func (x *ContainerPercentileSummary) GetCpuLimit() *MetricPercentiles { if x != nil { - return x.ReplicaSetCount + return x.CpuLimit } - return 0 + return nil } -func (x *ResourceSummary) GetPodCount() int32 { +func (x *ContainerPercentileSummary) GetMemoryLimit() *MetricPercentiles { if x != nil { - return x.PodCount + return x.MemoryLimit } - return 0 + return nil } -func (x *ResourceSummary) GetContainerCount() int32 { +func (x *ContainerPercentileSummary) GetGpuUsage() *MetricPercentiles { if x != nil { - return x.ContainerCount + return x.GpuUsage } - return 0 + return nil } -func (x *ResourceSummary) GetPendingPods() int32 { +func (x *ContainerPercentileSummary) GetGpuVramUsage() *MetricPercentiles { if x != nil { - return x.PendingPods + return x.GpuVramUsage } - return 0 + return nil } -func (x *ResourceSummary) GetRunningPods() int32 { +// Deprecated: Marked as deprecated in api/v1/common.proto. +func (x *ContainerPercentileSummary) GetCurrentCpuRequest() float64 { if x != nil { - return x.RunningPods + return x.CurrentCpuRequest } return 0 } -func (x *ResourceSummary) GetSucceededPods() int32 { +// Deprecated: Marked as deprecated in api/v1/common.proto. +func (x *ContainerPercentileSummary) GetCurrentMemoryRequest() float64 { if x != nil { - return x.SucceededPods + return x.CurrentMemoryRequest } return 0 } -func (x *ResourceSummary) GetFailedPods() int32 { +// Deprecated: Marked as deprecated in api/v1/common.proto. +func (x *ContainerPercentileSummary) GetCurrentCpuLimit() float64 { if x != nil { - return x.FailedPods + return x.CurrentCpuLimit } return 0 } -func (x *ResourceSummary) GetUnknownPods() int32 { +// Deprecated: Marked as deprecated in api/v1/common.proto. +func (x *ContainerPercentileSummary) GetCurrentMemoryLimit() float64 { if x != nil { - return x.UnknownPods + return x.CurrentMemoryLimit } return 0 } -func (x *ResourceSummary) GetUnderProvisionedCount() int32 { +func (x *ContainerPercentileSummary) GetNetworkReceiveBytes() *MetricPercentiles { if x != nil { - return x.UnderProvisionedCount + return x.NetworkReceiveBytes } - return 0 + return nil } -func (x *ResourceSummary) GetOverProvisionedCount() int32 { +func (x *ContainerPercentileSummary) GetNetworkTransmitBytes() *MetricPercentiles { if x != nil { - return x.OverProvisionedCount + return x.NetworkTransmitBytes } - return 0 + return nil } -// WorkloadItem represents a Kubernetes resource and its hierarchical children. -type WorkloadItem struct { +// Deprecated: Marked as deprecated in api/v1/common.proto. +func (x *ContainerPercentileSummary) GetFsReadBytes() *MetricPercentiles { + if x != nil { + return x.FsReadBytes + } + return nil +} + +// Deprecated: Marked as deprecated in api/v1/common.proto. +func (x *ContainerPercentileSummary) GetFsWriteBytes() *MetricPercentiles { + if x != nil { + return x.FsWriteBytes + } + return nil +} + +// ContainerFsPercentileSummary contains filesystem I/O percentile statistics for a single container. +type ContainerFsPercentileSummary struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"` // Kind of the resource (e.g., Pod, Container, Deployment). - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` // Name of the resource. - Uid string `protobuf:"bytes,3,opt,name=uid,proto3" json:"uid,omitempty"` // Unique identifier for the resource. - Namespace string `protobuf:"bytes,4,opt,name=namespace,proto3" json:"namespace,omitempty"` // Namespace of the resource. - OwnerKind string `protobuf:"bytes,5,opt,name=owner_kind,json=ownerKind,proto3" json:"owner_kind,omitempty"` // Kind of the owning resource, if any. - OwnerUid string `protobuf:"bytes,6,opt,name=owner_uid,json=ownerUid,proto3" json:"owner_uid,omitempty"` // UID of the owning resource, if any. - Children []*WorkloadItem `protobuf:"bytes,7,rep,name=children,proto3" json:"children,omitempty"` // Child resources of this workload item. - Labels map[string]string `protobuf:"bytes,8,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Resource labels. - Annotations map[string]string `protobuf:"bytes,9,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Resource annotations. - CreationTimestamp int64 `protobuf:"varint,10,opt,name=creation_timestamp,json=creationTimestamp,proto3" json:"creation_timestamp,omitempty"` // Creation time as a Unix timestamp. - ResourceMetrics *ResourceMetrics `protobuf:"bytes,11,opt,name=resource_metrics,json=resourceMetrics,proto3" json:"resource_metrics,omitempty"` // Resource metrics for the workload item. - CostInfo *CostInfo `protobuf:"bytes,12,opt,name=cost_info,json=costInfo,proto3" json:"cost_info,omitempty"` // Cost information for the workload item. - CostDataPoints []*CostDataPoint `protobuf:"bytes,13,rep,name=cost_data_points,json=costDataPoints,proto3" json:"cost_data_points,omitempty"` // Time-series cost data points for the workload. - ResourceDataPoints []*ResourceDataPoint `protobuf:"bytes,14,rep,name=resource_data_points,json=resourceDataPoints,proto3" json:"resource_data_points,omitempty"` // Time-series resource metrics for the workload. - ImpactScore float64 `protobuf:"fixed64,15,opt,name=impact_score,json=impactScore,proto3" json:"impact_score,omitempty"` // Optimization impact score for workload - CreatedAt *timestamppb.Timestamp `protobuf:"bytes,16,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Creation time of the workload item. - DeletedAt *timestamppb.Timestamp `protobuf:"bytes,17,opt,name=deleted_at,json=deletedAt,proto3,oneof" json:"deleted_at,omitempty"` // Last update time of the workload item. - ClusterId string `protobuf:"bytes,18,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` // Cluster id of the workload - Id string `protobuf:"bytes,19,opt,name=id,proto3" json:"id,omitempty"` // DevZero unique identifier + ContainerName string `protobuf:"bytes,1,opt,name=container_name,json=containerName,proto3" json:"container_name,omitempty"` + FsReadBytes *MetricPercentiles `protobuf:"bytes,2,opt,name=fs_read_bytes,json=fsReadBytes,proto3" json:"fs_read_bytes,omitempty"` + FsWriteBytes *MetricPercentiles `protobuf:"bytes,3,opt,name=fs_write_bytes,json=fsWriteBytes,proto3" json:"fs_write_bytes,omitempty"` +} + +func (x *ContainerFsPercentileSummary) Reset() { + *x = ContainerFsPercentileSummary{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_common_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContainerFsPercentileSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerFsPercentileSummary) ProtoMessage() {} + +func (x *ContainerFsPercentileSummary) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_common_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) +} + +// Deprecated: Use ContainerFsPercentileSummary.ProtoReflect.Descriptor instead. +func (*ContainerFsPercentileSummary) Descriptor() ([]byte, []int) { + return file_api_v1_common_proto_rawDescGZIP(), []int{6} +} + +func (x *ContainerFsPercentileSummary) GetContainerName() string { + if x != nil { + return x.ContainerName + } + return "" +} + +func (x *ContainerFsPercentileSummary) GetFsReadBytes() *MetricPercentiles { + if x != nil { + return x.FsReadBytes + } + return nil +} + +func (x *ContainerFsPercentileSummary) GetFsWriteBytes() *MetricPercentiles { + if x != nil { + return x.FsWriteBytes + } + return nil +} + +// ContainerRequestLimits contains the latest request/limit values for a single container. +type ContainerRequestLimits struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ContainerName string `protobuf:"bytes,1,opt,name=container_name,json=containerName,proto3" json:"container_name,omitempty"` + CurrentCpuRequest float64 `protobuf:"fixed64,2,opt,name=current_cpu_request,json=currentCpuRequest,proto3" json:"current_cpu_request,omitempty"` + CurrentMemoryRequest float64 `protobuf:"fixed64,3,opt,name=current_memory_request,json=currentMemoryRequest,proto3" json:"current_memory_request,omitempty"` + CurrentCpuLimit float64 `protobuf:"fixed64,4,opt,name=current_cpu_limit,json=currentCpuLimit,proto3" json:"current_cpu_limit,omitempty"` + CurrentMemoryLimit float64 `protobuf:"fixed64,5,opt,name=current_memory_limit,json=currentMemoryLimit,proto3" json:"current_memory_limit,omitempty"` +} + +func (x *ContainerRequestLimits) Reset() { + *x = ContainerRequestLimits{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_common_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContainerRequestLimits) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerRequestLimits) ProtoMessage() {} + +func (x *ContainerRequestLimits) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_common_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) +} + +// Deprecated: Use ContainerRequestLimits.ProtoReflect.Descriptor instead. +func (*ContainerRequestLimits) Descriptor() ([]byte, []int) { + return file_api_v1_common_proto_rawDescGZIP(), []int{7} +} + +func (x *ContainerRequestLimits) GetContainerName() string { + if x != nil { + return x.ContainerName + } + return "" +} + +func (x *ContainerRequestLimits) GetCurrentCpuRequest() float64 { + if x != nil { + return x.CurrentCpuRequest + } + return 0 +} + +func (x *ContainerRequestLimits) GetCurrentMemoryRequest() float64 { + if x != nil { + return x.CurrentMemoryRequest + } + return 0 +} + +func (x *ContainerRequestLimits) GetCurrentCpuLimit() float64 { + if x != nil { + return x.CurrentCpuLimit + } + return 0 +} + +func (x *ContainerRequestLimits) GetCurrentMemoryLimit() float64 { + if x != nil { + return x.CurrentMemoryLimit + } + return 0 +} + +// ForecastResourceMetrics encapsulates Forecasted CPU and memory capacity, usage, and utilization for nodes and containers. +type ForecastResourceMetrics struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Timestamp *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Forecast timestamp. + ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` // Cluster id of the container. + ApplicationId string `protobuf:"bytes,3,opt,name=application_id,json=applicationId,proto3" json:"application_id,omitempty"` // Application id of the container. + ApplicationKind string `protobuf:"bytes,4,opt,name=application_kind,json=applicationKind,proto3" json:"application_kind,omitempty"` // Application kind of the container. + Model string `protobuf:"bytes,5,opt,name=model,proto3" json:"model,omitempty"` // Model used for the forecast + NodeCpuCapacity float64 `protobuf:"fixed64,6,opt,name=node_cpu_capacity,json=nodeCpuCapacity,proto3" json:"node_cpu_capacity,omitempty"` // Total CPU capacity of nodes. + NodeMemoryCapacity float64 `protobuf:"fixed64,7,opt,name=node_memory_capacity,json=nodeMemoryCapacity,proto3" json:"node_memory_capacity,omitempty"` // Total memory capacity of nodes. + NodeCpuUsage float64 `protobuf:"fixed64,8,opt,name=node_cpu_usage,json=nodeCpuUsage,proto3" json:"node_cpu_usage,omitempty"` // Current CPU usage of nodes. + NodeMemoryUsage float64 `protobuf:"fixed64,9,opt,name=node_memory_usage,json=nodeMemoryUsage,proto3" json:"node_memory_usage,omitempty"` // Current memory usage of nodes. + NodeCpuUtilization float64 `protobuf:"fixed64,10,opt,name=node_cpu_utilization,json=nodeCpuUtilization,proto3" json:"node_cpu_utilization,omitempty"` // CPU utilization percentage of nodes. + NodeMemoryUtilization float64 `protobuf:"fixed64,11,opt,name=node_memory_utilization,json=nodeMemoryUtilization,proto3" json:"node_memory_utilization,omitempty"` // Memory utilization percentage of nodes. + ContainerCpuUsage float64 `protobuf:"fixed64,12,opt,name=container_cpu_usage,json=containerCpuUsage,proto3" json:"container_cpu_usage,omitempty"` // Current CPU usage of containers. + ContainerMemoryUsage float64 `protobuf:"fixed64,13,opt,name=container_memory_usage,json=containerMemoryUsage,proto3" json:"container_memory_usage,omitempty"` // Current memory usage of containers. + ContainerCpuUtilization float64 `protobuf:"fixed64,14,opt,name=container_cpu_utilization,json=containerCpuUtilization,proto3" json:"container_cpu_utilization,omitempty"` // CPU utilization percentage of containers. + ContainerMemoryUtilization float64 `protobuf:"fixed64,15,opt,name=container_memory_utilization,json=containerMemoryUtilization,proto3" json:"container_memory_utilization,omitempty"` // Memory utilization percentage of containers. + ContainerCpuRequested float64 `protobuf:"fixed64,16,opt,name=container_cpu_requested,json=containerCpuRequested,proto3" json:"container_cpu_requested,omitempty"` // CPU requested by containers. + ContainerMemoryRequested float64 `protobuf:"fixed64,17,opt,name=container_memory_requested,json=containerMemoryRequested,proto3" json:"container_memory_requested,omitempty"` // Memory requested by containers. + ContainerCpuLimits float64 `protobuf:"fixed64,18,opt,name=container_cpu_limits,json=containerCpuLimits,proto3" json:"container_cpu_limits,omitempty"` // CPU limits of containers. + ContainerMemoryLimits float64 `protobuf:"fixed64,19,opt,name=container_memory_limits,json=containerMemoryLimits,proto3" json:"container_memory_limits,omitempty"` // Memory limits of containers. + ContainerGpuUsage float64 `protobuf:"fixed64,20,opt,name=container_gpu_usage,json=containerGpuUsage,proto3" json:"container_gpu_usage,omitempty"` // GPU usage of containers. + ContainerGpuRequested float64 `protobuf:"fixed64,21,opt,name=container_gpu_requested,json=containerGpuRequested,proto3" json:"container_gpu_requested,omitempty"` // GPU requests of containers. + ContainerGpuLimits float64 `protobuf:"fixed64,22,opt,name=container_gpu_limits,json=containerGpuLimits,proto3" json:"container_gpu_limits,omitempty"` // GPU limits of containers. + ContainerGpuUtilization float64 `protobuf:"fixed64,23,opt,name=container_gpu_utilization,json=containerGpuUtilization,proto3" json:"container_gpu_utilization,omitempty"` // GPU utilization of containers. + NodeGpuCapacity float64 `protobuf:"fixed64,24,opt,name=node_gpu_capacity,json=nodeGpuCapacity,proto3" json:"node_gpu_capacity,omitempty"` // GPU capcity of nodes. + NodeGpuUsage float64 `protobuf:"fixed64,25,opt,name=node_gpu_usage,json=nodeGpuUsage,proto3" json:"node_gpu_usage,omitempty"` // GPU usage of nodes. + NodeGpuUtilization float64 `protobuf:"fixed64,26,opt,name=node_gpu_utilization,json=nodeGpuUtilization,proto3" json:"node_gpu_utilization,omitempty"` // GPU utilization of nodes. + NodeGpuVramUsage float64 `protobuf:"fixed64,27,opt,name=node_gpu_vram_usage,json=nodeGpuVramUsage,proto3" json:"node_gpu_vram_usage,omitempty"` // GPU VRAM usage of nodes. + ContainerGpuVramUsage float64 `protobuf:"fixed64,28,opt,name=container_gpu_vram_usage,json=containerGpuVramUsage,proto3" json:"container_gpu_vram_usage,omitempty"` // GPU VRAM usage of containers. + NodeGpuVramCapacity float64 `protobuf:"fixed64,29,opt,name=node_gpu_vram_capacity,json=nodeGpuVramCapacity,proto3" json:"node_gpu_vram_capacity,omitempty"` // GPU VRAM capacity of nodes. + NodeGpuVramUtilization float64 `protobuf:"fixed64,30,opt,name=node_gpu_vram_utilization,json=nodeGpuVramUtilization,proto3" json:"node_gpu_vram_utilization,omitempty"` // GPU VRAM utilization of nodes. + NormalizedNodeMemoryCapacity float64 `protobuf:"fixed64,31,opt,name=normalized_node_memory_capacity,json=normalizedNodeMemoryCapacity,proto3" json:"normalized_node_memory_capacity,omitempty"` // Total memory capacity of nodes, normalized to cover for missing bytes. + NormalizedGpuVramCapacity float64 `protobuf:"fixed64,32,opt,name=normalized_gpu_vram_capacity,json=normalizedGpuVramCapacity,proto3" json:"normalized_gpu_vram_capacity,omitempty"` // Normalized GPU VRAM capacity of nodes. +} + +func (x *ForecastResourceMetrics) Reset() { + *x = ForecastResourceMetrics{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_common_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ForecastResourceMetrics) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ForecastResourceMetrics) ProtoMessage() {} + +func (x *ForecastResourceMetrics) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_common_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) +} + +// Deprecated: Use ForecastResourceMetrics.ProtoReflect.Descriptor instead. +func (*ForecastResourceMetrics) Descriptor() ([]byte, []int) { + return file_api_v1_common_proto_rawDescGZIP(), []int{8} +} + +func (x *ForecastResourceMetrics) GetTimestamp() *timestamppb.Timestamp { + if x != nil { + return x.Timestamp + } + return nil +} + +func (x *ForecastResourceMetrics) GetClusterId() string { + if x != nil { + return x.ClusterId + } + return "" +} + +func (x *ForecastResourceMetrics) GetApplicationId() string { + if x != nil { + return x.ApplicationId + } + return "" +} + +func (x *ForecastResourceMetrics) GetApplicationKind() string { + if x != nil { + return x.ApplicationKind + } + return "" +} + +func (x *ForecastResourceMetrics) GetModel() string { + if x != nil { + return x.Model + } + return "" +} + +func (x *ForecastResourceMetrics) GetNodeCpuCapacity() float64 { + if x != nil { + return x.NodeCpuCapacity + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeMemoryCapacity() float64 { + if x != nil { + return x.NodeMemoryCapacity + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeCpuUsage() float64 { + if x != nil { + return x.NodeCpuUsage + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeMemoryUsage() float64 { + if x != nil { + return x.NodeMemoryUsage + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeCpuUtilization() float64 { + if x != nil { + return x.NodeCpuUtilization + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeMemoryUtilization() float64 { + if x != nil { + return x.NodeMemoryUtilization + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerCpuUsage() float64 { + if x != nil { + return x.ContainerCpuUsage + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerMemoryUsage() float64 { + if x != nil { + return x.ContainerMemoryUsage + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerCpuUtilization() float64 { + if x != nil { + return x.ContainerCpuUtilization + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerMemoryUtilization() float64 { + if x != nil { + return x.ContainerMemoryUtilization + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerCpuRequested() float64 { + if x != nil { + return x.ContainerCpuRequested + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerMemoryRequested() float64 { + if x != nil { + return x.ContainerMemoryRequested + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerCpuLimits() float64 { + if x != nil { + return x.ContainerCpuLimits + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerMemoryLimits() float64 { + if x != nil { + return x.ContainerMemoryLimits + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerGpuUsage() float64 { + if x != nil { + return x.ContainerGpuUsage + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerGpuRequested() float64 { + if x != nil { + return x.ContainerGpuRequested + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerGpuLimits() float64 { + if x != nil { + return x.ContainerGpuLimits + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerGpuUtilization() float64 { + if x != nil { + return x.ContainerGpuUtilization + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeGpuCapacity() float64 { + if x != nil { + return x.NodeGpuCapacity + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeGpuUsage() float64 { + if x != nil { + return x.NodeGpuUsage + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeGpuUtilization() float64 { + if x != nil { + return x.NodeGpuUtilization + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeGpuVramUsage() float64 { + if x != nil { + return x.NodeGpuVramUsage + } + return 0 +} + +func (x *ForecastResourceMetrics) GetContainerGpuVramUsage() float64 { + if x != nil { + return x.ContainerGpuVramUsage + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeGpuVramCapacity() float64 { + if x != nil { + return x.NodeGpuVramCapacity + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNodeGpuVramUtilization() float64 { + if x != nil { + return x.NodeGpuVramUtilization + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNormalizedNodeMemoryCapacity() float64 { + if x != nil { + return x.NormalizedNodeMemoryCapacity + } + return 0 +} + +func (x *ForecastResourceMetrics) GetNormalizedGpuVramCapacity() float64 { + if x != nil { + return x.NormalizedGpuVramCapacity + } + return 0 +} + +// ResourceSummary provides aggregated resource counts and pod status counts for a cluster or workload. +type ResourceSummary struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + DeploymentCount int32 `protobuf:"varint,1,opt,name=deployment_count,json=deploymentCount,proto3" json:"deployment_count,omitempty"` // Number of Deployments. + StatefulSetCount int32 `protobuf:"varint,2,opt,name=stateful_set_count,json=statefulSetCount,proto3" json:"stateful_set_count,omitempty"` // Number of StatefulSets. + DaemonSetCount int32 `protobuf:"varint,3,opt,name=daemon_set_count,json=daemonSetCount,proto3" json:"daemon_set_count,omitempty"` // Number of DaemonSets. + JobCount int32 `protobuf:"varint,4,opt,name=job_count,json=jobCount,proto3" json:"job_count,omitempty"` // Number of Jobs. + CronJobCount int32 `protobuf:"varint,5,opt,name=cron_job_count,json=cronJobCount,proto3" json:"cron_job_count,omitempty"` // Number of CronJobs. + ReplicaSetCount int32 `protobuf:"varint,6,opt,name=replica_set_count,json=replicaSetCount,proto3" json:"replica_set_count,omitempty"` // Number of ReplicaSets. + PodCount int32 `protobuf:"varint,7,opt,name=pod_count,json=podCount,proto3" json:"pod_count,omitempty"` // Number of Pods. + ContainerCount int32 `protobuf:"varint,8,opt,name=container_count,json=containerCount,proto3" json:"container_count,omitempty"` // Number of Containers. + PendingPods int32 `protobuf:"varint,9,opt,name=pending_pods,json=pendingPods,proto3" json:"pending_pods,omitempty"` // Number of Pods in Pending state. + RunningPods int32 `protobuf:"varint,10,opt,name=running_pods,json=runningPods,proto3" json:"running_pods,omitempty"` // Number of Pods in Running state. + SucceededPods int32 `protobuf:"varint,11,opt,name=succeeded_pods,json=succeededPods,proto3" json:"succeeded_pods,omitempty"` // Number of Pods in Succeeded state. + FailedPods int32 `protobuf:"varint,12,opt,name=failed_pods,json=failedPods,proto3" json:"failed_pods,omitempty"` // Number of Pods in Failed state. + UnknownPods int32 `protobuf:"varint,13,opt,name=unknown_pods,json=unknownPods,proto3" json:"unknown_pods,omitempty"` // Number of Pods in Unknown state. + UnderProvisionedCount int32 `protobuf:"varint,14,opt,name=under_provisioned_count,json=underProvisionedCount,proto3" json:"under_provisioned_count,omitempty"` // Number of resources under-provisioned. + OverProvisionedCount int32 `protobuf:"varint,15,opt,name=over_provisioned_count,json=overProvisionedCount,proto3" json:"over_provisioned_count,omitempty"` // Number of resources over-provisioned. +} + +func (x *ResourceSummary) Reset() { + *x = ResourceSummary{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_common_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ResourceSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResourceSummary) ProtoMessage() {} + +func (x *ResourceSummary) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_common_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 mi.MessageOf(x) +} + +// Deprecated: Use ResourceSummary.ProtoReflect.Descriptor instead. +func (*ResourceSummary) Descriptor() ([]byte, []int) { + return file_api_v1_common_proto_rawDescGZIP(), []int{9} +} + +func (x *ResourceSummary) GetDeploymentCount() int32 { + if x != nil { + return x.DeploymentCount + } + return 0 +} + +func (x *ResourceSummary) GetStatefulSetCount() int32 { + if x != nil { + return x.StatefulSetCount + } + return 0 +} + +func (x *ResourceSummary) GetDaemonSetCount() int32 { + if x != nil { + return x.DaemonSetCount + } + return 0 +} + +func (x *ResourceSummary) GetJobCount() int32 { + if x != nil { + return x.JobCount + } + return 0 +} + +func (x *ResourceSummary) GetCronJobCount() int32 { + if x != nil { + return x.CronJobCount + } + return 0 +} + +func (x *ResourceSummary) GetReplicaSetCount() int32 { + if x != nil { + return x.ReplicaSetCount + } + return 0 +} + +func (x *ResourceSummary) GetPodCount() int32 { + if x != nil { + return x.PodCount + } + return 0 +} + +func (x *ResourceSummary) GetContainerCount() int32 { + if x != nil { + return x.ContainerCount + } + return 0 +} + +func (x *ResourceSummary) GetPendingPods() int32 { + if x != nil { + return x.PendingPods + } + return 0 +} + +func (x *ResourceSummary) GetRunningPods() int32 { + if x != nil { + return x.RunningPods + } + return 0 +} + +func (x *ResourceSummary) GetSucceededPods() int32 { + if x != nil { + return x.SucceededPods + } + return 0 +} + +func (x *ResourceSummary) GetFailedPods() int32 { + if x != nil { + return x.FailedPods + } + return 0 +} + +func (x *ResourceSummary) GetUnknownPods() int32 { + if x != nil { + return x.UnknownPods + } + return 0 +} + +func (x *ResourceSummary) GetUnderProvisionedCount() int32 { + if x != nil { + return x.UnderProvisionedCount + } + return 0 +} + +func (x *ResourceSummary) GetOverProvisionedCount() int32 { + if x != nil { + return x.OverProvisionedCount + } + return 0 +} + +// WorkloadItem represents a Kubernetes resource and its hierarchical children. +type WorkloadItem struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"` // Kind of the resource (e.g., Pod, Container, Deployment). + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` // Name of the resource. + Uid string `protobuf:"bytes,3,opt,name=uid,proto3" json:"uid,omitempty"` // Unique identifier for the resource. + Namespace string `protobuf:"bytes,4,opt,name=namespace,proto3" json:"namespace,omitempty"` // Namespace of the resource. + OwnerKind string `protobuf:"bytes,5,opt,name=owner_kind,json=ownerKind,proto3" json:"owner_kind,omitempty"` // Kind of the owning resource, if any. + OwnerUid string `protobuf:"bytes,6,opt,name=owner_uid,json=ownerUid,proto3" json:"owner_uid,omitempty"` // UID of the owning resource, if any. + Children []*WorkloadItem `protobuf:"bytes,7,rep,name=children,proto3" json:"children,omitempty"` // Child resources of this workload item. + Labels map[string]string `protobuf:"bytes,8,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Resource labels. + Annotations map[string]string `protobuf:"bytes,9,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Resource annotations. + CreationTimestamp int64 `protobuf:"varint,10,opt,name=creation_timestamp,json=creationTimestamp,proto3" json:"creation_timestamp,omitempty"` // Creation time as a Unix timestamp. + ResourceMetrics *ResourceMetrics `protobuf:"bytes,11,opt,name=resource_metrics,json=resourceMetrics,proto3" json:"resource_metrics,omitempty"` // Resource metrics for the workload item. + CostInfo *CostInfo `protobuf:"bytes,12,opt,name=cost_info,json=costInfo,proto3" json:"cost_info,omitempty"` // Cost information for the workload item. + CostDataPoints []*CostDataPoint `protobuf:"bytes,13,rep,name=cost_data_points,json=costDataPoints,proto3" json:"cost_data_points,omitempty"` // Time-series cost data points for the workload. + ResourceDataPoints []*ResourceDataPoint `protobuf:"bytes,14,rep,name=resource_data_points,json=resourceDataPoints,proto3" json:"resource_data_points,omitempty"` // Time-series resource metrics for the workload. + ImpactScore float64 `protobuf:"fixed64,15,opt,name=impact_score,json=impactScore,proto3" json:"impact_score,omitempty"` // Optimization impact score for workload + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,16,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Creation time of the workload item. + DeletedAt *timestamppb.Timestamp `protobuf:"bytes,17,opt,name=deleted_at,json=deletedAt,proto3,oneof" json:"deleted_at,omitempty"` // Last update time of the workload item. + ClusterId string `protobuf:"bytes,18,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` // Cluster id of the workload + Id string `protobuf:"bytes,19,opt,name=id,proto3" json:"id,omitempty"` // DevZero unique identifier // Resource-specific details for different K8s resource types IsKarpenterResource bool `protobuf:"varint,20,opt,name=is_karpenter_resource,json=isKarpenterResource,proto3" json:"is_karpenter_resource,omitempty"` ResourceDetails *ResourceDetails `protobuf:"bytes,30,opt,name=resource_details,json=resourceDetails,proto3,oneof" json:"resource_details,omitempty"` @@ -2013,7 +2606,7 @@ type WorkloadItem struct { func (x *WorkloadItem) Reset() { *x = WorkloadItem{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[6] + mi := &file_api_v1_common_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2026,7 +2619,7 @@ func (x *WorkloadItem) String() string { func (*WorkloadItem) ProtoMessage() {} func (x *WorkloadItem) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[6] + mi := &file_api_v1_common_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2039,7 +2632,7 @@ func (x *WorkloadItem) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkloadItem.ProtoReflect.Descriptor instead. func (*WorkloadItem) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{6} + return file_api_v1_common_proto_rawDescGZIP(), []int{10} } func (x *WorkloadItem) GetKind() string { @@ -2244,7 +2837,7 @@ type ContainerRuntimeInfo struct { func (x *ContainerRuntimeInfo) Reset() { *x = ContainerRuntimeInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[7] + mi := &file_api_v1_common_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2257,7 +2850,7 @@ func (x *ContainerRuntimeInfo) String() string { func (*ContainerRuntimeInfo) ProtoMessage() {} func (x *ContainerRuntimeInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[7] + mi := &file_api_v1_common_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2270,7 +2863,7 @@ func (x *ContainerRuntimeInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ContainerRuntimeInfo.ProtoReflect.Descriptor instead. func (*ContainerRuntimeInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{7} + return file_api_v1_common_proto_rawDescGZIP(), []int{11} } func (x *ContainerRuntimeInfo) GetRuntimeName() string { @@ -2303,7 +2896,7 @@ type NodeInfo struct { func (x *NodeInfo) Reset() { *x = NodeInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[8] + mi := &file_api_v1_common_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2316,7 +2909,7 @@ func (x *NodeInfo) String() string { func (*NodeInfo) ProtoMessage() {} func (x *NodeInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[8] + mi := &file_api_v1_common_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2329,7 +2922,7 @@ func (x *NodeInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeInfo.ProtoReflect.Descriptor instead. func (*NodeInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{8} + return file_api_v1_common_proto_rawDescGZIP(), []int{12} } func (x *NodeInfo) GetNodeCount() int32 { @@ -2382,7 +2975,7 @@ type ResourceInfo struct { func (x *ResourceInfo) Reset() { *x = ResourceInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[9] + mi := &file_api_v1_common_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2395,7 +2988,7 @@ func (x *ResourceInfo) String() string { func (*ResourceInfo) ProtoMessage() {} func (x *ResourceInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[9] + mi := &file_api_v1_common_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2408,7 +3001,7 @@ func (x *ResourceInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceInfo.ProtoReflect.Descriptor instead. func (*ResourceInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{9} + return file_api_v1_common_proto_rawDescGZIP(), []int{13} } func (x *ResourceInfo) GetResourcesCount() int32 { @@ -2507,7 +3100,7 @@ type Node struct { func (x *Node) Reset() { *x = Node{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[10] + mi := &file_api_v1_common_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2520,7 +3113,7 @@ func (x *Node) String() string { func (*Node) ProtoMessage() {} func (x *Node) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[10] + mi := &file_api_v1_common_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2533,7 +3126,7 @@ func (x *Node) ProtoReflect() protoreflect.Message { // Deprecated: Use Node.ProtoReflect.Descriptor instead. func (*Node) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{10} + return file_api_v1_common_proto_rawDescGZIP(), []int{14} } func (x *Node) GetId() string { @@ -2849,7 +3442,7 @@ type AttachedVolume struct { func (x *AttachedVolume) Reset() { *x = AttachedVolume{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[11] + mi := &file_api_v1_common_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2862,7 +3455,7 @@ func (x *AttachedVolume) String() string { func (*AttachedVolume) ProtoMessage() {} func (x *AttachedVolume) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[11] + mi := &file_api_v1_common_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2875,7 +3468,7 @@ func (x *AttachedVolume) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachedVolume.ProtoReflect.Descriptor instead. func (*AttachedVolume) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{11} + return file_api_v1_common_proto_rawDescGZIP(), []int{15} } func (x *AttachedVolume) GetName() string { @@ -2911,7 +3504,7 @@ type NodeGroup struct { func (x *NodeGroup) Reset() { *x = NodeGroup{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[12] + mi := &file_api_v1_common_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2924,7 +3517,7 @@ func (x *NodeGroup) String() string { func (*NodeGroup) ProtoMessage() {} func (x *NodeGroup) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[12] + mi := &file_api_v1_common_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2937,7 +3530,7 @@ func (x *NodeGroup) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeGroup.ProtoReflect.Descriptor instead. func (*NodeGroup) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{12} + return file_api_v1_common_proto_rawDescGZIP(), []int{16} } func (x *NodeGroup) GetName() string { @@ -3009,7 +3602,7 @@ type CostDataPoint struct { func (x *CostDataPoint) Reset() { *x = CostDataPoint{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[13] + mi := &file_api_v1_common_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3022,7 +3615,7 @@ func (x *CostDataPoint) String() string { func (*CostDataPoint) ProtoMessage() {} func (x *CostDataPoint) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[13] + mi := &file_api_v1_common_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3035,7 +3628,7 @@ func (x *CostDataPoint) ProtoReflect() protoreflect.Message { // Deprecated: Use CostDataPoint.ProtoReflect.Descriptor instead. func (*CostDataPoint) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{13} + return file_api_v1_common_proto_rawDescGZIP(), []int{17} } func (x *CostDataPoint) GetTimestamp() int64 { @@ -3065,7 +3658,7 @@ type ResourceDataPoint struct { func (x *ResourceDataPoint) Reset() { *x = ResourceDataPoint{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[14] + mi := &file_api_v1_common_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3078,7 +3671,7 @@ func (x *ResourceDataPoint) String() string { func (*ResourceDataPoint) ProtoMessage() {} func (x *ResourceDataPoint) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[14] + mi := &file_api_v1_common_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3091,7 +3684,7 @@ func (x *ResourceDataPoint) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceDataPoint.ProtoReflect.Descriptor instead. func (*ResourceDataPoint) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{14} + return file_api_v1_common_proto_rawDescGZIP(), []int{18} } func (x *ResourceDataPoint) GetTimestamp() int64 { @@ -3127,7 +3720,7 @@ type SavingsData struct { func (x *SavingsData) Reset() { *x = SavingsData{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[15] + mi := &file_api_v1_common_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3140,7 +3733,7 @@ func (x *SavingsData) String() string { func (*SavingsData) ProtoMessage() {} func (x *SavingsData) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[15] + mi := &file_api_v1_common_proto_msgTypes[19] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3153,7 +3746,7 @@ func (x *SavingsData) ProtoReflect() protoreflect.Message { // Deprecated: Use SavingsData.ProtoReflect.Descriptor instead. func (*SavingsData) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{15} + return file_api_v1_common_proto_rawDescGZIP(), []int{19} } func (x *SavingsData) GetCpuSavingsMillicores() float64 { @@ -3231,7 +3824,7 @@ type SavingsDataPoint struct { func (x *SavingsDataPoint) Reset() { *x = SavingsDataPoint{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[16] + mi := &file_api_v1_common_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3244,7 +3837,7 @@ func (x *SavingsDataPoint) String() string { func (*SavingsDataPoint) ProtoMessage() {} func (x *SavingsDataPoint) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[16] + mi := &file_api_v1_common_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3257,7 +3850,7 @@ func (x *SavingsDataPoint) ProtoReflect() protoreflect.Message { // Deprecated: Use SavingsDataPoint.ProtoReflect.Descriptor instead. func (*SavingsDataPoint) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{16} + return file_api_v1_common_proto_rawDescGZIP(), []int{20} } func (x *SavingsDataPoint) GetTimestamp() int64 { @@ -3288,7 +3881,7 @@ type SavingsTimeSeries struct { func (x *SavingsTimeSeries) Reset() { *x = SavingsTimeSeries{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[17] + mi := &file_api_v1_common_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3301,7 +3894,7 @@ func (x *SavingsTimeSeries) String() string { func (*SavingsTimeSeries) ProtoMessage() {} func (x *SavingsTimeSeries) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[17] + mi := &file_api_v1_common_proto_msgTypes[21] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3314,7 +3907,7 @@ func (x *SavingsTimeSeries) ProtoReflect() protoreflect.Message { // Deprecated: Use SavingsTimeSeries.ProtoReflect.Descriptor instead. func (*SavingsTimeSeries) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{17} + return file_api_v1_common_proto_rawDescGZIP(), []int{21} } func (x *SavingsTimeSeries) GetSavingsDatapoints() []*SavingsDataPoint { @@ -3367,7 +3960,7 @@ type LabelSelectorRequirement struct { func (x *LabelSelectorRequirement) Reset() { *x = LabelSelectorRequirement{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[18] + mi := &file_api_v1_common_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3380,7 +3973,7 @@ func (x *LabelSelectorRequirement) String() string { func (*LabelSelectorRequirement) ProtoMessage() {} func (x *LabelSelectorRequirement) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[18] + mi := &file_api_v1_common_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3393,7 +3986,7 @@ func (x *LabelSelectorRequirement) ProtoReflect() protoreflect.Message { // Deprecated: Use LabelSelectorRequirement.ProtoReflect.Descriptor instead. func (*LabelSelectorRequirement) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{18} + return file_api_v1_common_proto_rawDescGZIP(), []int{22} } func (x *LabelSelectorRequirement) GetKey() string { @@ -3429,7 +4022,7 @@ type Label struct { func (x *Label) Reset() { *x = Label{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[19] + mi := &file_api_v1_common_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3442,7 +4035,7 @@ func (x *Label) String() string { func (*Label) ProtoMessage() {} func (x *Label) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[19] + mi := &file_api_v1_common_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3455,7 +4048,7 @@ func (x *Label) ProtoReflect() protoreflect.Message { // Deprecated: Use Label.ProtoReflect.Descriptor instead. func (*Label) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{19} + return file_api_v1_common_proto_rawDescGZIP(), []int{23} } func (x *Label) GetKey() string { @@ -3495,7 +4088,7 @@ type LabelSelector struct { func (x *LabelSelector) Reset() { *x = LabelSelector{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[20] + mi := &file_api_v1_common_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3508,7 +4101,7 @@ func (x *LabelSelector) String() string { func (*LabelSelector) ProtoMessage() {} func (x *LabelSelector) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[20] + mi := &file_api_v1_common_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3521,7 +4114,7 @@ func (x *LabelSelector) ProtoReflect() protoreflect.Message { // Deprecated: Use LabelSelector.ProtoReflect.Descriptor instead. func (*LabelSelector) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{20} + return file_api_v1_common_proto_rawDescGZIP(), []int{24} } // Deprecated: Marked as deprecated in api/v1/common.proto. @@ -3559,7 +4152,7 @@ type RegexPattern struct { func (x *RegexPattern) Reset() { *x = RegexPattern{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[21] + mi := &file_api_v1_common_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3572,7 +4165,7 @@ func (x *RegexPattern) String() string { func (*RegexPattern) ProtoMessage() {} func (x *RegexPattern) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[21] + mi := &file_api_v1_common_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3585,7 +4178,7 @@ func (x *RegexPattern) ProtoReflect() protoreflect.Message { // Deprecated: Use RegexPattern.ProtoReflect.Descriptor instead. func (*RegexPattern) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{21} + return file_api_v1_common_proto_rawDescGZIP(), []int{25} } func (x *RegexPattern) GetPattern() string { @@ -3812,7 +4405,7 @@ type ResourceDetails struct { func (x *ResourceDetails) Reset() { *x = ResourceDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[22] + mi := &file_api_v1_common_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3825,7 +4418,7 @@ func (x *ResourceDetails) String() string { func (*ResourceDetails) ProtoMessage() {} func (x *ResourceDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[22] + mi := &file_api_v1_common_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3838,7 +4431,7 @@ func (x *ResourceDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceDetails.ProtoReflect.Descriptor instead. func (*ResourceDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{22} + return file_api_v1_common_proto_rawDescGZIP(), []int{26} } func (m *ResourceDetails) GetDetails() isResourceDetails_Details { @@ -5299,7 +5892,7 @@ type PodDetails struct { func (x *PodDetails) Reset() { *x = PodDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[23] + mi := &file_api_v1_common_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5312,7 +5905,7 @@ func (x *PodDetails) String() string { func (*PodDetails) ProtoMessage() {} func (x *PodDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[23] + mi := &file_api_v1_common_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5325,7 +5918,7 @@ func (x *PodDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use PodDetails.ProtoReflect.Descriptor instead. func (*PodDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{23} + return file_api_v1_common_proto_rawDescGZIP(), []int{27} } func (x *PodDetails) GetContainers() []*ContainerSummary { @@ -5352,7 +5945,7 @@ type ContainerSummary struct { func (x *ContainerSummary) Reset() { *x = ContainerSummary{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[24] + mi := &file_api_v1_common_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5365,7 +5958,7 @@ func (x *ContainerSummary) String() string { func (*ContainerSummary) ProtoMessage() {} func (x *ContainerSummary) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[24] + mi := &file_api_v1_common_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5378,7 +5971,7 @@ func (x *ContainerSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use ContainerSummary.ProtoReflect.Descriptor instead. func (*ContainerSummary) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{24} + return file_api_v1_common_proto_rawDescGZIP(), []int{28} } func (x *ContainerSummary) GetName() string { @@ -5436,7 +6029,7 @@ type DeploymentDetails struct { func (x *DeploymentDetails) Reset() { *x = DeploymentDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[25] + mi := &file_api_v1_common_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5449,7 +6042,7 @@ func (x *DeploymentDetails) String() string { func (*DeploymentDetails) ProtoMessage() {} func (x *DeploymentDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[25] + mi := &file_api_v1_common_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5462,7 +6055,7 @@ func (x *DeploymentDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use DeploymentDetails.ProtoReflect.Descriptor instead. func (*DeploymentDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{25} + return file_api_v1_common_proto_rawDescGZIP(), []int{29} } func (x *DeploymentDetails) GetContainers() []*ContainerTemplate { @@ -5496,7 +6089,7 @@ type ContainerTemplate struct { func (x *ContainerTemplate) Reset() { *x = ContainerTemplate{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[26] + mi := &file_api_v1_common_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5509,7 +6102,7 @@ func (x *ContainerTemplate) String() string { func (*ContainerTemplate) ProtoMessage() {} func (x *ContainerTemplate) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[26] + mi := &file_api_v1_common_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5522,7 +6115,7 @@ func (x *ContainerTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use ContainerTemplate.ProtoReflect.Descriptor instead. func (*ContainerTemplate) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{26} + return file_api_v1_common_proto_rawDescGZIP(), []int{30} } func (x *ContainerTemplate) GetName() string { @@ -5583,7 +6176,7 @@ type DeploymentCondition struct { func (x *DeploymentCondition) Reset() { *x = DeploymentCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[27] + mi := &file_api_v1_common_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5596,7 +6189,7 @@ func (x *DeploymentCondition) String() string { func (*DeploymentCondition) ProtoMessage() {} func (x *DeploymentCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[27] + mi := &file_api_v1_common_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5609,7 +6202,7 @@ func (x *DeploymentCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use DeploymentCondition.ProtoReflect.Descriptor instead. func (*DeploymentCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{27} + return file_api_v1_common_proto_rawDescGZIP(), []int{31} } func (x *DeploymentCondition) GetType() string { @@ -5661,7 +6254,7 @@ type StatefulSetDetails struct { func (x *StatefulSetDetails) Reset() { *x = StatefulSetDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[28] + mi := &file_api_v1_common_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5674,7 +6267,7 @@ func (x *StatefulSetDetails) String() string { func (*StatefulSetDetails) ProtoMessage() {} func (x *StatefulSetDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[28] + mi := &file_api_v1_common_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5687,7 +6280,7 @@ func (x *StatefulSetDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use StatefulSetDetails.ProtoReflect.Descriptor instead. func (*StatefulSetDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{28} + return file_api_v1_common_proto_rawDescGZIP(), []int{32} } func (x *StatefulSetDetails) GetContainers() []*ContainerTemplate { @@ -5727,7 +6320,7 @@ type VolumeClaimTemplate struct { func (x *VolumeClaimTemplate) Reset() { *x = VolumeClaimTemplate{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[29] + mi := &file_api_v1_common_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5740,7 +6333,7 @@ func (x *VolumeClaimTemplate) String() string { func (*VolumeClaimTemplate) ProtoMessage() {} func (x *VolumeClaimTemplate) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[29] + mi := &file_api_v1_common_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5753,7 +6346,7 @@ func (x *VolumeClaimTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use VolumeClaimTemplate.ProtoReflect.Descriptor instead. func (*VolumeClaimTemplate) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{29} + return file_api_v1_common_proto_rawDescGZIP(), []int{33} } func (x *VolumeClaimTemplate) GetName() string { @@ -5805,7 +6398,7 @@ type DaemonSetDetails struct { func (x *DaemonSetDetails) Reset() { *x = DaemonSetDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[30] + mi := &file_api_v1_common_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5818,7 +6411,7 @@ func (x *DaemonSetDetails) String() string { func (*DaemonSetDetails) ProtoMessage() {} func (x *DaemonSetDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[30] + mi := &file_api_v1_common_proto_msgTypes[34] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5831,7 +6424,7 @@ func (x *DaemonSetDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use DaemonSetDetails.ProtoReflect.Descriptor instead. func (*DaemonSetDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{30} + return file_api_v1_common_proto_rawDescGZIP(), []int{34} } func (x *DaemonSetDetails) GetContainers() []*ContainerTemplate { @@ -5868,7 +6461,7 @@ type ReplicaSetDetails struct { func (x *ReplicaSetDetails) Reset() { *x = ReplicaSetDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[31] + mi := &file_api_v1_common_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5881,7 +6474,7 @@ func (x *ReplicaSetDetails) String() string { func (*ReplicaSetDetails) ProtoMessage() {} func (x *ReplicaSetDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[31] + mi := &file_api_v1_common_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5894,7 +6487,7 @@ func (x *ReplicaSetDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ReplicaSetDetails.ProtoReflect.Descriptor instead. func (*ReplicaSetDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{31} + return file_api_v1_common_proto_rawDescGZIP(), []int{35} } func (x *ReplicaSetDetails) GetContainers() []*ContainerTemplate { @@ -5925,7 +6518,7 @@ type JobDetails struct { func (x *JobDetails) Reset() { *x = JobDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[32] + mi := &file_api_v1_common_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5938,7 +6531,7 @@ func (x *JobDetails) String() string { func (*JobDetails) ProtoMessage() {} func (x *JobDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[32] + mi := &file_api_v1_common_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5951,7 +6544,7 @@ func (x *JobDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use JobDetails.ProtoReflect.Descriptor instead. func (*JobDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{32} + return file_api_v1_common_proto_rawDescGZIP(), []int{36} } func (x *JobDetails) GetContainers() []*ContainerTemplate { @@ -5992,7 +6585,7 @@ type JobCondition struct { func (x *JobCondition) Reset() { *x = JobCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[33] + mi := &file_api_v1_common_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6005,7 +6598,7 @@ func (x *JobCondition) String() string { func (*JobCondition) ProtoMessage() {} func (x *JobCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[33] + mi := &file_api_v1_common_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6018,7 +6611,7 @@ func (x *JobCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use JobCondition.ProtoReflect.Descriptor instead. func (*JobCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{33} + return file_api_v1_common_proto_rawDescGZIP(), []int{37} } func (x *JobCondition) GetType() string { @@ -6077,7 +6670,7 @@ type CronJobDetails struct { func (x *CronJobDetails) Reset() { *x = CronJobDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[34] + mi := &file_api_v1_common_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6090,7 +6683,7 @@ func (x *CronJobDetails) String() string { func (*CronJobDetails) ProtoMessage() {} func (x *CronJobDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[34] + mi := &file_api_v1_common_proto_msgTypes[38] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6103,7 +6696,7 @@ func (x *CronJobDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use CronJobDetails.ProtoReflect.Descriptor instead. func (*CronJobDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{34} + return file_api_v1_common_proto_rawDescGZIP(), []int{38} } func (x *CronJobDetails) GetContainers() []*ContainerTemplate { @@ -6142,7 +6735,7 @@ type ActiveJobReference struct { func (x *ActiveJobReference) Reset() { *x = ActiveJobReference{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[35] + mi := &file_api_v1_common_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6155,7 +6748,7 @@ func (x *ActiveJobReference) String() string { func (*ActiveJobReference) ProtoMessage() {} func (x *ActiveJobReference) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[35] + mi := &file_api_v1_common_proto_msgTypes[39] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6168,7 +6761,7 @@ func (x *ActiveJobReference) ProtoReflect() protoreflect.Message { // Deprecated: Use ActiveJobReference.ProtoReflect.Descriptor instead. func (*ActiveJobReference) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{35} + return file_api_v1_common_proto_rawDescGZIP(), []int{39} } func (x *ActiveJobReference) GetName() string { @@ -6215,7 +6808,7 @@ type JobTemplate struct { func (x *JobTemplate) Reset() { *x = JobTemplate{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[36] + mi := &file_api_v1_common_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6228,7 +6821,7 @@ func (x *JobTemplate) String() string { func (*JobTemplate) ProtoMessage() {} func (x *JobTemplate) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[36] + mi := &file_api_v1_common_proto_msgTypes[40] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6241,7 +6834,7 @@ func (x *JobTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use JobTemplate.ProtoReflect.Descriptor instead. func (*JobTemplate) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{36} + return file_api_v1_common_proto_rawDescGZIP(), []int{40} } func (x *JobTemplate) GetContainers() []*ContainerTemplate { @@ -6294,7 +6887,7 @@ type ServiceDetails struct { func (x *ServiceDetails) Reset() { *x = ServiceDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[37] + mi := &file_api_v1_common_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6307,7 +6900,7 @@ func (x *ServiceDetails) String() string { func (*ServiceDetails) ProtoMessage() {} func (x *ServiceDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[37] + mi := &file_api_v1_common_proto_msgTypes[41] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6320,7 +6913,7 @@ func (x *ServiceDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceDetails.ProtoReflect.Descriptor instead. func (*ServiceDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{37} + return file_api_v1_common_proto_rawDescGZIP(), []int{41} } func (x *ServiceDetails) GetPorts() []*ServicePort { @@ -6369,7 +6962,7 @@ type ServicePort struct { func (x *ServicePort) Reset() { *x = ServicePort{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[38] + mi := &file_api_v1_common_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6382,7 +6975,7 @@ func (x *ServicePort) String() string { func (*ServicePort) ProtoMessage() {} func (x *ServicePort) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[38] + mi := &file_api_v1_common_proto_msgTypes[42] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6395,7 +6988,7 @@ func (x *ServicePort) ProtoReflect() protoreflect.Message { // Deprecated: Use ServicePort.ProtoReflect.Descriptor instead. func (*ServicePort) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{38} + return file_api_v1_common_proto_rawDescGZIP(), []int{42} } func (x *ServicePort) GetName() string { @@ -6462,7 +7055,7 @@ type LoadBalancerIngress struct { func (x *LoadBalancerIngress) Reset() { *x = LoadBalancerIngress{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[39] + mi := &file_api_v1_common_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6475,7 +7068,7 @@ func (x *LoadBalancerIngress) String() string { func (*LoadBalancerIngress) ProtoMessage() {} func (x *LoadBalancerIngress) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[39] + mi := &file_api_v1_common_proto_msgTypes[43] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6488,7 +7081,7 @@ func (x *LoadBalancerIngress) ProtoReflect() protoreflect.Message { // Deprecated: Use LoadBalancerIngress.ProtoReflect.Descriptor instead. func (*LoadBalancerIngress) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{39} + return file_api_v1_common_proto_rawDescGZIP(), []int{43} } func (x *LoadBalancerIngress) GetIp() string { @@ -6534,7 +7127,7 @@ type IngressDetails struct { func (x *IngressDetails) Reset() { *x = IngressDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[40] + mi := &file_api_v1_common_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6547,7 +7140,7 @@ func (x *IngressDetails) String() string { func (*IngressDetails) ProtoMessage() {} func (x *IngressDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[40] + mi := &file_api_v1_common_proto_msgTypes[44] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6560,7 +7153,7 @@ func (x *IngressDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use IngressDetails.ProtoReflect.Descriptor instead. func (*IngressDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{40} + return file_api_v1_common_proto_rawDescGZIP(), []int{44} } func (x *IngressDetails) GetRules() []*IngressRule { @@ -6604,7 +7197,7 @@ type IngressRule struct { func (x *IngressRule) Reset() { *x = IngressRule{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[41] + mi := &file_api_v1_common_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6617,7 +7210,7 @@ func (x *IngressRule) String() string { func (*IngressRule) ProtoMessage() {} func (x *IngressRule) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[41] + mi := &file_api_v1_common_proto_msgTypes[45] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6630,7 +7223,7 @@ func (x *IngressRule) ProtoReflect() protoreflect.Message { // Deprecated: Use IngressRule.ProtoReflect.Descriptor instead. func (*IngressRule) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{41} + return file_api_v1_common_proto_rawDescGZIP(), []int{45} } func (x *IngressRule) GetHost() string { @@ -6661,7 +7254,7 @@ type IngressPath struct { func (x *IngressPath) Reset() { *x = IngressPath{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[42] + mi := &file_api_v1_common_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6674,7 +7267,7 @@ func (x *IngressPath) String() string { func (*IngressPath) ProtoMessage() {} func (x *IngressPath) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[42] + mi := &file_api_v1_common_proto_msgTypes[46] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6687,7 +7280,7 @@ func (x *IngressPath) ProtoReflect() protoreflect.Message { // Deprecated: Use IngressPath.ProtoReflect.Descriptor instead. func (*IngressPath) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{42} + return file_api_v1_common_proto_rawDescGZIP(), []int{46} } func (x *IngressPath) GetPath() string { @@ -6728,7 +7321,7 @@ type IngressBackend struct { func (x *IngressBackend) Reset() { *x = IngressBackend{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[43] + mi := &file_api_v1_common_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6741,7 +7334,7 @@ func (x *IngressBackend) String() string { func (*IngressBackend) ProtoMessage() {} func (x *IngressBackend) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[43] + mi := &file_api_v1_common_proto_msgTypes[47] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6754,7 +7347,7 @@ func (x *IngressBackend) ProtoReflect() protoreflect.Message { // Deprecated: Use IngressBackend.ProtoReflect.Descriptor instead. func (*IngressBackend) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{43} + return file_api_v1_common_proto_rawDescGZIP(), []int{47} } func (x *IngressBackend) GetServiceName() string { @@ -6812,7 +7405,7 @@ type IngressTLS struct { func (x *IngressTLS) Reset() { *x = IngressTLS{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[44] + mi := &file_api_v1_common_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6825,7 +7418,7 @@ func (x *IngressTLS) String() string { func (*IngressTLS) ProtoMessage() {} func (x *IngressTLS) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[44] + mi := &file_api_v1_common_proto_msgTypes[48] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6838,7 +7431,7 @@ func (x *IngressTLS) ProtoReflect() protoreflect.Message { // Deprecated: Use IngressTLS.ProtoReflect.Descriptor instead. func (*IngressTLS) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{44} + return file_api_v1_common_proto_rawDescGZIP(), []int{48} } func (x *IngressTLS) GetHosts() []string { @@ -6871,7 +7464,7 @@ type PersistentVolumeClaimDetails struct { func (x *PersistentVolumeClaimDetails) Reset() { *x = PersistentVolumeClaimDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[45] + mi := &file_api_v1_common_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6884,7 +7477,7 @@ func (x *PersistentVolumeClaimDetails) String() string { func (*PersistentVolumeClaimDetails) ProtoMessage() {} func (x *PersistentVolumeClaimDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[45] + mi := &file_api_v1_common_proto_msgTypes[49] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6897,7 +7490,7 @@ func (x *PersistentVolumeClaimDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use PersistentVolumeClaimDetails.ProtoReflect.Descriptor instead. func (*PersistentVolumeClaimDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{45} + return file_api_v1_common_proto_rawDescGZIP(), []int{49} } func (x *PersistentVolumeClaimDetails) GetResourceRequirements() *ResourceRequirements { @@ -6948,7 +7541,7 @@ type ResourceRequirements struct { func (x *ResourceRequirements) Reset() { *x = ResourceRequirements{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[46] + mi := &file_api_v1_common_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6961,7 +7554,7 @@ func (x *ResourceRequirements) String() string { func (*ResourceRequirements) ProtoMessage() {} func (x *ResourceRequirements) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[46] + mi := &file_api_v1_common_proto_msgTypes[50] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6974,7 +7567,7 @@ func (x *ResourceRequirements) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceRequirements.ProtoReflect.Descriptor instead. func (*ResourceRequirements) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{46} + return file_api_v1_common_proto_rawDescGZIP(), []int{50} } func (x *ResourceRequirements) GetRequests() map[string]string { @@ -7004,7 +7597,7 @@ type VolumeNodeAffinity struct { func (x *VolumeNodeAffinity) Reset() { *x = VolumeNodeAffinity{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[47] + mi := &file_api_v1_common_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7017,7 +7610,7 @@ func (x *VolumeNodeAffinity) String() string { func (*VolumeNodeAffinity) ProtoMessage() {} func (x *VolumeNodeAffinity) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[47] + mi := &file_api_v1_common_proto_msgTypes[51] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7030,7 +7623,7 @@ func (x *VolumeNodeAffinity) ProtoReflect() protoreflect.Message { // Deprecated: Use VolumeNodeAffinity.ProtoReflect.Descriptor instead. func (*VolumeNodeAffinity) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{47} + return file_api_v1_common_proto_rawDescGZIP(), []int{51} } func (x *VolumeNodeAffinity) GetRequired() []*NodeSelectorRequirement { @@ -7064,7 +7657,7 @@ type PVCCondition struct { func (x *PVCCondition) Reset() { *x = PVCCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[48] + mi := &file_api_v1_common_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7077,7 +7670,7 @@ func (x *PVCCondition) String() string { func (*PVCCondition) ProtoMessage() {} func (x *PVCCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[48] + mi := &file_api_v1_common_proto_msgTypes[52] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7090,7 +7683,7 @@ func (x *PVCCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use PVCCondition.ProtoReflect.Descriptor instead. func (*PVCCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{48} + return file_api_v1_common_proto_rawDescGZIP(), []int{52} } func (x *PVCCondition) GetType() string { @@ -7151,7 +7744,7 @@ type PersistentVolumeDetails struct { func (x *PersistentVolumeDetails) Reset() { *x = PersistentVolumeDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[49] + mi := &file_api_v1_common_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7164,7 +7757,7 @@ func (x *PersistentVolumeDetails) String() string { func (*PersistentVolumeDetails) ProtoMessage() {} func (x *PersistentVolumeDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[49] + mi := &file_api_v1_common_proto_msgTypes[53] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7177,7 +7770,7 @@ func (x *PersistentVolumeDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use PersistentVolumeDetails.ProtoReflect.Descriptor instead. func (*PersistentVolumeDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{49} + return file_api_v1_common_proto_rawDescGZIP(), []int{53} } func (x *PersistentVolumeDetails) GetCapacity() map[string]string { @@ -7231,7 +7824,7 @@ type PVClaimReference struct { func (x *PVClaimReference) Reset() { *x = PVClaimReference{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[50] + mi := &file_api_v1_common_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7244,7 +7837,7 @@ func (x *PVClaimReference) String() string { func (*PVClaimReference) ProtoMessage() {} func (x *PVClaimReference) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[50] + mi := &file_api_v1_common_proto_msgTypes[54] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7257,7 +7850,7 @@ func (x *PVClaimReference) ProtoReflect() protoreflect.Message { // Deprecated: Use PVClaimReference.ProtoReflect.Descriptor instead. func (*PVClaimReference) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{50} + return file_api_v1_common_proto_rawDescGZIP(), []int{54} } func (x *PVClaimReference) GetName() string { @@ -7311,7 +7904,7 @@ type PVVolumeSource struct { func (x *PVVolumeSource) Reset() { *x = PVVolumeSource{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[51] + mi := &file_api_v1_common_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7324,7 +7917,7 @@ func (x *PVVolumeSource) String() string { func (*PVVolumeSource) ProtoMessage() {} func (x *PVVolumeSource) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[51] + mi := &file_api_v1_common_proto_msgTypes[55] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7337,7 +7930,7 @@ func (x *PVVolumeSource) ProtoReflect() protoreflect.Message { // Deprecated: Use PVVolumeSource.ProtoReflect.Descriptor instead. func (*PVVolumeSource) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{51} + return file_api_v1_common_proto_rawDescGZIP(), []int{55} } func (x *PVVolumeSource) GetType() string { @@ -7391,7 +7984,7 @@ type CSIVolumeSource struct { func (x *CSIVolumeSource) Reset() { *x = CSIVolumeSource{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[52] + mi := &file_api_v1_common_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7404,7 +7997,7 @@ func (x *CSIVolumeSource) String() string { func (*CSIVolumeSource) ProtoMessage() {} func (x *CSIVolumeSource) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[52] + mi := &file_api_v1_common_proto_msgTypes[56] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7417,7 +8010,7 @@ func (x *CSIVolumeSource) ProtoReflect() protoreflect.Message { // Deprecated: Use CSIVolumeSource.ProtoReflect.Descriptor instead. func (*CSIVolumeSource) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{52} + return file_api_v1_common_proto_rawDescGZIP(), []int{56} } func (x *CSIVolumeSource) GetDriver() string { @@ -7468,7 +8061,7 @@ type HostPathVolumeSource struct { func (x *HostPathVolumeSource) Reset() { *x = HostPathVolumeSource{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[53] + mi := &file_api_v1_common_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7481,7 +8074,7 @@ func (x *HostPathVolumeSource) String() string { func (*HostPathVolumeSource) ProtoMessage() {} func (x *HostPathVolumeSource) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[53] + mi := &file_api_v1_common_proto_msgTypes[57] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7494,7 +8087,7 @@ func (x *HostPathVolumeSource) ProtoReflect() protoreflect.Message { // Deprecated: Use HostPathVolumeSource.ProtoReflect.Descriptor instead. func (*HostPathVolumeSource) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{53} + return file_api_v1_common_proto_rawDescGZIP(), []int{57} } func (x *HostPathVolumeSource) GetPath() string { @@ -7525,7 +8118,7 @@ type NFSVolumeSource struct { func (x *NFSVolumeSource) Reset() { *x = NFSVolumeSource{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[54] + mi := &file_api_v1_common_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7538,7 +8131,7 @@ func (x *NFSVolumeSource) String() string { func (*NFSVolumeSource) ProtoMessage() {} func (x *NFSVolumeSource) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[54] + mi := &file_api_v1_common_proto_msgTypes[58] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7551,7 +8144,7 @@ func (x *NFSVolumeSource) ProtoReflect() protoreflect.Message { // Deprecated: Use NFSVolumeSource.ProtoReflect.Descriptor instead. func (*NFSVolumeSource) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{54} + return file_api_v1_common_proto_rawDescGZIP(), []int{58} } func (x *NFSVolumeSource) GetServer() string { @@ -7593,7 +8186,7 @@ type StorageClassDetails struct { func (x *StorageClassDetails) Reset() { *x = StorageClassDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[55] + mi := &file_api_v1_common_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7606,7 +8199,7 @@ func (x *StorageClassDetails) String() string { func (*StorageClassDetails) ProtoMessage() {} func (x *StorageClassDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[55] + mi := &file_api_v1_common_proto_msgTypes[59] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7619,7 +8212,7 @@ func (x *StorageClassDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use StorageClassDetails.ProtoReflect.Descriptor instead. func (*StorageClassDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{55} + return file_api_v1_common_proto_rawDescGZIP(), []int{59} } func (x *StorageClassDetails) GetProvisioner() string { @@ -7685,7 +8278,7 @@ type NamespaceDetails struct { func (x *NamespaceDetails) Reset() { *x = NamespaceDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[56] + mi := &file_api_v1_common_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7698,7 +8291,7 @@ func (x *NamespaceDetails) String() string { func (*NamespaceDetails) ProtoMessage() {} func (x *NamespaceDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[56] + mi := &file_api_v1_common_proto_msgTypes[60] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7711,7 +8304,7 @@ func (x *NamespaceDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use NamespaceDetails.ProtoReflect.Descriptor instead. func (*NamespaceDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{56} + return file_api_v1_common_proto_rawDescGZIP(), []int{60} } func (x *NamespaceDetails) GetPhase() string { @@ -7752,7 +8345,7 @@ type NodeDetails struct { func (x *NodeDetails) Reset() { *x = NodeDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[57] + mi := &file_api_v1_common_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7765,7 +8358,7 @@ func (x *NodeDetails) String() string { func (*NodeDetails) ProtoMessage() {} func (x *NodeDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[57] + mi := &file_api_v1_common_proto_msgTypes[61] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7778,7 +8371,7 @@ func (x *NodeDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeDetails.ProtoReflect.Descriptor instead. func (*NodeDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{57} + return file_api_v1_common_proto_rawDescGZIP(), []int{61} } func (x *NodeDetails) GetAddresses() []*NodeAddress { @@ -7838,7 +8431,7 @@ type NodeTaint struct { func (x *NodeTaint) Reset() { *x = NodeTaint{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[58] + mi := &file_api_v1_common_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7851,7 +8444,7 @@ func (x *NodeTaint) String() string { func (*NodeTaint) ProtoMessage() {} func (x *NodeTaint) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[58] + mi := &file_api_v1_common_proto_msgTypes[62] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7864,7 +8457,7 @@ func (x *NodeTaint) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeTaint.ProtoReflect.Descriptor instead. func (*NodeTaint) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{58} + return file_api_v1_common_proto_rawDescGZIP(), []int{62} } func (x *NodeTaint) GetKey() string { @@ -7908,7 +8501,7 @@ type NodeAddress struct { func (x *NodeAddress) Reset() { *x = NodeAddress{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[59] + mi := &file_api_v1_common_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7921,7 +8514,7 @@ func (x *NodeAddress) String() string { func (*NodeAddress) ProtoMessage() {} func (x *NodeAddress) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[59] + mi := &file_api_v1_common_proto_msgTypes[63] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7934,7 +8527,7 @@ func (x *NodeAddress) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeAddress.ProtoReflect.Descriptor instead. func (*NodeAddress) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{59} + return file_api_v1_common_proto_rawDescGZIP(), []int{63} } func (x *NodeAddress) GetType() string { @@ -7968,7 +8561,7 @@ type NodeCondition struct { func (x *NodeCondition) Reset() { *x = NodeCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[60] + mi := &file_api_v1_common_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7981,7 +8574,7 @@ func (x *NodeCondition) String() string { func (*NodeCondition) ProtoMessage() {} func (x *NodeCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[60] + mi := &file_api_v1_common_proto_msgTypes[64] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7994,7 +8587,7 @@ func (x *NodeCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeCondition.ProtoReflect.Descriptor instead. func (*NodeCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{60} + return file_api_v1_common_proto_rawDescGZIP(), []int{64} } func (x *NodeCondition) GetType() string { @@ -8060,7 +8653,7 @@ type NodeSystemInfo struct { func (x *NodeSystemInfo) Reset() { *x = NodeSystemInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[61] + mi := &file_api_v1_common_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8073,7 +8666,7 @@ func (x *NodeSystemInfo) String() string { func (*NodeSystemInfo) ProtoMessage() {} func (x *NodeSystemInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[61] + mi := &file_api_v1_common_proto_msgTypes[65] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8086,7 +8679,7 @@ func (x *NodeSystemInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeSystemInfo.ProtoReflect.Descriptor instead. func (*NodeSystemInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{61} + return file_api_v1_common_proto_rawDescGZIP(), []int{65} } func (x *NodeSystemInfo) GetMachineId() string { @@ -8172,7 +8765,7 @@ type NodeImage struct { func (x *NodeImage) Reset() { *x = NodeImage{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[62] + mi := &file_api_v1_common_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8185,7 +8778,7 @@ func (x *NodeImage) String() string { func (*NodeImage) ProtoMessage() {} func (x *NodeImage) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[62] + mi := &file_api_v1_common_proto_msgTypes[66] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8198,7 +8791,7 @@ func (x *NodeImage) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeImage.ProtoReflect.Descriptor instead. func (*NodeImage) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{62} + return file_api_v1_common_proto_rawDescGZIP(), []int{66} } func (x *NodeImage) GetNames() []string { @@ -8227,7 +8820,7 @@ type TopologySelector struct { func (x *TopologySelector) Reset() { *x = TopologySelector{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[63] + mi := &file_api_v1_common_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8240,7 +8833,7 @@ func (x *TopologySelector) String() string { func (*TopologySelector) ProtoMessage() {} func (x *TopologySelector) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[63] + mi := &file_api_v1_common_proto_msgTypes[67] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8253,7 +8846,7 @@ func (x *TopologySelector) ProtoReflect() protoreflect.Message { // Deprecated: Use TopologySelector.ProtoReflect.Descriptor instead. func (*TopologySelector) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{63} + return file_api_v1_common_proto_rawDescGZIP(), []int{67} } func (x *TopologySelector) GetMatchLabelExpressions() []*TopologySelectorTerm { @@ -8275,7 +8868,7 @@ type TopologySelectorTerm struct { func (x *TopologySelectorTerm) Reset() { *x = TopologySelectorTerm{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[64] + mi := &file_api_v1_common_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8288,7 +8881,7 @@ func (x *TopologySelectorTerm) String() string { func (*TopologySelectorTerm) ProtoMessage() {} func (x *TopologySelectorTerm) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[64] + mi := &file_api_v1_common_proto_msgTypes[68] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8301,7 +8894,7 @@ func (x *TopologySelectorTerm) ProtoReflect() protoreflect.Message { // Deprecated: Use TopologySelectorTerm.ProtoReflect.Descriptor instead. func (*TopologySelectorTerm) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{64} + return file_api_v1_common_proto_rawDescGZIP(), []int{68} } func (x *TopologySelectorTerm) GetMatchLabels() map[string]string { @@ -8327,7 +8920,7 @@ type TolerationInfo struct { func (x *TolerationInfo) Reset() { *x = TolerationInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[65] + mi := &file_api_v1_common_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8340,7 +8933,7 @@ func (x *TolerationInfo) String() string { func (*TolerationInfo) ProtoMessage() {} func (x *TolerationInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[65] + mi := &file_api_v1_common_proto_msgTypes[69] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8353,7 +8946,7 @@ func (x *TolerationInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use TolerationInfo.ProtoReflect.Descriptor instead. func (*TolerationInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{65} + return file_api_v1_common_proto_rawDescGZIP(), []int{69} } func (x *TolerationInfo) GetKey() string { @@ -8403,7 +8996,7 @@ type NodeSelector struct { func (x *NodeSelector) Reset() { *x = NodeSelector{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[66] + mi := &file_api_v1_common_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8416,7 +9009,7 @@ func (x *NodeSelector) String() string { func (*NodeSelector) ProtoMessage() {} func (x *NodeSelector) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[66] + mi := &file_api_v1_common_proto_msgTypes[70] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8429,7 +9022,7 @@ func (x *NodeSelector) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeSelector.ProtoReflect.Descriptor instead. func (*NodeSelector) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{66} + return file_api_v1_common_proto_rawDescGZIP(), []int{70} } func (x *NodeSelector) GetTerms() []*NodeSelectorTerm { @@ -8452,7 +9045,7 @@ type NodeSelectorTerm struct { func (x *NodeSelectorTerm) Reset() { *x = NodeSelectorTerm{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[67] + mi := &file_api_v1_common_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8465,7 +9058,7 @@ func (x *NodeSelectorTerm) String() string { func (*NodeSelectorTerm) ProtoMessage() {} func (x *NodeSelectorTerm) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[67] + mi := &file_api_v1_common_proto_msgTypes[71] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8478,7 +9071,7 @@ func (x *NodeSelectorTerm) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeSelectorTerm.ProtoReflect.Descriptor instead. func (*NodeSelectorTerm) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{67} + return file_api_v1_common_proto_rawDescGZIP(), []int{71} } func (x *NodeSelectorTerm) GetMatchExpressions() []*NodeSelectorRequirement { @@ -8509,7 +9102,7 @@ type NodeSelectorRequirement struct { func (x *NodeSelectorRequirement) Reset() { *x = NodeSelectorRequirement{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[68] + mi := &file_api_v1_common_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8522,7 +9115,7 @@ func (x *NodeSelectorRequirement) String() string { func (*NodeSelectorRequirement) ProtoMessage() {} func (x *NodeSelectorRequirement) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[68] + mi := &file_api_v1_common_proto_msgTypes[72] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8535,7 +9128,7 @@ func (x *NodeSelectorRequirement) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeSelectorRequirement.ProtoReflect.Descriptor instead. func (*NodeSelectorRequirement) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{68} + return file_api_v1_common_proto_rawDescGZIP(), []int{72} } func (x *NodeSelectorRequirement) GetKey() string { @@ -8575,7 +9168,7 @@ type HPADetails struct { func (x *HPADetails) Reset() { *x = HPADetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[69] + mi := &file_api_v1_common_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8588,7 +9181,7 @@ func (x *HPADetails) String() string { func (*HPADetails) ProtoMessage() {} func (x *HPADetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[69] + mi := &file_api_v1_common_proto_msgTypes[73] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8601,7 +9194,7 @@ func (x *HPADetails) ProtoReflect() protoreflect.Message { // Deprecated: Use HPADetails.ProtoReflect.Descriptor instead. func (*HPADetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{69} + return file_api_v1_common_proto_rawDescGZIP(), []int{73} } func (x *HPADetails) GetScaleTargetRef() *ScaleTargetRef { @@ -8653,7 +9246,7 @@ type ScaleTargetRef struct { func (x *ScaleTargetRef) Reset() { *x = ScaleTargetRef{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[70] + mi := &file_api_v1_common_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8666,7 +9259,7 @@ func (x *ScaleTargetRef) String() string { func (*ScaleTargetRef) ProtoMessage() {} func (x *ScaleTargetRef) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[70] + mi := &file_api_v1_common_proto_msgTypes[74] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8679,7 +9272,7 @@ func (x *ScaleTargetRef) ProtoReflect() protoreflect.Message { // Deprecated: Use ScaleTargetRef.ProtoReflect.Descriptor instead. func (*ScaleTargetRef) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{70} + return file_api_v1_common_proto_rawDescGZIP(), []int{74} } func (x *ScaleTargetRef) GetKind() string { @@ -8719,7 +9312,7 @@ type HPAMetric struct { func (x *HPAMetric) Reset() { *x = HPAMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[71] + mi := &file_api_v1_common_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8732,7 +9325,7 @@ func (x *HPAMetric) String() string { func (*HPAMetric) ProtoMessage() {} func (x *HPAMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[71] + mi := &file_api_v1_common_proto_msgTypes[75] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8745,7 +9338,7 @@ func (x *HPAMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAMetric.ProtoReflect.Descriptor instead. func (*HPAMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{71} + return file_api_v1_common_proto_rawDescGZIP(), []int{75} } func (x *HPAMetric) GetType() string { @@ -8797,7 +9390,7 @@ type HPAResourceMetric struct { func (x *HPAResourceMetric) Reset() { *x = HPAResourceMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[72] + mi := &file_api_v1_common_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8810,7 +9403,7 @@ func (x *HPAResourceMetric) String() string { func (*HPAResourceMetric) ProtoMessage() {} func (x *HPAResourceMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[72] + mi := &file_api_v1_common_proto_msgTypes[76] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8823,7 +9416,7 @@ func (x *HPAResourceMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAResourceMetric.ProtoReflect.Descriptor instead. func (*HPAResourceMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{72} + return file_api_v1_common_proto_rawDescGZIP(), []int{76} } func (x *HPAResourceMetric) GetName() string { @@ -8861,7 +9454,7 @@ type HPAPodsMetric struct { func (x *HPAPodsMetric) Reset() { *x = HPAPodsMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[73] + mi := &file_api_v1_common_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8874,7 +9467,7 @@ func (x *HPAPodsMetric) String() string { func (*HPAPodsMetric) ProtoMessage() {} func (x *HPAPodsMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[73] + mi := &file_api_v1_common_proto_msgTypes[77] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8887,7 +9480,7 @@ func (x *HPAPodsMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAPodsMetric.ProtoReflect.Descriptor instead. func (*HPAPodsMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{73} + return file_api_v1_common_proto_rawDescGZIP(), []int{77} } func (x *HPAPodsMetric) GetMetric() *HPAMetricSelector { @@ -8926,7 +9519,7 @@ type HPAObjectMetric struct { func (x *HPAObjectMetric) Reset() { *x = HPAObjectMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[74] + mi := &file_api_v1_common_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8939,7 +9532,7 @@ func (x *HPAObjectMetric) String() string { func (*HPAObjectMetric) ProtoMessage() {} func (x *HPAObjectMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[74] + mi := &file_api_v1_common_proto_msgTypes[78] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8952,7 +9545,7 @@ func (x *HPAObjectMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAObjectMetric.ProtoReflect.Descriptor instead. func (*HPAObjectMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{74} + return file_api_v1_common_proto_rawDescGZIP(), []int{78} } func (x *HPAObjectMetric) GetDescribedObject() *HPAObjectReference { @@ -8997,7 +9590,7 @@ type HPAExternalMetric struct { func (x *HPAExternalMetric) Reset() { *x = HPAExternalMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[75] + mi := &file_api_v1_common_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9010,7 +9603,7 @@ func (x *HPAExternalMetric) String() string { func (*HPAExternalMetric) ProtoMessage() {} func (x *HPAExternalMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[75] + mi := &file_api_v1_common_proto_msgTypes[79] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9023,7 +9616,7 @@ func (x *HPAExternalMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAExternalMetric.ProtoReflect.Descriptor instead. func (*HPAExternalMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{75} + return file_api_v1_common_proto_rawDescGZIP(), []int{79} } func (x *HPAExternalMetric) GetMetric() *HPAMetricSelector { @@ -9060,7 +9653,7 @@ type HPAMetricSelector struct { func (x *HPAMetricSelector) Reset() { *x = HPAMetricSelector{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[76] + mi := &file_api_v1_common_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9073,7 +9666,7 @@ func (x *HPAMetricSelector) String() string { func (*HPAMetricSelector) ProtoMessage() {} func (x *HPAMetricSelector) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[76] + mi := &file_api_v1_common_proto_msgTypes[80] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9086,7 +9679,7 @@ func (x *HPAMetricSelector) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAMetricSelector.ProtoReflect.Descriptor instead. func (*HPAMetricSelector) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{76} + return file_api_v1_common_proto_rawDescGZIP(), []int{80} } func (x *HPAMetricSelector) GetName() string { @@ -9118,7 +9711,7 @@ type HPAObjectReference struct { func (x *HPAObjectReference) Reset() { *x = HPAObjectReference{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[77] + mi := &file_api_v1_common_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9131,7 +9724,7 @@ func (x *HPAObjectReference) String() string { func (*HPAObjectReference) ProtoMessage() {} func (x *HPAObjectReference) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[77] + mi := &file_api_v1_common_proto_msgTypes[81] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9144,7 +9737,7 @@ func (x *HPAObjectReference) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAObjectReference.ProtoReflect.Descriptor instead. func (*HPAObjectReference) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{77} + return file_api_v1_common_proto_rawDescGZIP(), []int{81} } func (x *HPAObjectReference) GetKind() string { @@ -9191,7 +9784,7 @@ type HPACurrentMetric struct { func (x *HPACurrentMetric) Reset() { *x = HPACurrentMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[78] + mi := &file_api_v1_common_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9204,7 +9797,7 @@ func (x *HPACurrentMetric) String() string { func (*HPACurrentMetric) ProtoMessage() {} func (x *HPACurrentMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[78] + mi := &file_api_v1_common_proto_msgTypes[82] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9217,7 +9810,7 @@ func (x *HPACurrentMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPACurrentMetric.ProtoReflect.Descriptor instead. func (*HPACurrentMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{78} + return file_api_v1_common_proto_rawDescGZIP(), []int{82} } func (x *HPACurrentMetric) GetType() string { @@ -9269,7 +9862,7 @@ type HPACurrentResourceMetric struct { func (x *HPACurrentResourceMetric) Reset() { *x = HPACurrentResourceMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[79] + mi := &file_api_v1_common_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9282,7 +9875,7 @@ func (x *HPACurrentResourceMetric) String() string { func (*HPACurrentResourceMetric) ProtoMessage() {} func (x *HPACurrentResourceMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[79] + mi := &file_api_v1_common_proto_msgTypes[83] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9295,7 +9888,7 @@ func (x *HPACurrentResourceMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPACurrentResourceMetric.ProtoReflect.Descriptor instead. func (*HPACurrentResourceMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{79} + return file_api_v1_common_proto_rawDescGZIP(), []int{83} } func (x *HPACurrentResourceMetric) GetName() string { @@ -9332,7 +9925,7 @@ type HPACurrentPodsMetric struct { func (x *HPACurrentPodsMetric) Reset() { *x = HPACurrentPodsMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[80] + mi := &file_api_v1_common_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9345,7 +9938,7 @@ func (x *HPACurrentPodsMetric) String() string { func (*HPACurrentPodsMetric) ProtoMessage() {} func (x *HPACurrentPodsMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[80] + mi := &file_api_v1_common_proto_msgTypes[84] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9358,7 +9951,7 @@ func (x *HPACurrentPodsMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPACurrentPodsMetric.ProtoReflect.Descriptor instead. func (*HPACurrentPodsMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{80} + return file_api_v1_common_proto_rawDescGZIP(), []int{84} } func (x *HPACurrentPodsMetric) GetMetric() *HPAMetricSelector { @@ -9389,7 +9982,7 @@ type HPACurrentObjectMetric struct { func (x *HPACurrentObjectMetric) Reset() { *x = HPACurrentObjectMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[81] + mi := &file_api_v1_common_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9402,7 +9995,7 @@ func (x *HPACurrentObjectMetric) String() string { func (*HPACurrentObjectMetric) ProtoMessage() {} func (x *HPACurrentObjectMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[81] + mi := &file_api_v1_common_proto_msgTypes[85] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9415,7 +10008,7 @@ func (x *HPACurrentObjectMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPACurrentObjectMetric.ProtoReflect.Descriptor instead. func (*HPACurrentObjectMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{81} + return file_api_v1_common_proto_rawDescGZIP(), []int{85} } func (x *HPACurrentObjectMetric) GetDescribedObject() *HPAObjectReference { @@ -9453,7 +10046,7 @@ type HPACurrentExternalMetric struct { func (x *HPACurrentExternalMetric) Reset() { *x = HPACurrentExternalMetric{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[82] + mi := &file_api_v1_common_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9466,7 +10059,7 @@ func (x *HPACurrentExternalMetric) String() string { func (*HPACurrentExternalMetric) ProtoMessage() {} func (x *HPACurrentExternalMetric) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[82] + mi := &file_api_v1_common_proto_msgTypes[86] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9479,7 +10072,7 @@ func (x *HPACurrentExternalMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use HPACurrentExternalMetric.ProtoReflect.Descriptor instead. func (*HPACurrentExternalMetric) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{82} + return file_api_v1_common_proto_rawDescGZIP(), []int{86} } func (x *HPACurrentExternalMetric) GetMetric() *HPAMetricSelector { @@ -9519,7 +10112,7 @@ type HPACondition struct { func (x *HPACondition) Reset() { *x = HPACondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[83] + mi := &file_api_v1_common_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9532,7 +10125,7 @@ func (x *HPACondition) String() string { func (*HPACondition) ProtoMessage() {} func (x *HPACondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[83] + mi := &file_api_v1_common_proto_msgTypes[87] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9545,7 +10138,7 @@ func (x *HPACondition) ProtoReflect() protoreflect.Message { // Deprecated: Use HPACondition.ProtoReflect.Descriptor instead. func (*HPACondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{83} + return file_api_v1_common_proto_rawDescGZIP(), []int{87} } func (x *HPACondition) GetType() string { @@ -9596,7 +10189,7 @@ type HPABehavior struct { func (x *HPABehavior) Reset() { *x = HPABehavior{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[84] + mi := &file_api_v1_common_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9609,7 +10202,7 @@ func (x *HPABehavior) String() string { func (*HPABehavior) ProtoMessage() {} func (x *HPABehavior) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[84] + mi := &file_api_v1_common_proto_msgTypes[88] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9622,7 +10215,7 @@ func (x *HPABehavior) ProtoReflect() protoreflect.Message { // Deprecated: Use HPABehavior.ProtoReflect.Descriptor instead. func (*HPABehavior) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{84} + return file_api_v1_common_proto_rawDescGZIP(), []int{88} } func (x *HPABehavior) GetScaleUp() *HPAScalingRules { @@ -9653,7 +10246,7 @@ type HPAScalingRules struct { func (x *HPAScalingRules) Reset() { *x = HPAScalingRules{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[85] + mi := &file_api_v1_common_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9666,7 +10259,7 @@ func (x *HPAScalingRules) String() string { func (*HPAScalingRules) ProtoMessage() {} func (x *HPAScalingRules) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[85] + mi := &file_api_v1_common_proto_msgTypes[89] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9679,7 +10272,7 @@ func (x *HPAScalingRules) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAScalingRules.ProtoReflect.Descriptor instead. func (*HPAScalingRules) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{85} + return file_api_v1_common_proto_rawDescGZIP(), []int{89} } func (x *HPAScalingRules) GetStabilizationWindowSeconds() int32 { @@ -9717,7 +10310,7 @@ type HPAScalingPolicy struct { func (x *HPAScalingPolicy) Reset() { *x = HPAScalingPolicy{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[86] + mi := &file_api_v1_common_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9730,7 +10323,7 @@ func (x *HPAScalingPolicy) String() string { func (*HPAScalingPolicy) ProtoMessage() {} func (x *HPAScalingPolicy) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[86] + mi := &file_api_v1_common_proto_msgTypes[90] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9743,7 +10336,7 @@ func (x *HPAScalingPolicy) ProtoReflect() protoreflect.Message { // Deprecated: Use HPAScalingPolicy.ProtoReflect.Descriptor instead. func (*HPAScalingPolicy) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{86} + return file_api_v1_common_proto_rawDescGZIP(), []int{90} } func (x *HPAScalingPolicy) GetType() string { @@ -9783,7 +10376,7 @@ type VPADetails struct { func (x *VPADetails) Reset() { *x = VPADetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[87] + mi := &file_api_v1_common_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9796,7 +10389,7 @@ func (x *VPADetails) String() string { func (*VPADetails) ProtoMessage() {} func (x *VPADetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[87] + mi := &file_api_v1_common_proto_msgTypes[91] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9809,7 +10402,7 @@ func (x *VPADetails) ProtoReflect() protoreflect.Message { // Deprecated: Use VPADetails.ProtoReflect.Descriptor instead. func (*VPADetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{87} + return file_api_v1_common_proto_rawDescGZIP(), []int{91} } func (x *VPADetails) GetTargetRef() *VPATargetRef { @@ -9861,7 +10454,7 @@ type VPATargetRef struct { func (x *VPATargetRef) Reset() { *x = VPATargetRef{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[88] + mi := &file_api_v1_common_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9874,7 +10467,7 @@ func (x *VPATargetRef) String() string { func (*VPATargetRef) ProtoMessage() {} func (x *VPATargetRef) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[88] + mi := &file_api_v1_common_proto_msgTypes[92] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9887,7 +10480,7 @@ func (x *VPATargetRef) ProtoReflect() protoreflect.Message { // Deprecated: Use VPATargetRef.ProtoReflect.Descriptor instead. func (*VPATargetRef) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{88} + return file_api_v1_common_proto_rawDescGZIP(), []int{92} } func (x *VPATargetRef) GetKind() string { @@ -9924,7 +10517,7 @@ type VPAUpdatePolicy struct { func (x *VPAUpdatePolicy) Reset() { *x = VPAUpdatePolicy{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[89] + mi := &file_api_v1_common_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9937,7 +10530,7 @@ func (x *VPAUpdatePolicy) String() string { func (*VPAUpdatePolicy) ProtoMessage() {} func (x *VPAUpdatePolicy) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[89] + mi := &file_api_v1_common_proto_msgTypes[93] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9950,7 +10543,7 @@ func (x *VPAUpdatePolicy) ProtoReflect() protoreflect.Message { // Deprecated: Use VPAUpdatePolicy.ProtoReflect.Descriptor instead. func (*VPAUpdatePolicy) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{89} + return file_api_v1_common_proto_rawDescGZIP(), []int{93} } func (x *VPAUpdatePolicy) GetUpdateMode() string { @@ -9979,7 +10572,7 @@ type VPAResourcePolicy struct { func (x *VPAResourcePolicy) Reset() { *x = VPAResourcePolicy{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[90] + mi := &file_api_v1_common_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9992,7 +10585,7 @@ func (x *VPAResourcePolicy) String() string { func (*VPAResourcePolicy) ProtoMessage() {} func (x *VPAResourcePolicy) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[90] + mi := &file_api_v1_common_proto_msgTypes[94] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10005,7 +10598,7 @@ func (x *VPAResourcePolicy) ProtoReflect() protoreflect.Message { // Deprecated: Use VPAResourcePolicy.ProtoReflect.Descriptor instead. func (*VPAResourcePolicy) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{90} + return file_api_v1_common_proto_rawDescGZIP(), []int{94} } func (x *VPAResourcePolicy) GetContainerPolicies() []*VPAContainerResourcePolicy { @@ -10032,7 +10625,7 @@ type VPAContainerResourcePolicy struct { func (x *VPAContainerResourcePolicy) Reset() { *x = VPAContainerResourcePolicy{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[91] + mi := &file_api_v1_common_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10045,7 +10638,7 @@ func (x *VPAContainerResourcePolicy) String() string { func (*VPAContainerResourcePolicy) ProtoMessage() {} func (x *VPAContainerResourcePolicy) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[91] + mi := &file_api_v1_common_proto_msgTypes[95] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10058,7 +10651,7 @@ func (x *VPAContainerResourcePolicy) ProtoReflect() protoreflect.Message { // Deprecated: Use VPAContainerResourcePolicy.ProtoReflect.Descriptor instead. func (*VPAContainerResourcePolicy) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{91} + return file_api_v1_common_proto_rawDescGZIP(), []int{95} } func (x *VPAContainerResourcePolicy) GetContainerName() string { @@ -10115,7 +10708,7 @@ type VPARecommendation struct { func (x *VPARecommendation) Reset() { *x = VPARecommendation{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[92] + mi := &file_api_v1_common_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10128,7 +10721,7 @@ func (x *VPARecommendation) String() string { func (*VPARecommendation) ProtoMessage() {} func (x *VPARecommendation) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[92] + mi := &file_api_v1_common_proto_msgTypes[96] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10141,7 +10734,7 @@ func (x *VPARecommendation) ProtoReflect() protoreflect.Message { // Deprecated: Use VPARecommendation.ProtoReflect.Descriptor instead. func (*VPARecommendation) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{92} + return file_api_v1_common_proto_rawDescGZIP(), []int{96} } func (x *VPARecommendation) GetContainerRecommendations() []*VPAContainerRecommendation { @@ -10167,7 +10760,7 @@ type VPAContainerRecommendation struct { func (x *VPAContainerRecommendation) Reset() { *x = VPAContainerRecommendation{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[93] + mi := &file_api_v1_common_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10180,7 +10773,7 @@ func (x *VPAContainerRecommendation) String() string { func (*VPAContainerRecommendation) ProtoMessage() {} func (x *VPAContainerRecommendation) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[93] + mi := &file_api_v1_common_proto_msgTypes[97] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10193,7 +10786,7 @@ func (x *VPAContainerRecommendation) ProtoReflect() protoreflect.Message { // Deprecated: Use VPAContainerRecommendation.ProtoReflect.Descriptor instead. func (*VPAContainerRecommendation) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{93} + return file_api_v1_common_proto_rawDescGZIP(), []int{97} } func (x *VPAContainerRecommendation) GetContainerName() string { @@ -10247,7 +10840,7 @@ type VPACondition struct { func (x *VPACondition) Reset() { *x = VPACondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[94] + mi := &file_api_v1_common_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10260,7 +10853,7 @@ func (x *VPACondition) String() string { func (*VPACondition) ProtoMessage() {} func (x *VPACondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[94] + mi := &file_api_v1_common_proto_msgTypes[98] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10273,7 +10866,7 @@ func (x *VPACondition) ProtoReflect() protoreflect.Message { // Deprecated: Use VPACondition.ProtoReflect.Descriptor instead. func (*VPACondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{94} + return file_api_v1_common_proto_rawDescGZIP(), []int{98} } func (x *VPACondition) GetType() string { @@ -10323,7 +10916,7 @@ type LimitRangeDetails struct { func (x *LimitRangeDetails) Reset() { *x = LimitRangeDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[95] + mi := &file_api_v1_common_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10336,7 +10929,7 @@ func (x *LimitRangeDetails) String() string { func (*LimitRangeDetails) ProtoMessage() {} func (x *LimitRangeDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[95] + mi := &file_api_v1_common_proto_msgTypes[99] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10349,7 +10942,7 @@ func (x *LimitRangeDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use LimitRangeDetails.ProtoReflect.Descriptor instead. func (*LimitRangeDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{95} + return file_api_v1_common_proto_rawDescGZIP(), []int{99} } func (x *LimitRangeDetails) GetLimits() []*LimitRangeItem { @@ -10376,7 +10969,7 @@ type LimitRangeItem struct { func (x *LimitRangeItem) Reset() { *x = LimitRangeItem{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[96] + mi := &file_api_v1_common_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10389,7 +10982,7 @@ func (x *LimitRangeItem) String() string { func (*LimitRangeItem) ProtoMessage() {} func (x *LimitRangeItem) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[96] + mi := &file_api_v1_common_proto_msgTypes[100] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10402,7 +10995,7 @@ func (x *LimitRangeItem) ProtoReflect() protoreflect.Message { // Deprecated: Use LimitRangeItem.ProtoReflect.Descriptor instead. func (*LimitRangeItem) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{96} + return file_api_v1_common_proto_rawDescGZIP(), []int{100} } func (x *LimitRangeItem) GetType() string { @@ -10462,7 +11055,7 @@ type ServiceAccountDetails struct { func (x *ServiceAccountDetails) Reset() { *x = ServiceAccountDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[97] + mi := &file_api_v1_common_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10475,7 +11068,7 @@ func (x *ServiceAccountDetails) String() string { func (*ServiceAccountDetails) ProtoMessage() {} func (x *ServiceAccountDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[97] + mi := &file_api_v1_common_proto_msgTypes[101] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10488,7 +11081,7 @@ func (x *ServiceAccountDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceAccountDetails.ProtoReflect.Descriptor instead. func (*ServiceAccountDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{97} + return file_api_v1_common_proto_rawDescGZIP(), []int{101} } func (x *ServiceAccountDetails) GetAutomountServiceAccountToken() bool { @@ -10531,7 +11124,7 @@ type RoleDetails struct { func (x *RoleDetails) Reset() { *x = RoleDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[98] + mi := &file_api_v1_common_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10544,7 +11137,7 @@ func (x *RoleDetails) String() string { func (*RoleDetails) ProtoMessage() {} func (x *RoleDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[98] + mi := &file_api_v1_common_proto_msgTypes[102] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10557,7 +11150,7 @@ func (x *RoleDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use RoleDetails.ProtoReflect.Descriptor instead. func (*RoleDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{98} + return file_api_v1_common_proto_rawDescGZIP(), []int{102} } func (x *RoleDetails) GetRules() []*RoleRule { @@ -10582,7 +11175,7 @@ type RoleRule struct { func (x *RoleRule) Reset() { *x = RoleRule{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[99] + mi := &file_api_v1_common_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10595,7 +11188,7 @@ func (x *RoleRule) String() string { func (*RoleRule) ProtoMessage() {} func (x *RoleRule) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[99] + mi := &file_api_v1_common_proto_msgTypes[103] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10608,7 +11201,7 @@ func (x *RoleRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RoleRule.ProtoReflect.Descriptor instead. func (*RoleRule) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{99} + return file_api_v1_common_proto_rawDescGZIP(), []int{103} } func (x *RoleRule) GetApiGroups() []string { @@ -10652,7 +11245,7 @@ type RoleBindingDetails struct { func (x *RoleBindingDetails) Reset() { *x = RoleBindingDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[100] + mi := &file_api_v1_common_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10665,7 +11258,7 @@ func (x *RoleBindingDetails) String() string { func (*RoleBindingDetails) ProtoMessage() {} func (x *RoleBindingDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[100] + mi := &file_api_v1_common_proto_msgTypes[104] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10678,7 +11271,7 @@ func (x *RoleBindingDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use RoleBindingDetails.ProtoReflect.Descriptor instead. func (*RoleBindingDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{100} + return file_api_v1_common_proto_rawDescGZIP(), []int{104} } func (x *RoleBindingDetails) GetSubjects() []*RoleBindingSubject { @@ -10710,7 +11303,7 @@ type RoleBindingSubject struct { func (x *RoleBindingSubject) Reset() { *x = RoleBindingSubject{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[101] + mi := &file_api_v1_common_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10723,7 +11316,7 @@ func (x *RoleBindingSubject) String() string { func (*RoleBindingSubject) ProtoMessage() {} func (x *RoleBindingSubject) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[101] + mi := &file_api_v1_common_proto_msgTypes[105] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10736,7 +11329,7 @@ func (x *RoleBindingSubject) ProtoReflect() protoreflect.Message { // Deprecated: Use RoleBindingSubject.ProtoReflect.Descriptor instead. func (*RoleBindingSubject) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{101} + return file_api_v1_common_proto_rawDescGZIP(), []int{105} } func (x *RoleBindingSubject) GetKind() string { @@ -10781,7 +11374,7 @@ type RoleReference struct { func (x *RoleReference) Reset() { *x = RoleReference{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[102] + mi := &file_api_v1_common_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10794,7 +11387,7 @@ func (x *RoleReference) String() string { func (*RoleReference) ProtoMessage() {} func (x *RoleReference) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[102] + mi := &file_api_v1_common_proto_msgTypes[106] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10807,7 +11400,7 @@ func (x *RoleReference) ProtoReflect() protoreflect.Message { // Deprecated: Use RoleReference.ProtoReflect.Descriptor instead. func (*RoleReference) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{102} + return file_api_v1_common_proto_rawDescGZIP(), []int{106} } func (x *RoleReference) GetKind() string { @@ -10850,7 +11443,7 @@ type KedaScaledObjectDetails struct { func (x *KedaScaledObjectDetails) Reset() { *x = KedaScaledObjectDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[103] + mi := &file_api_v1_common_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10863,7 +11456,7 @@ func (x *KedaScaledObjectDetails) String() string { func (*KedaScaledObjectDetails) ProtoMessage() {} func (x *KedaScaledObjectDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[103] + mi := &file_api_v1_common_proto_msgTypes[107] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10876,7 +11469,7 @@ func (x *KedaScaledObjectDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use KedaScaledObjectDetails.ProtoReflect.Descriptor instead. func (*KedaScaledObjectDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{103} + return file_api_v1_common_proto_rawDescGZIP(), []int{107} } func (x *KedaScaledObjectDetails) GetTargetName() string { @@ -10948,7 +11541,7 @@ type KedaScaledObjectTrigger struct { func (x *KedaScaledObjectTrigger) Reset() { *x = KedaScaledObjectTrigger{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[104] + mi := &file_api_v1_common_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10961,7 +11554,7 @@ func (x *KedaScaledObjectTrigger) String() string { func (*KedaScaledObjectTrigger) ProtoMessage() {} func (x *KedaScaledObjectTrigger) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[104] + mi := &file_api_v1_common_proto_msgTypes[108] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10974,7 +11567,7 @@ func (x *KedaScaledObjectTrigger) ProtoReflect() protoreflect.Message { // Deprecated: Use KedaScaledObjectTrigger.ProtoReflect.Descriptor instead. func (*KedaScaledObjectTrigger) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{104} + return file_api_v1_common_proto_rawDescGZIP(), []int{108} } func (x *KedaScaledObjectTrigger) GetType() string { @@ -11007,7 +11600,7 @@ type KedaScaledObjectCondition struct { func (x *KedaScaledObjectCondition) Reset() { *x = KedaScaledObjectCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[105] + mi := &file_api_v1_common_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11020,7 +11613,7 @@ func (x *KedaScaledObjectCondition) String() string { func (*KedaScaledObjectCondition) ProtoMessage() {} func (x *KedaScaledObjectCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[105] + mi := &file_api_v1_common_proto_msgTypes[109] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11033,7 +11626,7 @@ func (x *KedaScaledObjectCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use KedaScaledObjectCondition.ProtoReflect.Descriptor instead. func (*KedaScaledObjectCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{105} + return file_api_v1_common_proto_rawDescGZIP(), []int{109} } func (x *KedaScaledObjectCondition) GetType() string { @@ -11091,7 +11684,7 @@ type KarpenterResourceDetails struct { func (x *KarpenterResourceDetails) Reset() { *x = KarpenterResourceDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[106] + mi := &file_api_v1_common_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11104,7 +11697,7 @@ func (x *KarpenterResourceDetails) String() string { func (*KarpenterResourceDetails) ProtoMessage() {} func (x *KarpenterResourceDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[106] + mi := &file_api_v1_common_proto_msgTypes[110] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11117,7 +11710,7 @@ func (x *KarpenterResourceDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use KarpenterResourceDetails.ProtoReflect.Descriptor instead. func (*KarpenterResourceDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{106} + return file_api_v1_common_proto_rawDescGZIP(), []int{110} } func (x *KarpenterResourceDetails) GetResourceType() string { @@ -11199,7 +11792,7 @@ type KarpenterResourceCondition struct { func (x *KarpenterResourceCondition) Reset() { *x = KarpenterResourceCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[107] + mi := &file_api_v1_common_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11212,7 +11805,7 @@ func (x *KarpenterResourceCondition) String() string { func (*KarpenterResourceCondition) ProtoMessage() {} func (x *KarpenterResourceCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[107] + mi := &file_api_v1_common_proto_msgTypes[111] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11225,7 +11818,7 @@ func (x *KarpenterResourceCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use KarpenterResourceCondition.ProtoReflect.Descriptor instead. func (*KarpenterResourceCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{107} + return file_api_v1_common_proto_rawDescGZIP(), []int{111} } func (x *KarpenterResourceCondition) GetType() string { @@ -11277,7 +11870,7 @@ type KarpenterCapacity struct { func (x *KarpenterCapacity) Reset() { *x = KarpenterCapacity{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[108] + mi := &file_api_v1_common_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11290,7 +11883,7 @@ func (x *KarpenterCapacity) String() string { func (*KarpenterCapacity) ProtoMessage() {} func (x *KarpenterCapacity) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[108] + mi := &file_api_v1_common_proto_msgTypes[112] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11303,7 +11896,7 @@ func (x *KarpenterCapacity) ProtoReflect() protoreflect.Message { // Deprecated: Use KarpenterCapacity.ProtoReflect.Descriptor instead. func (*KarpenterCapacity) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{108} + return file_api_v1_common_proto_rawDescGZIP(), []int{112} } func (x *KarpenterCapacity) GetCpu() string { @@ -11341,7 +11934,7 @@ type KarpenterRequirement struct { func (x *KarpenterRequirement) Reset() { *x = KarpenterRequirement{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[109] + mi := &file_api_v1_common_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11354,7 +11947,7 @@ func (x *KarpenterRequirement) String() string { func (*KarpenterRequirement) ProtoMessage() {} func (x *KarpenterRequirement) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[109] + mi := &file_api_v1_common_proto_msgTypes[113] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11367,7 +11960,7 @@ func (x *KarpenterRequirement) ProtoReflect() protoreflect.Message { // Deprecated: Use KarpenterRequirement.ProtoReflect.Descriptor instead. func (*KarpenterRequirement) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{109} + return file_api_v1_common_proto_rawDescGZIP(), []int{113} } func (x *KarpenterRequirement) GetKey() string { @@ -11413,7 +12006,7 @@ type WorkloadFilters struct { func (x *WorkloadFilters) Reset() { *x = WorkloadFilters{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[110] + mi := &file_api_v1_common_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11426,7 +12019,7 @@ func (x *WorkloadFilters) String() string { func (*WorkloadFilters) ProtoMessage() {} func (x *WorkloadFilters) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[110] + mi := &file_api_v1_common_proto_msgTypes[114] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11439,7 +12032,7 @@ func (x *WorkloadFilters) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkloadFilters.ProtoReflect.Descriptor instead. func (*WorkloadFilters) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{110} + return file_api_v1_common_proto_rawDescGZIP(), []int{114} } func (x *WorkloadFilters) GetNamespaceSelector() *LabelSelector { @@ -11518,7 +12111,7 @@ type PodDisruptionBudgetDetails struct { func (x *PodDisruptionBudgetDetails) Reset() { *x = PodDisruptionBudgetDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[111] + mi := &file_api_v1_common_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11531,7 +12124,7 @@ func (x *PodDisruptionBudgetDetails) String() string { func (*PodDisruptionBudgetDetails) ProtoMessage() {} func (x *PodDisruptionBudgetDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[111] + mi := &file_api_v1_common_proto_msgTypes[115] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11544,7 +12137,7 @@ func (x *PodDisruptionBudgetDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use PodDisruptionBudgetDetails.ProtoReflect.Descriptor instead. func (*PodDisruptionBudgetDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{111} + return file_api_v1_common_proto_rawDescGZIP(), []int{115} } func (x *PodDisruptionBudgetDetails) GetMinAvailable() int32 { @@ -11626,7 +12219,7 @@ type PodDisruptionBudgetCondition struct { func (x *PodDisruptionBudgetCondition) Reset() { *x = PodDisruptionBudgetCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[112] + mi := &file_api_v1_common_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11639,7 +12232,7 @@ func (x *PodDisruptionBudgetCondition) String() string { func (*PodDisruptionBudgetCondition) ProtoMessage() {} func (x *PodDisruptionBudgetCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[112] + mi := &file_api_v1_common_proto_msgTypes[116] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11652,7 +12245,7 @@ func (x *PodDisruptionBudgetCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use PodDisruptionBudgetCondition.ProtoReflect.Descriptor instead. func (*PodDisruptionBudgetCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{112} + return file_api_v1_common_proto_rawDescGZIP(), []int{116} } func (x *PodDisruptionBudgetCondition) GetType() string { @@ -11707,7 +12300,7 @@ type ResourceQuotaDetails struct { func (x *ResourceQuotaDetails) Reset() { *x = ResourceQuotaDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[113] + mi := &file_api_v1_common_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11720,7 +12313,7 @@ func (x *ResourceQuotaDetails) String() string { func (*ResourceQuotaDetails) ProtoMessage() {} func (x *ResourceQuotaDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[113] + mi := &file_api_v1_common_proto_msgTypes[117] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11733,7 +12326,7 @@ func (x *ResourceQuotaDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceQuotaDetails.ProtoReflect.Descriptor instead. func (*ResourceQuotaDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{113} + return file_api_v1_common_proto_rawDescGZIP(), []int{117} } func (x *ResourceQuotaDetails) GetHardLimits() map[string]string { @@ -11794,7 +12387,7 @@ type ResourceQuotaCondition struct { func (x *ResourceQuotaCondition) Reset() { *x = ResourceQuotaCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[114] + mi := &file_api_v1_common_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11807,7 +12400,7 @@ func (x *ResourceQuotaCondition) String() string { func (*ResourceQuotaCondition) ProtoMessage() {} func (x *ResourceQuotaCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[114] + mi := &file_api_v1_common_proto_msgTypes[118] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11820,7 +12413,7 @@ func (x *ResourceQuotaCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceQuotaCondition.ProtoReflect.Descriptor instead. func (*ResourceQuotaCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{114} + return file_api_v1_common_proto_rawDescGZIP(), []int{118} } func (x *ResourceQuotaCondition) GetType() string { @@ -11876,7 +12469,7 @@ type VolcanoJobDetails struct { func (x *VolcanoJobDetails) Reset() { *x = VolcanoJobDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[115] + mi := &file_api_v1_common_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11889,7 +12482,7 @@ func (x *VolcanoJobDetails) String() string { func (*VolcanoJobDetails) ProtoMessage() {} func (x *VolcanoJobDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[115] + mi := &file_api_v1_common_proto_msgTypes[119] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11902,7 +12495,7 @@ func (x *VolcanoJobDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use VolcanoJobDetails.ProtoReflect.Descriptor instead. func (*VolcanoJobDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{115} + return file_api_v1_common_proto_rawDescGZIP(), []int{119} } func (x *VolcanoJobDetails) GetContainers() []*ContainerTemplate { @@ -11970,7 +12563,7 @@ type VolcanoJobCondition struct { func (x *VolcanoJobCondition) Reset() { *x = VolcanoJobCondition{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[116] + mi := &file_api_v1_common_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11983,7 +12576,7 @@ func (x *VolcanoJobCondition) String() string { func (*VolcanoJobCondition) ProtoMessage() {} func (x *VolcanoJobCondition) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[116] + mi := &file_api_v1_common_proto_msgTypes[120] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11996,7 +12589,7 @@ func (x *VolcanoJobCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use VolcanoJobCondition.ProtoReflect.Descriptor instead. func (*VolcanoJobCondition) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{116} + return file_api_v1_common_proto_rawDescGZIP(), []int{120} } func (x *VolcanoJobCondition) GetType() string { @@ -12048,7 +12641,7 @@ type VolcanoTask struct { func (x *VolcanoTask) Reset() { *x = VolcanoTask{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[117] + mi := &file_api_v1_common_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12061,7 +12654,7 @@ func (x *VolcanoTask) String() string { func (*VolcanoTask) ProtoMessage() {} func (x *VolcanoTask) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[117] + mi := &file_api_v1_common_proto_msgTypes[121] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12074,7 +12667,7 @@ func (x *VolcanoTask) ProtoReflect() protoreflect.Message { // Deprecated: Use VolcanoTask.ProtoReflect.Descriptor instead. func (*VolcanoTask) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{117} + return file_api_v1_common_proto_rawDescGZIP(), []int{121} } func (x *VolcanoTask) GetName() string { @@ -12125,7 +12718,7 @@ type SparkApplicationDetails struct { func (x *SparkApplicationDetails) Reset() { *x = SparkApplicationDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[118] + mi := &file_api_v1_common_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12138,7 +12731,7 @@ func (x *SparkApplicationDetails) String() string { func (*SparkApplicationDetails) ProtoMessage() {} func (x *SparkApplicationDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[118] + mi := &file_api_v1_common_proto_msgTypes[122] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12151,7 +12744,7 @@ func (x *SparkApplicationDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use SparkApplicationDetails.ProtoReflect.Descriptor instead. func (*SparkApplicationDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{118} + return file_api_v1_common_proto_rawDescGZIP(), []int{122} } func (x *SparkApplicationDetails) GetContainers() []*ContainerTemplate { @@ -12286,7 +12879,7 @@ type SparkDriverInfo struct { func (x *SparkDriverInfo) Reset() { *x = SparkDriverInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[119] + mi := &file_api_v1_common_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12299,7 +12892,7 @@ func (x *SparkDriverInfo) String() string { func (*SparkDriverInfo) ProtoMessage() {} func (x *SparkDriverInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[119] + mi := &file_api_v1_common_proto_msgTypes[123] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12312,7 +12905,7 @@ func (x *SparkDriverInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use SparkDriverInfo.ProtoReflect.Descriptor instead. func (*SparkDriverInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{119} + return file_api_v1_common_proto_rawDescGZIP(), []int{123} } func (x *SparkDriverInfo) GetPodName() string { @@ -12394,7 +12987,7 @@ type SparkRestartPolicyInfo struct { func (x *SparkRestartPolicyInfo) Reset() { *x = SparkRestartPolicyInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[120] + mi := &file_api_v1_common_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12407,7 +13000,7 @@ func (x *SparkRestartPolicyInfo) String() string { func (*SparkRestartPolicyInfo) ProtoMessage() {} func (x *SparkRestartPolicyInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[120] + mi := &file_api_v1_common_proto_msgTypes[124] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12420,7 +13013,7 @@ func (x *SparkRestartPolicyInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use SparkRestartPolicyInfo.ProtoReflect.Descriptor instead. func (*SparkRestartPolicyInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{120} + return file_api_v1_common_proto_rawDescGZIP(), []int{124} } func (x *SparkRestartPolicyInfo) GetType() string { @@ -12475,7 +13068,7 @@ type SparkDynamicAllocationInfo struct { func (x *SparkDynamicAllocationInfo) Reset() { *x = SparkDynamicAllocationInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[121] + mi := &file_api_v1_common_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12488,7 +13081,7 @@ func (x *SparkDynamicAllocationInfo) String() string { func (*SparkDynamicAllocationInfo) ProtoMessage() {} func (x *SparkDynamicAllocationInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[121] + mi := &file_api_v1_common_proto_msgTypes[125] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12501,7 +13094,7 @@ func (x *SparkDynamicAllocationInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use SparkDynamicAllocationInfo.ProtoReflect.Descriptor instead. func (*SparkDynamicAllocationInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{121} + return file_api_v1_common_proto_rawDescGZIP(), []int{125} } func (x *SparkDynamicAllocationInfo) GetEnabled() bool { @@ -12572,7 +13165,7 @@ type ScheduledSparkApplicationDetails struct { func (x *ScheduledSparkApplicationDetails) Reset() { *x = ScheduledSparkApplicationDetails{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[122] + mi := &file_api_v1_common_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12585,7 +13178,7 @@ func (x *ScheduledSparkApplicationDetails) String() string { func (*ScheduledSparkApplicationDetails) ProtoMessage() {} func (x *ScheduledSparkApplicationDetails) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[122] + mi := &file_api_v1_common_proto_msgTypes[126] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12598,7 +13191,7 @@ func (x *ScheduledSparkApplicationDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ScheduledSparkApplicationDetails.ProtoReflect.Descriptor instead. func (*ScheduledSparkApplicationDetails) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{122} + return file_api_v1_common_proto_rawDescGZIP(), []int{126} } func (x *ScheduledSparkApplicationDetails) GetSchedule() string { @@ -12725,6 +13318,9 @@ type Event struct { InvolvedObjectNamespace string `protobuf:"bytes,20,opt,name=involved_object_namespace,json=involvedObjectNamespace,proto3" json:"involved_object_namespace,omitempty"` ReportingController string `protobuf:"bytes,21,opt,name=reporting_controller,json=reportingController,proto3" json:"reporting_controller,omitempty"` ReportingInstance string `protobuf:"bytes,22,opt,name=reporting_instance,json=reportingInstance,proto3" json:"reporting_instance,omitempty"` + Annotations map[string]string `protobuf:"bytes,23,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Labels map[string]string `protobuf:"bytes,24,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + InvolvedObjectUid string `protobuf:"bytes,25,opt,name=involved_object_uid,json=involvedObjectUid,proto3" json:"involved_object_uid,omitempty"` CreatedAt *timestamppb.Timestamp `protobuf:"bytes,41,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,42,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` LastSeen *timestamppb.Timestamp `protobuf:"bytes,43,opt,name=last_seen,json=lastSeen,proto3" json:"last_seen,omitempty"` @@ -12737,7 +13333,7 @@ type Event struct { func (x *Event) Reset() { *x = Event{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[123] + mi := &file_api_v1_common_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12750,7 +13346,7 @@ func (x *Event) String() string { func (*Event) ProtoMessage() {} func (x *Event) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[123] + mi := &file_api_v1_common_proto_msgTypes[127] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12763,7 +13359,7 @@ func (x *Event) ProtoReflect() protoreflect.Message { // Deprecated: Use Event.ProtoReflect.Descriptor instead. func (*Event) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{123} + return file_api_v1_common_proto_rawDescGZIP(), []int{127} } func (x *Event) GetId() string { @@ -12913,6 +13509,27 @@ func (x *Event) GetReportingInstance() string { return "" } +func (x *Event) GetAnnotations() map[string]string { + if x != nil { + return x.Annotations + } + return nil +} + +func (x *Event) GetLabels() map[string]string { + if x != nil { + return x.Labels + } + return nil +} + +func (x *Event) GetInvolvedObjectUid() string { + if x != nil { + return x.InvolvedObjectUid + } + return "" +} + func (x *Event) GetCreatedAt() *timestamppb.Timestamp { if x != nil { return x.CreatedAt @@ -12979,7 +13596,7 @@ type EventDatapointInfo struct { func (x *EventDatapointInfo) Reset() { *x = EventDatapointInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[124] + mi := &file_api_v1_common_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12992,7 +13609,7 @@ func (x *EventDatapointInfo) String() string { func (*EventDatapointInfo) ProtoMessage() {} func (x *EventDatapointInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[124] + mi := &file_api_v1_common_proto_msgTypes[128] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13005,7 +13622,7 @@ func (x *EventDatapointInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use EventDatapointInfo.ProtoReflect.Descriptor instead. func (*EventDatapointInfo) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{124} + return file_api_v1_common_proto_rawDescGZIP(), []int{128} } func (x *EventDatapointInfo) GetName() string { @@ -13062,15 +13679,18 @@ type EventDatapoint struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - UtcTime string `protobuf:"bytes,1,opt,name=utc_time,json=utcTime,proto3" json:"utc_time,omitempty"` - Count int32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` // Number of events in this time bucket - Events []*EventDatapointInfo `protobuf:"bytes,3,rep,name=events,proto3" json:"events,omitempty"` // Details of events in this bucket + UtcTime string `protobuf:"bytes,1,opt,name=utc_time,json=utcTime,proto3" json:"utc_time,omitempty"` + Count int32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` // Number of events in this time bucket + Events []*EventDatapointInfo `protobuf:"bytes,3,rep,name=events,proto3" json:"events,omitempty"` // Details of events in this bucket (deprecated: use normal_count/warning_count) + NormalCount int32 `protobuf:"varint,4,opt,name=normal_count,json=normalCount,proto3" json:"normal_count,omitempty"` // Count of Normal events in this time bucket + WarningCount int32 `protobuf:"varint,5,opt,name=warning_count,json=warningCount,proto3" json:"warning_count,omitempty"` // Count of Warning events in this time bucket + CriticalCount int32 `protobuf:"varint,6,opt,name=critical_count,json=criticalCount,proto3" json:"critical_count,omitempty"` // Count of events with critical reasons (OOMKilled, CrashLoopBackOff, NodeNotReady, etc.) } func (x *EventDatapoint) Reset() { *x = EventDatapoint{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_common_proto_msgTypes[125] + mi := &file_api_v1_common_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13083,7 +13703,7 @@ func (x *EventDatapoint) String() string { func (*EventDatapoint) ProtoMessage() {} func (x *EventDatapoint) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_common_proto_msgTypes[125] + mi := &file_api_v1_common_proto_msgTypes[129] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13096,7 +13716,7 @@ func (x *EventDatapoint) ProtoReflect() protoreflect.Message { // Deprecated: Use EventDatapoint.ProtoReflect.Descriptor instead. func (*EventDatapoint) Descriptor() ([]byte, []int) { - return file_api_v1_common_proto_rawDescGZIP(), []int{125} + return file_api_v1_common_proto_rawDescGZIP(), []int{129} } func (x *EventDatapoint) GetUtcTime() string { @@ -13120,6 +13740,209 @@ func (x *EventDatapoint) GetEvents() []*EventDatapointInfo { return nil } +func (x *EventDatapoint) GetNormalCount() int32 { + if x != nil { + return x.NormalCount + } + return 0 +} + +func (x *EventDatapoint) GetWarningCount() int32 { + if x != nil { + return x.WarningCount + } + return 0 +} + +func (x *EventDatapoint) GetCriticalCount() int32 { + if x != nil { + return x.CriticalCount + } + return 0 +} + +type DimensionCount struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + Count int32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` + Percentage float64 `protobuf:"fixed64,3,opt,name=percentage,proto3" json:"percentage,omitempty"` +} + +func (x *DimensionCount) Reset() { + *x = DimensionCount{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_common_proto_msgTypes[130] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DimensionCount) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DimensionCount) ProtoMessage() {} + +func (x *DimensionCount) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_common_proto_msgTypes[130] + 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) +} + +// Deprecated: Use DimensionCount.ProtoReflect.Descriptor instead. +func (*DimensionCount) Descriptor() ([]byte, []int) { + return file_api_v1_common_proto_rawDescGZIP(), []int{130} +} + +func (x *DimensionCount) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +func (x *DimensionCount) GetCount() int32 { + if x != nil { + return x.Count + } + return 0 +} + +func (x *DimensionCount) GetPercentage() float64 { + if x != nil { + return x.Percentage + } + return 0 +} + +type EventGroup struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` + Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"` + WorkloadName string `protobuf:"bytes,3,opt,name=workload_name,json=workloadName,proto3" json:"workload_name,omitempty"` + WorkloadKind string `protobuf:"bytes,4,opt,name=workload_kind,json=workloadKind,proto3" json:"workload_kind,omitempty"` + Node string `protobuf:"bytes,5,opt,name=node,proto3" json:"node,omitempty"` + Count int32 `protobuf:"varint,6,opt,name=count,proto3" json:"count,omitempty"` + AffectedObjects int32 `protobuf:"varint,7,opt,name=affected_objects,json=affectedObjects,proto3" json:"affected_objects,omitempty"` + FirstSeen *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=first_seen,json=firstSeen,proto3" json:"first_seen,omitempty"` + LastSeen *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=last_seen,json=lastSeen,proto3" json:"last_seen,omitempty"` + Type string `protobuf:"bytes,10,opt,name=type,proto3" json:"type,omitempty"` +} + +func (x *EventGroup) Reset() { + *x = EventGroup{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_common_proto_msgTypes[131] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventGroup) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventGroup) ProtoMessage() {} + +func (x *EventGroup) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_common_proto_msgTypes[131] + 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) +} + +// Deprecated: Use EventGroup.ProtoReflect.Descriptor instead. +func (*EventGroup) Descriptor() ([]byte, []int) { + return file_api_v1_common_proto_rawDescGZIP(), []int{131} +} + +func (x *EventGroup) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +func (x *EventGroup) GetNamespace() string { + if x != nil { + return x.Namespace + } + return "" +} + +func (x *EventGroup) GetWorkloadName() string { + if x != nil { + return x.WorkloadName + } + return "" +} + +func (x *EventGroup) GetWorkloadKind() string { + if x != nil { + return x.WorkloadKind + } + return "" +} + +func (x *EventGroup) GetNode() string { + if x != nil { + return x.Node + } + return "" +} + +func (x *EventGroup) GetCount() int32 { + if x != nil { + return x.Count + } + return 0 +} + +func (x *EventGroup) GetAffectedObjects() int32 { + if x != nil { + return x.AffectedObjects + } + return 0 +} + +func (x *EventGroup) GetFirstSeen() *timestamppb.Timestamp { + if x != nil { + return x.FirstSeen + } + return nil +} + +func (x *EventGroup) GetLastSeen() *timestamppb.Timestamp { + if x != nil { + return x.LastSeen + } + return nil +} + +func (x *EventGroup) GetType() string { + if x != nil { + return x.Type + } + return "" +} + var File_api_v1_common_proto protoreflect.FileDescriptor var file_api_v1_common_proto_rawDesc = []byte{ @@ -13592,1734 +14415,1839 @@ var file_api_v1_common_proto_rawDesc = []byte{ 0x79, 0x5f, 0x69, 0x6e, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x2c, 0x0a, 0x2a, 0x5f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x5f, - 0x69, 0x6e, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0xf2, 0x0c, 0x0a, 0x17, 0x46, 0x6f, - 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, - 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 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, 0x54, 0x69, 0x6d, 0x65, 0x73, - 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, - 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x25, - 0x0a, 0x0e, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x69, 0x6e, 0x64, - 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, - 0x70, 0x75, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x01, 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x70, 0x75, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, - 0x74, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, - 0x79, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x43, 0x61, 0x70, 0x61, - 0x63, 0x69, 0x74, 0x79, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x70, 0x75, - 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x6e, 0x6f, - 0x64, 0x65, 0x43, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x6f, - 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x6d, 0x6f, 0x72, - 0x79, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, - 0x70, 0x75, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0a, - 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x70, 0x75, 0x55, 0x74, 0x69, - 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x17, 0x6e, 0x6f, 0x64, 0x65, - 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x6e, 0x6f, 0x64, 0x65, 0x4d, - 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x63, 0x70, - 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x63, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, 0x65, - 0x12, 0x34, 0x0a, 0x16, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6d, 0x65, - 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x14, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x6f, 0x72, - 0x79, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, - 0x6e, 0x65, 0x72, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x43, 0x70, 0x75, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x1c, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, + 0x69, 0x6e, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0xf9, 0x03, 0x0a, 0x11, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x12, + 0x10, 0x0a, 0x03, 0x6d, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x6d, 0x69, + 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x76, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, + 0x61, 0x76, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x61, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x03, 0x6d, 0x61, 0x78, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x35, 0x30, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x03, 0x70, 0x35, 0x30, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x39, 0x35, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x39, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x39, 0x39, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x39, 0x39, 0x12, 0x12, 0x0a, 0x04, 0x70, + 0x31, 0x30, 0x30, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x04, 0x70, 0x31, 0x30, 0x30, 0x12, + 0x10, 0x0a, 0x03, 0x70, 0x31, 0x30, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x31, + 0x30, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x32, 0x35, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, + 0x70, 0x32, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x37, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x03, 0x70, 0x37, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x39, 0x30, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x03, 0x70, 0x39, 0x30, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x39, 0x39, 0x39, 0x18, + 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x04, 0x70, 0x39, 0x39, 0x39, 0x12, 0x0e, 0x0a, 0x02, 0x70, + 0x31, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x01, 0x52, 0x02, 0x70, 0x31, 0x12, 0x0e, 0x0a, 0x02, 0x70, + 0x35, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x02, 0x70, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x70, + 0x31, 0x35, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x31, 0x35, 0x12, 0x10, 0x0a, + 0x03, 0x70, 0x32, 0x30, 0x18, 0x10, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x32, 0x30, 0x12, + 0x10, 0x0a, 0x03, 0x70, 0x33, 0x30, 0x18, 0x11, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x33, + 0x30, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x33, 0x35, 0x18, 0x12, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, + 0x70, 0x33, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x34, 0x30, 0x18, 0x13, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x03, 0x70, 0x34, 0x30, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x34, 0x35, 0x18, 0x14, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x03, 0x70, 0x34, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x35, 0x35, 0x18, 0x15, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x35, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x36, 0x30, + 0x18, 0x16, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x36, 0x30, 0x12, 0x10, 0x0a, 0x03, 0x70, + 0x36, 0x35, 0x18, 0x17, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x36, 0x35, 0x12, 0x10, 0x0a, + 0x03, 0x70, 0x37, 0x30, 0x18, 0x18, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x37, 0x30, 0x12, + 0x10, 0x0a, 0x03, 0x70, 0x38, 0x30, 0x18, 0x19, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x70, 0x38, + 0x30, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x38, 0x35, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, + 0x70, 0x38, 0x35, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x39, 0x37, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x03, 0x70, 0x39, 0x37, 0x22, 0xa2, 0x08, 0x0a, 0x1a, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x53, 0x75, 0x6d, + 0x6d, 0x61, 0x72, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x36, 0x0a, 0x09, 0x63, + 0x70, 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, + 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x08, 0x63, 0x70, 0x75, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x12, 0x3c, 0x0a, 0x0c, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x75, 0x73, + 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, + 0x69, 0x6c, 0x65, 0x73, 0x52, 0x0b, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x55, 0x73, 0x61, 0x67, + 0x65, 0x12, 0x3a, 0x0a, 0x0b, 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, + 0x73, 0x52, 0x0a, 0x63, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x40, 0x0a, + 0x0e, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, + 0x52, 0x0d, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x36, 0x0a, 0x09, 0x63, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x08, 0x63, + 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x3c, 0x0a, 0x0c, 0x6d, 0x65, 0x6d, 0x6f, 0x72, + 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, + 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x0b, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x36, 0x0a, 0x09, 0x67, 0x70, 0x75, 0x5f, 0x75, 0x73, 0x61, + 0x67, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, + 0x6c, 0x65, 0x73, 0x52, 0x08, 0x67, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3f, 0x0a, + 0x0e, 0x67, 0x70, 0x75, 0x5f, 0x76, 0x72, 0x61, 0x6d, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, + 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, + 0x52, 0x0c, 0x67, 0x70, 0x75, 0x56, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x32, + 0x0a, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, + 0x11, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x43, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x38, 0x0a, 0x16, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x14, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4d, + 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2e, 0x0a, 0x11, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0f, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x74, 0x43, 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x34, 0x0a, 0x14, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x6c, + 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x12, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, + 0x69, 0x74, 0x12, 0x4d, 0x0a, 0x15, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x72, 0x65, + 0x63, 0x65, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, + 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x13, 0x6e, 0x65, + 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x12, 0x4f, 0x0a, 0x16, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, + 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x14, 0x6e, 0x65, + 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x12, 0x41, 0x0a, 0x0d, 0x66, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, + 0x69, 0x6c, 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x66, 0x73, 0x52, 0x65, 0x61, 0x64, + 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x43, 0x0a, 0x0e, 0x66, 0x73, 0x5f, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, + 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x66, 0x73, + 0x57, 0x72, 0x69, 0x74, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x22, 0xc5, 0x01, 0x0a, 0x1c, 0x43, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x46, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, + 0x74, 0x69, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x3d, 0x0a, 0x0d, 0x66, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, + 0x69, 0x6c, 0x65, 0x73, 0x52, 0x0b, 0x66, 0x73, 0x52, 0x65, 0x61, 0x64, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x12, 0x3f, 0x0a, 0x0e, 0x66, 0x73, 0x5f, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, + 0x69, 0x6c, 0x65, 0x73, 0x52, 0x0c, 0x66, 0x73, 0x57, 0x72, 0x69, 0x74, 0x65, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x22, 0x83, 0x02, 0x0a, 0x16, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x25, 0x0a, + 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, + 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x11, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x43, 0x70, 0x75, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, + 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x14, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x6d, + 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x43, 0x70, + 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x74, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x6d, + 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0xf2, 0x0c, 0x0a, 0x17, 0x46, 0x6f, 0x72, + 0x65, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x73, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 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, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x1d, + 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x25, 0x0a, + 0x0e, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x69, 0x6e, 0x64, 0x12, + 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x70, + 0x75, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x70, 0x75, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, + 0x79, 0x12, 0x30, 0x0a, 0x14, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x43, 0x61, 0x70, 0x61, 0x63, + 0x69, 0x74, 0x79, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x70, 0x75, 0x5f, + 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x6e, 0x6f, 0x64, + 0x65, 0x43, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x6f, 0x64, + 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x70, + 0x75, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0a, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x70, 0x75, 0x55, 0x74, 0x69, 0x6c, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x17, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x1a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, - 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, - 0x10, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, - 0x43, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x3c, 0x0a, 0x1a, - 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, - 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x11, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x18, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x6f, 0x72, - 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x30, 0x0a, 0x14, 0x63, 0x6f, - 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, - 0x74, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, - 0x6e, 0x65, 0x72, 0x43, 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x36, 0x0a, 0x17, - 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, - 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x13, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x63, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x4c, 0x69, - 0x6d, 0x69, 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, - 0x01, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x47, 0x70, 0x75, 0x55, - 0x73, 0x61, 0x67, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, - 0x15, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, - 0x47, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x30, 0x0a, 0x14, - 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x6c, 0x69, - 0x6d, 0x69, 0x74, 0x73, 0x18, 0x16, 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x47, 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x3a, - 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, 0x5f, - 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x17, 0x20, 0x01, 0x28, - 0x01, 0x52, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x47, 0x70, 0x75, 0x55, - 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x6f, - 0x64, 0x65, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, - 0x18, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x70, 0x75, 0x43, 0x61, - 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, - 0x70, 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x19, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, - 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, - 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x6e, 0x6f, 0x64, 0x65, - 0x47, 0x70, 0x75, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, - 0x0a, 0x13, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x76, 0x72, 0x61, 0x6d, 0x5f, - 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x6e, 0x6f, 0x64, - 0x65, 0x47, 0x70, 0x75, 0x56, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, - 0x18, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x76, - 0x72, 0x61, 0x6d, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x15, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x47, 0x70, 0x75, 0x56, 0x72, 0x61, - 0x6d, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, - 0x70, 0x75, 0x5f, 0x76, 0x72, 0x61, 0x6d, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, - 0x18, 0x1d, 0x20, 0x01, 0x28, 0x01, 0x52, 0x13, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x70, 0x75, 0x56, - 0x72, 0x61, 0x6d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x39, 0x0a, 0x19, 0x6e, - 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x76, 0x72, 0x61, 0x6d, 0x5f, 0x75, 0x74, 0x69, - 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x16, - 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x70, 0x75, 0x56, 0x72, 0x61, 0x6d, 0x55, 0x74, 0x69, 0x6c, 0x69, - 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x1f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, - 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, - 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x1c, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x4d, - 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x3f, 0x0a, - 0x1c, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x67, 0x70, 0x75, 0x5f, - 0x76, 0x72, 0x61, 0x6d, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x20, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x19, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x47, - 0x70, 0x75, 0x56, 0x72, 0x61, 0x6d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x22, 0xe8, - 0x04, 0x0a, 0x0f, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, - 0x72, 0x79, 0x12, 0x29, 0x0a, 0x10, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, - 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x64, 0x65, - 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2c, 0x0a, - 0x12, 0x73, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x6f, - 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x73, 0x74, 0x61, 0x74, 0x65, - 0x66, 0x75, 0x6c, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x64, - 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x64, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x53, 0x65, 0x74, - 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, 0x75, - 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6a, 0x6f, 0x62, 0x43, 0x6f, 0x75, - 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x63, - 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x63, 0x72, 0x6f, 0x6e, - 0x4a, 0x6f, 0x62, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x43, - 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x70, 0x6f, 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, - 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x70, 0x6f, 0x64, 0x43, 0x6f, 0x75, 0x6e, - 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x63, - 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x65, - 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x0b, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x21, 0x0a, - 0x0c, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x0a, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0b, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x64, 0x73, - 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x6f, - 0x64, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, - 0x64, 0x65, 0x64, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x69, 0x6c, 0x65, - 0x64, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x61, - 0x69, 0x6c, 0x65, 0x64, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x75, 0x6e, 0x6b, 0x6e, - 0x6f, 0x77, 0x6e, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, - 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x75, - 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, - 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x75, 0x6e, - 0x64, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x43, 0x6f, - 0x75, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x6f, 0x76, - 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0f, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x14, 0x6f, 0x76, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, - 0x6f, 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xf1, 0x0a, 0x0a, 0x0c, 0x57, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, - 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, - 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x03, 0x75, 0x69, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, - 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x12, 0x30, - 0x0a, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, - 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, - 0x12, 0x38, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, - 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x47, 0x0a, 0x0b, 0x61, 0x6e, - 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x25, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, - 0x64, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, - 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x11, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, - 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, - 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, - 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, - 0x6e, 0x66, 0x6f, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, - 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3f, 0x0a, 0x10, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x64, 0x61, - 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, - 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0e, 0x63, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, - 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x4b, 0x0a, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0e, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, - 0x12, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, - 0x6e, 0x74, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x73, 0x63, - 0x6f, 0x72, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x69, 0x6d, 0x70, 0x61, 0x63, - 0x74, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x64, 0x5f, 0x61, 0x74, 0x18, 0x10, 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, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, - 0x74, 0x12, 0x3e, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, - 0x11, 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, 0x48, 0x00, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, 0x88, 0x01, - 0x01, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, - 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, - 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, - 0x12, 0x32, 0x0a, 0x15, 0x69, 0x73, 0x5f, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, - 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x13, 0x69, 0x73, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x12, 0x47, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x01, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x88, 0x01, 0x01, 0x12, 0x1d, 0x0a, - 0x0a, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x38, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x09, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x64, 0x73, 0x12, 0x30, 0x0a, 0x14, - 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x18, 0x4c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x72, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2c, - 0x0a, 0x12, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, - 0x73, 0x70, 0x65, 0x63, 0x18, 0x4d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x72, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x53, 0x70, 0x65, 0x63, 0x12, 0x32, 0x0a, 0x15, - 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x6d, 0x65, - 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x4e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x72, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, - 0x12, 0x26, 0x0a, 0x0f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6b, - 0x69, 0x6e, 0x64, 0x18, 0x5b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x6f, 0x6f, 0x74, 0x4f, - 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x6f, 0x6f, 0x74, - 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x5c, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0c, 0x72, 0x6f, 0x6f, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x1a, 0x39, - 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 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, 0x3e, 0x0a, 0x10, 0x41, 0x6e, 0x6e, - 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x64, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x42, 0x13, 0x0a, 0x11, 0x5f, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x53, 0x0a, - 0x14, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, - 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, - 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x75, 0x6e, - 0x74, 0x69, 0x6d, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x22, 0xbc, 0x01, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, - 0x1d, 0x0a, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x26, - 0x0a, 0x0f, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, - 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x6e, 0x44, 0x65, 0x6d, 0x61, 0x6e, - 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, - 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1d, 0x0a, - 0x0a, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x09, 0x73, 0x70, 0x6f, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, - 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0c, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x43, 0x6f, 0x75, 0x6e, - 0x74, 0x22, 0xe5, 0x01, 0x0a, 0x0c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, - 0x66, 0x6f, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x5f, - 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x18, 0x73, - 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x16, 0x73, - 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3c, 0x0a, 0x1a, 0x75, 0x6e, 0x73, 0x63, 0x68, 0x65, 0x64, - 0x75, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6f, - 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x18, 0x75, 0x6e, 0x73, 0x63, 0x68, - 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, - 0x75, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x14, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xf7, 0x10, 0x0a, 0x04, 0x4e, 0x6f, - 0x64, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, - 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, - 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x69, - 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, - 0x16, 0x0a, 0x06, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x06, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x7a, 0x6f, 0x6e, 0x65, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x7a, 0x6f, 0x6e, 0x65, 0x12, 0x42, 0x0a, 0x10, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, - 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, - 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x08, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x26, - 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, - 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x72, 0x65, 0x61, - 0x64, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x52, 0x65, 0x61, 0x64, - 0x79, 0x12, 0x4e, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x72, - 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, - 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x10, 0x63, 0x6f, - 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x88, 0x01, - 0x01, 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x28, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x0f, 0x72, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1d, 0x0a, - 0x0a, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x29, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1b, 0x0a, 0x09, - 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x12, 0x30, 0x0a, 0x08, 0x63, 0x68, 0x69, - 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x18, 0x2b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, - 0x6d, 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x30, 0x0a, 0x06, 0x6c, - 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x3f, 0x0a, - 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x2d, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, - 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x28, - 0x0a, 0x0e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x68, 0x6f, 0x75, 0x72, - 0x18, 0x32, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x70, 0x72, 0x69, 0x63, - 0x65, 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, 0x12, 0x28, 0x0a, 0x0e, 0x70, 0x72, 0x69, 0x63, - 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x63, 0x70, 0x75, 0x18, 0x33, 0x20, 0x01, 0x28, 0x01, - 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x70, 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x56, 0x63, - 0x70, 0x75, 0x12, 0x26, 0x0a, 0x0d, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, - 0x67, 0x69, 0x62, 0x18, 0x34, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x70, - 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x47, 0x69, 0x62, 0x12, 0x26, 0x0a, 0x0d, 0x70, 0x72, - 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, 0x18, 0x35, 0x20, 0x01, 0x28, - 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x70, 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x47, - 0x70, 0x75, 0x12, 0x1f, 0x0a, 0x09, 0x63, 0x70, 0x75, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, - 0x36, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x63, 0x70, 0x75, 0x50, 0x72, - 0x69, 0x63, 0x65, 0x12, 0x25, 0x0a, 0x0c, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x70, 0x72, - 0x69, 0x63, 0x65, 0x18, 0x37, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x6d, - 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x09, 0x67, 0x70, - 0x75, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x38, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, - 0x01, 0x52, 0x08, 0x67, 0x70, 0x75, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x43, 0x0a, 0x14, 0x6d, - 0x6f, 0x6e, 0x65, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x68, - 0x6f, 0x75, 0x72, 0x18, 0x39, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x11, 0x6d, - 0x6f, 0x6e, 0x65, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, - 0x12, 0x50, 0x0a, 0x1b, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x5f, 0x65, 0x66, 0x66, 0x5f, 0x70, 0x65, - 0x72, 0x69, 0x6f, 0x64, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, - 0x3a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, - 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x17, 0x6d, 0x6f, 0x6e, 0x65, 0x79, - 0x45, 0x66, 0x66, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, - 0x73, 0x74, 0x12, 0x43, 0x0a, 0x14, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x63, - 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x63, 0x70, 0x75, 0x18, 0x3b, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, - 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x11, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, - 0x50, 0x65, 0x72, 0x56, 0x63, 0x70, 0x75, 0x12, 0x41, 0x0a, 0x13, 0x6d, 0x6f, 0x6e, 0x65, 0x79, - 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x67, 0x69, 0x62, 0x18, 0x50, + 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x6e, 0x6f, 0x64, 0x65, 0x4d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x2e, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x63, 0x70, 0x75, + 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, + 0x34, 0x0a, 0x16, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6d, 0x65, 0x6d, + 0x6f, 0x72, 0x79, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x14, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x43, 0x70, 0x75, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x40, 0x0a, 0x1c, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6d, + 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x1a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x10, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, + 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x3c, 0x0a, 0x1a, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x11, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x18, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x30, 0x0a, 0x14, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x43, 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x13, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, + 0x69, 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x47, 0x70, 0x75, 0x55, 0x73, + 0x61, 0x67, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x15, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x47, + 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x30, 0x0a, 0x14, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x73, 0x18, 0x16, 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x47, 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x3a, 0x0a, + 0x19, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x75, + 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x17, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x47, 0x70, 0x75, 0x55, 0x74, + 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x6f, 0x64, + 0x65, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x18, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x70, 0x75, 0x43, 0x61, 0x70, + 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x70, + 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x19, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x6e, + 0x6f, 0x64, 0x65, 0x47, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6e, + 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x47, + 0x70, 0x75, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x0a, + 0x13, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x76, 0x72, 0x61, 0x6d, 0x5f, 0x75, + 0x73, 0x61, 0x67, 0x65, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x6e, 0x6f, 0x64, 0x65, + 0x47, 0x70, 0x75, 0x56, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x18, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x76, 0x72, + 0x61, 0x6d, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x47, 0x70, 0x75, 0x56, 0x72, 0x61, 0x6d, + 0x55, 0x73, 0x61, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x70, + 0x75, 0x5f, 0x76, 0x72, 0x61, 0x6d, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, + 0x1d, 0x20, 0x01, 0x28, 0x01, 0x52, 0x13, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x70, 0x75, 0x56, 0x72, + 0x61, 0x6d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x39, 0x0a, 0x19, 0x6e, 0x6f, + 0x64, 0x65, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x76, 0x72, 0x61, 0x6d, 0x5f, 0x75, 0x74, 0x69, 0x6c, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x16, 0x6e, + 0x6f, 0x64, 0x65, 0x47, 0x70, 0x75, 0x56, 0x72, 0x61, 0x6d, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x1f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, + 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x1c, + 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x3f, 0x0a, 0x1c, + 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x76, + 0x72, 0x61, 0x6d, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x20, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x19, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x47, 0x70, + 0x75, 0x56, 0x72, 0x61, 0x6d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x22, 0xe8, 0x04, + 0x0a, 0x0f, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, + 0x79, 0x12, 0x29, 0x0a, 0x10, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x64, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2c, 0x0a, 0x12, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x73, 0x74, 0x61, 0x74, 0x65, 0x66, + 0x75, 0x6c, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x64, 0x61, + 0x65, 0x6d, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x64, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6a, 0x6f, 0x62, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x63, 0x72, 0x6f, 0x6e, 0x4a, + 0x6f, 0x62, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x43, 0x6f, + 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x70, 0x6f, 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x70, 0x6f, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x65, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0b, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x0c, + 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0b, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x64, 0x73, 0x12, + 0x25, 0x0a, 0x0e, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x6f, 0x64, + 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, + 0x65, 0x64, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, + 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x66, 0x61, 0x69, + 0x6c, 0x65, 0x64, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, + 0x77, 0x6e, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x75, + 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x75, 0x6e, + 0x64, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x5f, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x75, 0x6e, 0x64, + 0x65, 0x72, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0f, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x14, 0x6f, 0x76, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xf1, 0x0a, 0x0a, 0x0c, 0x57, 0x6f, 0x72, + 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x75, 0x69, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, + 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x12, 0x30, 0x0a, + 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, + 0x38, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x47, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, + 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, + 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, + 0x66, 0x6f, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3f, 0x0a, 0x10, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x64, 0x61, 0x74, + 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, + 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0e, 0x63, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, + 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x4b, 0x0a, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0e, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x12, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, + 0x74, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x73, 0x63, 0x6f, + 0x72, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x53, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x5f, 0x61, 0x74, 0x18, 0x10, 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, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, + 0x12, 0x3e, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x11, + 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, + 0x48, 0x00, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, 0x88, 0x01, 0x01, + 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x12, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, + 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, + 0x32, 0x0a, 0x15, 0x69, 0x73, 0x5f, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x5f, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, + 0x69, 0x73, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x12, 0x47, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x01, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x88, 0x01, 0x01, 0x12, 0x1d, 0x0a, 0x0a, + 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x38, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x09, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x64, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x4c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2c, 0x0a, + 0x12, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, + 0x70, 0x65, 0x63, 0x18, 0x4d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x53, 0x70, 0x65, 0x63, 0x12, 0x32, 0x0a, 0x15, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x6d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x73, 0x18, 0x4e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, + 0x26, 0x0a, 0x0f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6b, 0x69, + 0x6e, 0x64, 0x18, 0x5b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x6f, 0x6f, 0x74, 0x4f, 0x77, + 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x6f, 0x6f, 0x74, 0x5f, + 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x5c, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x72, 0x6f, 0x6f, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x1a, 0x39, 0x0a, + 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 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, 0x3e, 0x0a, 0x10, 0x41, 0x6e, 0x6e, 0x6f, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x64, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x42, 0x13, 0x0a, 0x11, 0x5f, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x53, 0x0a, 0x14, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x75, 0x6e, 0x74, + 0x69, 0x6d, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x22, 0xbc, 0x01, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, + 0x0a, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x26, 0x0a, + 0x0f, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x6e, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, + 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x64, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, + 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x09, 0x73, 0x70, 0x6f, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x75, + 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0c, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x22, 0xe5, 0x01, 0x0a, 0x0c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x5f, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x18, 0x73, 0x63, + 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x16, 0x73, 0x63, + 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3c, 0x0a, 0x1a, 0x75, 0x6e, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, + 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x18, 0x75, 0x6e, 0x73, 0x63, 0x68, 0x65, + 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x14, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xf7, 0x10, 0x0a, 0x04, 0x4e, 0x6f, 0x64, + 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, + 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x6e, + 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x7a, 0x6f, 0x6e, 0x65, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, + 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x26, 0x0a, + 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, + 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x52, 0x65, 0x61, 0x64, 0x79, + 0x12, 0x4e, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x72, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x10, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, + 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x28, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1d, 0x0a, 0x0a, + 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x29, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6f, + 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x12, 0x30, 0x0a, 0x08, 0x63, 0x68, 0x69, 0x6c, + 0x64, 0x72, 0x65, 0x6e, 0x18, 0x2b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, + 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x30, 0x0a, 0x06, 0x6c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x3f, 0x0a, 0x0b, + 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x2d, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x2e, + 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x28, 0x0a, + 0x0e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x68, 0x6f, 0x75, 0x72, 0x18, + 0x32, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x70, 0x72, 0x69, 0x63, 0x65, + 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, 0x12, 0x28, 0x0a, 0x0e, 0x70, 0x72, 0x69, 0x63, 0x65, + 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x63, 0x70, 0x75, 0x18, 0x33, 0x20, 0x01, 0x28, 0x01, 0x42, + 0x02, 0x18, 0x01, 0x52, 0x0c, 0x70, 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x56, 0x63, 0x70, + 0x75, 0x12, 0x26, 0x0a, 0x0d, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x67, + 0x69, 0x62, 0x18, 0x34, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x70, 0x72, + 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x47, 0x69, 0x62, 0x12, 0x26, 0x0a, 0x0d, 0x70, 0x72, 0x69, + 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, 0x18, 0x35, 0x20, 0x01, 0x28, 0x01, + 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x70, 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x47, 0x70, + 0x75, 0x12, 0x1f, 0x0a, 0x09, 0x63, 0x70, 0x75, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x36, + 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x63, 0x70, 0x75, 0x50, 0x72, 0x69, + 0x63, 0x65, 0x12, 0x25, 0x0a, 0x0c, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x70, 0x72, 0x69, + 0x63, 0x65, 0x18, 0x37, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x6d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x09, 0x67, 0x70, 0x75, + 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x38, 0x20, 0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, + 0x52, 0x08, 0x67, 0x70, 0x75, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x43, 0x0a, 0x14, 0x6d, 0x6f, + 0x6e, 0x65, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x68, 0x6f, + 0x75, 0x72, 0x18, 0x39, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x11, 0x6d, 0x6f, + 0x6e, 0x65, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, 0x12, + 0x50, 0x0a, 0x1b, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x5f, 0x65, 0x66, 0x66, 0x5f, 0x70, 0x65, 0x72, + 0x69, 0x6f, 0x64, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x3a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x79, - 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x10, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x50, - 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x47, 0x69, 0x62, 0x12, 0x41, 0x0a, 0x13, 0x6d, 0x6f, - 0x6e, 0x65, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x67, 0x70, - 0x75, 0x18, 0x51, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x10, 0x6d, 0x6f, 0x6e, - 0x65, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x47, 0x70, 0x75, 0x12, 0x3a, 0x0a, - 0x0f, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, - 0x18, 0x52, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, - 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x0d, 0x6d, 0x6f, 0x6e, 0x65, - 0x79, 0x43, 0x70, 0x75, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x40, 0x0a, 0x12, 0x6d, 0x6f, 0x6e, - 0x65, 0x79, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, - 0x53, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, - 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x10, 0x6d, 0x6f, 0x6e, 0x65, 0x79, - 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x3a, 0x0a, 0x0f, 0x6d, - 0x6f, 0x6e, 0x65, 0x79, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x54, + 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x17, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x45, + 0x66, 0x66, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x73, + 0x74, 0x12, 0x43, 0x0a, 0x14, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, + 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x63, 0x70, 0x75, 0x18, 0x3b, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, + 0x6e, 0x65, 0x79, 0x52, 0x11, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, + 0x65, 0x72, 0x56, 0x63, 0x70, 0x75, 0x12, 0x41, 0x0a, 0x13, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x5f, + 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x67, 0x69, 0x62, 0x18, 0x50, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x79, 0x70, + 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x10, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x50, 0x72, + 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x47, 0x69, 0x62, 0x12, 0x41, 0x0a, 0x13, 0x6d, 0x6f, 0x6e, + 0x65, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x67, 0x70, 0x75, + 0x18, 0x51, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x10, 0x6d, 0x6f, 0x6e, 0x65, + 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x65, 0x72, 0x47, 0x70, 0x75, 0x12, 0x3a, 0x0a, 0x0f, + 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, + 0x52, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, + 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x0d, 0x6d, 0x6f, 0x6e, 0x65, 0x79, + 0x43, 0x70, 0x75, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x40, 0x0a, 0x12, 0x6d, 0x6f, 0x6e, 0x65, + 0x79, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x53, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x79, - 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x0d, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x47, - 0x70, 0x75, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x65, 0x78, 0x74, 0x72, 0x61, - 0x63, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x3c, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x65, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x65, 0x64, 0x4e, - 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x76, 0x61, 0x69, 0x6c, - 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x3d, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x10, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, - 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, - 0x65, 0x73, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x3e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6b, 0x75, - 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x55, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, - 0x3f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, - 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x0a, 0x0e, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, - 0x73, 0x5f, 0x69, 0x6e, 0x5f, 0x75, 0x73, 0x65, 0x18, 0x41, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, - 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x49, 0x6e, 0x55, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x10, - 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x5f, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, - 0x18, 0x42, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x41, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x0f, - 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x41, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x12, - 0x37, 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x18, 0x46, 0x20, 0x01, + 0x70, 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x10, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x4d, + 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x3a, 0x0a, 0x0f, 0x6d, 0x6f, + 0x6e, 0x65, 0x79, 0x5f, 0x67, 0x70, 0x75, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x54, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x79, 0x70, + 0x65, 0x2e, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x52, 0x0d, 0x6d, 0x6f, 0x6e, 0x65, 0x79, 0x47, 0x70, + 0x75, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x65, 0x78, 0x74, 0x72, 0x61, 0x63, + 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x3c, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x11, 0x65, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x65, 0x64, 0x4e, 0x6f, + 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, + 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x3d, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x10, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5a, + 0x6f, 0x6e, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, + 0x73, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x3e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6b, 0x75, 0x62, + 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x55, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x3f, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x0a, 0x0e, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, + 0x5f, 0x69, 0x6e, 0x5f, 0x75, 0x73, 0x65, 0x18, 0x41, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x76, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x49, 0x6e, 0x55, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x10, 0x76, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x5f, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x18, + 0x42, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x41, + 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x52, 0x0f, 0x76, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x73, 0x41, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x12, 0x37, + 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x18, 0x46, 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, 0x08, 0x6c, + 0x61, 0x73, 0x74, 0x53, 0x65, 0x65, 0x6e, 0x12, 0x3d, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x47, 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, 0x0b, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x49, 0x0a, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x48, 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, 0x08, - 0x6c, 0x61, 0x73, 0x74, 0x53, 0x65, 0x65, 0x6e, 0x12, 0x3d, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x47, 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, 0x0b, 0x63, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x49, 0x0a, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x74, - 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x48, 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, - 0x11, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 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, 0x3e, 0x0a, - 0x10, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x42, 0x14, 0x0a, - 0x12, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x72, 0x75, 0x6e, 0x74, - 0x69, 0x6d, 0x65, 0x22, 0x45, 0x0a, 0x0e, 0x41, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x56, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x76, - 0x69, 0x63, 0x65, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, - 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x50, 0x61, 0x74, 0x68, 0x22, 0xae, 0x03, 0x0a, 0x09, 0x4e, - 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x05, - 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, - 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, - 0x72, 0x69, 0x63, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, - 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, - 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, - 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, - 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, - 0x66, 0x6f, 0x12, 0x39, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, - 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3f, 0x0a, - 0x10, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, - 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0e, - 0x63, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x4b, - 0x0a, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, - 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x12, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x5c, 0x0a, 0x0d, 0x43, - 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, - 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, - 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x75, 0x0a, 0x11, 0x52, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x11, + 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 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, 0x3e, 0x0a, 0x10, + 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x42, 0x14, 0x0a, 0x12, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x72, 0x75, 0x6e, 0x74, 0x69, + 0x6d, 0x65, 0x22, 0x45, 0x0a, 0x0e, 0x41, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x76, 0x69, + 0x63, 0x65, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, + 0x65, 0x76, 0x69, 0x63, 0x65, 0x50, 0x61, 0x74, 0x68, 0x22, 0xae, 0x03, 0x0a, 0x09, 0x4e, 0x6f, + 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x05, 0x6e, + 0x6f, 0x64, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x12, + 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, + 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, + 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x12, 0x39, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x6e, + 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3f, 0x0a, 0x10, + 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, + 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x43, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0e, 0x63, + 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x4b, 0x0a, + 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, + 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x12, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x5c, 0x0a, 0x0d, 0x43, 0x6f, + 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, + 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, + 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x75, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, + 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x42, 0x0a, 0x10, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x22, + 0xc8, 0x03, 0x0a, 0x0b, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x12, + 0x34, 0x0a, 0x16, 0x63, 0x70, 0x75, 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x6d, + 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x14, 0x63, 0x70, 0x75, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, + 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x13, 0x63, 0x70, 0x75, 0x5f, 0x68, 0x69, 0x67, + 0x68, 0x5f, 0x77, 0x61, 0x74, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x10, 0x63, 0x70, 0x75, 0x48, 0x69, 0x67, 0x68, 0x57, 0x61, 0x74, 0x65, 0x72, + 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x63, + 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x10, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x49, 0x0a, 0x21, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x6d, 0x69, 0x6c, + 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x1e, 0x63, + 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x43, 0x70, 0x75, 0x53, 0x61, 0x76, 0x69, + 0x6e, 0x67, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x3d, 0x0a, + 0x1b, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, + 0x74, 0x5f, 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x18, 0x63, 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x57, 0x69, 0x74, 0x68, 0x6f, + 0x75, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x0f, + 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x70, 0x75, + 0x43, 0x6f, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, + 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, + 0x63, 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x24, + 0x0a, 0x0e, 0x63, 0x70, 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x73, 0x74, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x63, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, 0x65, + 0x43, 0x6f, 0x73, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, + 0x5f, 0x77, 0x61, 0x73, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x63, 0x70, + 0x75, 0x43, 0x6f, 0x73, 0x74, 0x57, 0x61, 0x73, 0x74, 0x65, 0x22, 0x68, 0x0a, 0x10, 0x53, 0x61, + 0x76, 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x42, 0x0a, 0x10, - 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, - 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, - 0x22, 0xc8, 0x03, 0x0a, 0x0b, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, - 0x12, 0x34, 0x0a, 0x16, 0x63, 0x70, 0x75, 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, - 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x14, 0x63, 0x70, 0x75, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x4d, 0x69, 0x6c, 0x6c, - 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x13, 0x63, 0x70, 0x75, 0x5f, 0x68, 0x69, - 0x67, 0x68, 0x5f, 0x77, 0x61, 0x74, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x10, 0x63, 0x70, 0x75, 0x48, 0x69, 0x67, 0x68, 0x57, 0x61, 0x74, 0x65, - 0x72, 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x5f, - 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x01, 0x52, 0x10, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x49, 0x0a, 0x21, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, - 0x65, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x6d, 0x69, - 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x1e, - 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x43, 0x70, 0x75, 0x53, 0x61, 0x76, - 0x69, 0x6e, 0x67, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x3d, - 0x0a, 0x1b, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x6f, - 0x75, 0x74, 0x5f, 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x72, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x18, 0x63, 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x57, 0x69, 0x74, 0x68, - 0x6f, 0x75, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x72, 0x12, 0x26, 0x0a, - 0x0f, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x70, - 0x75, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, - 0x74, 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x0e, 0x63, 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x12, - 0x24, 0x0a, 0x0e, 0x63, 0x70, 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x73, - 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x63, 0x70, 0x75, 0x55, 0x73, 0x61, 0x67, - 0x65, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, - 0x74, 0x5f, 0x77, 0x61, 0x73, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x63, - 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x57, 0x61, 0x73, 0x74, 0x65, 0x22, 0x68, 0x0a, 0x10, 0x53, - 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, - 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x36, 0x0a, - 0x0c, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x61, 0x76, - 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x0b, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, - 0x73, 0x44, 0x61, 0x74, 0x61, 0x22, 0x83, 0x02, 0x0a, 0x11, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, - 0x73, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x12, 0x73, - 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, - 0x74, 0x52, 0x11, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, - 0x69, 0x6e, 0x74, 0x73, 0x12, 0x3f, 0x0a, 0x1c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x70, - 0x75, 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x63, - 0x6f, 0x72, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x19, 0x74, 0x6f, 0x74, 0x61, - 0x6c, 0x43, 0x70, 0x75, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, - 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x33, 0x0a, 0x16, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, - 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x13, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x70, 0x75, 0x43, - 0x6f, 0x73, 0x74, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x2f, 0x0a, 0x14, 0x74, 0x6f, - 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x77, 0x61, 0x73, - 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, - 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x57, 0x61, 0x73, 0x74, 0x65, 0x22, 0x7f, 0x0a, 0x18, 0x4c, - 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, - 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x39, 0x0a, 0x08, 0x6f, 0x70, 0x65, - 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, - 0x6f, 0x72, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, - 0x61, 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x03, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0x2f, 0x0a, 0x05, - 0x4c, 0x61, 0x62, 0x65, 0x6c, 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, 0x22, 0x94, 0x02, - 0x0a, 0x0d, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, - 0x29, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x0d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x42, 0x02, - 0x18, 0x01, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x49, 0x0a, 0x0c, 0x6d, 0x61, - 0x74, 0x63, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x26, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, - 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x4c, - 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x4d, 0x0a, 0x11, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x65, - 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, - 0x6e, 0x74, 0x52, 0x10, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x45, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, - 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x3e, 0x0a, 0x10, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, - 0x65, 0x6c, 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, 0x3e, 0x0a, 0x0c, 0x52, 0x65, 0x67, 0x65, 0x78, 0x50, 0x61, 0x74, - 0x74, 0x65, 0x72, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x12, 0x14, - 0x0a, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x66, - 0x6c, 0x61, 0x67, 0x73, 0x22, 0xe0, 0x47, 0x0a, 0x0f, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x35, 0x0a, 0x0b, 0x70, 0x6f, 0x64, 0x5f, - 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x48, 0x00, 0x52, 0x0a, 0x70, 0x6f, 0x64, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, - 0x4a, 0x0a, 0x12, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x64, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x44, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x11, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, - 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4e, 0x0a, 0x14, 0x73, - 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x53, 0x65, 0x74, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x12, 0x73, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, - 0x6c, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x48, 0x0a, 0x12, 0x64, - 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x48, 0x00, 0x52, 0x10, 0x64, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4b, 0x0a, 0x13, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, - 0x11, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x12, 0x35, 0x0a, 0x0b, 0x6a, 0x6f, 0x62, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x6a, - 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x42, 0x0a, 0x10, 0x63, 0x72, 0x6f, - 0x6e, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x07, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x6f, - 0x6e, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0e, 0x63, - 0x72, 0x6f, 0x6e, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x41, 0x0a, - 0x0f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, - 0x52, 0x0e, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x12, 0x41, 0x0a, 0x0f, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x64, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x48, 0x00, 0x52, 0x0e, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x12, 0x48, 0x0a, 0x0b, 0x70, 0x76, 0x63, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x18, 0x8c, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, 0x6f, 0x6c, - 0x75, 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, - 0x00, 0x52, 0x0a, 0x70, 0x76, 0x63, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x41, 0x0a, - 0x0a, 0x70, 0x76, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x8d, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, - 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x09, 0x70, 0x76, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x12, 0x3d, 0x0a, 0x0a, 0x73, 0x63, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x8e, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, - 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x48, 0x00, 0x52, 0x09, 0x73, 0x63, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, - 0x3a, 0x0a, 0x0a, 0x6e, 0x73, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x8f, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, - 0x52, 0x09, 0x6e, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0c, 0x6e, - 0x6f, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x90, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, - 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x44, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x36, 0x0a, 0x0b, 0x68, 0x70, 0x61, 0x5f, 0x64, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x91, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x48, 0x00, 0x52, 0x0a, 0x68, 0x70, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x36, - 0x0a, 0x0b, 0x76, 0x70, 0x61, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x92, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, - 0x41, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x76, 0x70, 0x61, 0x44, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4c, 0x0a, 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, - 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x93, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, - 0x00, 0x52, 0x11, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x12, 0x58, 0x0a, 0x17, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, - 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, - 0xe8, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x15, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, - 0x0a, 0x0c, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xe9, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x6f, 0x6c, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x72, 0x6f, - 0x6c, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4f, 0x0a, 0x14, 0x72, 0x6f, 0x6c, - 0x65, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x18, 0xea, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x12, 0x72, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, - 0x69, 0x6e, 0x67, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x5f, 0x0a, 0x1a, 0x6b, 0x65, - 0x64, 0x61, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, - 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xeb, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, - 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x48, 0x00, 0x52, 0x17, 0x6b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x61, 0x0a, 0x1a, 0x6b, - 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xec, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, - 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x48, 0x00, 0x52, 0x18, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x68, - 0x0a, 0x1d, 0x70, 0x6f, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x62, 0x75, 0x64, 0x67, 0x65, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, - 0xed, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x50, 0x6f, 0x64, 0x44, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, - 0x67, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x1a, 0x70, 0x6f, - 0x64, 0x44, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, 0x65, - 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x55, 0x0a, 0x16, 0x72, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x61, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x18, 0xee, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, - 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, - 0x4c, 0x0a, 0x13, 0x76, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xef, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x4a, 0x6f, - 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x11, 0x76, 0x6f, 0x6c, 0x63, - 0x61, 0x6e, 0x6f, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x5e, 0x0a, - 0x19, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xf2, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, - 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x48, 0x00, 0x52, 0x17, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x7a, 0x0a, - 0x23, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x70, 0x61, 0x72, 0x6b, - 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x18, 0xf3, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x53, 0x70, - 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, - 0x65, 0x64, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x68, 0x61, - 0x73, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, - 0x15, 0x0a, 0x06, 0x70, 0x6f, 0x64, 0x5f, 0x69, 0x70, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x70, 0x6f, 0x64, 0x49, 0x70, 0x12, 0x17, 0x0a, 0x07, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x69, - 0x70, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x68, 0x6f, 0x73, 0x74, 0x49, 0x70, 0x12, - 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0d, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, - 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x72, 0x65, 0x61, - 0x64, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x71, 0x6f, 0x73, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, - 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x71, 0x6f, 0x73, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, - 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x75, - 0x6e, 0x74, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, - 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x0c, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x36, 0x0a, - 0x17, 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, 0x6d, 0x69, - 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, - 0x63, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, - 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, - 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x15, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x70, 0x75, - 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, - 0x65, 0x73, 0x18, 0x16, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x63, 0x70, 0x75, 0x4c, 0x69, 0x6d, - 0x69, 0x74, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x2e, 0x0a, - 0x13, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x62, - 0x79, 0x74, 0x65, 0x73, 0x18, 0x17, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x6d, 0x65, 0x6d, 0x6f, - 0x72, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x23, 0x0a, - 0x0d, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x1e, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x61, 0x73, - 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, - 0x5f, 0x62, 0x79, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x42, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x20, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x61, 0x67, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x18, 0x28, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x44, 0x65, 0x73, - 0x69, 0x72, 0x65, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, - 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x29, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x2d, 0x0a, 0x12, 0x72, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, - 0x65, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x73, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x18, 0x2b, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x55, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, - 0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x74, - 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x76, - 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, - 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x67, - 0x72, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, - 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, - 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, - 0x2f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, - 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, - 0x73, 0x18, 0x30, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x12, - 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x3c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4e, 0x61, - 0x6d, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x70, 0x6f, 0x64, 0x5f, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, - 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x3d, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x13, 0x70, 0x6f, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, - 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x3e, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72, 0x61, - 0x74, 0x65, 0x67, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3d, 0x0a, 0x1b, 0x76, 0x6f, 0x6c, 0x75, - 0x6d, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, - 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x3f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x18, 0x76, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, - 0x74, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x70, 0x76, 0x63, 0x5f, 0x72, - 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, - 0x40, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x76, 0x63, 0x52, 0x65, 0x74, 0x65, 0x6e, 0x74, - 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x41, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x76, 0x69, - 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x72, - 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x42, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x75, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, - 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x18, 0x46, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x44, 0x65, 0x73, 0x69, 0x72, - 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, - 0x79, 0x18, 0x47, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, - 0x61, 0x64, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x61, 0x76, 0x61, - 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x48, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x6e, 0x6f, - 0x64, 0x65, 0x73, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d, - 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x49, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x64, 0x18, 0x4a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x55, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, - 0x6d, 0x69, 0x73, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x18, 0x4b, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x11, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x4d, 0x69, 0x73, 0x73, 0x63, 0x68, 0x65, - 0x64, 0x75, 0x6c, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f, 0x75, 0x6e, 0x61, - 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x4c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, - 0x6d, 0x61, 0x78, 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x25, - 0x0a, 0x0e, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, - 0x18, 0x4d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, - 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, 0x6d, - 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, - 0x18, 0x50, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x6a, 0x6f, 0x62, 0x43, 0x6f, 0x6d, 0x70, 0x6c, - 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x12, 0x3a, 0x0a, - 0x19, 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x18, 0x51, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x17, 0x6a, 0x6f, 0x62, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x6a, 0x6f, 0x62, - 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x18, 0x52, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x0e, 0x6a, 0x6f, 0x62, 0x50, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, - 0x73, 0x6d, 0x12, 0x2a, 0x0a, 0x11, 0x6a, 0x6f, 0x62, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x6f, 0x66, - 0x66, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x53, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x6a, - 0x6f, 0x62, 0x42, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2e, - 0x0a, 0x13, 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x54, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6a, 0x6f, 0x62, - 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x23, - 0x0a, 0x0d, 0x6a, 0x6f, 0x62, 0x5f, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x18, - 0x55, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6a, 0x6f, 0x62, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, - 0x64, 0x65, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x6a, 0x6f, 0x62, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x56, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6a, 0x6f, 0x62, 0x44, 0x75, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6a, 0x6f, 0x62, 0x5f, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x18, 0x57, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6a, 0x6f, 0x62, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x6a, 0x6f, 0x62, 0x5f, 0x61, 0x63, 0x74, - 0x69, 0x76, 0x65, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x58, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, - 0x6a, 0x6f, 0x62, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x26, 0x0a, - 0x0f, 0x6a, 0x6f, 0x62, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x70, 0x6f, 0x64, 0x73, - 0x18, 0x59, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6a, 0x6f, 0x62, 0x46, 0x61, 0x69, 0x6c, 0x65, - 0x64, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x73, 0x63, - 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x18, 0x5a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x72, - 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x72, - 0x6f, 0x6e, 0x5f, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x18, 0x5b, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x0d, 0x63, 0x72, 0x6f, 0x6e, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, - 0x64, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, - 0x5f, 0x6a, 0x6f, 0x62, 0x73, 0x18, 0x5c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x63, 0x72, 0x6f, - 0x6e, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4a, 0x6f, 0x62, 0x73, 0x12, 0x35, 0x0a, 0x17, 0x63, - 0x72, 0x6f, 0x6e, 0x5f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, - 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x5d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x63, 0x72, - 0x6f, 0x6e, 0x4c, 0x61, 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x54, 0x69, - 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x17, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x6e, 0x65, 0x78, 0x74, 0x5f, - 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x5e, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x14, 0x63, 0x72, 0x6f, 0x6e, 0x4e, 0x65, 0x78, 0x74, 0x53, 0x63, 0x68, - 0x65, 0x64, 0x75, 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x63, 0x72, 0x6f, - 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x70, 0x6f, - 0x6c, 0x69, 0x63, 0x79, 0x18, 0x5f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x63, 0x72, 0x6f, 0x6e, - 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, - 0x79, 0x12, 0x3b, 0x0a, 0x1a, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, - 0x73, 0x66, 0x75, 0x6c, 0x5f, 0x6a, 0x6f, 0x62, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, - 0x60, 0x20, 0x01, 0x28, 0x05, 0x52, 0x17, 0x63, 0x72, 0x6f, 0x6e, 0x53, 0x75, 0x63, 0x63, 0x65, - 0x73, 0x73, 0x66, 0x75, 0x6c, 0x4a, 0x6f, 0x62, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x33, - 0x0a, 0x16, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x6a, 0x6f, - 0x62, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x61, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, - 0x63, 0x72, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x4a, 0x6f, 0x62, 0x73, 0x4c, 0x69, - 0x6d, 0x69, 0x74, 0x12, 0x43, 0x0a, 0x1e, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x73, 0x65, - 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x62, 0x20, 0x01, 0x28, 0x05, 0x52, 0x1b, 0x63, 0x72, 0x6f, - 0x6e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, - 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x64, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, - 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x73, - 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, - 0x70, 0x18, 0x65, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x70, 0x12, 0x30, 0x0a, 0x14, 0x73, 0x65, 0x72, - 0x76, 0x69, 0x63, 0x65, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x70, - 0x73, 0x18, 0x66, 0x20, 0x03, 0x28, 0x09, 0x52, 0x12, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x70, 0x73, 0x12, 0x38, 0x0a, 0x0d, 0x73, - 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x18, 0x67, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x50, 0x6f, 0x72, 0x74, 0x73, 0x12, 0x57, 0x0a, 0x10, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x68, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x2c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x73, - 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x38, - 0x0a, 0x18, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x5f, 0x61, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x18, 0x69, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x16, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, - 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x12, 0x45, 0x0a, 0x1f, 0x73, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x74, 0x72, 0x61, - 0x66, 0x66, 0x69, 0x63, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x6a, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x1c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, - 0x45, 0x0a, 0x1f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x5f, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x5f, 0x70, 0x6f, 0x6c, 0x69, - 0x63, 0x79, 0x18, 0x6b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, - 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x4c, 0x0a, 0x23, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x5f, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, 0x6c, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x1f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4c, 0x6f, 0x61, 0x64, - 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x73, 0x12, 0x3d, 0x0a, 0x1b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, - 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x63, 0x6c, - 0x61, 0x73, 0x73, 0x18, 0x6d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x73, 0x65, 0x72, 0x76, 0x69, - 0x63, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x43, 0x6c, - 0x61, 0x73, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, - 0x70, 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x65, 0x73, 0x18, 0x6e, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x11, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x49, 0x70, 0x46, 0x61, 0x6d, 0x69, 0x6c, - 0x69, 0x65, 0x73, 0x12, 0x37, 0x0a, 0x18, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, - 0x70, 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, - 0x6f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x49, 0x70, - 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x2c, 0x0a, 0x12, - 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x78, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, - 0x73, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, - 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x68, 0x6f, 0x73, 0x74, 0x73, 0x18, 0x79, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x0c, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x48, 0x6f, 0x73, 0x74, 0x73, 0x12, - 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, - 0x18, 0x7a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x50, - 0x61, 0x74, 0x68, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, - 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x73, 0x18, 0x7b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, - 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x73, 0x12, - 0x2a, 0x0a, 0x11, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x6c, 0x73, 0x5f, 0x68, - 0x6f, 0x73, 0x74, 0x73, 0x18, 0x7c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x69, 0x6e, 0x67, 0x72, - 0x65, 0x73, 0x73, 0x54, 0x6c, 0x73, 0x48, 0x6f, 0x73, 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x69, - 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x6c, 0x73, 0x5f, 0x73, 0x65, 0x63, 0x72, 0x65, - 0x74, 0x73, 0x18, 0x7d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x11, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, - 0x73, 0x54, 0x6c, 0x73, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x39, 0x0a, 0x19, 0x69, - 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, - 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x70, 0x73, 0x18, 0x7e, 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, - 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, - 0x63, 0x65, 0x72, 0x49, 0x70, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, - 0x73, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x7f, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x11, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x75, 0x6c, 0x65, - 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, - 0x73, 0x5f, 0x74, 0x6c, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x80, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x0f, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x54, 0x6c, 0x73, 0x43, 0x6f, - 0x75, 0x6e, 0x74, 0x12, 0x3e, 0x0a, 0x1b, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x68, - 0x61, 0x73, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x65, - 0x6e, 0x64, 0x18, 0x81, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x69, 0x6e, 0x67, 0x72, 0x65, - 0x73, 0x73, 0x48, 0x61, 0x73, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x61, 0x63, 0x6b, - 0x65, 0x6e, 0x64, 0x12, 0x34, 0x0a, 0x16, 0x70, 0x76, 0x63, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x61, - 0x67, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x82, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x70, 0x76, 0x63, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, - 0x43, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x16, 0x70, 0x76, 0x63, - 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, - 0x69, 0x74, 0x79, 0x18, 0x83, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x70, 0x76, 0x63, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, - 0x12, 0x2f, 0x0a, 0x13, 0x70, 0x76, 0x63, 0x5f, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x63, - 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x84, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, - 0x70, 0x76, 0x63, 0x41, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, - 0x79, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x76, 0x63, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, - 0x6d, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x85, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x76, - 0x63, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, - 0x70, 0x76, 0x63, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, - 0x86, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x76, 0x63, 0x56, 0x6f, 0x6c, 0x75, 0x6d, - 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x76, 0x63, 0x5f, 0x76, 0x6f, 0x6c, - 0x75, 0x6d, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x87, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0d, 0x70, 0x76, 0x63, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1e, - 0x0a, 0x0a, 0x70, 0x76, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x88, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x76, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x21, - 0x0a, 0x0c, 0x70, 0x76, 0x63, 0x5f, 0x69, 0x73, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x89, - 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x70, 0x76, 0x63, 0x49, 0x73, 0x42, 0x6f, 0x75, 0x6e, - 0x64, 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x76, 0x63, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, - 0x72, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x8a, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x70, 0x76, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, - 0x6f, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x35, 0x0a, - 0x16, 0x70, 0x76, 0x63, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x70, - 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x65, 0x73, 0x18, 0x8b, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x14, - 0x70, 0x76, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, - 0x67, 0x69, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x70, 0x76, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x61, - 0x67, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x96, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x76, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, - 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x76, 0x5f, 0x63, - 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x97, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, - 0x70, 0x76, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x76, - 0x5f, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x98, 0x01, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x76, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, - 0x64, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x76, 0x5f, 0x72, 0x65, 0x63, 0x6c, 0x61, 0x69, - 0x6d, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x99, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0f, 0x70, 0x76, 0x52, 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, - 0x12, 0x2a, 0x0a, 0x11, 0x70, 0x76, 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x66, - 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x9a, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x76, - 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x34, 0x0a, 0x16, - 0x70, 0x76, 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x66, 0x5f, 0x6e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x9b, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x70, - 0x76, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x76, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, - 0x9c, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x76, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x76, 0x5f, 0x69, 0x73, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, - 0x9d, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x70, 0x76, 0x49, 0x73, 0x42, 0x6f, 0x75, 0x6e, - 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x76, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x6d, - 0x6f, 0x64, 0x65, 0x18, 0x9e, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x76, 0x56, 0x6f, - 0x6c, 0x75, 0x6d, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x76, 0x5f, 0x63, - 0x73, 0x69, 0x5f, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x18, 0x9f, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0b, 0x70, 0x76, 0x43, 0x73, 0x69, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x12, 0x32, 0x0a, - 0x15, 0x70, 0x76, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0xa0, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, - 0x76, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x34, 0x0a, 0x16, 0x70, 0x76, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x61, 0x66, 0x66, - 0x69, 0x6e, 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x73, 0x18, 0xa1, 0x01, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x13, 0x70, 0x76, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69, - 0x74, 0x79, 0x5a, 0x6f, 0x6e, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x0e, 0x73, 0x63, 0x5f, 0x70, 0x72, - 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x18, 0xaa, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0d, 0x73, 0x63, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x12, - 0x2b, 0x0a, 0x11, 0x73, 0x63, 0x5f, 0x72, 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x70, 0x6f, - 0x6c, 0x69, 0x63, 0x79, 0x18, 0xab, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x63, 0x52, - 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x34, 0x0a, 0x16, - 0x73, 0x63, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, - 0x67, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0xac, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x73, - 0x63, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4d, 0x6f, - 0x64, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x73, 0x63, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x76, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, - 0xad, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x73, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x56, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x4f, - 0x0a, 0x0d, 0x73, 0x63, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, - 0xae, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, - 0x53, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x0c, 0x73, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, - 0x33, 0x0a, 0x15, 0x73, 0x63, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x74, 0x6f, - 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x65, 0x73, 0x18, 0xaf, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x13, 0x73, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, - 0x67, 0x69, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x73, 0x63, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, - 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xb0, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x0e, 0x73, 0x63, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, - 0x1c, 0x0a, 0x09, 0x6e, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0xb1, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x24, 0x0a, - 0x0d, 0x6e, 0x73, 0x5f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x73, 0x18, 0xb2, - 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x6e, 0x73, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, - 0x65, 0x72, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x70, 0x75, 0x5f, - 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0xb3, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x70, 0x75, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, - 0x12, 0x31, 0x0a, 0x14, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, - 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0xb4, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x43, 0x61, 0x70, 0x61, 0x63, - 0x69, 0x74, 0x79, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x64, - 0x79, 0x18, 0xb5, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x52, 0x65, - 0x61, 0x64, 0x79, 0x12, 0x33, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x69, 0x6e, - 0x74, 0x73, 0x18, 0xb6, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x61, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x6e, 0x6f, - 0x64, 0x65, 0x54, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x6f, 0x64, 0x65, - 0x5f, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x18, 0xb7, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x6e, - 0x6f, 0x64, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, - 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x70, 0x18, 0xb8, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x49, 0x70, 0x12, 0x29, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x65, 0x78, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x70, 0x18, 0xb9, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, - 0x6e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x70, 0x12, 0x22, - 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0xba, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, - 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0xbb, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x73, 0x18, 0xbc, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x73, 0x12, 0x35, 0x0a, 0x16, 0x6e, - 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x72, 0x75, - 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18, 0xbd, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x6e, 0x6f, - 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, - 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6d, 0x61, 0x67, 0x65, - 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xbe, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x6e, - 0x6f, 0x64, 0x65, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x29, 0x0a, - 0x10, 0x68, 0x70, 0x61, 0x5f, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x73, 0x18, 0xc8, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x68, 0x70, 0x61, 0x4d, 0x69, 0x6e, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x68, 0x70, 0x61, 0x5f, - 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0xc9, 0x01, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0e, 0x68, 0x70, 0x61, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x73, 0x12, 0x31, 0x0a, 0x14, 0x68, 0x70, 0x61, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, - 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0xca, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x12, 0x68, 0x70, 0x61, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x31, 0x0a, 0x14, 0x68, 0x70, 0x61, 0x5f, 0x64, 0x65, - 0x73, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0xcb, - 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x68, 0x70, 0x61, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, - 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x68, 0x70, 0x61, - 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xcc, - 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x68, 0x70, 0x61, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x68, 0x70, 0x61, 0x5f, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x18, 0xcd, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x70, 0x61, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x68, 0x70, 0x61, 0x5f, 0x73, 0x63, - 0x61, 0x6c, 0x65, 0x5f, 0x75, 0x70, 0x5f, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xce, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x17, 0x68, 0x70, 0x61, - 0x53, 0x63, 0x61, 0x6c, 0x65, 0x55, 0x70, 0x53, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x1c, 0x68, 0x70, 0x61, 0x5f, 0x73, 0x63, 0x61, 0x6c, - 0x65, 0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xcf, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x19, 0x68, 0x70, 0x61, - 0x53, 0x63, 0x61, 0x6c, 0x65, 0x44, 0x6f, 0x77, 0x6e, 0x53, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, - 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x76, 0x70, 0x61, 0x5f, 0x75, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0xd2, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0d, 0x76, 0x70, 0x61, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, - 0x2d, 0x0a, 0x12, 0x76, 0x70, 0x61, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x5f, - 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xd3, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x76, 0x70, - 0x61, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3b, - 0x0a, 0x19, 0x76, 0x70, 0x61, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xd4, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x17, 0x76, 0x70, 0x61, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x76, - 0x70, 0x61, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0xd5, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x70, 0x61, 0x43, 0x70, 0x75, 0x54, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x76, 0x70, 0x61, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, - 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0xd6, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, - 0x76, 0x70, 0x61, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, - 0x1e, 0x0a, 0x0a, 0x76, 0x70, 0x61, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0xd7, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x76, 0x70, 0x61, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, - 0x36, 0x0a, 0x17, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x69, - 0x74, 0x65, 0x6d, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xdc, 0x01, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x14, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, - 0x6d, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x6c, 0x69, 0x6d, 0x69, 0x74, - 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0xdd, 0x01, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x54, - 0x79, 0x70, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x18, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, - 0x6e, 0x67, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, - 0x18, 0xde, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x2e, - 0x0a, 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x61, - 0x78, 0x5f, 0x63, 0x70, 0x75, 0x18, 0xdf, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6c, 0x69, - 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4d, 0x61, 0x78, 0x43, 0x70, 0x75, 0x12, 0x34, - 0x0a, 0x16, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x61, - 0x78, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0xe0, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4d, 0x61, 0x78, 0x4d, 0x65, - 0x6d, 0x6f, 0x72, 0x79, 0x12, 0x2e, 0x0a, 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, - 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x70, 0x75, 0x18, 0xe1, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x10, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4d, 0x69, - 0x6e, 0x43, 0x70, 0x75, 0x12, 0x34, 0x0a, 0x16, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, - 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0xe2, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, - 0x65, 0x4d, 0x69, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x12, 0x41, 0x0a, 0x1d, 0x6c, 0x69, - 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, - 0x74, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0xe3, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x19, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, - 0x66, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x47, 0x0a, - 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x66, - 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, - 0x74, 0x18, 0xe4, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1c, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, - 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x65, 0x6d, 0x6f, 0x72, - 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x45, 0x0a, 0x1f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, - 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x70, - 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0xe5, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x1b, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x66, 0x61, - 0x75, 0x6c, 0x74, 0x43, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4b, 0x0a, - 0x22, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x66, - 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x18, 0xe6, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1e, 0x6c, 0x69, 0x6d, 0x69, - 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x65, 0x6d, - 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x6c, 0x69, - 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x18, 0xe7, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2a, 0x0a, 0x10, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0xf0, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x18, 0xf1, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, - 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x42, 0x0a, 0x14, 0x53, 0x65, 0x72, 0x76, 0x69, - 0x63, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x36, 0x0a, 0x0c, + 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x61, 0x76, 0x69, + 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x0b, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, + 0x44, 0x61, 0x74, 0x61, 0x22, 0x83, 0x02, 0x0a, 0x11, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, + 0x54, 0x69, 0x6d, 0x65, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x12, 0x73, 0x61, + 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, + 0x52, 0x11, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x73, 0x12, 0x3f, 0x0a, 0x1c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x70, 0x75, + 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, + 0x72, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x19, 0x74, 0x6f, 0x74, 0x61, 0x6c, + 0x43, 0x70, 0x75, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x63, + 0x6f, 0x72, 0x65, 0x73, 0x12, 0x33, 0x0a, 0x16, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x70, + 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x13, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x70, 0x75, 0x43, 0x6f, + 0x73, 0x74, 0x53, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x2f, 0x0a, 0x14, 0x74, 0x6f, 0x74, + 0x61, 0x6c, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x77, 0x61, 0x73, 0x74, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x70, + 0x75, 0x43, 0x6f, 0x73, 0x74, 0x57, 0x61, 0x73, 0x74, 0x65, 0x22, 0x7f, 0x0a, 0x18, 0x4c, 0x61, + 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x39, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0x2f, 0x0a, 0x05, 0x4c, + 0x61, 0x62, 0x65, 0x6c, 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, 0x22, 0x94, 0x02, 0x0a, + 0x0d, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x29, + 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0d, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x42, 0x02, 0x18, + 0x01, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x49, 0x0a, 0x0c, 0x6d, 0x61, 0x74, + 0x63, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x26, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, + 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x12, 0x4d, 0x0a, 0x11, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x78, + 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x52, 0x10, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x45, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x73, 0x1a, 0x3e, 0x0a, 0x10, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, + 0x6c, 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, 0x3e, 0x0a, 0x0c, 0x52, 0x65, 0x67, 0x65, 0x78, 0x50, 0x61, 0x74, 0x74, + 0x65, 0x72, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x12, 0x14, 0x0a, + 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x66, 0x6c, + 0x61, 0x67, 0x73, 0x22, 0xe0, 0x47, 0x0a, 0x0f, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x35, 0x0a, 0x0b, 0x70, 0x6f, 0x64, 0x5f, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x48, 0x00, 0x52, 0x0a, 0x70, 0x6f, 0x64, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4a, + 0x0a, 0x12, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x11, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, + 0x65, 0x6e, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4e, 0x0a, 0x14, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x12, 0x73, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, + 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x48, 0x0a, 0x12, 0x64, 0x61, + 0x65, 0x6d, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x44, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x48, 0x00, 0x52, 0x10, 0x64, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4b, 0x0a, 0x13, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, + 0x73, 0x65, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x11, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x35, 0x0a, 0x0b, 0x6a, 0x6f, 0x62, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x6a, 0x6f, + 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x42, 0x0a, 0x10, 0x63, 0x72, 0x6f, 0x6e, + 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x6f, 0x6e, + 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0e, 0x63, 0x72, + 0x6f, 0x6e, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x41, 0x0a, 0x0f, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, + 0x0e, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, + 0x41, 0x0a, 0x0f, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x48, 0x00, 0x52, 0x0e, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x12, 0x48, 0x0a, 0x0b, 0x70, 0x76, 0x63, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x18, 0x8c, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, 0x6f, 0x6c, 0x75, + 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, + 0x52, 0x0a, 0x70, 0x76, 0x63, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x41, 0x0a, 0x0a, + 0x70, 0x76, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x8d, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, + 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x48, 0x00, 0x52, 0x09, 0x70, 0x76, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, + 0x3d, 0x0a, 0x0a, 0x73, 0x63, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x8e, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x48, 0x00, 0x52, 0x09, 0x73, 0x63, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3a, + 0x0a, 0x0a, 0x6e, 0x73, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x8f, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x61, 0x6d, + 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, + 0x09, 0x6e, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0c, 0x6e, 0x6f, + 0x64, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x90, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x36, 0x0a, 0x0b, 0x68, 0x70, 0x61, 0x5f, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x18, 0x91, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, + 0x00, 0x52, 0x0a, 0x68, 0x70, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x36, 0x0a, + 0x0b, 0x76, 0x70, 0x61, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x92, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x76, 0x70, 0x61, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4c, 0x0a, 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, + 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x93, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, + 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, + 0x52, 0x11, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x12, 0x58, 0x0a, 0x17, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xe8, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x15, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, + 0x0c, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xe9, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, + 0x6c, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x72, 0x6f, 0x6c, + 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4f, 0x0a, 0x14, 0x72, 0x6f, 0x6c, 0x65, + 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x18, 0xea, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x12, 0x72, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x5f, 0x0a, 0x1a, 0x6b, 0x65, 0x64, + 0x61, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xeb, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, + 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, + 0x00, 0x52, 0x17, 0x6b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x61, 0x0a, 0x1a, 0x6b, 0x61, + 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xec, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x48, 0x00, 0x52, 0x18, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x68, 0x0a, + 0x1d, 0x70, 0x6f, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x62, 0x75, 0x64, 0x67, 0x65, 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xed, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, + 0x6f, 0x64, 0x44, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, + 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x1a, 0x70, 0x6f, 0x64, + 0x44, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x55, 0x0a, 0x16, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x61, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x18, 0xee, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x4c, + 0x0a, 0x13, 0x76, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x64, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xef, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x4a, 0x6f, 0x62, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x11, 0x76, 0x6f, 0x6c, 0x63, 0x61, + 0x6e, 0x6f, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x5e, 0x0a, 0x19, + 0x73, 0x70, 0x61, 0x72, 0x6b, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0xf2, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, + 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x48, 0x00, 0x52, 0x17, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x7a, 0x0a, 0x23, + 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x5f, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x18, 0xf3, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x53, 0x70, 0x61, + 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, + 0x64, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, + 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x15, + 0x0a, 0x06, 0x70, 0x6f, 0x64, 0x5f, 0x69, 0x70, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x70, 0x6f, 0x64, 0x49, 0x70, 0x12, 0x17, 0x0a, 0x07, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x70, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x68, 0x6f, 0x73, 0x74, 0x49, 0x70, 0x12, 0x1b, + 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x72, + 0x65, 0x61, 0x64, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x72, 0x65, 0x61, 0x64, + 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x71, 0x6f, 0x73, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x0f, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x71, 0x6f, 0x73, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x27, + 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, + 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x36, 0x0a, 0x17, + 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, 0x6d, 0x69, 0x6c, + 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x63, + 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x63, + 0x6f, 0x72, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x15, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x13, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x70, 0x75, 0x5f, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, + 0x73, 0x18, 0x16, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x63, 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, + 0x74, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x2e, 0x0a, 0x13, + 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x18, 0x17, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x6d, 0x65, 0x6d, 0x6f, 0x72, + 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x1e, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x5f, + 0x62, 0x79, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x64, 0x42, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x20, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x61, 0x67, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x5f, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x18, 0x28, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x44, 0x65, 0x73, 0x69, + 0x72, 0x65, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, + 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x29, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x2d, 0x0a, 0x12, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, + 0x18, 0x2a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x18, 0x2b, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x67, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x76, 0x61, + 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x76, + 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x67, 0x72, + 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x72, + 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x2f, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, + 0x18, 0x30, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x12, 0x21, + 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x3c, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x32, 0x0a, 0x15, 0x70, 0x6f, 0x64, 0x5f, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x3d, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x13, 0x70, 0x6f, 0x64, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x3e, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x12, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72, 0x61, 0x74, + 0x65, 0x67, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3d, 0x0a, 0x1b, 0x76, 0x6f, 0x6c, 0x75, 0x6d, + 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, + 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x3f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x18, 0x76, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, + 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x70, 0x76, 0x63, 0x5f, 0x72, 0x65, + 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x40, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x76, 0x63, 0x52, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, + 0x6f, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x41, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x65, + 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x42, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, + 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x18, 0x46, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, + 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, + 0x18, 0x47, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x61, + 0x64, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x61, 0x76, 0x61, 0x69, + 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x48, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x6e, 0x6f, 0x64, + 0x65, 0x73, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6e, + 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x49, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, + 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x64, 0x18, 0x4a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x6d, + 0x69, 0x73, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x18, 0x4b, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x11, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x4d, 0x69, 0x73, 0x73, 0x63, 0x68, 0x65, 0x64, + 0x75, 0x6c, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f, 0x75, 0x6e, 0x61, 0x76, + 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x4c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6d, + 0x61, 0x78, 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x25, 0x0a, + 0x0e, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, + 0x4d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, 0x6d, 0x70, + 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x18, + 0x50, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x6a, 0x6f, 0x62, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x12, 0x3a, 0x0a, 0x19, + 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, + 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x18, 0x51, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x17, 0x6a, 0x6f, 0x62, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x53, + 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x6a, 0x6f, 0x62, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x18, 0x52, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0e, 0x6a, 0x6f, 0x62, 0x50, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, + 0x6d, 0x12, 0x2a, 0x0a, 0x11, 0x6a, 0x6f, 0x62, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, + 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x53, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x6a, 0x6f, + 0x62, 0x42, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2e, 0x0a, + 0x13, 0x6a, 0x6f, 0x62, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x54, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6a, 0x6f, 0x62, 0x43, + 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x23, 0x0a, + 0x0d, 0x6a, 0x6f, 0x62, 0x5f, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x18, 0x55, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6a, 0x6f, 0x62, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, + 0x65, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x6a, 0x6f, 0x62, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x56, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6a, 0x6f, 0x62, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6a, 0x6f, 0x62, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x57, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6a, 0x6f, 0x62, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x6a, 0x6f, 0x62, 0x5f, 0x61, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x58, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6a, + 0x6f, 0x62, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x26, 0x0a, 0x0f, + 0x6a, 0x6f, 0x62, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, + 0x59, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6a, 0x6f, 0x62, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, + 0x50, 0x6f, 0x64, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x73, 0x63, 0x68, + 0x65, 0x64, 0x75, 0x6c, 0x65, 0x18, 0x5a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x72, 0x6f, + 0x6e, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x72, 0x6f, + 0x6e, 0x5f, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x18, 0x5b, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0d, 0x63, 0x72, 0x6f, 0x6e, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, + 0x12, 0x28, 0x0a, 0x10, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, + 0x6a, 0x6f, 0x62, 0x73, 0x18, 0x5c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x63, 0x72, 0x6f, 0x6e, + 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4a, 0x6f, 0x62, 0x73, 0x12, 0x35, 0x0a, 0x17, 0x63, 0x72, + 0x6f, 0x6e, 0x5f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x5d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x63, 0x72, 0x6f, + 0x6e, 0x4c, 0x61, 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x35, 0x0a, 0x17, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x73, + 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x5e, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x14, 0x63, 0x72, 0x6f, 0x6e, 0x4e, 0x65, 0x78, 0x74, 0x53, 0x63, 0x68, 0x65, + 0x64, 0x75, 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x63, 0x72, 0x6f, 0x6e, + 0x5f, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x70, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x18, 0x5f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x63, 0x72, 0x6f, 0x6e, 0x43, + 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x12, 0x3b, 0x0a, 0x1a, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, + 0x66, 0x75, 0x6c, 0x5f, 0x6a, 0x6f, 0x62, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x60, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x17, 0x63, 0x72, 0x6f, 0x6e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, + 0x73, 0x66, 0x75, 0x6c, 0x4a, 0x6f, 0x62, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x33, 0x0a, + 0x16, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x6a, 0x6f, 0x62, + 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x61, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x63, + 0x72, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x4a, 0x6f, 0x62, 0x73, 0x4c, 0x69, 0x6d, + 0x69, 0x74, 0x12, 0x43, 0x0a, 0x1e, 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x73, 0x65, 0x63, + 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x62, 0x20, 0x01, 0x28, 0x05, 0x52, 0x1b, 0x63, 0x72, 0x6f, 0x6e, + 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, + 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x64, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x70, + 0x18, 0x65, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x70, 0x12, 0x30, 0x0a, 0x14, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x70, 0x73, + 0x18, 0x66, 0x20, 0x03, 0x28, 0x09, 0x52, 0x12, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x45, + 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x70, 0x73, 0x12, 0x38, 0x0a, 0x0d, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x18, 0x67, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, + 0x6f, 0x72, 0x74, 0x73, 0x12, 0x57, 0x0a, 0x10, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, + 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x68, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x53, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x38, 0x0a, + 0x18, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x5f, 0x61, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x18, 0x69, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x16, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x41, + 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x12, 0x45, 0x0a, 0x1f, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x74, 0x72, 0x61, 0x66, + 0x66, 0x69, 0x63, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x6a, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x1c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x45, + 0x0a, 0x1f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, + 0x61, 0x6c, 0x5f, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, + 0x79, 0x18, 0x6b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x4c, 0x0a, 0x23, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, 0x6c, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x1f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x42, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x61, 0x6e, + 0x67, 0x65, 0x73, 0x12, 0x3d, 0x0a, 0x1b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x6c, + 0x6f, 0x61, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x18, 0x6d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, 0x70, + 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x65, 0x73, 0x18, 0x6e, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x11, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x49, 0x70, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x69, + 0x65, 0x73, 0x12, 0x37, 0x0a, 0x18, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, 0x70, + 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x6f, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x49, 0x70, 0x46, + 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x2c, 0x0a, 0x12, 0x69, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x78, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x67, + 0x72, 0x65, 0x73, 0x73, 0x5f, 0x68, 0x6f, 0x73, 0x74, 0x73, 0x18, 0x79, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0c, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x48, 0x6f, 0x73, 0x74, 0x73, 0x12, 0x23, + 0x0a, 0x0d, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, + 0x7a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x50, 0x61, + 0x74, 0x68, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x62, + 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x73, 0x18, 0x7b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x69, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x73, 0x12, 0x2a, + 0x0a, 0x11, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x6c, 0x73, 0x5f, 0x68, 0x6f, + 0x73, 0x74, 0x73, 0x18, 0x7c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x69, 0x6e, 0x67, 0x72, 0x65, + 0x73, 0x73, 0x54, 0x6c, 0x73, 0x48, 0x6f, 0x73, 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x69, 0x6e, + 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x6c, 0x73, 0x5f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x73, 0x18, 0x7d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x11, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x54, 0x6c, 0x73, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x39, 0x0a, 0x19, 0x69, 0x6e, + 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x72, 0x5f, 0x69, 0x70, 0x73, 0x18, 0x7e, 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, 0x69, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x72, 0x49, 0x70, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x7f, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x11, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x5f, 0x74, 0x6c, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x80, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0f, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x54, 0x6c, 0x73, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x12, 0x3e, 0x0a, 0x1b, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x68, 0x61, + 0x73, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, + 0x64, 0x18, 0x81, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, + 0x73, 0x48, 0x61, 0x73, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x61, 0x63, 0x6b, 0x65, + 0x6e, 0x64, 0x12, 0x34, 0x0a, 0x16, 0x70, 0x76, 0x63, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x82, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x13, 0x70, 0x76, 0x63, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x16, 0x70, 0x76, 0x63, 0x5f, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, + 0x74, 0x79, 0x18, 0x83, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x70, 0x76, 0x63, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, + 0x2f, 0x0a, 0x13, 0x70, 0x76, 0x63, 0x5f, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x63, 0x61, + 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x84, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x70, + 0x76, 0x63, 0x41, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, + 0x12, 0x29, 0x0a, 0x10, 0x70, 0x76, 0x63, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x6d, + 0x6f, 0x64, 0x65, 0x73, 0x18, 0x85, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x76, 0x63, + 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x70, + 0x76, 0x63, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x86, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x76, 0x63, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, + 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x76, 0x63, 0x5f, 0x76, 0x6f, 0x6c, 0x75, + 0x6d, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x87, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, + 0x70, 0x76, 0x63, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, + 0x0a, 0x70, 0x76, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x88, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x70, 0x76, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x21, 0x0a, + 0x0c, 0x70, 0x76, 0x63, 0x5f, 0x69, 0x73, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x89, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x70, 0x76, 0x63, 0x49, 0x73, 0x42, 0x6f, 0x75, 0x6e, 0x64, + 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x76, 0x63, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x8a, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x70, 0x76, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x35, 0x0a, 0x16, + 0x70, 0x76, 0x63, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x70, 0x6f, + 0x6c, 0x6f, 0x67, 0x69, 0x65, 0x73, 0x18, 0x8b, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x14, 0x70, + 0x76, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, + 0x69, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x70, 0x76, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x96, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x76, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x76, 0x5f, 0x63, 0x61, + 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x97, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, + 0x76, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x76, 0x5f, + 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x98, 0x01, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x76, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x64, + 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x76, 0x5f, 0x72, 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, + 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x99, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, + 0x70, 0x76, 0x52, 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, + 0x2a, 0x0a, 0x11, 0x70, 0x76, 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x66, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x9a, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x76, 0x43, + 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x34, 0x0a, 0x16, 0x70, + 0x76, 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x66, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x9b, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x70, 0x76, + 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x76, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x9c, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x76, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x1f, 0x0a, 0x0b, 0x70, 0x76, 0x5f, 0x69, 0x73, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x9d, + 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x70, 0x76, 0x49, 0x73, 0x42, 0x6f, 0x75, 0x6e, 0x64, + 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x76, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x6d, 0x6f, + 0x64, 0x65, 0x18, 0x9e, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x76, 0x56, 0x6f, 0x6c, + 0x75, 0x6d, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x76, 0x5f, 0x63, 0x73, + 0x69, 0x5f, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x18, 0x9f, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x70, 0x76, 0x43, 0x73, 0x69, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x15, + 0x70, 0x76, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0xa0, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x76, + 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x34, 0x0a, 0x16, 0x70, 0x76, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x61, 0x66, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x73, 0x18, 0xa1, 0x01, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x13, 0x70, 0x76, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x79, 0x5a, 0x6f, 0x6e, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x0e, 0x73, 0x63, 0x5f, 0x70, 0x72, 0x6f, + 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x18, 0xaa, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x73, 0x63, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x12, 0x2b, + 0x0a, 0x11, 0x73, 0x63, 0x5f, 0x72, 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x70, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x18, 0xab, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x63, 0x52, 0x65, + 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x34, 0x0a, 0x16, 0x73, + 0x63, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0xac, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x73, 0x63, + 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4d, 0x6f, 0x64, + 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x73, 0x63, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x76, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0xad, + 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x73, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x45, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x4f, 0x0a, + 0x0d, 0x73, 0x63, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0xae, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x53, + 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0c, 0x73, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x33, + 0x0a, 0x15, 0x73, 0x63, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x70, + 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x65, 0x73, 0x18, 0xaf, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x13, + 0x73, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, + 0x69, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x73, 0x63, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xb0, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, + 0x73, 0x63, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1c, + 0x0a, 0x09, 0x6e, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0xb1, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x24, 0x0a, 0x0d, + 0x6e, 0x73, 0x5f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x73, 0x18, 0xb2, 0x01, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x6e, 0x73, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x72, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x63, + 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0xb3, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, + 0x6e, 0x6f, 0x64, 0x65, 0x43, 0x70, 0x75, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, + 0x31, 0x0a, 0x14, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x63, + 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0xb4, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, + 0x6e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, + 0x74, 0x79, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, + 0x18, 0xb5, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x61, + 0x64, 0x79, 0x12, 0x33, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x69, 0x6e, 0x74, + 0x73, 0x18, 0xb6, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x61, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x6e, 0x6f, 0x64, + 0x65, 0x54, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x5f, + 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x18, 0xb7, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x6f, + 0x64, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x70, 0x18, 0xb8, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x49, 0x70, 0x12, 0x29, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x70, 0x18, 0xb9, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6e, + 0x6f, 0x64, 0x65, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x70, 0x12, 0x22, 0x0a, + 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0xba, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, + 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0xbb, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, + 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x73, 0x18, 0xbc, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x73, 0x12, 0x35, 0x0a, 0x16, 0x6e, 0x6f, + 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x72, 0x75, 0x6e, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0xbd, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x6e, 0x6f, 0x64, + 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, + 0x65, 0x12, 0x29, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x5f, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xbe, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x6e, 0x6f, + 0x64, 0x65, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x29, 0x0a, 0x10, + 0x68, 0x70, 0x61, 0x5f, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x18, 0xc8, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x68, 0x70, 0x61, 0x4d, 0x69, 0x6e, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x68, 0x70, 0x61, 0x5f, 0x6d, + 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0xc9, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0e, 0x68, 0x70, 0x61, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x12, 0x31, 0x0a, 0x14, 0x68, 0x70, 0x61, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0xca, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x12, 0x68, 0x70, 0x61, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x31, 0x0a, 0x14, 0x68, 0x70, 0x61, 0x5f, 0x64, 0x65, 0x73, + 0x69, 0x72, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0xcb, 0x01, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x68, 0x70, 0x61, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x68, 0x70, 0x61, 0x5f, + 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xcc, 0x01, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x68, 0x70, 0x61, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, + 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x68, 0x70, 0x61, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0xcd, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x70, 0x61, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x68, 0x70, 0x61, 0x5f, 0x73, 0x63, 0x61, + 0x6c, 0x65, 0x5f, 0x75, 0x70, 0x5f, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0xce, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x17, 0x68, 0x70, 0x61, 0x53, + 0x63, 0x61, 0x6c, 0x65, 0x55, 0x70, 0x53, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x1c, 0x68, 0x70, 0x61, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, + 0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0xcf, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x19, 0x68, 0x70, 0x61, 0x53, + 0x63, 0x61, 0x6c, 0x65, 0x44, 0x6f, 0x77, 0x6e, 0x53, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x76, 0x70, 0x61, 0x5f, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0xd2, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x76, 0x70, 0x61, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x2d, + 0x0a, 0x12, 0x76, 0x70, 0x61, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x5f, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xd3, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x76, 0x70, 0x61, + 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3b, 0x0a, + 0x19, 0x76, 0x70, 0x61, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xd4, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x17, 0x76, 0x70, 0x61, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x76, 0x70, + 0x61, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0xd5, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x70, 0x61, 0x43, 0x70, 0x75, 0x54, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x76, 0x70, 0x61, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0xd6, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x76, + 0x70, 0x61, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x1e, + 0x0a, 0x0a, 0x76, 0x70, 0x61, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0xd7, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x76, 0x70, 0x61, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x36, + 0x0a, 0x17, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x69, 0x74, + 0x65, 0x6d, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0xdc, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x14, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, + 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, + 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0xdd, 0x01, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x18, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x18, + 0xde, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, + 0x67, 0x65, 0x48, 0x61, 0x73, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x2e, 0x0a, + 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x61, 0x78, + 0x5f, 0x63, 0x70, 0x75, 0x18, 0xdf, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4d, 0x61, 0x78, 0x43, 0x70, 0x75, 0x12, 0x34, 0x0a, + 0x16, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x61, 0x78, + 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0xe0, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4d, 0x61, 0x78, 0x4d, 0x65, 0x6d, + 0x6f, 0x72, 0x79, 0x12, 0x2e, 0x0a, 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x70, 0x75, 0x18, 0xe1, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x10, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4d, 0x69, 0x6e, + 0x43, 0x70, 0x75, 0x12, 0x34, 0x0a, 0x16, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0xe2, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, + 0x4d, 0x69, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x12, 0x41, 0x0a, 0x1d, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0xe3, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x19, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x43, 0x70, 0x75, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x47, 0x0a, 0x20, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6c, 0x74, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x18, 0xe4, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1c, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, + 0x6e, 0x67, 0x65, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x45, 0x0a, 0x1f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, + 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x70, 0x75, + 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0xe5, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x1b, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x66, 0x61, 0x75, + 0x6c, 0x74, 0x43, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4b, 0x0a, 0x22, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6c, 0x74, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x18, 0xe6, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1e, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x65, 0x6d, 0x6f, + 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0xe7, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, + 0x67, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2a, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0xf0, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0xf1, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x42, 0x0a, 0x14, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 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, 0x3f, 0x0a, 0x11, 0x53, 0x63, + 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, 0x3f, 0x0a, 0x11, 0x53, - 0x63, 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, 0x42, 0x09, 0x0a, 0x07, - 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x46, 0x0a, 0x0a, 0x50, 0x6f, 0x64, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x38, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, - 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x53, 0x75, 0x6d, 0x6d, - 0x61, 0x72, 0x79, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x22, - 0xb0, 0x01, 0x0a, 0x10, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x53, 0x75, 0x6d, - 0x6d, 0x61, 0x72, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x14, - 0x0a, 0x05, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x72, - 0x65, 0x61, 0x64, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, - 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x72, 0x65, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, - 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, - 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x61, 0x73, - 0x6f, 0x6e, 0x22, 0x8b, 0x01, 0x0a, 0x11, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, - 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, - 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, - 0x65, 0x72, 0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x64, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x22, 0x8d, 0x02, 0x0a, 0x11, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, - 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, - 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, - 0x12, 0x36, 0x0a, 0x17, 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, - 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x15, 0x63, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x4d, 0x69, - 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6d, 0x65, 0x6d, 0x6f, - 0x72, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x74, 0x65, - 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, - 0x63, 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, - 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x63, 0x70, 0x75, - 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, - 0x12, 0x2e, 0x0a, 0x13, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, - 0x73, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x6d, - 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x73, - 0x22, 0x9d, 0x01, 0x0a, 0x13, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, - 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x0e, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, - 0x22, 0xc0, 0x01, 0x0a, 0x12, 0x53, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x53, 0x65, 0x74, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x09, 0x0a, 0x07, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x46, 0x0a, 0x0a, 0x50, 0x6f, 0x64, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x12, 0x38, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x53, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x22, 0xb0, + 0x01, 0x0a, 0x10, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x53, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x72, 0x65, + 0x61, 0x64, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, + 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x22, 0x8b, 0x01, 0x0a, 0x11, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, + 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, + 0x8d, 0x02, 0x0a, 0x11, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, + 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, + 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, + 0x36, 0x0a, 0x17, 0x63, 0x70, 0x75, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, + 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x15, 0x63, 0x70, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x4d, 0x69, 0x6c, + 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6d, 0x65, 0x6d, 0x6f, 0x72, + 0x79, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x63, + 0x70, 0x75, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x63, + 0x6f, 0x72, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x63, 0x70, 0x75, 0x4c, + 0x69, 0x6d, 0x69, 0x74, 0x73, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, + 0x2e, 0x0a, 0x13, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, + 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x6d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x73, 0x22, + 0x9d, 0x01, 0x0a, 0x13, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, + 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0e, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x22, + 0xc0, 0x01, 0x0a, 0x12, 0x53, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x53, 0x65, 0x74, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, + 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x73, 0x12, 0x51, 0x0a, 0x16, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x69, + 0x6d, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, + 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x14, + 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x54, 0x65, 0x6d, 0x70, 0x6c, + 0x61, 0x74, 0x65, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x22, 0xbd, 0x01, 0x0a, 0x13, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6c, 0x61, + 0x69, 0x6d, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, + 0x0a, 0x0c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x64, 0x65, + 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4d, 0x6f, + 0x64, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x73, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x23, 0x0a, + 0x0d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x22, 0xc2, 0x01, 0x0a, 0x10, 0x44, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x73, 0x12, 0x51, 0x0a, 0x16, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x63, 0x6c, 0x61, - 0x69, 0x6d, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, - 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, - 0x14, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x54, 0x65, 0x6d, 0x70, - 0x6c, 0x61, 0x74, 0x65, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x22, 0xbd, 0x01, 0x0a, 0x13, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6c, - 0x61, 0x69, 0x6d, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, - 0x21, 0x0a, 0x0c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x73, 0x18, - 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x64, - 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x6d, 0x6f, 0x64, - 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4d, - 0x6f, 0x64, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x72, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x73, - 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x23, - 0x0a, 0x0d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, 0x6c, - 0x61, 0x73, 0x73, 0x22, 0xc2, 0x01, 0x0a, 0x10, 0x44, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x53, 0x65, - 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, - 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, - 0x65, 0x72, 0x73, 0x12, 0x38, 0x0a, 0x0b, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x0b, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x39, 0x0a, - 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, - 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, - 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x81, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, - 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x31, 0x0a, 0x08, 0x73, 0x65, 0x6c, - 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, - 0x6f, 0x72, 0x52, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0xb0, 0x01, 0x0a, - 0x0a, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, - 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4a, 0x6f, 0x62, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x31, 0x0a, 0x08, - 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, - 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, - 0xc6, 0x01, 0x0a, 0x0c, 0x4a, 0x6f, 0x62, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, - 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, - 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, - 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x26, - 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x62, 0x65, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x50, 0x72, 0x6f, - 0x62, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, - 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xc0, 0x01, 0x0a, 0x0e, 0x43, 0x72, 0x6f, - 0x6e, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, - 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x3b, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, - 0x5f, 0x6a, 0x6f, 0x62, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, - 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4a, - 0x6f, 0x62, 0x73, 0x12, 0x36, 0x0a, 0x0c, 0x6a, 0x6f, 0x62, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, - 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4a, 0x6f, 0x62, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0b, - 0x6a, 0x6f, 0x62, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x22, 0x7d, 0x0a, 0x12, 0x41, - 0x63, 0x74, 0x69, 0x76, 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, - 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x72, - 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xda, 0x01, 0x0a, 0x0b, 0x4a, - 0x6f, 0x62, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, + 0x72, 0x73, 0x12, 0x38, 0x0a, 0x0b, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x0b, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x39, 0x0a, 0x0d, + 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, + 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x53, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x81, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, + 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x31, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x52, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0xb0, 0x01, 0x0a, 0x0a, + 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x62, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, - 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x62, 0x61, - 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, - 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x20, 0x0a, 0x0b, - 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x12, 0x27, - 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x6f, 0x64, - 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, - 0x69, 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0xba, 0x02, 0x0a, 0x0e, 0x53, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x29, 0x0a, 0x05, 0x70, 0x6f, - 0x72, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x52, 0x05, - 0x70, 0x6f, 0x72, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, - 0x72, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, - 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x73, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x4f, 0x0a, 0x15, 0x6c, 0x6f, 0x61, 0x64, 0x5f, - 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, - 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x49, 0x6e, 0x67, 0x72, - 0x65, 0x73, 0x73, 0x52, 0x13, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, - 0x72, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x65, 0x6e, 0x64, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x04, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x11, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x41, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x53, 0x65, 0x6c, 0x65, 0x63, - 0x74, 0x6f, 0x72, 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, 0xdc, 0x01, 0x0a, 0x0b, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x50, 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x1f, 0x0a, 0x0b, - 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x28, 0x0a, - 0x10, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, - 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, - 0x6f, 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x63, 0x6f, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x63, 0x6f, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x70, 0x6f, 0x72, 0x74, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x50, 0x6f, 0x72, 0x74, - 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x50, 0x72, 0x6f, 0x74, 0x6f, - 0x63, 0x6f, 0x6c, 0x22, 0x70, 0x0a, 0x13, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, - 0x63, 0x65, 0x72, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x70, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x70, 0x12, 0x1a, 0x0a, 0x08, 0x68, 0x6f, - 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x68, 0x6f, - 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x12, 0x17, 0x0a, 0x07, - 0x69, 0x70, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x69, - 0x70, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0xf3, 0x01, 0x0a, 0x0e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, - 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x29, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x05, 0x72, 0x75, - 0x6c, 0x65, 0x73, 0x12, 0x24, 0x0a, 0x03, 0x74, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, - 0x73, 0x54, 0x4c, 0x53, 0x52, 0x03, 0x74, 0x6c, 0x73, 0x12, 0x3f, 0x0a, 0x0f, 0x64, 0x65, 0x66, - 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, - 0x65, 0x73, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61, - 0x75, 0x6c, 0x74, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x12, 0x4f, 0x0a, 0x15, 0x6c, 0x6f, - 0x61, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x67, 0x72, - 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x49, - 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x13, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, - 0x6e, 0x63, 0x65, 0x72, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x22, 0x4c, 0x0a, 0x0b, 0x49, - 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, - 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x29, - 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x50, 0x61, - 0x74, 0x68, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x22, 0x70, 0x0a, 0x0b, 0x49, 0x6e, 0x67, - 0x72, 0x65, 0x73, 0x73, 0x50, 0x61, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1b, 0x0a, 0x09, - 0x70, 0x61, 0x74, 0x68, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x70, 0x61, 0x74, 0x68, 0x54, 0x79, 0x70, 0x65, 0x12, 0x30, 0x0a, 0x07, 0x62, 0x61, 0x63, - 0x6b, 0x65, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x65, - 0x6e, 0x64, 0x52, 0x07, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x22, 0xfe, 0x01, 0x0a, 0x0e, - 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x12, 0x21, - 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4e, 0x61, 0x6d, - 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x72, - 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x50, 0x6f, 0x72, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, - 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x30, 0x0a, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x61, 0x70, 0x69, - 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, - 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6b, - 0x69, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, - 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x43, 0x0a, 0x0a, - 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x54, 0x4c, 0x53, 0x12, 0x14, 0x0a, 0x05, 0x68, 0x6f, - 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x68, 0x6f, 0x73, 0x74, 0x73, - 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4e, 0x61, 0x6d, - 0x65, 0x22, 0xd0, 0x02, 0x0a, 0x1c, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, - 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x44, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x12, 0x51, 0x0a, 0x15, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x72, - 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, - 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, - 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x31, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, - 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x08, - 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x4c, 0x0a, 0x14, 0x76, 0x6f, 0x6c, 0x75, - 0x6d, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x61, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, - 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69, - 0x74, 0x79, 0x52, 0x12, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x66, - 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x56, 0x43, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x26, 0x0a, 0x0f, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, - 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x42, 0x79, - 0x50, 0x6f, 0x64, 0x73, 0x22, 0x98, 0x02, 0x0a, 0x14, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x46, 0x0a, - 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x2a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x72, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, - 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, - 0x6e, 0x74, 0x73, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 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, 0x39, 0x0a, 0x0b, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, 0x6e, + 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4a, 0x6f, 0x62, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x31, 0x0a, 0x08, 0x73, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0xc6, + 0x01, 0x0a, 0x0c, 0x4a, 0x6f, 0x62, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, + 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x26, 0x0a, + 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x62, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x62, + 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xc0, 0x01, 0x0a, 0x0e, 0x43, 0x72, 0x6f, 0x6e, + 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x3b, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, + 0x6a, 0x6f, 0x62, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4a, 0x6f, + 0x62, 0x73, 0x12, 0x36, 0x0a, 0x0c, 0x6a, 0x6f, 0x62, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, + 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4a, 0x6f, 0x62, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0b, 0x6a, + 0x6f, 0x62, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x22, 0x7d, 0x0a, 0x12, 0x41, 0x63, + 0x74, 0x69, 0x76, 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xda, 0x01, 0x0a, 0x0b, 0x4a, 0x6f, + 0x62, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x62, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x5f, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x62, 0x61, 0x63, + 0x6b, 0x6f, 0x66, 0x66, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, + 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, + 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, + 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x12, 0x27, 0x0a, + 0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x6f, 0x64, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, + 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0xba, 0x02, 0x0a, 0x0e, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x29, 0x0a, 0x05, 0x70, 0x6f, 0x72, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x52, 0x05, 0x70, + 0x6f, 0x72, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x53, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x73, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x4f, 0x0a, 0x15, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x62, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, + 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x49, 0x6e, 0x67, 0x72, 0x65, + 0x73, 0x73, 0x52, 0x13, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, + 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x65, 0x6e, 0x64, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x04, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x11, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x41, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, + 0x6f, 0x72, 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, 0xdc, 0x01, 0x0a, 0x0b, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, + 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x28, 0x0a, 0x10, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x6f, + 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x12, + 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x22, 0x70, 0x0a, 0x13, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x72, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x70, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x70, 0x12, 0x1a, 0x0a, 0x08, 0x68, 0x6f, 0x73, + 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x68, 0x6f, 0x73, + 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x69, + 0x70, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x69, 0x70, + 0x4d, 0x6f, 0x64, 0x65, 0x22, 0xf3, 0x01, 0x0a, 0x0e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x29, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x05, 0x72, 0x75, 0x6c, + 0x65, 0x73, 0x12, 0x24, 0x0a, 0x03, 0x74, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x54, 0x4c, 0x53, 0x52, 0x03, 0x74, 0x6c, 0x73, 0x12, 0x3f, 0x0a, 0x0f, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6c, 0x74, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, + 0x73, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, + 0x6c, 0x74, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x12, 0x4f, 0x0a, 0x15, 0x6c, 0x6f, 0x61, + 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x67, 0x72, 0x65, + 0x73, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x49, 0x6e, + 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x13, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x72, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x22, 0x4c, 0x0a, 0x0b, 0x49, 0x6e, + 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x29, 0x0a, + 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x50, 0x61, 0x74, + 0x68, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x22, 0x70, 0x0a, 0x0b, 0x49, 0x6e, 0x67, 0x72, + 0x65, 0x73, 0x73, 0x50, 0x61, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1b, 0x0a, 0x09, 0x70, + 0x61, 0x74, 0x68, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x70, 0x61, 0x74, 0x68, 0x54, 0x79, 0x70, 0x65, 0x12, 0x30, 0x0a, 0x07, 0x62, 0x61, 0x63, 0x6b, + 0x65, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, + 0x64, 0x52, 0x07, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x22, 0xfe, 0x01, 0x0a, 0x0e, 0x49, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x12, 0x21, 0x0a, + 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x72, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, + 0x6f, 0x72, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x70, + 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x30, 0x0a, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6b, 0x69, + 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x43, 0x0a, 0x0a, 0x49, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x54, 0x4c, 0x53, 0x12, 0x14, 0x0a, 0x05, 0x68, 0x6f, 0x73, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x68, 0x6f, 0x73, 0x74, 0x73, 0x12, + 0x1f, 0x0a, 0x0b, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, + 0x22, 0xd0, 0x02, 0x0a, 0x1c, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x51, 0x0a, 0x15, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x72, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x14, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x12, 0x31, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x73, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x4c, 0x0a, 0x14, 0x76, 0x6f, 0x6c, 0x75, 0x6d, + 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x61, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x79, 0x52, 0x12, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x66, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x79, 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x50, 0x56, 0x43, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x05, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x42, 0x79, 0x50, + 0x6f, 0x64, 0x73, 0x22, 0x98, 0x02, 0x0a, 0x14, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x46, 0x0a, 0x08, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 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, 0x39, 0x0a, 0x0b, 0x4c, 0x69, 0x6d, 0x69, 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, 0x90, + 0x01, 0x0a, 0x12, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x66, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x79, 0x12, 0x3b, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, + 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x09, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, + 0x64, 0x22, 0xc6, 0x01, 0x0a, 0x0c, 0x50, 0x56, 0x43, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, + 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x12, 0x26, 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x62, 0x65, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x50, + 0x72, 0x6f, 0x62, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, + 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xf5, 0x02, 0x0a, 0x17, 0x50, + 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x49, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, + 0x74, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, 0x6f, 0x6c, 0x75, + 0x6d, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, + 0x74, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, + 0x79, 0x12, 0x35, 0x0a, 0x09, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x56, + 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x08, + 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x66, 0x12, 0x3b, 0x0a, 0x0d, 0x76, 0x6f, 0x6c, 0x75, + 0x6d, 0x65, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x56, 0x56, 0x6f, 0x6c, 0x75, 0x6d, + 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x0c, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x39, 0x0a, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x61, 0x66, + 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, + 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, + 0x79, 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, 0xa2, 0x01, 0x0a, 0x10, 0x50, 0x56, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, + 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x61, + 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xd5, 0x02, 0x0a, 0x0e, 0x50, 0x56, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x29, + 0x0a, 0x03, 0x63, 0x73, 0x69, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x49, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x52, 0x03, 0x63, 0x73, 0x69, 0x12, 0x39, 0x0a, 0x09, 0x68, 0x6f, 0x73, + 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x6f, 0x73, 0x74, 0x50, 0x61, 0x74, 0x68, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x08, 0x68, 0x6f, 0x73, 0x74, + 0x50, 0x61, 0x74, 0x68, 0x12, 0x29, 0x0a, 0x03, 0x6e, 0x66, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x46, 0x53, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x03, 0x6e, 0x66, 0x73, 0x12, + 0x59, 0x0a, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x56, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, + 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x1a, 0x43, 0x0a, 0x15, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 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, - 0x90, 0x01, 0x0a, 0x12, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x66, - 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x12, 0x3b, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, - 0x65, 0x64, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, - 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, - 0x72, 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, - 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, - 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x09, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, - 0x65, 0x64, 0x22, 0xc6, 0x01, 0x0a, 0x0c, 0x50, 0x56, 0x43, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, - 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, - 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x62, 0x65, 0x5f, - 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, - 0x50, 0x72, 0x6f, 0x62, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, - 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, - 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xf5, 0x02, 0x0a, 0x17, - 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, - 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x49, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, - 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x56, 0x6f, 0x6c, - 0x75, 0x6d, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x43, 0x61, 0x70, 0x61, 0x63, - 0x69, 0x74, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, - 0x74, 0x79, 0x12, 0x35, 0x0a, 0x09, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x66, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, - 0x56, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, - 0x08, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x66, 0x12, 0x3b, 0x0a, 0x0d, 0x76, 0x6f, 0x6c, - 0x75, 0x6d, 0x65, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x56, 0x56, 0x6f, 0x6c, 0x75, - 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x0c, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, - 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x39, 0x0a, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x61, - 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, - 0x74, 0x6f, 0x72, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, - 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x4f, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, - 0x74, 0x79, 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, 0xa2, 0x01, 0x0a, 0x10, 0x50, 0x56, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, - 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, - 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, - 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, - 0x61, 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, - 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xd5, 0x02, 0x0a, 0x0e, 0x50, 0x56, 0x56, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, - 0x29, 0x0a, 0x03, 0x63, 0x73, 0x69, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x49, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x03, 0x63, 0x73, 0x69, 0x12, 0x39, 0x0a, 0x09, 0x68, 0x6f, - 0x73, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x6f, 0x73, 0x74, 0x50, 0x61, 0x74, 0x68, 0x56, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x08, 0x68, 0x6f, 0x73, - 0x74, 0x50, 0x61, 0x74, 0x68, 0x12, 0x29, 0x0a, 0x03, 0x6e, 0x66, 0x73, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x46, 0x53, 0x56, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x03, 0x6e, 0x66, 0x73, - 0x12, 0x59, 0x0a, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x61, 0x74, 0x74, 0x72, 0x69, - 0x62, 0x75, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x56, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, - 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, - 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x1a, 0x43, 0x0a, 0x15, 0x56, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 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, 0xa5, 0x02, 0x0a, 0x0f, 0x43, 0x53, 0x49, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, - 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x48, 0x61, 0x6e, 0x64, 0x6c, - 0x65, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x66, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, - 0x61, 0x64, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, - 0x65, 0x61, 0x64, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x5a, 0x0a, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, - 0x65, 0x5f, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x49, 0x56, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x56, 0x6f, 0x6c, 0x75, - 0x6d, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, - 0x74, 0x65, 0x73, 0x1a, 0x43, 0x0a, 0x15, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x41, 0x74, 0x74, - 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 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, 0x3e, 0x0a, 0x14, 0x48, 0x6f, 0x73, 0x74, - 0x50, 0x61, 0x74, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, - 0x70, 0x61, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x5a, 0x0a, 0x0f, 0x4e, 0x46, 0x53, 0x56, - 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x61, 0x64, 0x5f, - 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x61, 0x64, - 0x4f, 0x6e, 0x6c, 0x79, 0x22, 0xbe, 0x03, 0x0a, 0x13, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, - 0x43, 0x6c, 0x61, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x20, 0x0a, 0x0b, - 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x12, 0x4b, - 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, - 0x61, 0x67, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 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, 0x12, 0x61, - 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x65, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, - 0x72, 0x52, 0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, - 0x67, 0x69, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6f, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x6d, 0x6f, 0x75, - 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x76, 0x6f, 0x6c, - 0x75, 0x6d, 0x65, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x6f, 0x64, 0x65, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x42, 0x69, - 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x63, - 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0d, 0x72, 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, - 0x12, 0x34, 0x0a, 0x16, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, - 0x5f, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x14, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x45, 0x78, 0x70, - 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 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, 0xd1, 0x01, 0x0a, 0x10, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x68, - 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, - 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x73, - 0x12, 0x48, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x43, - 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, - 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x43, 0x6f, - 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 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, 0xdf, 0x03, 0x0a, 0x0b, 0x4e, 0x6f, - 0x64, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x31, 0x0a, 0x09, 0x61, 0x64, 0x64, - 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, - 0x73, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x35, 0x0a, 0x0a, - 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x43, 0x6f, - 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x37, 0x0a, 0x0b, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x69, 0x6e, - 0x66, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x0a, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3d, 0x0a, 0x08, - 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x2e, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x46, 0x0a, 0x0b, 0x61, - 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x12, 0x29, 0x0a, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x18, 0x06, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, - 0x65, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x1a, 0x3b, - 0x0a, 0x0d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 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, 0x3e, 0x0a, 0x10, 0x41, - 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x61, 0x62, 0x6c, 0x65, 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, 0x6a, 0x0a, 0x09, 0x4e, - 0x6f, 0x64, 0x65, 0x54, 0x61, 0x69, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0xa5, 0x02, 0x0a, 0x0f, 0x43, 0x53, 0x49, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x76, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0c, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x12, 0x17, 0x0a, 0x07, 0x66, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x66, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x61, + 0x64, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, + 0x61, 0x64, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x5a, 0x0a, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, + 0x5f, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x2d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x49, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6d, + 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x10, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x65, 0x73, 0x1a, 0x43, 0x0a, 0x15, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x41, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 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, 0x3e, 0x0a, 0x14, 0x48, 0x6f, 0x73, 0x74, 0x50, + 0x61, 0x74, 0x68, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, + 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, + 0x61, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x5a, 0x0a, 0x0f, 0x4e, 0x46, 0x53, 0x56, 0x6f, + 0x6c, 0x75, 0x6d, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x6f, + 0x6e, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x61, 0x64, 0x4f, + 0x6e, 0x6c, 0x79, 0x22, 0xbe, 0x03, 0x0a, 0x13, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x12, 0x4b, 0x0a, + 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x2b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x61, + 0x67, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 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, 0x12, 0x61, 0x6c, + 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x65, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x52, 0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, + 0x69, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x76, 0x6f, 0x6c, 0x75, + 0x6d, 0x65, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x42, 0x69, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x63, 0x6c, + 0x61, 0x69, 0x6d, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0d, 0x72, 0x65, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, + 0x34, 0x0a, 0x16, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x5f, + 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x14, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x45, 0x78, 0x70, 0x61, + 0x6e, 0x73, 0x69, 0x6f, 0x6e, 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, - 0x12, 0x16, 0x0a, 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, - 0x5f, 0x61, 0x64, 0x64, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, - 0x6d, 0x65, 0x41, 0x64, 0x64, 0x65, 0x64, 0x22, 0x3b, 0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x41, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, - 0x72, 0x65, 0x73, 0x73, 0x22, 0xcf, 0x01, 0x0a, 0x0d, 0x4e, 0x6f, 0x64, 0x65, 0x43, 0x6f, 0x6e, - 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, - 0x73, 0x61, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61, - 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, - 0x54, 0x69, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, - 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x8d, 0x03, 0x0a, 0x0e, 0x4e, 0x6f, 0x64, 0x65, 0x53, - 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x63, - 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, - 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x79, 0x73, 0x74, - 0x65, 0x6d, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, - 0x79, 0x73, 0x74, 0x65, 0x6d, 0x55, 0x75, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x62, 0x6f, 0x6f, - 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x62, 0x6f, 0x6f, 0x74, - 0x49, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x6b, 0x65, 0x72, 0x6e, 0x65, 0x6c, 0x5f, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6b, 0x65, 0x72, 0x6e, - 0x65, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x73, 0x5f, - 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x73, 0x49, - 0x6d, 0x61, 0x67, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x5f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, - 0x65, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x12, 0x27, 0x0a, 0x0f, 0x6b, 0x75, 0x62, 0x65, 0x6c, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6b, 0x75, 0x62, 0x65, 0x6c, - 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x0a, 0x12, 0x6b, 0x75, 0x62, - 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, - 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6b, 0x75, 0x62, 0x65, 0x50, 0x72, 0x6f, 0x78, 0x79, - 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x65, 0x72, 0x61, - 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x18, 0x09, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x53, 0x79, 0x73, 0x74, - 0x65, 0x6d, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, - 0x72, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, - 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x22, 0x40, 0x0a, 0x09, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6d, - 0x61, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 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, 0x68, 0x0a, 0x10, 0x54, 0x6f, 0x70, 0x6f, - 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x54, 0x0a, 0x17, - 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x5f, 0x65, 0x78, 0x70, 0x72, - 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x65, 0x72, 0x6d, 0x52, 0x15, 0x6d, 0x61, 0x74, - 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x45, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x73, 0x22, 0xa8, 0x01, 0x0a, 0x14, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x65, 0x72, 0x6d, 0x12, 0x50, 0x0a, 0x0c, 0x6d, - 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x2d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c, - 0x6f, 0x67, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x65, 0x72, 0x6d, 0x2e, + 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd1, 0x01, 0x0a, 0x10, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x68, 0x61, + 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, + 0x1e, 0x0a, 0x0a, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x73, 0x12, + 0x48, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x61, 0x6d, + 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x43, 0x6f, + 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x63, + 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 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, 0xdf, 0x03, 0x0a, 0x0b, 0x4e, 0x6f, 0x64, + 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x31, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x35, 0x0a, 0x0a, 0x63, + 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x43, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x37, 0x0a, 0x0b, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x69, 0x6e, 0x66, + 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x0a, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3d, 0x0a, 0x08, 0x63, + 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x2e, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x46, 0x0a, 0x0b, 0x61, 0x6c, + 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x12, 0x29, 0x0a, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, + 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x1a, 0x3b, 0x0a, + 0x0d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 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, 0x3e, 0x0a, 0x10, 0x41, 0x6c, + 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x61, 0x62, 0x6c, 0x65, 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, 0x6a, 0x0a, 0x09, 0x4e, 0x6f, + 0x64, 0x65, 0x54, 0x61, 0x69, 0x6e, 0x74, 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, 0x12, + 0x16, 0x0a, 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, + 0x61, 0x64, 0x64, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, + 0x65, 0x41, 0x64, 0x64, 0x65, 0x64, 0x22, 0x3b, 0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x22, 0xcf, 0x01, 0x0a, 0x0d, 0x4e, 0x6f, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x72, + 0x74, 0x62, 0x65, 0x61, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x8d, 0x03, 0x0a, 0x0e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x79, + 0x73, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x63, 0x68, + 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, + 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x79, 0x73, 0x74, 0x65, + 0x6d, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6d, 0x55, 0x75, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x62, 0x6f, 0x6f, 0x74, + 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x62, 0x6f, 0x6f, 0x74, 0x49, + 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x6b, 0x65, 0x72, 0x6e, 0x65, 0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6b, 0x65, 0x72, 0x6e, 0x65, + 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x73, 0x5f, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x73, 0x49, 0x6d, + 0x61, 0x67, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x5f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x27, 0x0a, 0x0f, 0x6b, 0x75, 0x62, 0x65, 0x6c, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6b, 0x75, 0x62, 0x65, 0x6c, 0x65, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x0a, 0x12, 0x6b, 0x75, 0x62, 0x65, + 0x5f, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6b, 0x75, 0x62, 0x65, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x53, 0x79, 0x73, 0x74, 0x65, + 0x6d, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, + 0x63, 0x74, 0x75, 0x72, 0x65, 0x22, 0x40, 0x0a, 0x09, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6d, 0x61, + 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 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, 0x68, 0x0a, 0x10, 0x54, 0x6f, 0x70, 0x6f, 0x6c, + 0x6f, 0x67, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x54, 0x0a, 0x17, 0x6d, + 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x65, 0x72, 0x6d, 0x52, 0x15, 0x6d, 0x61, 0x74, 0x63, + 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x45, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x73, 0x22, 0xa8, 0x01, 0x0a, 0x14, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x65, 0x72, 0x6d, 0x12, 0x50, 0x0a, 0x0c, 0x6d, 0x61, + 0x74, 0x63, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x2d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, + 0x67, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x65, 0x72, 0x6d, 0x2e, 0x4d, + 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x0b, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x3e, 0x0a, 0x10, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, - 0x52, 0x0b, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x3e, 0x0a, - 0x10, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 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, 0x9b, 0x01, - 0x0a, 0x0e, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, - 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x14, - 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x12, 0x2d, 0x0a, 0x12, - 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, - 0x64, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0x3e, 0x0a, 0x0c, 0x4e, - 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x2e, 0x0a, 0x05, 0x74, - 0x65, 0x72, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, + 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, 0x9b, 0x01, 0x0a, + 0x0e, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x74, + 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, + 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0x3e, 0x0a, 0x0c, 0x4e, 0x6f, + 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x2e, 0x0a, 0x05, 0x74, 0x65, + 0x72, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, + 0x65, 0x72, 0x6d, 0x52, 0x05, 0x74, 0x65, 0x72, 0x6d, 0x73, 0x22, 0xa4, 0x01, 0x0a, 0x10, 0x4e, + 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x65, 0x72, 0x6d, 0x12, + 0x4c, 0x0a, 0x11, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, - 0x54, 0x65, 0x72, 0x6d, 0x52, 0x05, 0x74, 0x65, 0x72, 0x6d, 0x73, 0x22, 0xa4, 0x01, 0x0a, 0x10, - 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x65, 0x72, 0x6d, - 0x12, 0x4c, 0x0a, 0x11, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, - 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x10, 0x6d, 0x61, - 0x74, 0x63, 0x68, 0x45, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x42, - 0x0a, 0x0c, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, - 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, - 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0b, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x46, 0x69, 0x65, 0x6c, - 0x64, 0x73, 0x22, 0x5f, 0x0a, 0x17, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, - 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x10, 0x0a, - 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, - 0x1a, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x73, 0x22, 0xa5, 0x02, 0x0a, 0x0a, 0x48, 0x50, 0x41, 0x44, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x12, 0x40, 0x0a, 0x10, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x5f, 0x74, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x52, 0x65, 0x66, 0x52, 0x0e, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x52, 0x65, 0x66, 0x12, 0x2b, 0x0a, 0x07, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, - 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, - 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x07, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x73, 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, - 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, - 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2f, 0x0a, 0x08, 0x62, 0x65, 0x68, 0x61, 0x76, - 0x69, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x42, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x52, 0x08, - 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x12, 0x41, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x43, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x0e, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x22, 0x59, 0x0a, 0x0e, 0x53, - 0x63, 0x61, 0x6c, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x66, 0x12, 0x12, 0x0a, - 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, - 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, - 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xe9, 0x01, 0x0a, 0x09, 0x48, 0x50, 0x41, 0x4d, 0x65, - 0x74, 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, - 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, - 0x29, 0x0a, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x50, 0x6f, 0x64, 0x73, 0x4d, 0x65, - 0x74, 0x72, 0x69, 0x63, 0x52, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x12, 0x2f, 0x0a, 0x06, 0x6f, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, - 0x72, 0x69, 0x63, 0x52, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x35, 0x0a, 0x08, 0x65, - 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x08, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x22, 0x6b, 0x0a, 0x11, 0x48, 0x50, 0x41, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c, - 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, - 0x86, 0x01, 0x0a, 0x0d, 0x48, 0x50, 0x41, 0x50, 0x6f, 0x64, 0x73, 0x4d, 0x65, 0x74, 0x72, 0x69, - 0x63, 0x12, 0x31, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, 0x65, - 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6d, 0x65, - 0x74, 0x72, 0x69, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xcf, 0x01, 0x0a, 0x0f, 0x48, 0x50, 0x41, - 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x45, 0x0a, 0x10, - 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x48, 0x50, 0x41, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, - 0x63, 0x65, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x4f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x12, 0x31, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, - 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, - 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x11, 0x48, - 0x50, 0x41, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, + 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x10, 0x6d, 0x61, 0x74, + 0x63, 0x68, 0x45, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x42, 0x0a, + 0x0c, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, + 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0b, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x73, 0x22, 0x5f, 0x0a, 0x17, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x1a, + 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x22, 0xa5, 0x02, 0x0a, 0x0a, 0x48, 0x50, 0x41, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x40, 0x0a, 0x10, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x52, 0x65, 0x66, 0x52, 0x0e, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x52, 0x65, 0x66, 0x12, 0x2b, 0x0a, 0x07, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, + 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x07, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, + 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, + 0x41, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2f, 0x0a, 0x08, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, + 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x48, 0x50, 0x41, 0x42, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x52, 0x08, 0x62, + 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x12, 0x41, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x22, 0x59, 0x0a, 0x0e, 0x53, 0x63, + 0x61, 0x6c, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x66, 0x12, 0x12, 0x0a, 0x04, + 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xe9, 0x01, 0x0a, 0x09, 0x48, 0x50, 0x41, 0x4d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x52, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x29, + 0x0a, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x50, 0x6f, 0x64, 0x73, 0x4d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x52, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x12, 0x2f, 0x0a, 0x06, 0x6f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x52, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x78, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x08, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x22, 0x6b, 0x0a, 0x11, 0x48, 0x50, 0x41, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x86, + 0x01, 0x0a, 0x0d, 0x48, 0x50, 0x41, 0x50, 0x6f, 0x64, 0x73, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x31, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6d, 0x65, 0x74, @@ -15327,516 +16255,583 @@ var file_api_v1_common_proto_rawDesc = []byte{ 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xa9, 0x01, 0x0a, 0x11, 0x48, 0x50, 0x41, 0x4d, - 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x12, 0x0a, - 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, - 0x65, 0x12, 0x43, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, - 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x53, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x73, 0x65, - 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a, 0x3b, 0x0a, 0x0d, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, - 0x6f, 0x72, 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, 0x7b, 0x0a, 0x12, 0x48, 0x50, 0x41, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, - 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, - 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, - 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x22, 0x8c, 0x02, 0x0a, 0x10, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4d, - 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x08, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x08, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x30, 0x0a, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, - 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x50, 0x6f, 0x64, 0x73, 0x4d, 0x65, 0x74, - 0x72, 0x69, 0x63, 0x52, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x12, 0x36, 0x0a, 0x06, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x12, 0x3c, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, - 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4d, - 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x08, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x22, - 0x93, 0x01, 0x0a, 0x18, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, + 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xcf, 0x01, 0x0a, 0x0f, 0x48, 0x50, 0x41, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x45, 0x0a, 0x10, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, + 0x50, 0x41, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, + 0x65, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x12, 0x31, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x11, 0x48, 0x50, + 0x41, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, + 0x31, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xa9, 0x01, 0x0a, 0x11, 0x48, 0x50, 0x41, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x75, 0x74, 0x69, 0x6c, - 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x76, 0x65, - 0x72, 0x61, 0x67, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x7d, 0x0a, 0x14, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x74, 0x50, 0x6f, 0x64, 0x73, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x31, 0x0a, - 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x12, 0x32, 0x0a, 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x76, 0x65, 0x72, - 0x61, 0x67, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x22, 0xb7, 0x01, 0x0a, 0x16, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, - 0x45, 0x0a, 0x10, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x66, 0x65, - 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, - 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x31, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x48, 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, - 0x72, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xa6, - 0x01, 0x0a, 0x18, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x78, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x31, 0x0a, 0x06, 0x6d, - 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, - 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x23, - 0x0a, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, - 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x76, 0x65, 0x72, 0x61, - 0x67, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x9e, 0x01, 0x0a, 0x0c, 0x48, 0x50, 0x41, 0x43, - 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, - 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x79, 0x0a, 0x0b, 0x48, 0x50, 0x41, 0x42, - 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x12, 0x32, 0x0a, 0x08, 0x73, 0x63, 0x61, 0x6c, 0x65, - 0x5f, 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, - 0x65, 0x73, 0x52, 0x07, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x55, 0x70, 0x12, 0x36, 0x0a, 0x0a, 0x73, - 0x63, 0x61, 0x6c, 0x65, 0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, - 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x09, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x44, - 0x6f, 0x77, 0x6e, 0x22, 0xae, 0x01, 0x0a, 0x0f, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, 0x69, - 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x40, 0x0a, 0x1c, 0x73, 0x74, 0x61, 0x62, 0x69, - 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x5f, - 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x1a, 0x73, - 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x65, 0x6c, - 0x65, 0x63, 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x34, - 0x0a, 0x08, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, - 0x6c, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x08, 0x70, 0x6f, 0x6c, 0x69, - 0x63, 0x69, 0x65, 0x73, 0x22, 0x63, 0x0a, 0x10, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, 0x69, - 0x6e, 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x5f, 0x73, 0x65, 0x63, - 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x70, 0x65, 0x72, 0x69, - 0x6f, 0x64, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0xbc, 0x02, 0x0a, 0x0a, 0x56, 0x50, - 0x41, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x33, 0x0a, 0x0a, 0x74, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, - 0x65, 0x66, 0x52, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x66, 0x12, 0x3c, 0x0a, - 0x0d, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, - 0x41, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0c, 0x75, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x42, 0x0a, 0x0f, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, - 0x41, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, - 0x0e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, - 0x41, 0x0a, 0x0e, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x56, 0x50, 0x41, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x0e, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, - 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x57, 0x0a, 0x0c, 0x56, 0x50, 0x41, 0x54, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x66, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, + 0x12, 0x43, 0x0a, 0x08, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x53, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x73, 0x65, 0x6c, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a, 0x3b, 0x0a, 0x0d, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, + 0x72, 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, 0x7b, 0x0a, 0x12, 0x48, 0x50, 0x41, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, + 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x22, 0x55, 0x0a, 0x0f, 0x56, 0x50, 0x41, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x6f, - 0x6c, 0x69, 0x63, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x6d, - 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x6e, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x22, 0x66, 0x0a, 0x11, 0x56, 0x50, 0x41, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x51, 0x0a, - 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, - 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x11, 0x63, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, - 0x22, 0xdf, 0x03, 0x0a, 0x1a, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, - 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, - 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x12, 0x53, 0x0a, 0x0b, 0x6d, 0x69, - 0x6e, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x32, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, - 0x69, 0x63, 0x79, 0x2e, 0x4d, 0x69, 0x6e, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x0a, 0x6d, 0x69, 0x6e, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x12, - 0x53, 0x0a, 0x0b, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x18, 0x04, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, - 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x4d, 0x61, 0x78, 0x41, 0x6c, 0x6c, 0x6f, - 0x77, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x6d, 0x61, 0x78, 0x41, 0x6c, 0x6c, - 0x6f, 0x77, 0x65, 0x64, 0x12, 0x31, 0x0a, 0x14, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x13, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x52, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x10, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x4d, 0x69, 0x6e, 0x41, 0x6c, 0x6c, 0x6f, 0x77, - 0x65, 0x64, 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, 0x4d, 0x61, 0x78, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, + 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, + 0x8c, 0x02, 0x0a, 0x10, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x08, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x30, 0x0a, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, + 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x50, 0x6f, 0x64, 0x73, 0x4d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x52, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x12, 0x36, 0x0a, 0x06, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x12, 0x3c, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x43, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x52, 0x08, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x22, 0x93, + 0x01, 0x0a, 0x18, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x2f, 0x0a, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x75, 0x74, 0x69, 0x6c, 0x69, + 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x32, 0x0a, 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x76, 0x65, 0x72, + 0x61, 0x67, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x22, 0x7d, 0x0a, 0x14, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x50, 0x6f, 0x64, 0x73, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x31, 0x0a, 0x06, + 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, + 0x32, 0x0a, 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x76, 0x65, 0x72, 0x61, + 0x67, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x22, 0xb7, 0x01, 0x0a, 0x16, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x45, + 0x0a, 0x10, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x63, 0x65, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x31, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, + 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xa6, 0x01, + 0x0a, 0x18, 0x48, 0x50, 0x41, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x78, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x31, 0x0a, 0x06, 0x6d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x53, 0x65, 0x6c, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x23, 0x0a, + 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x76, + 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, + 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x9e, 0x01, 0x0a, 0x0c, 0x48, 0x50, 0x41, 0x43, 0x6f, + 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x79, 0x0a, 0x0b, 0x48, 0x50, 0x41, 0x42, 0x65, + 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x12, 0x32, 0x0a, 0x08, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x5f, + 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, + 0x73, 0x52, 0x07, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x55, 0x70, 0x12, 0x36, 0x0a, 0x0a, 0x73, 0x63, + 0x61, 0x6c, 0x65, 0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, 0x69, + 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x09, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x44, 0x6f, + 0x77, 0x6e, 0x22, 0xae, 0x01, 0x0a, 0x0f, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, + 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x40, 0x0a, 0x1c, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x5f, 0x73, + 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x1a, 0x73, 0x74, + 0x61, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x65, 0x6c, 0x65, + 0x63, 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x34, 0x0a, + 0x08, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, + 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x08, 0x70, 0x6f, 0x6c, 0x69, 0x63, + 0x69, 0x65, 0x73, 0x22, 0x63, 0x0a, 0x10, 0x48, 0x50, 0x41, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, + 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x5f, 0x73, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x70, 0x65, 0x72, 0x69, 0x6f, + 0x64, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0xbc, 0x02, 0x0a, 0x0a, 0x56, 0x50, 0x41, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x33, 0x0a, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, + 0x66, 0x52, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x66, 0x12, 0x3c, 0x0a, 0x0d, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0c, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x42, 0x0a, 0x0f, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0e, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x41, + 0x0a, 0x0e, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x56, 0x50, 0x41, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x0e, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, + 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x57, 0x0a, 0x0c, 0x56, 0x50, 0x41, 0x54, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x66, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x1f, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x22, 0x55, 0x0a, 0x0f, 0x56, 0x50, 0x41, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x6d, 0x6f, + 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x22, 0x66, 0x0a, 0x11, 0x56, 0x50, 0x41, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x51, 0x0a, 0x12, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, + 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x11, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x22, + 0xdf, 0x03, 0x0a, 0x1a, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x25, + 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x12, 0x53, 0x0a, 0x0b, 0x6d, 0x69, 0x6e, + 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x2e, 0x4d, 0x69, 0x6e, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0a, 0x6d, 0x69, 0x6e, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x12, 0x53, + 0x0a, 0x0b, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x18, 0x04, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x4d, 0x61, 0x78, 0x41, 0x6c, 0x6c, 0x6f, 0x77, + 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x6d, 0x61, 0x78, 0x41, 0x6c, 0x6c, 0x6f, + 0x77, 0x65, 0x64, 0x12, 0x31, 0x0a, 0x14, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x13, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x10, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x4d, 0x69, 0x6e, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 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, 0x74, 0x0a, 0x11, 0x56, 0x50, 0x41, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, - 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5f, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, - 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x18, - 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, - 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x92, 0x05, 0x0a, 0x1a, 0x56, 0x50, 0x41, - 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, - 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x46, - 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x2e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, - 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x53, 0x0a, 0x0b, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x5f, - 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, - 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x0a, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x53, 0x0a, 0x0b, 0x75, - 0x70, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x32, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, - 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x55, 0x70, 0x70, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x75, 0x70, 0x70, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, - 0x12, 0x5f, 0x0a, 0x0f, 0x75, 0x6e, 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x4d, 0x61, 0x78, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, + 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, 0x74, 0x0a, 0x11, 0x56, 0x50, 0x41, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5f, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, - 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x55, 0x6e, - 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x0e, 0x75, 0x6e, 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x1a, 0x39, 0x0a, 0x0b, 0x54, 0x61, 0x72, 0x67, 0x65, 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, - 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x18, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x92, 0x05, 0x0a, 0x1a, 0x56, 0x50, 0x41, 0x43, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x46, 0x0a, + 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x53, 0x0a, 0x0b, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x62, + 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4c, + 0x6f, 0x77, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, + 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x53, 0x0a, 0x0b, 0x75, 0x70, + 0x70, 0x65, 0x72, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x32, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x55, 0x70, 0x70, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x0a, 0x75, 0x70, 0x70, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x12, + 0x5f, 0x0a, 0x0f, 0x75, 0x6e, 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, + 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x55, 0x6e, 0x63, + 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0e, 0x75, 0x6e, 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x1a, 0x39, 0x0a, 0x0b, 0x54, 0x61, 0x72, 0x67, 0x65, 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, 0x55, - 0x70, 0x70, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x4c, + 0x6f, 0x77, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 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, 0x41, 0x0a, 0x13, 0x55, 0x6e, - 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x45, 0x6e, 0x74, 0x72, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x55, 0x70, + 0x70, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 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, 0x41, 0x0a, 0x13, 0x55, 0x6e, 0x63, + 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 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, 0x9e, 0x01, 0x0a, + 0x0c, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, + 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, + 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x43, 0x0a, + 0x11, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x12, 0x2e, 0x0a, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, 0x69, + 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x06, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x73, 0x22, 0xd8, 0x05, 0x0a, 0x0e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, + 0x65, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x50, 0x0a, 0x0e, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, + 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x53, 0x0a, 0x0f, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x44, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x31, 0x0a, 0x03, 0x6d, 0x61, 0x78, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, + 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4d, 0x61, 0x78, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x03, + 0x6d, 0x61, 0x78, 0x12, 0x31, 0x0a, 0x03, 0x6d, 0x69, 0x6e, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, + 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4d, 0x69, 0x6e, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x03, 0x6d, 0x69, 0x6e, 0x12, 0x67, 0x0a, 0x17, 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x69, + 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, + 0x4d, 0x61, 0x78, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, + 0x61, 0x74, 0x69, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x14, 0x6d, 0x61, 0x78, 0x4c, 0x69, + 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x1a, + 0x40, 0x0a, 0x12, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4c, 0x69, 0x6d, 0x69, 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, 0x41, 0x0a, 0x13, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, + 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, 0x1a, 0x36, 0x0a, 0x08, 0x4d, 0x61, 0x78, 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, 0x36, 0x0a, 0x08, + 0x4d, 0x69, 0x6e, 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, 0x47, 0x0a, 0x19, 0x4d, 0x61, 0x78, 0x4c, 0x69, 0x6d, 0x69, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x69, 0x6f, 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, 0x9e, 0x01, - 0x0a, 0x0c, 0x56, 0x50, 0x41, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, - 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, - 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, - 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, - 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, - 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, - 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, - 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x43, - 0x0a, 0x11, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x12, 0x2e, 0x0a, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, - 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x06, 0x6c, 0x69, 0x6d, - 0x69, 0x74, 0x73, 0x22, 0xd8, 0x05, 0x0a, 0x0e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, - 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x50, 0x0a, 0x0e, 0x64, 0x65, - 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, 0x69, - 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x44, 0x65, 0x66, 0x61, 0x75, - 0x6c, 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x64, - 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x53, 0x0a, 0x0f, - 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x44, 0x65, - 0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x31, 0x0a, 0x03, 0x6d, 0x61, 0x78, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, - 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4d, 0x61, 0x78, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x03, 0x6d, 0x61, 0x78, 0x12, 0x31, 0x0a, 0x03, 0x6d, 0x69, 0x6e, 0x18, 0x05, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, - 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4d, 0x69, 0x6e, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x52, 0x03, 0x6d, 0x69, 0x6e, 0x12, 0x67, 0x0a, 0x17, 0x6d, 0x61, 0x78, 0x5f, 0x6c, - 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x74, 0x65, 0x6d, - 0x2e, 0x4d, 0x61, 0x78, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x52, 0x61, 0x74, 0x69, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x14, 0x6d, 0x61, 0x78, 0x4c, - 0x69, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x69, 0x6f, - 0x1a, 0x40, 0x0a, 0x12, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x4c, 0x69, 0x6d, 0x69, 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, 0x41, 0x0a, 0x13, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, - 0x75, 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, 0x1a, 0x36, 0x0a, 0x08, 0x4d, 0x61, 0x78, 0x45, 0x6e, 0x74, 0x72, + 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd1, 0x01, + 0x0a, 0x15, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x45, 0x0a, 0x1f, 0x61, 0x75, 0x74, 0x6f, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x63, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x1c, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x18, + 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x5f, 0x70, 0x75, 0x6c, 0x6c, 0x5f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x50, 0x75, 0x6c, 0x6c, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x22, 0x35, 0x0a, 0x0b, 0x52, 0x6f, 0x6c, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x12, 0x26, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x75, 0x6c, + 0x65, 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x22, 0x84, 0x01, 0x0a, 0x08, 0x52, 0x6f, 0x6c, + 0x65, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x70, 0x69, 0x5f, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x70, 0x69, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x65, 0x72, 0x62, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x65, 0x72, 0x62, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x22, + 0x7e, 0x0a, 0x12, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x36, 0x0a, 0x08, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x75, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x52, 0x08, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x30, 0x0a, + 0x08, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x07, 0x72, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x66, 0x22, + 0x77, 0x0a, 0x12, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x75, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, + 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x61, + 0x70, 0x69, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x61, 0x70, 0x69, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, 0x54, 0x0a, 0x0d, 0x52, 0x6f, 0x6c, 0x65, + 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x70, 0x69, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x61, 0x70, 0x69, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, 0xe4, + 0x02, 0x0a, 0x17, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x21, 0x0a, 0x0c, + 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, + 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x3b, 0x0a, + 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, + 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x52, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, 0x41, 0x0a, 0x0a, 0x63, 0x6f, + 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, + 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x16, 0x0a, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xb5, 0x01, 0x0a, 0x17, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, + 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x49, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 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, 0x36, 0x0a, - 0x08, 0x4d, 0x69, 0x6e, 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, 0x47, 0x0a, 0x19, 0x4d, 0x61, 0x78, 0x4c, 0x69, 0x6d, 0x69, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x69, 0x6f, 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, 0xd1, - 0x01, 0x0a, 0x15, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, - 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x45, 0x0a, 0x1f, 0x61, 0x75, 0x74, 0x6f, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x63, - 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x1c, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, - 0x18, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x69, 0x6d, 0x61, - 0x67, 0x65, 0x5f, 0x70, 0x75, 0x6c, 0x6c, 0x5f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x50, 0x75, 0x6c, 0x6c, - 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x22, 0x35, 0x0a, 0x0b, 0x52, 0x6f, 0x6c, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x12, 0x26, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x75, - 0x6c, 0x65, 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x22, 0x84, 0x01, 0x0a, 0x08, 0x52, 0x6f, - 0x6c, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x70, 0x69, 0x5f, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x70, 0x69, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x65, 0x72, 0x62, 0x73, 0x18, 0x03, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x05, 0x76, 0x65, 0x72, 0x62, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, - 0x22, 0x7e, 0x0a, 0x12, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x36, 0x0a, 0x08, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x75, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x52, 0x08, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x30, - 0x0a, 0x08, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, - 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x07, 0x72, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x66, - 0x22, 0x77, 0x0a, 0x12, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, - 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, - 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, - 0x61, 0x70, 0x69, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x61, 0x70, 0x69, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, 0x54, 0x0a, 0x0d, 0x52, 0x6f, 0x6c, - 0x65, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, - 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, - 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x70, 0x69, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x61, 0x70, 0x69, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, - 0xe4, 0x02, 0x0a, 0x17, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x74, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, - 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x21, 0x0a, - 0x0c, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, - 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x72, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x3b, - 0x0a, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, - 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x52, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, 0x41, 0x0a, 0x0a, 0x63, - 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x21, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, - 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x16, - 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xb5, 0x01, 0x0a, 0x17, 0x4b, 0x65, 0x64, 0x61, 0x53, - 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x49, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, - 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, - 0x63, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, - 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, - 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 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, 0xab, - 0x01, 0x0a, 0x19, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, - 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, - 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, - 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, - 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, - 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, - 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x85, 0x04, 0x0a, - 0x18, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, - 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x42, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, - 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x35, 0x0a, 0x08, 0x63, 0x61, - 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x43, - 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, - 0x79, 0x12, 0x40, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, - 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, - 0x6e, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, - 0x73, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6e, 0x6f, 0x64, - 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x65, 0x66, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, - 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, - 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x44, 0x0a, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, - 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xab, 0x01, + 0x0a, 0x19, 0x4b, 0x65, 0x64, 0x61, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, + 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, + 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, + 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x85, 0x04, 0x0a, 0x18, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x2b, 0x0a, 0x11, - 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, - 0x65, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x69, 0x6d, - 0x69, 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, 0x1a, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, - 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, - 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, - 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, - 0x69, 0x6d, 0x65, 0x22, 0xb3, 0x01, 0x0a, 0x11, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, - 0x72, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x63, 0x70, 0x75, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x63, 0x70, 0x75, 0x12, 0x16, 0x0a, 0x06, 0x6d, - 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x6d, - 0x6f, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x05, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x18, 0x03, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x61, 0x72, 0x70, - 0x65, 0x6e, 0x74, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x2e, 0x4f, 0x74, - 0x68, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x1a, - 0x38, 0x0a, 0x0a, 0x4f, 0x74, 0x68, 0x65, 0x72, 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, 0x14, 0x4b, 0x61, 0x72, - 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, - 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, - 0x6b, 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, - 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0xc5, 0x04, 0x0a, 0x0f, 0x57, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x12, 0x49, 0x0a, 0x12, 0x6e, - 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, - 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x48, 0x00, - 0x52, 0x11, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, - 0x74, 0x6f, 0x72, 0x88, 0x01, 0x01, 0x12, 0x47, 0x0a, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, - 0x61, 0x64, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, - 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x48, 0x01, 0x52, 0x10, 0x77, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x88, 0x01, 0x01, 0x12, - 0x36, 0x0a, 0x0b, 0x6b, 0x69, 0x6e, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0d, - 0x20, 0x03, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, - 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x0a, 0x6b, 0x69, 0x6e, - 0x64, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x5f, - 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x50, 0x61, 0x74, 0x74, - 0x65, 0x72, 0x6e, 0x48, 0x02, 0x52, 0x0b, 0x6e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x74, 0x74, 0x65, - 0x72, 0x6e, 0x88, 0x01, 0x01, 0x12, 0x4b, 0x0a, 0x13, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x0f, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, - 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x48, 0x03, 0x52, 0x12, 0x61, 0x6e, 0x6e, - 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x88, - 0x01, 0x01, 0x12, 0x25, 0x0a, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6e, - 0x61, 0x6d, 0x65, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x77, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x6f, 0x64, - 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x15, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x1e, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x46, 0x69, 0x6c, 0x74, 0x65, - 0x72, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x15, 0x0a, 0x13, 0x5f, 0x6e, 0x61, + 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x42, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, + 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x35, 0x0a, 0x08, 0x63, 0x61, 0x70, + 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x43, 0x61, + 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, + 0x12, 0x40, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x5f, 0x72, 0x65, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6e, 0x6f, 0x64, 0x65, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x65, 0x66, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, + 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x44, 0x0a, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, + 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, + 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x6b, + 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, + 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x69, 0x6d, 0x69, + 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, 0x1a, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, + 0x72, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, + 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, + 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, + 0x6d, 0x65, 0x22, 0xb3, 0x01, 0x0a, 0x11, 0x4b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, + 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x63, 0x70, 0x75, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x63, 0x70, 0x75, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x6d, 0x6f, + 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x05, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x61, 0x72, 0x70, 0x65, + 0x6e, 0x74, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x2e, 0x4f, 0x74, 0x68, + 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x1a, 0x38, + 0x0a, 0x0a, 0x4f, 0x74, 0x68, 0x65, 0x72, 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, 0x14, 0x4b, 0x61, 0x72, 0x70, + 0x65, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x16, + 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0xc5, 0x04, 0x0a, 0x0f, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x12, 0x49, 0x0a, 0x12, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, - 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x73, 0x65, - 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, - 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x42, 0x16, 0x0a, 0x14, 0x5f, 0x61, 0x6e, 0x6e, 0x6f, - 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, - 0x94, 0x04, 0x0a, 0x1a, 0x50, 0x6f, 0x64, 0x44, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x23, - 0x0a, 0x0d, 0x6d, 0x69, 0x6e, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, - 0x62, 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f, 0x75, 0x6e, 0x61, 0x76, 0x61, - 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x6d, 0x61, - 0x78, 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0f, - 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x65, - 0x61, 0x6c, 0x74, 0x68, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, - 0x5f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, - 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x12, 0x2f, - 0x0a, 0x13, 0x64, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x61, 0x6c, - 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x64, 0x69, 0x73, - 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x12, - 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x6f, 0x64, 0x73, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, - 0x50, 0x6f, 0x64, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x5f, 0x0a, 0x0f, - 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, - 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, - 0x6f, 0x64, 0x44, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, - 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, - 0x6f, 0x72, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x73, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x44, 0x0a, - 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x44, 0x69, - 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, 0x43, 0x6f, - 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x1a, 0x41, 0x0a, 0x13, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x4c, - 0x61, 0x62, 0x65, 0x6c, 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, 0xae, 0x01, 0x0a, 0x1c, 0x50, 0x6f, 0x64, 0x44, 0x69, - 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, 0x43, 0x6f, + 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x48, 0x00, 0x52, + 0x11, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x88, 0x01, 0x01, 0x12, 0x47, 0x0a, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x48, 0x01, 0x52, 0x10, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x88, 0x01, 0x01, 0x12, 0x36, + 0x0a, 0x0b, 0x6b, 0x69, 0x6e, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0d, 0x20, + 0x03, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, + 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x0a, 0x6b, 0x69, 0x6e, 0x64, + 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x50, 0x61, 0x74, 0x74, 0x65, + 0x72, 0x6e, 0x48, 0x02, 0x52, 0x0b, 0x6e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x74, 0x74, 0x65, 0x72, + 0x6e, 0x88, 0x01, 0x01, 0x12, 0x4b, 0x0a, 0x13, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, + 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x48, 0x03, 0x52, 0x12, 0x61, 0x6e, 0x6e, 0x6f, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x88, 0x01, + 0x01, 0x12, 0x25, 0x0a, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, + 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x15, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, + 0x65, 0x73, 0x12, 0x34, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x1e, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, + 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x15, 0x0a, 0x13, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, + 0x14, 0x0a, 0x12, 0x5f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x73, 0x65, 0x6c, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x42, 0x16, 0x0a, 0x14, 0x5f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x94, + 0x04, 0x0a, 0x1a, 0x50, 0x6f, 0x64, 0x44, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x23, 0x0a, + 0x0d, 0x6d, 0x69, 0x6e, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, + 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f, 0x75, 0x6e, 0x61, 0x76, 0x61, 0x69, + 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x6d, 0x61, 0x78, + 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, + 0x6c, 0x74, 0x68, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x5f, + 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x64, + 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x12, 0x2f, 0x0a, + 0x13, 0x64, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x64, 0x69, 0x73, 0x72, + 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x12, 0x23, + 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, + 0x6f, 0x64, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x5f, 0x0a, 0x0f, 0x73, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x08, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, + 0x64, 0x44, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, 0x65, + 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x73, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x44, 0x0a, 0x0a, + 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x44, 0x69, 0x73, + 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x1a, 0x41, 0x0a, 0x13, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x4c, 0x61, + 0x62, 0x65, 0x6c, 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, 0xae, 0x01, 0x0a, 0x1c, 0x50, 0x6f, 0x64, 0x44, 0x69, 0x73, + 0x72, 0x75, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xa3, 0x04, 0x0a, 0x14, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, + 0x4d, 0x0a, 0x0b, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x2e, 0x48, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0a, 0x68, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x3a, + 0x0a, 0x04, 0x75, 0x73, 0x65, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, + 0x6f, 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x55, 0x73, 0x65, 0x64, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x75, 0x73, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, + 0x6f, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x73, 0x12, 0x56, 0x0a, 0x0e, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x73, 0x65, 0x6c, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, + 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x53, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x73, 0x63, 0x6f, + 0x70, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x12, 0x3e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x43, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x48, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x6d, 0x69, 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, 0x37, 0x0a, 0x09, 0x55, 0x73, 0x65, 0x64, 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, 0x53, 0x63, + 0x6f, 0x70, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 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, 0xa8, 0x01, 0x0a, + 0x16, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, @@ -15846,452 +16841,461 @@ var file_api_v1_common_proto_rawDesc = []byte{ 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xa3, 0x04, 0x0a, 0x14, 0x52, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x12, 0x4d, 0x0a, 0x0b, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x2e, 0x48, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x0a, 0x68, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, - 0x3a, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, - 0x75, 0x6f, 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x55, 0x73, 0x65, 0x64, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x75, 0x73, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, - 0x63, 0x6f, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x63, 0x6f, - 0x70, 0x65, 0x73, 0x12, 0x56, 0x0a, 0x0e, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x73, 0x65, 0x6c, - 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, - 0x74, 0x61, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x53, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x73, 0x63, - 0x6f, 0x70, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x73, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x12, 0x3e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x43, 0x6f, - 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x48, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x6d, 0x69, 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, 0x37, 0x0a, 0x09, 0x55, 0x73, 0x65, 0x64, 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, 0x53, - 0x63, 0x6f, 0x70, 0x65, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 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, 0xa8, 0x01, - 0x0a, 0x16, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x43, - 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, - 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xc1, 0x02, 0x0a, 0x11, 0x56, 0x6f, 0x6c, - 0x63, 0x61, 0x6e, 0x6f, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, - 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, - 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x4a, 0x6f, - 0x62, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x75, 0x65, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x71, 0x75, 0x65, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0d, - 0x6d, 0x69, 0x6e, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, - 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x70, 0x6f, - 0x6c, 0x69, 0x63, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x63, 0x68, 0x65, - 0x64, 0x75, 0x6c, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x72, - 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0d, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6c, 0x61, 0x73, - 0x73, 0x12, 0x29, 0x0a, 0x05, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, - 0x6f, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x05, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x22, 0xa5, 0x01, 0x0a, - 0x13, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x4a, 0x6f, 0x62, 0x43, 0x6f, 0x6e, 0x64, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, - 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x54, 0x69, 0x6d, 0x65, 0x22, 0x78, 0x0a, 0x0b, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x54, - 0x61, 0x73, 0x6b, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, - 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x22, 0x8f, - 0x06, 0x0a, 0x17, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, - 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x5f, 0x76, - 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x70, - 0x61, 0x72, 0x6b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x70, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x5f, - 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, - 0x6f, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x69, 0x6e, 0x5f, 0x63, - 0x6c, 0x61, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x69, 0x6e, - 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6d, 0x61, 0x69, 0x6e, 0x5f, 0x61, 0x70, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x6d, 0x61, 0x69, 0x6e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x72, 0x67, - 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x72, - 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x43, 0x0a, 0x11, 0x73, 0x70, 0x61, 0x72, 0x6b, - 0x5f, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x08, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, - 0x6b, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0f, 0x73, 0x70, 0x61, - 0x72, 0x6b, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x12, - 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, - 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, - 0x6f, 0x72, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x65, - 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x10, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x52, - 0x65, 0x61, 0x64, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x10, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x12, 0x30, 0x0a, 0x14, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x12, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x75, 0x62, 0x6d, - 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x75, 0x73, 0x70, - 0x65, 0x6e, 0x64, 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x73, 0x75, 0x73, - 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x12, 0x45, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x52, 0x65, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, - 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x51, 0x0a, - 0x12, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x41, - 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x11, 0x64, - 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x22, 0xdc, 0x02, 0x0a, 0x0f, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, - 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, - 0x2d, 0x0a, 0x13, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x77, 0x65, - 0x62, 0x55, 0x69, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x24, - 0x0a, 0x0e, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x77, 0x65, 0x62, 0x55, 0x69, 0x41, 0x64, 0x64, - 0x72, 0x65, 0x73, 0x73, 0x12, 0x1e, 0x0a, 0x0b, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x70, - 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x77, 0x65, 0x62, 0x55, 0x69, - 0x50, 0x6f, 0x72, 0x74, 0x12, 0x2d, 0x0a, 0x13, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x69, - 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x10, 0x77, 0x65, 0x62, 0x55, 0x69, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x4e, - 0x61, 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x69, 0x6e, - 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x13, 0x77, 0x65, 0x62, 0x55, 0x69, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, - 0x73, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x72, 0x65, - 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x16, - 0x0a, 0x06, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0e, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, - 0xa8, 0x02, 0x0a, 0x16, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x2c, - 0x0a, 0x12, 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x74, - 0x72, 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x6f, 0x6e, 0x46, 0x61, - 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x19, - 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x79, - 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x16, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x74, 0x72, 0x79, 0x49, - 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x41, 0x0a, 0x1d, 0x6f, 0x6e, 0x5f, 0x73, 0x75, - 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, - 0x5f, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x1a, - 0x6f, 0x6e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, - 0x75, 0x72, 0x65, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x4e, 0x0a, 0x24, 0x6f, 0x6e, - 0x5f, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, - 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, - 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x20, 0x6f, 0x6e, 0x53, 0x75, 0x62, 0x6d, - 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x74, - 0x72, 0x79, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x22, 0xa1, 0x02, 0x0a, 0x1a, 0x53, - 0x70, 0x61, 0x72, 0x6b, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, - 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, - 0x6c, 0x65, 0x64, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x65, - 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, - 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, - 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x69, 0x6e, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, - 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x45, 0x78, 0x65, 0x63, - 0x75, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x5f, 0x65, 0x78, 0x65, - 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6d, 0x61, - 0x78, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x38, 0x0a, 0x18, 0x73, 0x68, - 0x75, 0x66, 0x66, 0x6c, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x5f, 0x65, - 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x73, 0x68, - 0x75, 0x66, 0x66, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x61, - 0x62, 0x6c, 0x65, 0x64, 0x12, 0x38, 0x0a, 0x18, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x5f, - 0x74, 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x16, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x54, - 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0xad, - 0x05, 0x0a, 0x20, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x53, 0x70, 0x61, 0x72, - 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, - 0x1b, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x1c, 0x0a, 0x09, - 0x73, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x09, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x6f, - 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, - 0x6e, 0x63, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x3f, 0x0a, 0x1c, 0x73, 0x75, 0x63, - 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x68, 0x69, 0x73, 0x74, - 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x19, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x52, 0x75, 0x6e, 0x48, 0x69, - 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x37, 0x0a, 0x18, 0x66, 0x61, - 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, - 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x66, 0x61, - 0x69, 0x6c, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4c, 0x69, - 0x6d, 0x69, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x5f, - 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x73, 0x63, 0x68, - 0x65, 0x64, 0x75, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x6c, 0x61, - 0x73, 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x35, - 0x0a, 0x08, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x09, 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, 0x07, 0x6c, 0x61, - 0x73, 0x74, 0x52, 0x75, 0x6e, 0x12, 0x35, 0x0a, 0x08, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x72, 0x75, - 0x6e, 0x18, 0x0a, 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, 0x07, 0x6e, 0x65, 0x78, 0x74, 0x52, 0x75, 0x6e, 0x12, 0x39, 0x0a, 0x19, - 0x70, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x5f, - 0x72, 0x75, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x16, 0x70, 0x61, 0x73, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x52, - 0x75, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x31, 0x0a, 0x15, 0x70, 0x61, 0x73, 0x74, 0x5f, - 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x18, 0x0c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x12, 0x70, 0x61, 0x73, 0x74, 0x46, 0x61, 0x69, 0x6c, - 0x65, 0x64, 0x52, 0x75, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, - 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, - 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x10, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x5f, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x0f, 0x74, - 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x8b, - 0x08, 0x0a, 0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, - 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1b, 0x0a, - 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x77, - 0x6e, 0x65, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x77, 0x6e, - 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, - 0x77, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, - 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, - 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0c, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, - 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, - 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0e, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x74, 0x79, 0x70, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x12, 0x30, 0x0a, 0x14, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, - 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, - 0x6e, 0x64, 0x12, 0x30, 0x0a, 0x14, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x5f, 0x6f, - 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x12, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, - 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, - 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, - 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x12, 0x31, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, - 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x12, 0x2d, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, - 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x11, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, - 0x63, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, - 0x18, 0x29, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xc1, 0x02, 0x0a, 0x11, 0x56, 0x6f, 0x6c, 0x63, + 0x61, 0x6e, 0x6f, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, + 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x4a, 0x6f, 0x62, + 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x75, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x71, 0x75, 0x65, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6d, + 0x69, 0x6e, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, + 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x70, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x63, 0x68, 0x65, 0x64, + 0x75, 0x6c, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x72, 0x69, + 0x6f, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0d, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, + 0x12, 0x29, 0x0a, 0x05, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, + 0x54, 0x61, 0x73, 0x6b, 0x52, 0x05, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x22, 0xa5, 0x01, 0x0a, 0x13, + 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x4a, 0x6f, 0x62, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, + 0x69, 0x6d, 0x65, 0x22, 0x78, 0x0a, 0x0b, 0x56, 0x6f, 0x6c, 0x63, 0x61, 0x6e, 0x6f, 0x54, 0x61, + 0x73, 0x6b, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, + 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x22, 0x8f, 0x06, + 0x0a, 0x17, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x5f, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x70, 0x61, + 0x72, 0x6b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x5f, 0x6d, + 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, + 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x69, 0x6e, 0x5f, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x69, 0x6e, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6d, 0x61, 0x69, 0x6e, 0x5f, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x13, 0x6d, 0x61, 0x69, 0x6e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x72, 0x67, 0x75, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x72, 0x67, + 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x43, 0x0a, 0x11, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x5f, + 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, + 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0f, 0x73, 0x70, 0x61, 0x72, + 0x6b, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x12, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, + 0x72, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x10, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x0e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, + 0x61, 0x64, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x12, 0x30, 0x0a, 0x14, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, + 0x73, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x5f, 0x69, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x75, 0x62, 0x6d, 0x69, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x75, 0x73, 0x70, 0x65, + 0x6e, 0x64, 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x73, 0x75, 0x73, 0x70, + 0x65, 0x6e, 0x64, 0x65, 0x64, 0x12, 0x45, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x72, + 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x51, 0x0a, 0x12, + 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x41, 0x6c, + 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x11, 0x64, 0x79, + 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0xdc, 0x02, 0x0a, 0x0f, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x44, 0x72, 0x69, 0x76, 0x65, 0x72, 0x49, + 0x6e, 0x66, 0x6f, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2d, + 0x0a, 0x13, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x77, 0x65, 0x62, + 0x55, 0x69, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x24, 0x0a, + 0x0e, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x77, 0x65, 0x62, 0x55, 0x69, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x12, 0x1e, 0x0a, 0x0b, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x70, 0x6f, + 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x77, 0x65, 0x62, 0x55, 0x69, 0x50, + 0x6f, 0x72, 0x74, 0x12, 0x2d, 0x0a, 0x13, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x69, 0x6e, + 0x67, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x10, 0x77, 0x65, 0x62, 0x55, 0x69, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x77, 0x65, 0x62, 0x5f, 0x75, 0x69, 0x5f, 0x69, 0x6e, 0x67, + 0x72, 0x65, 0x73, 0x73, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x13, 0x77, 0x65, 0x62, 0x55, 0x69, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x72, 0x65, 0x73, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x16, 0x0a, + 0x06, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, + 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xa8, + 0x02, 0x0a, 0x16, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x2c, 0x0a, + 0x12, 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x74, 0x72, + 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x6f, 0x6e, 0x46, 0x61, 0x69, + 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x19, 0x6f, + 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x16, + 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x74, 0x72, 0x79, 0x49, 0x6e, + 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x41, 0x0a, 0x1d, 0x6f, 0x6e, 0x5f, 0x73, 0x75, 0x62, + 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, + 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x1a, 0x6f, + 0x6e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x4e, 0x0a, 0x24, 0x6f, 0x6e, 0x5f, + 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, + 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x20, 0x6f, 0x6e, 0x53, 0x75, 0x62, 0x6d, 0x69, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x74, 0x72, + 0x79, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x22, 0xa1, 0x02, 0x0a, 0x1a, 0x53, 0x70, + 0x61, 0x72, 0x6b, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, + 0x65, 0x64, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x12, + 0x23, 0x0a, 0x0d, 0x6d, 0x69, 0x6e, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x6f, 0x72, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x5f, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6d, 0x61, 0x78, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x38, 0x0a, 0x18, 0x73, 0x68, 0x75, + 0x66, 0x66, 0x6c, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x5f, 0x65, 0x6e, + 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x73, 0x68, 0x75, + 0x66, 0x66, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x64, 0x12, 0x38, 0x0a, 0x18, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x5f, 0x74, + 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x16, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x54, 0x72, + 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0xad, 0x05, + 0x0a, 0x20, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x53, 0x70, 0x61, 0x72, 0x6b, + 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x1b, + 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, + 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, + 0x73, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x6f, 0x6e, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x3f, 0x0a, 0x1c, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x68, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x19, + 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x52, 0x75, 0x6e, 0x48, 0x69, 0x73, + 0x74, 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x37, 0x0a, 0x18, 0x66, 0x61, 0x69, + 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x5f, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x66, 0x61, 0x69, + 0x6c, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, + 0x69, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x73, 0x63, 0x68, 0x65, + 0x64, 0x75, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x6c, 0x61, 0x73, + 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, + 0x08, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x09, 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, 0x07, 0x6c, 0x61, 0x73, + 0x74, 0x52, 0x75, 0x6e, 0x12, 0x35, 0x0a, 0x08, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x72, 0x75, 0x6e, + 0x18, 0x0a, 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, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, - 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x2a, 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, 0x09, 0x75, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x37, 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, - 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x18, 0x2b, 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, 0x08, 0x6c, 0x61, 0x73, 0x74, 0x53, 0x65, 0x65, - 0x6e, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x5f, - 0x61, 0x67, 0x65, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x64, 0x41, 0x74, 0x41, 0x67, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x75, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x64, 0x5f, 0x61, 0x74, 0x5f, 0x61, 0x67, 0x65, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x41, 0x67, 0x65, 0x12, 0x22, 0x0a, - 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x5f, 0x61, 0x67, 0x65, 0x18, 0x2e, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x53, 0x65, 0x65, 0x6e, 0x41, 0x67, - 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, - 0x2f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x6d, 0x70, 0x52, 0x07, 0x6e, 0x65, 0x78, 0x74, 0x52, 0x75, 0x6e, 0x12, 0x39, 0x0a, 0x19, 0x70, + 0x61, 0x73, 0x74, 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x5f, 0x72, + 0x75, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, + 0x70, 0x61, 0x73, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x52, 0x75, + 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x31, 0x0a, 0x15, 0x70, 0x61, 0x73, 0x74, 0x5f, 0x66, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, + 0x0c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x12, 0x70, 0x61, 0x73, 0x74, 0x46, 0x61, 0x69, 0x6c, 0x65, + 0x64, 0x52, 0x75, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x12, 0x4a, 0x0a, 0x10, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x5f, 0x64, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x0f, 0x74, 0x65, + 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0xab, 0x0a, + 0x0a, 0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x0a, + 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, + 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x77, 0x6e, + 0x65, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, + 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x77, 0x6e, 0x65, + 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x77, + 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x70, 0x69, 0x5f, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x70, + 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0c, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0e, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, + 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, + 0x30, 0x0a, 0x14, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x69, + 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, + 0x64, 0x12, 0x30, 0x0a, 0x14, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x5f, 0x6f, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x12, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x5f, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, + 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, + 0x31, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x72, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x12, 0x2d, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x5f, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, + 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, + 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x17, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x31, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x18, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, + 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, + 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x19, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x11, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x4f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x55, 0x69, 0x64, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x5f, 0x61, 0x74, 0x18, 0x29, 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, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, + 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, + 0x2a, 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, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0xc9, 0x01, 0x0a, - 0x12, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x49, - 0x6e, 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 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, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x12, 0x1d, - 0x0a, 0x0a, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, - 0x0a, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x75, 0x0a, 0x0e, 0x45, 0x76, 0x65, 0x6e, + 0x70, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x37, 0x0a, 0x09, + 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x18, 0x2b, 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, 0x08, 0x6c, 0x61, 0x73, + 0x74, 0x53, 0x65, 0x65, 0x6e, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x5f, 0x61, 0x74, 0x5f, 0x61, 0x67, 0x65, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x41, 0x67, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x5f, 0x61, 0x67, 0x65, 0x18, 0x2d, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x41, 0x67, + 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x5f, 0x61, + 0x67, 0x65, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x53, 0x65, + 0x65, 0x6e, 0x41, 0x67, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, + 0x5f, 0x61, 0x74, 0x18, 0x2f, 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, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, + 0x1a, 0x3e, 0x0a, 0x10, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 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, 0xc9, 0x01, 0x0a, 0x12, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 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, + 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x69, 0x64, 0x12, 0x1d, 0x0a, + 0x0a, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, 0x0a, + 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, + 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0xe4, 0x01, 0x0a, 0x0e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x75, 0x74, 0x63, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x75, 0x74, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x32, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, - 0x69, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2a, - 0xc5, 0x0a, 0x0a, 0x0d, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, - 0x64, 0x12, 0x1f, 0x0a, 0x1b, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, - 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, - 0x10, 0x00, 0x12, 0x1e, 0x0a, 0x1a, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, - 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, - 0x10, 0x01, 0x12, 0x1f, 0x0a, 0x1b, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, - 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x52, 0x45, 0x50, 0x4c, 0x49, 0x43, 0x41, 0x5f, 0x53, 0x45, - 0x54, 0x10, 0x02, 0x12, 0x20, 0x0a, 0x1c, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, - 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x46, 0x55, 0x4c, 0x5f, - 0x53, 0x45, 0x54, 0x10, 0x03, 0x12, 0x1e, 0x0a, 0x1a, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, - 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x44, 0x41, 0x45, 0x4d, 0x4f, 0x4e, 0x5f, - 0x53, 0x45, 0x54, 0x10, 0x04, 0x12, 0x17, 0x0a, 0x13, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, - 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4a, 0x4f, 0x42, 0x10, 0x05, 0x12, 0x1c, - 0x0a, 0x18, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, - 0x44, 0x5f, 0x43, 0x52, 0x4f, 0x4e, 0x5f, 0x4a, 0x4f, 0x42, 0x10, 0x06, 0x12, 0x2a, 0x0a, 0x26, + 0x69, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, + 0x21, 0x0a, 0x0c, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x77, 0x61, 0x72, 0x6e, 0x69, + 0x6e, 0x67, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x72, 0x69, 0x74, 0x69, + 0x63, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0d, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5c, + 0x0a, 0x0e, 0x44, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1e, 0x0a, 0x0a, + 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x22, 0xe9, 0x02, 0x0a, + 0x0a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x72, + 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x77, + 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x6f, 0x64, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, + 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x12, 0x39, 0x0a, 0x0a, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x18, 0x08, + 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, 0x09, 0x66, 0x69, 0x72, 0x73, 0x74, 0x53, 0x65, 0x65, 0x6e, 0x12, 0x37, 0x0a, 0x09, 0x6c, + 0x61, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x18, 0x09, 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, 0x08, 0x6c, 0x61, 0x73, 0x74, + 0x53, 0x65, 0x65, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x2a, 0xc5, 0x0a, 0x0a, 0x0d, 0x4b, 0x38, 0x73, + 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1f, 0x0a, 0x1b, 0x4b, 0x38, + 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x55, 0x4e, + 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1e, 0x0a, 0x1a, 0x4b, + 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x44, + 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x10, 0x01, 0x12, 0x1f, 0x0a, 0x1b, 0x4b, + 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x52, + 0x45, 0x50, 0x4c, 0x49, 0x43, 0x41, 0x5f, 0x53, 0x45, 0x54, 0x10, 0x02, 0x12, 0x20, 0x0a, 0x1c, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, - 0x52, 0x45, 0x50, 0x4c, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x54, - 0x52, 0x4f, 0x4c, 0x4c, 0x45, 0x52, 0x10, 0x07, 0x12, 0x17, 0x0a, 0x13, 0x4b, 0x38, 0x53, 0x5f, - 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x50, 0x4f, 0x44, 0x10, - 0x08, 0x12, 0x1d, 0x0a, 0x19, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, - 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x53, 0x50, 0x41, 0x43, 0x45, 0x10, 0x09, - 0x12, 0x18, 0x0a, 0x14, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, - 0x49, 0x4e, 0x44, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x10, 0x0a, 0x12, 0x1b, 0x0a, 0x17, 0x4b, 0x38, - 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x49, 0x4e, - 0x47, 0x52, 0x45, 0x53, 0x53, 0x10, 0x0b, 0x12, 0x1d, 0x0a, 0x19, 0x4b, 0x38, 0x53, 0x5f, 0x4f, - 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x41, - 0x49, 0x4e, 0x45, 0x52, 0x10, 0x0c, 0x12, 0x1b, 0x0a, 0x17, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, - 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, - 0x45, 0x10, 0x0d, 0x12, 0x1e, 0x0a, 0x1a, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, - 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x4d, 0x41, - 0x50, 0x10, 0x0e, 0x12, 0x25, 0x0a, 0x21, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, - 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x50, 0x45, 0x52, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, - 0x54, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x10, 0x0f, 0x12, 0x2b, 0x0a, 0x27, 0x4b, 0x38, - 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x50, 0x45, - 0x52, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x54, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x5f, - 0x43, 0x4c, 0x41, 0x49, 0x4d, 0x10, 0x10, 0x12, 0x21, 0x0a, 0x1d, 0x4b, 0x38, 0x53, 0x5f, 0x4f, - 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x4f, 0x52, 0x41, - 0x47, 0x45, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x10, 0x11, 0x12, 0x20, 0x0a, 0x1c, 0x4b, 0x38, - 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x41, 0x52, - 0x47, 0x4f, 0x5f, 0x52, 0x4f, 0x4c, 0x4c, 0x4f, 0x55, 0x54, 0x10, 0x12, 0x12, 0x2d, 0x0a, 0x29, + 0x53, 0x54, 0x41, 0x54, 0x45, 0x46, 0x55, 0x4c, 0x5f, 0x53, 0x45, 0x54, 0x10, 0x03, 0x12, 0x1e, + 0x0a, 0x1a, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, + 0x44, 0x5f, 0x44, 0x41, 0x45, 0x4d, 0x4f, 0x4e, 0x5f, 0x53, 0x45, 0x54, 0x10, 0x04, 0x12, 0x17, + 0x0a, 0x13, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, + 0x44, 0x5f, 0x4a, 0x4f, 0x42, 0x10, 0x05, 0x12, 0x1c, 0x0a, 0x18, 0x4b, 0x38, 0x53, 0x5f, 0x4f, + 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x43, 0x52, 0x4f, 0x4e, 0x5f, + 0x4a, 0x4f, 0x42, 0x10, 0x06, 0x12, 0x2a, 0x0a, 0x26, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, + 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x52, 0x45, 0x50, 0x4c, 0x49, 0x43, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x4f, 0x4c, 0x4c, 0x45, 0x52, 0x10, + 0x07, 0x12, 0x17, 0x0a, 0x13, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, + 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x50, 0x4f, 0x44, 0x10, 0x08, 0x12, 0x1d, 0x0a, 0x19, 0x4b, 0x38, + 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4e, 0x41, + 0x4d, 0x45, 0x53, 0x50, 0x41, 0x43, 0x45, 0x10, 0x09, 0x12, 0x18, 0x0a, 0x14, 0x4b, 0x38, 0x53, + 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4e, 0x4f, 0x44, + 0x45, 0x10, 0x0a, 0x12, 0x1b, 0x0a, 0x17, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, + 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x49, 0x4e, 0x47, 0x52, 0x45, 0x53, 0x53, 0x10, 0x0b, + 0x12, 0x1d, 0x0a, 0x19, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, + 0x49, 0x4e, 0x44, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x45, 0x52, 0x10, 0x0c, 0x12, + 0x1b, 0x0a, 0x17, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, + 0x4e, 0x44, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x10, 0x0d, 0x12, 0x1e, 0x0a, 0x1a, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, - 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x4f, 0x4e, 0x54, 0x41, 0x4c, 0x5f, 0x50, 0x4f, 0x44, 0x5f, 0x41, - 0x55, 0x54, 0x4f, 0x53, 0x43, 0x41, 0x4c, 0x45, 0x52, 0x10, 0x13, 0x12, 0x2b, 0x0a, 0x27, 0x4b, - 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x56, - 0x45, 0x52, 0x54, 0x49, 0x43, 0x41, 0x4c, 0x5f, 0x50, 0x4f, 0x44, 0x5f, 0x41, 0x55, 0x54, 0x4f, - 0x53, 0x43, 0x41, 0x4c, 0x45, 0x52, 0x10, 0x14, 0x12, 0x1f, 0x0a, 0x1b, 0x4b, 0x38, 0x53, 0x5f, - 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4c, 0x49, 0x4d, 0x49, - 0x54, 0x5f, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x10, 0x15, 0x12, 0x23, 0x0a, 0x1f, 0x4b, 0x38, 0x53, - 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x45, 0x52, - 0x56, 0x49, 0x43, 0x45, 0x5f, 0x41, 0x43, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x10, 0x16, 0x12, 0x18, - 0x0a, 0x14, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, - 0x44, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x10, 0x17, 0x12, 0x20, 0x0a, 0x1c, 0x4b, 0x38, 0x53, 0x5f, - 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x52, 0x4f, 0x4c, 0x45, - 0x5f, 0x42, 0x49, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x18, 0x12, 0x26, 0x0a, 0x22, 0x4b, 0x38, - 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4b, 0x45, - 0x44, 0x41, 0x5f, 0x53, 0x43, 0x41, 0x4c, 0x45, 0x44, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, - 0x10, 0x19, 0x12, 0x26, 0x0a, 0x22, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, - 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4b, 0x41, 0x52, 0x50, 0x45, 0x4e, 0x54, 0x45, 0x52, 0x5f, - 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x1a, 0x12, 0x29, 0x0a, 0x25, 0x4b, 0x38, - 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x50, 0x4f, - 0x44, 0x5f, 0x44, 0x49, 0x53, 0x52, 0x55, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x42, 0x55, 0x44, - 0x47, 0x45, 0x54, 0x10, 0x1b, 0x12, 0x22, 0x0a, 0x1e, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, - 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, - 0x45, 0x5f, 0x51, 0x55, 0x4f, 0x54, 0x41, 0x10, 0x1c, 0x12, 0x25, 0x0a, 0x21, 0x4b, 0x38, 0x53, - 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4b, 0x55, 0x42, - 0x45, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4e, 0x4f, 0x54, 0x45, 0x42, 0x4f, 0x4f, 0x4b, 0x10, 0x1d, - 0x12, 0x1f, 0x0a, 0x1b, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, - 0x49, 0x4e, 0x44, 0x5f, 0x56, 0x4f, 0x4c, 0x43, 0x41, 0x4e, 0x4f, 0x5f, 0x4a, 0x4f, 0x42, 0x10, - 0x1e, 0x12, 0x1a, 0x0a, 0x16, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, - 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x45, 0x43, 0x52, 0x45, 0x54, 0x10, 0x1f, 0x12, 0x20, 0x0a, - 0x1c, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, - 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x10, 0x20, 0x12, - 0x28, 0x0a, 0x24, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, - 0x4e, 0x44, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, - 0x42, 0x49, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x21, 0x12, 0x22, 0x0a, 0x1e, 0x4b, 0x38, 0x53, - 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4e, 0x45, 0x54, - 0x57, 0x4f, 0x52, 0x4b, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x10, 0x22, 0x12, 0x20, 0x0a, - 0x1c, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, - 0x5f, 0x43, 0x4e, 0x50, 0x47, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x10, 0x23, 0x12, - 0x25, 0x0a, 0x21, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, - 0x4e, 0x44, 0x5f, 0x53, 0x50, 0x41, 0x52, 0x4b, 0x5f, 0x41, 0x50, 0x50, 0x4c, 0x49, 0x43, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x24, 0x12, 0x2f, 0x0a, 0x2b, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, - 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x43, 0x48, 0x45, 0x44, 0x55, - 0x4c, 0x45, 0x44, 0x5f, 0x53, 0x50, 0x41, 0x52, 0x4b, 0x5f, 0x41, 0x50, 0x50, 0x4c, 0x49, 0x43, - 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x25, 0x2a, 0x48, 0x0a, 0x0b, 0x4f, 0x72, 0x64, 0x65, 0x72, - 0x42, 0x79, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x22, 0x0a, 0x1e, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x5f, - 0x42, 0x59, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x44, 0x45, 0x53, 0x43, 0x5f, 0x55, 0x4e, 0x53, - 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x52, - 0x44, 0x45, 0x52, 0x5f, 0x42, 0x59, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x41, 0x53, 0x43, 0x10, - 0x01, 0x2a, 0x94, 0x02, 0x0a, 0x15, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, - 0x74, 0x6f, 0x72, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x27, 0x0a, 0x23, 0x4c, - 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, - 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, - 0x45, 0x44, 0x10, 0x00, 0x12, 0x1e, 0x0a, 0x1a, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, - 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, - 0x49, 0x4e, 0x10, 0x01, 0x12, 0x22, 0x0a, 0x1e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, + 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x4d, 0x41, 0x50, 0x10, 0x0e, 0x12, 0x25, 0x0a, 0x21, + 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, + 0x50, 0x45, 0x52, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x54, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, + 0x45, 0x10, 0x0f, 0x12, 0x2b, 0x0a, 0x27, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, + 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x50, 0x45, 0x52, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, + 0x54, 0x5f, 0x56, 0x4f, 0x4c, 0x55, 0x4d, 0x45, 0x5f, 0x43, 0x4c, 0x41, 0x49, 0x4d, 0x10, 0x10, + 0x12, 0x21, 0x0a, 0x1d, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, + 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x54, 0x4f, 0x52, 0x41, 0x47, 0x45, 0x5f, 0x43, 0x4c, 0x41, 0x53, + 0x53, 0x10, 0x11, 0x12, 0x20, 0x0a, 0x1c, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, + 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x41, 0x52, 0x47, 0x4f, 0x5f, 0x52, 0x4f, 0x4c, 0x4c, + 0x4f, 0x55, 0x54, 0x10, 0x12, 0x12, 0x2d, 0x0a, 0x29, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, + 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x4f, 0x4e, + 0x54, 0x41, 0x4c, 0x5f, 0x50, 0x4f, 0x44, 0x5f, 0x41, 0x55, 0x54, 0x4f, 0x53, 0x43, 0x41, 0x4c, + 0x45, 0x52, 0x10, 0x13, 0x12, 0x2b, 0x0a, 0x27, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, + 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x56, 0x45, 0x52, 0x54, 0x49, 0x43, 0x41, 0x4c, + 0x5f, 0x50, 0x4f, 0x44, 0x5f, 0x41, 0x55, 0x54, 0x4f, 0x53, 0x43, 0x41, 0x4c, 0x45, 0x52, 0x10, + 0x14, 0x12, 0x1f, 0x0a, 0x1b, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, + 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4c, 0x49, 0x4d, 0x49, 0x54, 0x5f, 0x52, 0x41, 0x4e, 0x47, 0x45, + 0x10, 0x15, 0x12, 0x23, 0x0a, 0x1f, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, + 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x41, 0x43, + 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x10, 0x16, 0x12, 0x18, 0x0a, 0x14, 0x4b, 0x38, 0x53, 0x5f, 0x4f, + 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x10, + 0x17, 0x12, 0x20, 0x0a, 0x1c, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, + 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x42, 0x49, 0x4e, 0x44, 0x49, 0x4e, + 0x47, 0x10, 0x18, 0x12, 0x26, 0x0a, 0x22, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, + 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4b, 0x45, 0x44, 0x41, 0x5f, 0x53, 0x43, 0x41, 0x4c, + 0x45, 0x44, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x19, 0x12, 0x26, 0x0a, 0x22, 0x4b, + 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4b, + 0x41, 0x52, 0x50, 0x45, 0x4e, 0x54, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, + 0x45, 0x10, 0x1a, 0x12, 0x29, 0x0a, 0x25, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, + 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x50, 0x4f, 0x44, 0x5f, 0x44, 0x49, 0x53, 0x52, 0x55, + 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x42, 0x55, 0x44, 0x47, 0x45, 0x54, 0x10, 0x1b, 0x12, 0x22, + 0x0a, 0x1e, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, + 0x44, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x51, 0x55, 0x4f, 0x54, 0x41, + 0x10, 0x1c, 0x12, 0x25, 0x0a, 0x21, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, + 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4b, 0x55, 0x42, 0x45, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4e, + 0x4f, 0x54, 0x45, 0x42, 0x4f, 0x4f, 0x4b, 0x10, 0x1d, 0x12, 0x1f, 0x0a, 0x1b, 0x4b, 0x38, 0x53, + 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x56, 0x4f, 0x4c, + 0x43, 0x41, 0x4e, 0x4f, 0x5f, 0x4a, 0x4f, 0x42, 0x10, 0x1e, 0x12, 0x1a, 0x0a, 0x16, 0x4b, 0x38, + 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x45, + 0x43, 0x52, 0x45, 0x54, 0x10, 0x1f, 0x12, 0x20, 0x0a, 0x1c, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, + 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, + 0x52, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x10, 0x20, 0x12, 0x28, 0x0a, 0x24, 0x4b, 0x38, 0x53, 0x5f, + 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x43, 0x4c, 0x55, 0x53, + 0x54, 0x45, 0x52, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x42, 0x49, 0x4e, 0x44, 0x49, 0x4e, 0x47, + 0x10, 0x21, 0x12, 0x22, 0x0a, 0x1e, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, + 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4e, 0x45, 0x54, 0x57, 0x4f, 0x52, 0x4b, 0x5f, 0x50, 0x4f, + 0x4c, 0x49, 0x43, 0x59, 0x10, 0x22, 0x12, 0x20, 0x0a, 0x1c, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, + 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x43, 0x4e, 0x50, 0x47, 0x5f, 0x43, + 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x10, 0x23, 0x12, 0x25, 0x0a, 0x21, 0x4b, 0x38, 0x53, 0x5f, + 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x50, 0x41, 0x52, + 0x4b, 0x5f, 0x41, 0x50, 0x50, 0x4c, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x24, 0x12, + 0x2f, 0x0a, 0x2b, 0x4b, 0x38, 0x53, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4b, 0x49, + 0x4e, 0x44, 0x5f, 0x53, 0x43, 0x48, 0x45, 0x44, 0x55, 0x4c, 0x45, 0x44, 0x5f, 0x53, 0x50, 0x41, + 0x52, 0x4b, 0x5f, 0x41, 0x50, 0x50, 0x4c, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x25, + 0x2a, 0x48, 0x0a, 0x0b, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x42, 0x79, 0x45, 0x6e, 0x75, 0x6d, 0x12, + 0x22, 0x0a, 0x1e, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x5f, 0x42, 0x59, 0x5f, 0x45, 0x4e, 0x55, 0x4d, + 0x5f, 0x44, 0x45, 0x53, 0x43, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, + 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x5f, 0x42, 0x59, 0x5f, + 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x41, 0x53, 0x43, 0x10, 0x01, 0x2a, 0x94, 0x02, 0x0a, 0x15, 0x4c, + 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x6f, 0x72, 0x12, 0x27, 0x0a, 0x23, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, - 0x4e, 0x4f, 0x54, 0x5f, 0x49, 0x4e, 0x10, 0x02, 0x12, 0x22, 0x0a, 0x1e, 0x4c, 0x41, 0x42, 0x45, - 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, - 0x54, 0x4f, 0x52, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x10, 0x03, 0x12, 0x2a, 0x0a, 0x26, - 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x4f, - 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, - 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, 0x04, 0x12, 0x1e, 0x0a, 0x1a, 0x4c, 0x41, 0x42, 0x45, - 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, - 0x54, 0x4f, 0x52, 0x5f, 0x47, 0x54, 0x10, 0x05, 0x12, 0x1e, 0x0a, 0x1a, 0x4c, 0x41, 0x42, 0x45, - 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, - 0x54, 0x4f, 0x52, 0x5f, 0x4c, 0x54, 0x10, 0x06, 0x2a, 0xa6, 0x01, 0x0a, 0x14, 0x57, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x46, 0x69, 0x6c, 0x74, 0x65, - 0x72, 0x12, 0x26, 0x0a, 0x22, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x53, 0x54, - 0x41, 0x54, 0x55, 0x53, 0x5f, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, - 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x21, 0x0a, 0x1d, 0x57, 0x4f, 0x52, + 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1e, 0x0a, + 0x1a, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, + 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x49, 0x4e, 0x10, 0x01, 0x12, 0x22, 0x0a, + 0x1e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, + 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x49, 0x4e, 0x10, + 0x02, 0x12, 0x22, 0x0a, 0x1e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, + 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x45, 0x58, 0x49, + 0x53, 0x54, 0x53, 0x10, 0x03, 0x12, 0x2a, 0x0a, 0x26, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, + 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, + 0x5f, 0x44, 0x4f, 0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, + 0x04, 0x12, 0x1e, 0x0a, 0x1a, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, + 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x47, 0x54, 0x10, + 0x05, 0x12, 0x1e, 0x0a, 0x1a, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, + 0x54, 0x4f, 0x52, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4c, 0x54, 0x10, + 0x06, 0x2a, 0xa6, 0x01, 0x0a, 0x14, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x22, 0x57, 0x4f, + 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x46, 0x49, + 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x21, 0x0a, 0x1d, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x43, 0x54, + 0x49, 0x56, 0x45, 0x10, 0x01, 0x12, 0x22, 0x0a, 0x1e, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, + 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, + 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x44, 0x10, 0x02, 0x12, 0x1f, 0x0a, 0x1b, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x46, 0x49, 0x4c, - 0x54, 0x45, 0x52, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x01, 0x12, 0x22, 0x0a, 0x1e, - 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, - 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x44, 0x10, 0x02, - 0x12, 0x1f, 0x0a, 0x1b, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x53, 0x54, 0x41, - 0x54, 0x55, 0x53, 0x5f, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x42, 0x4f, 0x54, 0x48, 0x10, - 0x03, 0x42, 0x84, 0x01, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x42, 0x0b, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, - 0x30, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x65, 0x76, 0x7a, - 0x65, 0x72, 0x6f, 0x2d, 0x69, 0x6e, 0x63, 0x2f, 0x7a, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, - 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x3b, 0x61, 0x70, 0x69, 0x76, - 0x31, 0xa2, 0x02, 0x03, 0x41, 0x58, 0x58, 0xaa, 0x02, 0x06, 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, - 0xca, 0x02, 0x06, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x12, 0x41, 0x70, 0x69, 0x5c, - 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, - 0x07, 0x41, 0x70, 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x54, 0x45, 0x52, 0x5f, 0x42, 0x4f, 0x54, 0x48, 0x10, 0x03, 0x42, 0x84, 0x01, 0x0a, 0x0a, 0x63, + 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x42, 0x0b, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x30, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x65, 0x76, 0x7a, 0x65, 0x72, 0x6f, 0x2d, 0x69, 0x6e, 0x63, + 0x2f, 0x7a, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x3b, 0x61, 0x70, 0x69, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x41, 0x58, 0x58, + 0xaa, 0x02, 0x06, 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, 0x41, 0x70, 0x69, 0x5c, + 0x56, 0x31, 0xe2, 0x02, 0x12, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x41, 0x70, 0x69, 0x3a, 0x3a, 0x56, + 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -16307,7 +17311,7 @@ func file_api_v1_common_proto_rawDescGZIP() []byte { } var file_api_v1_common_proto_enumTypes = make([]protoimpl.EnumInfo, 4) -var file_api_v1_common_proto_msgTypes = make([]protoimpl.MessageInfo, 163) +var file_api_v1_common_proto_msgTypes = make([]protoimpl.MessageInfo, 171) var file_api_v1_common_proto_goTypes = []interface{}{ (K8SObjectKind)(0), // 0: api.v1.K8sObjectKind (OrderByEnum)(0), // 1: api.v1.OrderByEnum @@ -16317,417 +17321,443 @@ var file_api_v1_common_proto_goTypes = []interface{}{ (*Pagination)(nil), // 5: api.v1.Pagination (*CostInfo)(nil), // 6: api.v1.CostInfo (*ResourceMetrics)(nil), // 7: api.v1.ResourceMetrics - (*ForecastResourceMetrics)(nil), // 8: api.v1.ForecastResourceMetrics - (*ResourceSummary)(nil), // 9: api.v1.ResourceSummary - (*WorkloadItem)(nil), // 10: api.v1.WorkloadItem - (*ContainerRuntimeInfo)(nil), // 11: api.v1.ContainerRuntimeInfo - (*NodeInfo)(nil), // 12: api.v1.NodeInfo - (*ResourceInfo)(nil), // 13: api.v1.ResourceInfo - (*Node)(nil), // 14: api.v1.Node - (*AttachedVolume)(nil), // 15: api.v1.AttachedVolume - (*NodeGroup)(nil), // 16: api.v1.NodeGroup - (*CostDataPoint)(nil), // 17: api.v1.CostDataPoint - (*ResourceDataPoint)(nil), // 18: api.v1.ResourceDataPoint - (*SavingsData)(nil), // 19: api.v1.SavingsData - (*SavingsDataPoint)(nil), // 20: api.v1.SavingsDataPoint - (*SavingsTimeSeries)(nil), // 21: api.v1.SavingsTimeSeries - (*LabelSelectorRequirement)(nil), // 22: api.v1.LabelSelectorRequirement - (*Label)(nil), // 23: api.v1.Label - (*LabelSelector)(nil), // 24: api.v1.LabelSelector - (*RegexPattern)(nil), // 25: api.v1.RegexPattern - (*ResourceDetails)(nil), // 26: api.v1.ResourceDetails - (*PodDetails)(nil), // 27: api.v1.PodDetails - (*ContainerSummary)(nil), // 28: api.v1.ContainerSummary - (*DeploymentDetails)(nil), // 29: api.v1.DeploymentDetails - (*ContainerTemplate)(nil), // 30: api.v1.ContainerTemplate - (*DeploymentCondition)(nil), // 31: api.v1.DeploymentCondition - (*StatefulSetDetails)(nil), // 32: api.v1.StatefulSetDetails - (*VolumeClaimTemplate)(nil), // 33: api.v1.VolumeClaimTemplate - (*DaemonSetDetails)(nil), // 34: api.v1.DaemonSetDetails - (*ReplicaSetDetails)(nil), // 35: api.v1.ReplicaSetDetails - (*JobDetails)(nil), // 36: api.v1.JobDetails - (*JobCondition)(nil), // 37: api.v1.JobCondition - (*CronJobDetails)(nil), // 38: api.v1.CronJobDetails - (*ActiveJobReference)(nil), // 39: api.v1.ActiveJobReference - (*JobTemplate)(nil), // 40: api.v1.JobTemplate - (*ServiceDetails)(nil), // 41: api.v1.ServiceDetails - (*ServicePort)(nil), // 42: api.v1.ServicePort - (*LoadBalancerIngress)(nil), // 43: api.v1.LoadBalancerIngress - (*IngressDetails)(nil), // 44: api.v1.IngressDetails - (*IngressRule)(nil), // 45: api.v1.IngressRule - (*IngressPath)(nil), // 46: api.v1.IngressPath - (*IngressBackend)(nil), // 47: api.v1.IngressBackend - (*IngressTLS)(nil), // 48: api.v1.IngressTLS - (*PersistentVolumeClaimDetails)(nil), // 49: api.v1.PersistentVolumeClaimDetails - (*ResourceRequirements)(nil), // 50: api.v1.ResourceRequirements - (*VolumeNodeAffinity)(nil), // 51: api.v1.VolumeNodeAffinity - (*PVCCondition)(nil), // 52: api.v1.PVCCondition - (*PersistentVolumeDetails)(nil), // 53: api.v1.PersistentVolumeDetails - (*PVClaimReference)(nil), // 54: api.v1.PVClaimReference - (*PVVolumeSource)(nil), // 55: api.v1.PVVolumeSource - (*CSIVolumeSource)(nil), // 56: api.v1.CSIVolumeSource - (*HostPathVolumeSource)(nil), // 57: api.v1.HostPathVolumeSource - (*NFSVolumeSource)(nil), // 58: api.v1.NFSVolumeSource - (*StorageClassDetails)(nil), // 59: api.v1.StorageClassDetails - (*NamespaceDetails)(nil), // 60: api.v1.NamespaceDetails - (*NodeDetails)(nil), // 61: api.v1.NodeDetails - (*NodeTaint)(nil), // 62: api.v1.NodeTaint - (*NodeAddress)(nil), // 63: api.v1.NodeAddress - (*NodeCondition)(nil), // 64: api.v1.NodeCondition - (*NodeSystemInfo)(nil), // 65: api.v1.NodeSystemInfo - (*NodeImage)(nil), // 66: api.v1.NodeImage - (*TopologySelector)(nil), // 67: api.v1.TopologySelector - (*TopologySelectorTerm)(nil), // 68: api.v1.TopologySelectorTerm - (*TolerationInfo)(nil), // 69: api.v1.TolerationInfo - (*NodeSelector)(nil), // 70: api.v1.NodeSelector - (*NodeSelectorTerm)(nil), // 71: api.v1.NodeSelectorTerm - (*NodeSelectorRequirement)(nil), // 72: api.v1.NodeSelectorRequirement - (*HPADetails)(nil), // 73: api.v1.HPADetails - (*ScaleTargetRef)(nil), // 74: api.v1.ScaleTargetRef - (*HPAMetric)(nil), // 75: api.v1.HPAMetric - (*HPAResourceMetric)(nil), // 76: api.v1.HPAResourceMetric - (*HPAPodsMetric)(nil), // 77: api.v1.HPAPodsMetric - (*HPAObjectMetric)(nil), // 78: api.v1.HPAObjectMetric - (*HPAExternalMetric)(nil), // 79: api.v1.HPAExternalMetric - (*HPAMetricSelector)(nil), // 80: api.v1.HPAMetricSelector - (*HPAObjectReference)(nil), // 81: api.v1.HPAObjectReference - (*HPACurrentMetric)(nil), // 82: api.v1.HPACurrentMetric - (*HPACurrentResourceMetric)(nil), // 83: api.v1.HPACurrentResourceMetric - (*HPACurrentPodsMetric)(nil), // 84: api.v1.HPACurrentPodsMetric - (*HPACurrentObjectMetric)(nil), // 85: api.v1.HPACurrentObjectMetric - (*HPACurrentExternalMetric)(nil), // 86: api.v1.HPACurrentExternalMetric - (*HPACondition)(nil), // 87: api.v1.HPACondition - (*HPABehavior)(nil), // 88: api.v1.HPABehavior - (*HPAScalingRules)(nil), // 89: api.v1.HPAScalingRules - (*HPAScalingPolicy)(nil), // 90: api.v1.HPAScalingPolicy - (*VPADetails)(nil), // 91: api.v1.VPADetails - (*VPATargetRef)(nil), // 92: api.v1.VPATargetRef - (*VPAUpdatePolicy)(nil), // 93: api.v1.VPAUpdatePolicy - (*VPAResourcePolicy)(nil), // 94: api.v1.VPAResourcePolicy - (*VPAContainerResourcePolicy)(nil), // 95: api.v1.VPAContainerResourcePolicy - (*VPARecommendation)(nil), // 96: api.v1.VPARecommendation - (*VPAContainerRecommendation)(nil), // 97: api.v1.VPAContainerRecommendation - (*VPACondition)(nil), // 98: api.v1.VPACondition - (*LimitRangeDetails)(nil), // 99: api.v1.LimitRangeDetails - (*LimitRangeItem)(nil), // 100: api.v1.LimitRangeItem - (*ServiceAccountDetails)(nil), // 101: api.v1.ServiceAccountDetails - (*RoleDetails)(nil), // 102: api.v1.RoleDetails - (*RoleRule)(nil), // 103: api.v1.RoleRule - (*RoleBindingDetails)(nil), // 104: api.v1.RoleBindingDetails - (*RoleBindingSubject)(nil), // 105: api.v1.RoleBindingSubject - (*RoleReference)(nil), // 106: api.v1.RoleReference - (*KedaScaledObjectDetails)(nil), // 107: api.v1.KedaScaledObjectDetails - (*KedaScaledObjectTrigger)(nil), // 108: api.v1.KedaScaledObjectTrigger - (*KedaScaledObjectCondition)(nil), // 109: api.v1.KedaScaledObjectCondition - (*KarpenterResourceDetails)(nil), // 110: api.v1.KarpenterResourceDetails - (*KarpenterResourceCondition)(nil), // 111: api.v1.KarpenterResourceCondition - (*KarpenterCapacity)(nil), // 112: api.v1.KarpenterCapacity - (*KarpenterRequirement)(nil), // 113: api.v1.KarpenterRequirement - (*WorkloadFilters)(nil), // 114: api.v1.WorkloadFilters - (*PodDisruptionBudgetDetails)(nil), // 115: api.v1.PodDisruptionBudgetDetails - (*PodDisruptionBudgetCondition)(nil), // 116: api.v1.PodDisruptionBudgetCondition - (*ResourceQuotaDetails)(nil), // 117: api.v1.ResourceQuotaDetails - (*ResourceQuotaCondition)(nil), // 118: api.v1.ResourceQuotaCondition - (*VolcanoJobDetails)(nil), // 119: api.v1.VolcanoJobDetails - (*VolcanoJobCondition)(nil), // 120: api.v1.VolcanoJobCondition - (*VolcanoTask)(nil), // 121: api.v1.VolcanoTask - (*SparkApplicationDetails)(nil), // 122: api.v1.SparkApplicationDetails - (*SparkDriverInfo)(nil), // 123: api.v1.SparkDriverInfo - (*SparkRestartPolicyInfo)(nil), // 124: api.v1.SparkRestartPolicyInfo - (*SparkDynamicAllocationInfo)(nil), // 125: api.v1.SparkDynamicAllocationInfo - (*ScheduledSparkApplicationDetails)(nil), // 126: api.v1.ScheduledSparkApplicationDetails - (*Event)(nil), // 127: api.v1.Event - (*EventDatapointInfo)(nil), // 128: api.v1.EventDatapointInfo - (*EventDatapoint)(nil), // 129: api.v1.EventDatapoint - nil, // 130: api.v1.WorkloadItem.LabelsEntry - nil, // 131: api.v1.WorkloadItem.AnnotationsEntry - nil, // 132: api.v1.Node.LabelsEntry - nil, // 133: api.v1.Node.AnnotationsEntry - nil, // 134: api.v1.LabelSelector.MatchLabelsEntry - nil, // 135: api.v1.ResourceDetails.ServiceSelectorEntry - nil, // 136: api.v1.ResourceDetails.ScParametersEntry - nil, // 137: api.v1.ServiceDetails.SelectorEntry - nil, // 138: api.v1.ResourceRequirements.RequestsEntry - nil, // 139: api.v1.ResourceRequirements.LimitsEntry - nil, // 140: api.v1.PersistentVolumeDetails.CapacityEntry - nil, // 141: api.v1.PVVolumeSource.VolumeAttributesEntry - nil, // 142: api.v1.CSIVolumeSource.VolumeAttributesEntry - nil, // 143: api.v1.StorageClassDetails.ParametersEntry - nil, // 144: api.v1.NamespaceDetails.ConditionsEntry - nil, // 145: api.v1.NodeDetails.CapacityEntry - nil, // 146: api.v1.NodeDetails.AllocatableEntry - nil, // 147: api.v1.TopologySelectorTerm.MatchLabelsEntry - nil, // 148: api.v1.HPAMetricSelector.SelectorEntry - nil, // 149: api.v1.VPAContainerResourcePolicy.MinAllowedEntry - nil, // 150: api.v1.VPAContainerResourcePolicy.MaxAllowedEntry - nil, // 151: api.v1.VPAContainerRecommendation.TargetEntry - nil, // 152: api.v1.VPAContainerRecommendation.LowerBoundEntry - nil, // 153: api.v1.VPAContainerRecommendation.UpperBoundEntry - nil, // 154: api.v1.VPAContainerRecommendation.UncappedTargetEntry - nil, // 155: api.v1.LimitRangeItem.DefaultLimitsEntry - nil, // 156: api.v1.LimitRangeItem.DefaultRequestEntry - nil, // 157: api.v1.LimitRangeItem.MaxEntry - nil, // 158: api.v1.LimitRangeItem.MinEntry - nil, // 159: api.v1.LimitRangeItem.MaxLimitRequestRatioEntry - nil, // 160: api.v1.KedaScaledObjectTrigger.MetadataEntry - nil, // 161: api.v1.KarpenterResourceDetails.LimitsEntry - nil, // 162: api.v1.KarpenterCapacity.OtherEntry - nil, // 163: api.v1.PodDisruptionBudgetDetails.SelectorLabelsEntry - nil, // 164: api.v1.ResourceQuotaDetails.HardLimitsEntry - nil, // 165: api.v1.ResourceQuotaDetails.UsedEntry - nil, // 166: api.v1.ResourceQuotaDetails.ScopeSelectorEntry - (*timestamppb.Timestamp)(nil), // 167: google.protobuf.Timestamp - (*money.Money)(nil), // 168: google.type.Money + (*MetricPercentiles)(nil), // 8: api.v1.MetricPercentiles + (*ContainerPercentileSummary)(nil), // 9: api.v1.ContainerPercentileSummary + (*ContainerFsPercentileSummary)(nil), // 10: api.v1.ContainerFsPercentileSummary + (*ContainerRequestLimits)(nil), // 11: api.v1.ContainerRequestLimits + (*ForecastResourceMetrics)(nil), // 12: api.v1.ForecastResourceMetrics + (*ResourceSummary)(nil), // 13: api.v1.ResourceSummary + (*WorkloadItem)(nil), // 14: api.v1.WorkloadItem + (*ContainerRuntimeInfo)(nil), // 15: api.v1.ContainerRuntimeInfo + (*NodeInfo)(nil), // 16: api.v1.NodeInfo + (*ResourceInfo)(nil), // 17: api.v1.ResourceInfo + (*Node)(nil), // 18: api.v1.Node + (*AttachedVolume)(nil), // 19: api.v1.AttachedVolume + (*NodeGroup)(nil), // 20: api.v1.NodeGroup + (*CostDataPoint)(nil), // 21: api.v1.CostDataPoint + (*ResourceDataPoint)(nil), // 22: api.v1.ResourceDataPoint + (*SavingsData)(nil), // 23: api.v1.SavingsData + (*SavingsDataPoint)(nil), // 24: api.v1.SavingsDataPoint + (*SavingsTimeSeries)(nil), // 25: api.v1.SavingsTimeSeries + (*LabelSelectorRequirement)(nil), // 26: api.v1.LabelSelectorRequirement + (*Label)(nil), // 27: api.v1.Label + (*LabelSelector)(nil), // 28: api.v1.LabelSelector + (*RegexPattern)(nil), // 29: api.v1.RegexPattern + (*ResourceDetails)(nil), // 30: api.v1.ResourceDetails + (*PodDetails)(nil), // 31: api.v1.PodDetails + (*ContainerSummary)(nil), // 32: api.v1.ContainerSummary + (*DeploymentDetails)(nil), // 33: api.v1.DeploymentDetails + (*ContainerTemplate)(nil), // 34: api.v1.ContainerTemplate + (*DeploymentCondition)(nil), // 35: api.v1.DeploymentCondition + (*StatefulSetDetails)(nil), // 36: api.v1.StatefulSetDetails + (*VolumeClaimTemplate)(nil), // 37: api.v1.VolumeClaimTemplate + (*DaemonSetDetails)(nil), // 38: api.v1.DaemonSetDetails + (*ReplicaSetDetails)(nil), // 39: api.v1.ReplicaSetDetails + (*JobDetails)(nil), // 40: api.v1.JobDetails + (*JobCondition)(nil), // 41: api.v1.JobCondition + (*CronJobDetails)(nil), // 42: api.v1.CronJobDetails + (*ActiveJobReference)(nil), // 43: api.v1.ActiveJobReference + (*JobTemplate)(nil), // 44: api.v1.JobTemplate + (*ServiceDetails)(nil), // 45: api.v1.ServiceDetails + (*ServicePort)(nil), // 46: api.v1.ServicePort + (*LoadBalancerIngress)(nil), // 47: api.v1.LoadBalancerIngress + (*IngressDetails)(nil), // 48: api.v1.IngressDetails + (*IngressRule)(nil), // 49: api.v1.IngressRule + (*IngressPath)(nil), // 50: api.v1.IngressPath + (*IngressBackend)(nil), // 51: api.v1.IngressBackend + (*IngressTLS)(nil), // 52: api.v1.IngressTLS + (*PersistentVolumeClaimDetails)(nil), // 53: api.v1.PersistentVolumeClaimDetails + (*ResourceRequirements)(nil), // 54: api.v1.ResourceRequirements + (*VolumeNodeAffinity)(nil), // 55: api.v1.VolumeNodeAffinity + (*PVCCondition)(nil), // 56: api.v1.PVCCondition + (*PersistentVolumeDetails)(nil), // 57: api.v1.PersistentVolumeDetails + (*PVClaimReference)(nil), // 58: api.v1.PVClaimReference + (*PVVolumeSource)(nil), // 59: api.v1.PVVolumeSource + (*CSIVolumeSource)(nil), // 60: api.v1.CSIVolumeSource + (*HostPathVolumeSource)(nil), // 61: api.v1.HostPathVolumeSource + (*NFSVolumeSource)(nil), // 62: api.v1.NFSVolumeSource + (*StorageClassDetails)(nil), // 63: api.v1.StorageClassDetails + (*NamespaceDetails)(nil), // 64: api.v1.NamespaceDetails + (*NodeDetails)(nil), // 65: api.v1.NodeDetails + (*NodeTaint)(nil), // 66: api.v1.NodeTaint + (*NodeAddress)(nil), // 67: api.v1.NodeAddress + (*NodeCondition)(nil), // 68: api.v1.NodeCondition + (*NodeSystemInfo)(nil), // 69: api.v1.NodeSystemInfo + (*NodeImage)(nil), // 70: api.v1.NodeImage + (*TopologySelector)(nil), // 71: api.v1.TopologySelector + (*TopologySelectorTerm)(nil), // 72: api.v1.TopologySelectorTerm + (*TolerationInfo)(nil), // 73: api.v1.TolerationInfo + (*NodeSelector)(nil), // 74: api.v1.NodeSelector + (*NodeSelectorTerm)(nil), // 75: api.v1.NodeSelectorTerm + (*NodeSelectorRequirement)(nil), // 76: api.v1.NodeSelectorRequirement + (*HPADetails)(nil), // 77: api.v1.HPADetails + (*ScaleTargetRef)(nil), // 78: api.v1.ScaleTargetRef + (*HPAMetric)(nil), // 79: api.v1.HPAMetric + (*HPAResourceMetric)(nil), // 80: api.v1.HPAResourceMetric + (*HPAPodsMetric)(nil), // 81: api.v1.HPAPodsMetric + (*HPAObjectMetric)(nil), // 82: api.v1.HPAObjectMetric + (*HPAExternalMetric)(nil), // 83: api.v1.HPAExternalMetric + (*HPAMetricSelector)(nil), // 84: api.v1.HPAMetricSelector + (*HPAObjectReference)(nil), // 85: api.v1.HPAObjectReference + (*HPACurrentMetric)(nil), // 86: api.v1.HPACurrentMetric + (*HPACurrentResourceMetric)(nil), // 87: api.v1.HPACurrentResourceMetric + (*HPACurrentPodsMetric)(nil), // 88: api.v1.HPACurrentPodsMetric + (*HPACurrentObjectMetric)(nil), // 89: api.v1.HPACurrentObjectMetric + (*HPACurrentExternalMetric)(nil), // 90: api.v1.HPACurrentExternalMetric + (*HPACondition)(nil), // 91: api.v1.HPACondition + (*HPABehavior)(nil), // 92: api.v1.HPABehavior + (*HPAScalingRules)(nil), // 93: api.v1.HPAScalingRules + (*HPAScalingPolicy)(nil), // 94: api.v1.HPAScalingPolicy + (*VPADetails)(nil), // 95: api.v1.VPADetails + (*VPATargetRef)(nil), // 96: api.v1.VPATargetRef + (*VPAUpdatePolicy)(nil), // 97: api.v1.VPAUpdatePolicy + (*VPAResourcePolicy)(nil), // 98: api.v1.VPAResourcePolicy + (*VPAContainerResourcePolicy)(nil), // 99: api.v1.VPAContainerResourcePolicy + (*VPARecommendation)(nil), // 100: api.v1.VPARecommendation + (*VPAContainerRecommendation)(nil), // 101: api.v1.VPAContainerRecommendation + (*VPACondition)(nil), // 102: api.v1.VPACondition + (*LimitRangeDetails)(nil), // 103: api.v1.LimitRangeDetails + (*LimitRangeItem)(nil), // 104: api.v1.LimitRangeItem + (*ServiceAccountDetails)(nil), // 105: api.v1.ServiceAccountDetails + (*RoleDetails)(nil), // 106: api.v1.RoleDetails + (*RoleRule)(nil), // 107: api.v1.RoleRule + (*RoleBindingDetails)(nil), // 108: api.v1.RoleBindingDetails + (*RoleBindingSubject)(nil), // 109: api.v1.RoleBindingSubject + (*RoleReference)(nil), // 110: api.v1.RoleReference + (*KedaScaledObjectDetails)(nil), // 111: api.v1.KedaScaledObjectDetails + (*KedaScaledObjectTrigger)(nil), // 112: api.v1.KedaScaledObjectTrigger + (*KedaScaledObjectCondition)(nil), // 113: api.v1.KedaScaledObjectCondition + (*KarpenterResourceDetails)(nil), // 114: api.v1.KarpenterResourceDetails + (*KarpenterResourceCondition)(nil), // 115: api.v1.KarpenterResourceCondition + (*KarpenterCapacity)(nil), // 116: api.v1.KarpenterCapacity + (*KarpenterRequirement)(nil), // 117: api.v1.KarpenterRequirement + (*WorkloadFilters)(nil), // 118: api.v1.WorkloadFilters + (*PodDisruptionBudgetDetails)(nil), // 119: api.v1.PodDisruptionBudgetDetails + (*PodDisruptionBudgetCondition)(nil), // 120: api.v1.PodDisruptionBudgetCondition + (*ResourceQuotaDetails)(nil), // 121: api.v1.ResourceQuotaDetails + (*ResourceQuotaCondition)(nil), // 122: api.v1.ResourceQuotaCondition + (*VolcanoJobDetails)(nil), // 123: api.v1.VolcanoJobDetails + (*VolcanoJobCondition)(nil), // 124: api.v1.VolcanoJobCondition + (*VolcanoTask)(nil), // 125: api.v1.VolcanoTask + (*SparkApplicationDetails)(nil), // 126: api.v1.SparkApplicationDetails + (*SparkDriverInfo)(nil), // 127: api.v1.SparkDriverInfo + (*SparkRestartPolicyInfo)(nil), // 128: api.v1.SparkRestartPolicyInfo + (*SparkDynamicAllocationInfo)(nil), // 129: api.v1.SparkDynamicAllocationInfo + (*ScheduledSparkApplicationDetails)(nil), // 130: api.v1.ScheduledSparkApplicationDetails + (*Event)(nil), // 131: api.v1.Event + (*EventDatapointInfo)(nil), // 132: api.v1.EventDatapointInfo + (*EventDatapoint)(nil), // 133: api.v1.EventDatapoint + (*DimensionCount)(nil), // 134: api.v1.DimensionCount + (*EventGroup)(nil), // 135: api.v1.EventGroup + nil, // 136: api.v1.WorkloadItem.LabelsEntry + nil, // 137: api.v1.WorkloadItem.AnnotationsEntry + nil, // 138: api.v1.Node.LabelsEntry + nil, // 139: api.v1.Node.AnnotationsEntry + nil, // 140: api.v1.LabelSelector.MatchLabelsEntry + nil, // 141: api.v1.ResourceDetails.ServiceSelectorEntry + nil, // 142: api.v1.ResourceDetails.ScParametersEntry + nil, // 143: api.v1.ServiceDetails.SelectorEntry + nil, // 144: api.v1.ResourceRequirements.RequestsEntry + nil, // 145: api.v1.ResourceRequirements.LimitsEntry + nil, // 146: api.v1.PersistentVolumeDetails.CapacityEntry + nil, // 147: api.v1.PVVolumeSource.VolumeAttributesEntry + nil, // 148: api.v1.CSIVolumeSource.VolumeAttributesEntry + nil, // 149: api.v1.StorageClassDetails.ParametersEntry + nil, // 150: api.v1.NamespaceDetails.ConditionsEntry + nil, // 151: api.v1.NodeDetails.CapacityEntry + nil, // 152: api.v1.NodeDetails.AllocatableEntry + nil, // 153: api.v1.TopologySelectorTerm.MatchLabelsEntry + nil, // 154: api.v1.HPAMetricSelector.SelectorEntry + nil, // 155: api.v1.VPAContainerResourcePolicy.MinAllowedEntry + nil, // 156: api.v1.VPAContainerResourcePolicy.MaxAllowedEntry + nil, // 157: api.v1.VPAContainerRecommendation.TargetEntry + nil, // 158: api.v1.VPAContainerRecommendation.LowerBoundEntry + nil, // 159: api.v1.VPAContainerRecommendation.UpperBoundEntry + nil, // 160: api.v1.VPAContainerRecommendation.UncappedTargetEntry + nil, // 161: api.v1.LimitRangeItem.DefaultLimitsEntry + nil, // 162: api.v1.LimitRangeItem.DefaultRequestEntry + nil, // 163: api.v1.LimitRangeItem.MaxEntry + nil, // 164: api.v1.LimitRangeItem.MinEntry + nil, // 165: api.v1.LimitRangeItem.MaxLimitRequestRatioEntry + nil, // 166: api.v1.KedaScaledObjectTrigger.MetadataEntry + nil, // 167: api.v1.KarpenterResourceDetails.LimitsEntry + nil, // 168: api.v1.KarpenterCapacity.OtherEntry + nil, // 169: api.v1.PodDisruptionBudgetDetails.SelectorLabelsEntry + nil, // 170: api.v1.ResourceQuotaDetails.HardLimitsEntry + nil, // 171: api.v1.ResourceQuotaDetails.UsedEntry + nil, // 172: api.v1.ResourceQuotaDetails.ScopeSelectorEntry + nil, // 173: api.v1.Event.AnnotationsEntry + nil, // 174: api.v1.Event.LabelsEntry + (*timestamppb.Timestamp)(nil), // 175: google.protobuf.Timestamp + (*money.Money)(nil), // 176: google.type.Money } var file_api_v1_common_proto_depIdxs = []int32{ 0, // 0: api.v1.AuditLogEntry.workload_type:type_name -> api.v1.K8sObjectKind - 167, // 1: api.v1.AuditLogEntry.created_at:type_name -> google.protobuf.Timestamp - 167, // 2: api.v1.AuditLogEntry.updated_at:type_name -> google.protobuf.Timestamp + 175, // 1: api.v1.AuditLogEntry.created_at:type_name -> google.protobuf.Timestamp + 175, // 2: api.v1.AuditLogEntry.updated_at:type_name -> google.protobuf.Timestamp 1, // 3: api.v1.Pagination.order_by:type_name -> api.v1.OrderByEnum - 168, // 4: api.v1.CostInfo.node_recommendation_saved_cost_last_month:type_name -> google.type.Money - 168, // 5: api.v1.CostInfo.money_cpu_cost_per_hour:type_name -> google.type.Money - 168, // 6: api.v1.CostInfo.money_memory_cost_per_hour:type_name -> google.type.Money - 168, // 7: api.v1.CostInfo.money_total_cost_per_hour:type_name -> google.type.Money - 168, // 8: api.v1.CostInfo.money_total_cost_per_month:type_name -> google.type.Money - 168, // 9: api.v1.CostInfo.money_total_cost_per_year:type_name -> google.type.Money - 168, // 10: api.v1.CostInfo.money_optimized_cpu_cost_per_hour:type_name -> google.type.Money - 168, // 11: api.v1.CostInfo.money_optimized_memory_cost_per_hour:type_name -> google.type.Money - 168, // 12: api.v1.CostInfo.money_optimized_total_cost_per_hour:type_name -> google.type.Money - 168, // 13: api.v1.CostInfo.money_optimized_total_cost_per_month:type_name -> google.type.Money - 168, // 14: api.v1.CostInfo.money_optimized_total_cost_per_year:type_name -> google.type.Money - 168, // 15: api.v1.CostInfo.money_cpu_cost_for_time_period:type_name -> google.type.Money - 168, // 16: api.v1.CostInfo.money_memory_cost_for_time_period:type_name -> google.type.Money - 168, // 17: api.v1.CostInfo.money_total_cost_for_time_period:type_name -> google.type.Money - 168, // 18: api.v1.CostInfo.money_optimized_cpu_cost_for_time_period:type_name -> google.type.Money - 168, // 19: api.v1.CostInfo.money_optimized_memory_cost_for_time_period:type_name -> google.type.Money - 168, // 20: api.v1.CostInfo.money_optimized_total_cost_for_time_period:type_name -> google.type.Money - 168, // 21: api.v1.CostInfo.money_optimized_gpu_cost_for_time_period:type_name -> google.type.Money - 168, // 22: api.v1.CostInfo.money_gpu_cost_for_time_period:type_name -> google.type.Money - 168, // 23: api.v1.CostInfo.money_gpu_cost_per_hour:type_name -> google.type.Money - 168, // 24: api.v1.CostInfo.money_optimized_gpu_cost_per_hour:type_name -> google.type.Money - 168, // 25: api.v1.CostInfo.money_cpu_cost_per_vcpu_per_hour:type_name -> google.type.Money - 168, // 26: api.v1.CostInfo.money_memory_cost_per_gib_per_hour:type_name -> google.type.Money - 167, // 27: api.v1.ForecastResourceMetrics.timestamp:type_name -> google.protobuf.Timestamp - 10, // 28: api.v1.WorkloadItem.children:type_name -> api.v1.WorkloadItem - 130, // 29: api.v1.WorkloadItem.labels:type_name -> api.v1.WorkloadItem.LabelsEntry - 131, // 30: api.v1.WorkloadItem.annotations:type_name -> api.v1.WorkloadItem.AnnotationsEntry - 7, // 31: api.v1.WorkloadItem.resource_metrics:type_name -> api.v1.ResourceMetrics - 6, // 32: api.v1.WorkloadItem.cost_info:type_name -> api.v1.CostInfo - 17, // 33: api.v1.WorkloadItem.cost_data_points:type_name -> api.v1.CostDataPoint - 18, // 34: api.v1.WorkloadItem.resource_data_points:type_name -> api.v1.ResourceDataPoint - 167, // 35: api.v1.WorkloadItem.created_at:type_name -> google.protobuf.Timestamp - 167, // 36: api.v1.WorkloadItem.deleted_at:type_name -> google.protobuf.Timestamp - 26, // 37: api.v1.WorkloadItem.resource_details:type_name -> api.v1.ResourceDetails - 7, // 38: api.v1.Node.resource_metrics:type_name -> api.v1.ResourceMetrics - 6, // 39: api.v1.Node.cost_info:type_name -> api.v1.CostInfo - 11, // 40: api.v1.Node.container_runtime:type_name -> api.v1.ContainerRuntimeInfo - 26, // 41: api.v1.Node.resource_details:type_name -> api.v1.ResourceDetails - 10, // 42: api.v1.Node.children:type_name -> api.v1.WorkloadItem - 132, // 43: api.v1.Node.labels:type_name -> api.v1.Node.LabelsEntry - 133, // 44: api.v1.Node.annotations:type_name -> api.v1.Node.AnnotationsEntry - 168, // 45: api.v1.Node.money_price_per_hour:type_name -> google.type.Money - 168, // 46: api.v1.Node.money_eff_period_total_cost:type_name -> google.type.Money - 168, // 47: api.v1.Node.money_price_per_vcpu:type_name -> google.type.Money - 168, // 48: api.v1.Node.money_price_per_gib:type_name -> google.type.Money - 168, // 49: api.v1.Node.money_price_per_gpu:type_name -> google.type.Money - 168, // 50: api.v1.Node.money_cpu_price:type_name -> google.type.Money - 168, // 51: api.v1.Node.money_memory_price:type_name -> google.type.Money - 168, // 52: api.v1.Node.money_gpu_price:type_name -> google.type.Money - 15, // 53: api.v1.Node.volumes_attached:type_name -> api.v1.AttachedVolume - 167, // 54: api.v1.Node.last_seen:type_name -> google.protobuf.Timestamp - 167, // 55: api.v1.Node.collected_at:type_name -> google.protobuf.Timestamp - 167, // 56: api.v1.Node.deletion_timestamp:type_name -> google.protobuf.Timestamp - 14, // 57: api.v1.NodeGroup.nodes:type_name -> api.v1.Node - 7, // 58: api.v1.NodeGroup.resource_metrics:type_name -> api.v1.ResourceMetrics - 6, // 59: api.v1.NodeGroup.cost_info:type_name -> api.v1.CostInfo - 12, // 60: api.v1.NodeGroup.node_info:type_name -> api.v1.NodeInfo - 13, // 61: api.v1.NodeGroup.resource_info:type_name -> api.v1.ResourceInfo - 17, // 62: api.v1.NodeGroup.cost_data_points:type_name -> api.v1.CostDataPoint - 18, // 63: api.v1.NodeGroup.resource_data_points:type_name -> api.v1.ResourceDataPoint - 6, // 64: api.v1.CostDataPoint.cost_info:type_name -> api.v1.CostInfo - 7, // 65: api.v1.ResourceDataPoint.resource_metrics:type_name -> api.v1.ResourceMetrics - 19, // 66: api.v1.SavingsDataPoint.savings_data:type_name -> api.v1.SavingsData - 20, // 67: api.v1.SavingsTimeSeries.savings_datapoints:type_name -> api.v1.SavingsDataPoint - 2, // 68: api.v1.LabelSelectorRequirement.operator:type_name -> api.v1.LabelSelectorOperator - 23, // 69: api.v1.LabelSelector.labels:type_name -> api.v1.Label - 134, // 70: api.v1.LabelSelector.match_labels:type_name -> api.v1.LabelSelector.MatchLabelsEntry - 22, // 71: api.v1.LabelSelector.match_expressions:type_name -> api.v1.LabelSelectorRequirement - 27, // 72: api.v1.ResourceDetails.pod_details:type_name -> api.v1.PodDetails - 29, // 73: api.v1.ResourceDetails.deployment_details:type_name -> api.v1.DeploymentDetails - 32, // 74: api.v1.ResourceDetails.stateful_set_details:type_name -> api.v1.StatefulSetDetails - 34, // 75: api.v1.ResourceDetails.daemon_set_details:type_name -> api.v1.DaemonSetDetails - 35, // 76: api.v1.ResourceDetails.replica_set_details:type_name -> api.v1.ReplicaSetDetails - 36, // 77: api.v1.ResourceDetails.job_details:type_name -> api.v1.JobDetails - 38, // 78: api.v1.ResourceDetails.cron_job_details:type_name -> api.v1.CronJobDetails - 41, // 79: api.v1.ResourceDetails.service_details:type_name -> api.v1.ServiceDetails - 44, // 80: api.v1.ResourceDetails.ingress_details:type_name -> api.v1.IngressDetails - 49, // 81: api.v1.ResourceDetails.pvc_details:type_name -> api.v1.PersistentVolumeClaimDetails - 53, // 82: api.v1.ResourceDetails.pv_details:type_name -> api.v1.PersistentVolumeDetails - 59, // 83: api.v1.ResourceDetails.sc_details:type_name -> api.v1.StorageClassDetails - 60, // 84: api.v1.ResourceDetails.ns_details:type_name -> api.v1.NamespaceDetails - 61, // 85: api.v1.ResourceDetails.node_details:type_name -> api.v1.NodeDetails - 73, // 86: api.v1.ResourceDetails.hpa_details:type_name -> api.v1.HPADetails - 91, // 87: api.v1.ResourceDetails.vpa_details:type_name -> api.v1.VPADetails - 99, // 88: api.v1.ResourceDetails.limit_range_details:type_name -> api.v1.LimitRangeDetails - 101, // 89: api.v1.ResourceDetails.service_account_details:type_name -> api.v1.ServiceAccountDetails - 102, // 90: api.v1.ResourceDetails.role_details:type_name -> api.v1.RoleDetails - 104, // 91: api.v1.ResourceDetails.role_binding_details:type_name -> api.v1.RoleBindingDetails - 107, // 92: api.v1.ResourceDetails.keda_scaled_object_details:type_name -> api.v1.KedaScaledObjectDetails - 110, // 93: api.v1.ResourceDetails.karpenter_resource_details:type_name -> api.v1.KarpenterResourceDetails - 115, // 94: api.v1.ResourceDetails.pod_disruption_budget_details:type_name -> api.v1.PodDisruptionBudgetDetails - 117, // 95: api.v1.ResourceDetails.resource_quota_details:type_name -> api.v1.ResourceQuotaDetails - 119, // 96: api.v1.ResourceDetails.volcano_job_details:type_name -> api.v1.VolcanoJobDetails - 122, // 97: api.v1.ResourceDetails.spark_application_details:type_name -> api.v1.SparkApplicationDetails - 126, // 98: api.v1.ResourceDetails.scheduled_spark_application_details:type_name -> api.v1.ScheduledSparkApplicationDetails - 42, // 99: api.v1.ResourceDetails.service_ports:type_name -> api.v1.ServicePort - 135, // 100: api.v1.ResourceDetails.service_selector:type_name -> api.v1.ResourceDetails.ServiceSelectorEntry - 136, // 101: api.v1.ResourceDetails.sc_parameters:type_name -> api.v1.ResourceDetails.ScParametersEntry - 62, // 102: api.v1.ResourceDetails.node_taints:type_name -> api.v1.NodeTaint - 28, // 103: api.v1.PodDetails.containers:type_name -> api.v1.ContainerSummary - 30, // 104: api.v1.DeploymentDetails.containers:type_name -> api.v1.ContainerTemplate - 31, // 105: api.v1.DeploymentDetails.conditions:type_name -> api.v1.DeploymentCondition - 30, // 106: api.v1.StatefulSetDetails.containers:type_name -> api.v1.ContainerTemplate - 33, // 107: api.v1.StatefulSetDetails.volume_claim_templates:type_name -> api.v1.VolumeClaimTemplate - 30, // 108: api.v1.DaemonSetDetails.containers:type_name -> api.v1.ContainerTemplate - 69, // 109: api.v1.DaemonSetDetails.tolerations:type_name -> api.v1.TolerationInfo - 70, // 110: api.v1.DaemonSetDetails.node_selector:type_name -> api.v1.NodeSelector - 30, // 111: api.v1.ReplicaSetDetails.containers:type_name -> api.v1.ContainerTemplate - 24, // 112: api.v1.ReplicaSetDetails.selector:type_name -> api.v1.LabelSelector - 30, // 113: api.v1.JobDetails.containers:type_name -> api.v1.ContainerTemplate - 37, // 114: api.v1.JobDetails.conditions:type_name -> api.v1.JobCondition - 24, // 115: api.v1.JobDetails.selector:type_name -> api.v1.LabelSelector - 30, // 116: api.v1.CronJobDetails.containers:type_name -> api.v1.ContainerTemplate - 39, // 117: api.v1.CronJobDetails.active_jobs:type_name -> api.v1.ActiveJobReference - 40, // 118: api.v1.CronJobDetails.job_template:type_name -> api.v1.JobTemplate - 30, // 119: api.v1.JobTemplate.containers:type_name -> api.v1.ContainerTemplate - 42, // 120: api.v1.ServiceDetails.ports:type_name -> api.v1.ServicePort - 137, // 121: api.v1.ServiceDetails.selector:type_name -> api.v1.ServiceDetails.SelectorEntry - 43, // 122: api.v1.ServiceDetails.load_balancer_ingress:type_name -> api.v1.LoadBalancerIngress - 45, // 123: api.v1.IngressDetails.rules:type_name -> api.v1.IngressRule - 48, // 124: api.v1.IngressDetails.tls:type_name -> api.v1.IngressTLS - 47, // 125: api.v1.IngressDetails.default_backend:type_name -> api.v1.IngressBackend - 43, // 126: api.v1.IngressDetails.load_balancer_ingress:type_name -> api.v1.LoadBalancerIngress - 46, // 127: api.v1.IngressRule.paths:type_name -> api.v1.IngressPath - 47, // 128: api.v1.IngressPath.backend:type_name -> api.v1.IngressBackend - 50, // 129: api.v1.PersistentVolumeClaimDetails.resource_requirements:type_name -> api.v1.ResourceRequirements - 24, // 130: api.v1.PersistentVolumeClaimDetails.selector:type_name -> api.v1.LabelSelector - 51, // 131: api.v1.PersistentVolumeClaimDetails.volume_node_affinity:type_name -> api.v1.VolumeNodeAffinity - 52, // 132: api.v1.PersistentVolumeClaimDetails.conditions:type_name -> api.v1.PVCCondition - 138, // 133: api.v1.ResourceRequirements.requests:type_name -> api.v1.ResourceRequirements.RequestsEntry - 139, // 134: api.v1.ResourceRequirements.limits:type_name -> api.v1.ResourceRequirements.LimitsEntry - 72, // 135: api.v1.VolumeNodeAffinity.required:type_name -> api.v1.NodeSelectorRequirement - 72, // 136: api.v1.VolumeNodeAffinity.preferred:type_name -> api.v1.NodeSelectorRequirement - 140, // 137: api.v1.PersistentVolumeDetails.capacity:type_name -> api.v1.PersistentVolumeDetails.CapacityEntry - 54, // 138: api.v1.PersistentVolumeDetails.claim_ref:type_name -> api.v1.PVClaimReference - 55, // 139: api.v1.PersistentVolumeDetails.volume_source:type_name -> api.v1.PVVolumeSource - 70, // 140: api.v1.PersistentVolumeDetails.node_affinity:type_name -> api.v1.NodeSelector - 56, // 141: api.v1.PVVolumeSource.csi:type_name -> api.v1.CSIVolumeSource - 57, // 142: api.v1.PVVolumeSource.host_path:type_name -> api.v1.HostPathVolumeSource - 58, // 143: api.v1.PVVolumeSource.nfs:type_name -> api.v1.NFSVolumeSource - 141, // 144: api.v1.PVVolumeSource.volume_attributes:type_name -> api.v1.PVVolumeSource.VolumeAttributesEntry - 142, // 145: api.v1.CSIVolumeSource.volume_attributes:type_name -> api.v1.CSIVolumeSource.VolumeAttributesEntry - 143, // 146: api.v1.StorageClassDetails.parameters:type_name -> api.v1.StorageClassDetails.ParametersEntry - 67, // 147: api.v1.StorageClassDetails.allowed_topologies:type_name -> api.v1.TopologySelector - 144, // 148: api.v1.NamespaceDetails.conditions:type_name -> api.v1.NamespaceDetails.ConditionsEntry - 63, // 149: api.v1.NodeDetails.addresses:type_name -> api.v1.NodeAddress - 64, // 150: api.v1.NodeDetails.conditions:type_name -> api.v1.NodeCondition - 65, // 151: api.v1.NodeDetails.system_info:type_name -> api.v1.NodeSystemInfo - 145, // 152: api.v1.NodeDetails.capacity:type_name -> api.v1.NodeDetails.CapacityEntry - 146, // 153: api.v1.NodeDetails.allocatable:type_name -> api.v1.NodeDetails.AllocatableEntry - 66, // 154: api.v1.NodeDetails.images:type_name -> api.v1.NodeImage - 68, // 155: api.v1.TopologySelector.match_label_expressions:type_name -> api.v1.TopologySelectorTerm - 147, // 156: api.v1.TopologySelectorTerm.match_labels:type_name -> api.v1.TopologySelectorTerm.MatchLabelsEntry - 71, // 157: api.v1.NodeSelector.terms:type_name -> api.v1.NodeSelectorTerm - 72, // 158: api.v1.NodeSelectorTerm.match_expressions:type_name -> api.v1.NodeSelectorRequirement - 72, // 159: api.v1.NodeSelectorTerm.match_fields:type_name -> api.v1.NodeSelectorRequirement - 74, // 160: api.v1.HPADetails.scale_target_ref:type_name -> api.v1.ScaleTargetRef - 75, // 161: api.v1.HPADetails.metrics:type_name -> api.v1.HPAMetric - 87, // 162: api.v1.HPADetails.conditions:type_name -> api.v1.HPACondition - 88, // 163: api.v1.HPADetails.behavior:type_name -> api.v1.HPABehavior - 82, // 164: api.v1.HPADetails.current_metrics:type_name -> api.v1.HPACurrentMetric - 76, // 165: api.v1.HPAMetric.resource:type_name -> api.v1.HPAResourceMetric - 77, // 166: api.v1.HPAMetric.pods:type_name -> api.v1.HPAPodsMetric - 78, // 167: api.v1.HPAMetric.object:type_name -> api.v1.HPAObjectMetric - 79, // 168: api.v1.HPAMetric.external:type_name -> api.v1.HPAExternalMetric - 80, // 169: api.v1.HPAPodsMetric.metric:type_name -> api.v1.HPAMetricSelector - 81, // 170: api.v1.HPAObjectMetric.described_object:type_name -> api.v1.HPAObjectReference - 80, // 171: api.v1.HPAObjectMetric.metric:type_name -> api.v1.HPAMetricSelector - 80, // 172: api.v1.HPAExternalMetric.metric:type_name -> api.v1.HPAMetricSelector - 148, // 173: api.v1.HPAMetricSelector.selector:type_name -> api.v1.HPAMetricSelector.SelectorEntry - 83, // 174: api.v1.HPACurrentMetric.resource:type_name -> api.v1.HPACurrentResourceMetric - 84, // 175: api.v1.HPACurrentMetric.pods:type_name -> api.v1.HPACurrentPodsMetric - 85, // 176: api.v1.HPACurrentMetric.object:type_name -> api.v1.HPACurrentObjectMetric - 86, // 177: api.v1.HPACurrentMetric.external:type_name -> api.v1.HPACurrentExternalMetric - 80, // 178: api.v1.HPACurrentPodsMetric.metric:type_name -> api.v1.HPAMetricSelector - 81, // 179: api.v1.HPACurrentObjectMetric.described_object:type_name -> api.v1.HPAObjectReference - 80, // 180: api.v1.HPACurrentObjectMetric.metric:type_name -> api.v1.HPAMetricSelector - 80, // 181: api.v1.HPACurrentExternalMetric.metric:type_name -> api.v1.HPAMetricSelector - 89, // 182: api.v1.HPABehavior.scale_up:type_name -> api.v1.HPAScalingRules - 89, // 183: api.v1.HPABehavior.scale_down:type_name -> api.v1.HPAScalingRules - 90, // 184: api.v1.HPAScalingRules.policies:type_name -> api.v1.HPAScalingPolicy - 92, // 185: api.v1.VPADetails.target_ref:type_name -> api.v1.VPATargetRef - 93, // 186: api.v1.VPADetails.update_policy:type_name -> api.v1.VPAUpdatePolicy - 94, // 187: api.v1.VPADetails.resource_policy:type_name -> api.v1.VPAResourcePolicy - 96, // 188: api.v1.VPADetails.recommendation:type_name -> api.v1.VPARecommendation - 98, // 189: api.v1.VPADetails.conditions:type_name -> api.v1.VPACondition - 95, // 190: api.v1.VPAResourcePolicy.container_policies:type_name -> api.v1.VPAContainerResourcePolicy - 149, // 191: api.v1.VPAContainerResourcePolicy.min_allowed:type_name -> api.v1.VPAContainerResourcePolicy.MinAllowedEntry - 150, // 192: api.v1.VPAContainerResourcePolicy.max_allowed:type_name -> api.v1.VPAContainerResourcePolicy.MaxAllowedEntry - 97, // 193: api.v1.VPARecommendation.container_recommendations:type_name -> api.v1.VPAContainerRecommendation - 151, // 194: api.v1.VPAContainerRecommendation.target:type_name -> api.v1.VPAContainerRecommendation.TargetEntry - 152, // 195: api.v1.VPAContainerRecommendation.lower_bound:type_name -> api.v1.VPAContainerRecommendation.LowerBoundEntry - 153, // 196: api.v1.VPAContainerRecommendation.upper_bound:type_name -> api.v1.VPAContainerRecommendation.UpperBoundEntry - 154, // 197: api.v1.VPAContainerRecommendation.uncapped_target:type_name -> api.v1.VPAContainerRecommendation.UncappedTargetEntry - 100, // 198: api.v1.LimitRangeDetails.limits:type_name -> api.v1.LimitRangeItem - 155, // 199: api.v1.LimitRangeItem.default_limits:type_name -> api.v1.LimitRangeItem.DefaultLimitsEntry - 156, // 200: api.v1.LimitRangeItem.default_request:type_name -> api.v1.LimitRangeItem.DefaultRequestEntry - 157, // 201: api.v1.LimitRangeItem.max:type_name -> api.v1.LimitRangeItem.MaxEntry - 158, // 202: api.v1.LimitRangeItem.min:type_name -> api.v1.LimitRangeItem.MinEntry - 159, // 203: api.v1.LimitRangeItem.max_limit_request_ratio:type_name -> api.v1.LimitRangeItem.MaxLimitRequestRatioEntry - 103, // 204: api.v1.RoleDetails.rules:type_name -> api.v1.RoleRule - 105, // 205: api.v1.RoleBindingDetails.subjects:type_name -> api.v1.RoleBindingSubject - 106, // 206: api.v1.RoleBindingDetails.role_ref:type_name -> api.v1.RoleReference - 108, // 207: api.v1.KedaScaledObjectDetails.triggers:type_name -> api.v1.KedaScaledObjectTrigger - 109, // 208: api.v1.KedaScaledObjectDetails.conditions:type_name -> api.v1.KedaScaledObjectCondition - 160, // 209: api.v1.KedaScaledObjectTrigger.metadata:type_name -> api.v1.KedaScaledObjectTrigger.MetadataEntry - 111, // 210: api.v1.KarpenterResourceDetails.conditions:type_name -> api.v1.KarpenterResourceCondition - 112, // 211: api.v1.KarpenterResourceDetails.capacity:type_name -> api.v1.KarpenterCapacity - 113, // 212: api.v1.KarpenterResourceDetails.requirements:type_name -> api.v1.KarpenterRequirement - 161, // 213: api.v1.KarpenterResourceDetails.limits:type_name -> api.v1.KarpenterResourceDetails.LimitsEntry - 162, // 214: api.v1.KarpenterCapacity.other:type_name -> api.v1.KarpenterCapacity.OtherEntry - 24, // 215: api.v1.WorkloadFilters.namespace_selector:type_name -> api.v1.LabelSelector - 24, // 216: api.v1.WorkloadFilters.workload_selector:type_name -> api.v1.LabelSelector - 0, // 217: api.v1.WorkloadFilters.kind_filter:type_name -> api.v1.K8sObjectKind - 25, // 218: api.v1.WorkloadFilters.name_pattern:type_name -> api.v1.RegexPattern - 24, // 219: api.v1.WorkloadFilters.annotation_selector:type_name -> api.v1.LabelSelector - 3, // 220: api.v1.WorkloadFilters.status:type_name -> api.v1.WorkloadStatusFilter - 163, // 221: api.v1.PodDisruptionBudgetDetails.selector_labels:type_name -> api.v1.PodDisruptionBudgetDetails.SelectorLabelsEntry - 116, // 222: api.v1.PodDisruptionBudgetDetails.conditions:type_name -> api.v1.PodDisruptionBudgetCondition - 164, // 223: api.v1.ResourceQuotaDetails.hard_limits:type_name -> api.v1.ResourceQuotaDetails.HardLimitsEntry - 165, // 224: api.v1.ResourceQuotaDetails.used:type_name -> api.v1.ResourceQuotaDetails.UsedEntry - 166, // 225: api.v1.ResourceQuotaDetails.scope_selector:type_name -> api.v1.ResourceQuotaDetails.ScopeSelectorEntry - 118, // 226: api.v1.ResourceQuotaDetails.conditions:type_name -> api.v1.ResourceQuotaCondition - 30, // 227: api.v1.VolcanoJobDetails.containers:type_name -> api.v1.ContainerTemplate - 120, // 228: api.v1.VolcanoJobDetails.conditions:type_name -> api.v1.VolcanoJobCondition - 121, // 229: api.v1.VolcanoJobDetails.tasks:type_name -> api.v1.VolcanoTask - 30, // 230: api.v1.VolcanoTask.containers:type_name -> api.v1.ContainerTemplate - 30, // 231: api.v1.SparkApplicationDetails.containers:type_name -> api.v1.ContainerTemplate - 123, // 232: api.v1.SparkApplicationDetails.spark_driver_info:type_name -> api.v1.SparkDriverInfo - 124, // 233: api.v1.SparkApplicationDetails.restart_policy:type_name -> api.v1.SparkRestartPolicyInfo - 125, // 234: api.v1.SparkApplicationDetails.dynamic_allocation:type_name -> api.v1.SparkDynamicAllocationInfo - 167, // 235: api.v1.ScheduledSparkApplicationDetails.last_run:type_name -> google.protobuf.Timestamp - 167, // 236: api.v1.ScheduledSparkApplicationDetails.next_run:type_name -> google.protobuf.Timestamp - 122, // 237: api.v1.ScheduledSparkApplicationDetails.template_details:type_name -> api.v1.SparkApplicationDetails - 167, // 238: api.v1.Event.created_at:type_name -> google.protobuf.Timestamp - 167, // 239: api.v1.Event.updated_at:type_name -> google.protobuf.Timestamp - 167, // 240: api.v1.Event.last_seen:type_name -> google.protobuf.Timestamp - 167, // 241: api.v1.Event.deleted_at:type_name -> google.protobuf.Timestamp - 128, // 242: api.v1.EventDatapoint.events:type_name -> api.v1.EventDatapointInfo - 243, // [243:243] is the sub-list for method output_type - 243, // [243:243] is the sub-list for method input_type - 243, // [243:243] is the sub-list for extension type_name - 243, // [243:243] is the sub-list for extension extendee - 0, // [0:243] is the sub-list for field type_name + 176, // 4: api.v1.CostInfo.node_recommendation_saved_cost_last_month:type_name -> google.type.Money + 176, // 5: api.v1.CostInfo.money_cpu_cost_per_hour:type_name -> google.type.Money + 176, // 6: api.v1.CostInfo.money_memory_cost_per_hour:type_name -> google.type.Money + 176, // 7: api.v1.CostInfo.money_total_cost_per_hour:type_name -> google.type.Money + 176, // 8: api.v1.CostInfo.money_total_cost_per_month:type_name -> google.type.Money + 176, // 9: api.v1.CostInfo.money_total_cost_per_year:type_name -> google.type.Money + 176, // 10: api.v1.CostInfo.money_optimized_cpu_cost_per_hour:type_name -> google.type.Money + 176, // 11: api.v1.CostInfo.money_optimized_memory_cost_per_hour:type_name -> google.type.Money + 176, // 12: api.v1.CostInfo.money_optimized_total_cost_per_hour:type_name -> google.type.Money + 176, // 13: api.v1.CostInfo.money_optimized_total_cost_per_month:type_name -> google.type.Money + 176, // 14: api.v1.CostInfo.money_optimized_total_cost_per_year:type_name -> google.type.Money + 176, // 15: api.v1.CostInfo.money_cpu_cost_for_time_period:type_name -> google.type.Money + 176, // 16: api.v1.CostInfo.money_memory_cost_for_time_period:type_name -> google.type.Money + 176, // 17: api.v1.CostInfo.money_total_cost_for_time_period:type_name -> google.type.Money + 176, // 18: api.v1.CostInfo.money_optimized_cpu_cost_for_time_period:type_name -> google.type.Money + 176, // 19: api.v1.CostInfo.money_optimized_memory_cost_for_time_period:type_name -> google.type.Money + 176, // 20: api.v1.CostInfo.money_optimized_total_cost_for_time_period:type_name -> google.type.Money + 176, // 21: api.v1.CostInfo.money_optimized_gpu_cost_for_time_period:type_name -> google.type.Money + 176, // 22: api.v1.CostInfo.money_gpu_cost_for_time_period:type_name -> google.type.Money + 176, // 23: api.v1.CostInfo.money_gpu_cost_per_hour:type_name -> google.type.Money + 176, // 24: api.v1.CostInfo.money_optimized_gpu_cost_per_hour:type_name -> google.type.Money + 176, // 25: api.v1.CostInfo.money_cpu_cost_per_vcpu_per_hour:type_name -> google.type.Money + 176, // 26: api.v1.CostInfo.money_memory_cost_per_gib_per_hour:type_name -> google.type.Money + 8, // 27: api.v1.ContainerPercentileSummary.cpu_usage:type_name -> api.v1.MetricPercentiles + 8, // 28: api.v1.ContainerPercentileSummary.memory_usage:type_name -> api.v1.MetricPercentiles + 8, // 29: api.v1.ContainerPercentileSummary.cpu_request:type_name -> api.v1.MetricPercentiles + 8, // 30: api.v1.ContainerPercentileSummary.memory_request:type_name -> api.v1.MetricPercentiles + 8, // 31: api.v1.ContainerPercentileSummary.cpu_limit:type_name -> api.v1.MetricPercentiles + 8, // 32: api.v1.ContainerPercentileSummary.memory_limit:type_name -> api.v1.MetricPercentiles + 8, // 33: api.v1.ContainerPercentileSummary.gpu_usage:type_name -> api.v1.MetricPercentiles + 8, // 34: api.v1.ContainerPercentileSummary.gpu_vram_usage:type_name -> api.v1.MetricPercentiles + 8, // 35: api.v1.ContainerPercentileSummary.network_receive_bytes:type_name -> api.v1.MetricPercentiles + 8, // 36: api.v1.ContainerPercentileSummary.network_transmit_bytes:type_name -> api.v1.MetricPercentiles + 8, // 37: api.v1.ContainerPercentileSummary.fs_read_bytes:type_name -> api.v1.MetricPercentiles + 8, // 38: api.v1.ContainerPercentileSummary.fs_write_bytes:type_name -> api.v1.MetricPercentiles + 8, // 39: api.v1.ContainerFsPercentileSummary.fs_read_bytes:type_name -> api.v1.MetricPercentiles + 8, // 40: api.v1.ContainerFsPercentileSummary.fs_write_bytes:type_name -> api.v1.MetricPercentiles + 175, // 41: api.v1.ForecastResourceMetrics.timestamp:type_name -> google.protobuf.Timestamp + 14, // 42: api.v1.WorkloadItem.children:type_name -> api.v1.WorkloadItem + 136, // 43: api.v1.WorkloadItem.labels:type_name -> api.v1.WorkloadItem.LabelsEntry + 137, // 44: api.v1.WorkloadItem.annotations:type_name -> api.v1.WorkloadItem.AnnotationsEntry + 7, // 45: api.v1.WorkloadItem.resource_metrics:type_name -> api.v1.ResourceMetrics + 6, // 46: api.v1.WorkloadItem.cost_info:type_name -> api.v1.CostInfo + 21, // 47: api.v1.WorkloadItem.cost_data_points:type_name -> api.v1.CostDataPoint + 22, // 48: api.v1.WorkloadItem.resource_data_points:type_name -> api.v1.ResourceDataPoint + 175, // 49: api.v1.WorkloadItem.created_at:type_name -> google.protobuf.Timestamp + 175, // 50: api.v1.WorkloadItem.deleted_at:type_name -> google.protobuf.Timestamp + 30, // 51: api.v1.WorkloadItem.resource_details:type_name -> api.v1.ResourceDetails + 7, // 52: api.v1.Node.resource_metrics:type_name -> api.v1.ResourceMetrics + 6, // 53: api.v1.Node.cost_info:type_name -> api.v1.CostInfo + 15, // 54: api.v1.Node.container_runtime:type_name -> api.v1.ContainerRuntimeInfo + 30, // 55: api.v1.Node.resource_details:type_name -> api.v1.ResourceDetails + 14, // 56: api.v1.Node.children:type_name -> api.v1.WorkloadItem + 138, // 57: api.v1.Node.labels:type_name -> api.v1.Node.LabelsEntry + 139, // 58: api.v1.Node.annotations:type_name -> api.v1.Node.AnnotationsEntry + 176, // 59: api.v1.Node.money_price_per_hour:type_name -> google.type.Money + 176, // 60: api.v1.Node.money_eff_period_total_cost:type_name -> google.type.Money + 176, // 61: api.v1.Node.money_price_per_vcpu:type_name -> google.type.Money + 176, // 62: api.v1.Node.money_price_per_gib:type_name -> google.type.Money + 176, // 63: api.v1.Node.money_price_per_gpu:type_name -> google.type.Money + 176, // 64: api.v1.Node.money_cpu_price:type_name -> google.type.Money + 176, // 65: api.v1.Node.money_memory_price:type_name -> google.type.Money + 176, // 66: api.v1.Node.money_gpu_price:type_name -> google.type.Money + 19, // 67: api.v1.Node.volumes_attached:type_name -> api.v1.AttachedVolume + 175, // 68: api.v1.Node.last_seen:type_name -> google.protobuf.Timestamp + 175, // 69: api.v1.Node.collected_at:type_name -> google.protobuf.Timestamp + 175, // 70: api.v1.Node.deletion_timestamp:type_name -> google.protobuf.Timestamp + 18, // 71: api.v1.NodeGroup.nodes:type_name -> api.v1.Node + 7, // 72: api.v1.NodeGroup.resource_metrics:type_name -> api.v1.ResourceMetrics + 6, // 73: api.v1.NodeGroup.cost_info:type_name -> api.v1.CostInfo + 16, // 74: api.v1.NodeGroup.node_info:type_name -> api.v1.NodeInfo + 17, // 75: api.v1.NodeGroup.resource_info:type_name -> api.v1.ResourceInfo + 21, // 76: api.v1.NodeGroup.cost_data_points:type_name -> api.v1.CostDataPoint + 22, // 77: api.v1.NodeGroup.resource_data_points:type_name -> api.v1.ResourceDataPoint + 6, // 78: api.v1.CostDataPoint.cost_info:type_name -> api.v1.CostInfo + 7, // 79: api.v1.ResourceDataPoint.resource_metrics:type_name -> api.v1.ResourceMetrics + 23, // 80: api.v1.SavingsDataPoint.savings_data:type_name -> api.v1.SavingsData + 24, // 81: api.v1.SavingsTimeSeries.savings_datapoints:type_name -> api.v1.SavingsDataPoint + 2, // 82: api.v1.LabelSelectorRequirement.operator:type_name -> api.v1.LabelSelectorOperator + 27, // 83: api.v1.LabelSelector.labels:type_name -> api.v1.Label + 140, // 84: api.v1.LabelSelector.match_labels:type_name -> api.v1.LabelSelector.MatchLabelsEntry + 26, // 85: api.v1.LabelSelector.match_expressions:type_name -> api.v1.LabelSelectorRequirement + 31, // 86: api.v1.ResourceDetails.pod_details:type_name -> api.v1.PodDetails + 33, // 87: api.v1.ResourceDetails.deployment_details:type_name -> api.v1.DeploymentDetails + 36, // 88: api.v1.ResourceDetails.stateful_set_details:type_name -> api.v1.StatefulSetDetails + 38, // 89: api.v1.ResourceDetails.daemon_set_details:type_name -> api.v1.DaemonSetDetails + 39, // 90: api.v1.ResourceDetails.replica_set_details:type_name -> api.v1.ReplicaSetDetails + 40, // 91: api.v1.ResourceDetails.job_details:type_name -> api.v1.JobDetails + 42, // 92: api.v1.ResourceDetails.cron_job_details:type_name -> api.v1.CronJobDetails + 45, // 93: api.v1.ResourceDetails.service_details:type_name -> api.v1.ServiceDetails + 48, // 94: api.v1.ResourceDetails.ingress_details:type_name -> api.v1.IngressDetails + 53, // 95: api.v1.ResourceDetails.pvc_details:type_name -> api.v1.PersistentVolumeClaimDetails + 57, // 96: api.v1.ResourceDetails.pv_details:type_name -> api.v1.PersistentVolumeDetails + 63, // 97: api.v1.ResourceDetails.sc_details:type_name -> api.v1.StorageClassDetails + 64, // 98: api.v1.ResourceDetails.ns_details:type_name -> api.v1.NamespaceDetails + 65, // 99: api.v1.ResourceDetails.node_details:type_name -> api.v1.NodeDetails + 77, // 100: api.v1.ResourceDetails.hpa_details:type_name -> api.v1.HPADetails + 95, // 101: api.v1.ResourceDetails.vpa_details:type_name -> api.v1.VPADetails + 103, // 102: api.v1.ResourceDetails.limit_range_details:type_name -> api.v1.LimitRangeDetails + 105, // 103: api.v1.ResourceDetails.service_account_details:type_name -> api.v1.ServiceAccountDetails + 106, // 104: api.v1.ResourceDetails.role_details:type_name -> api.v1.RoleDetails + 108, // 105: api.v1.ResourceDetails.role_binding_details:type_name -> api.v1.RoleBindingDetails + 111, // 106: api.v1.ResourceDetails.keda_scaled_object_details:type_name -> api.v1.KedaScaledObjectDetails + 114, // 107: api.v1.ResourceDetails.karpenter_resource_details:type_name -> api.v1.KarpenterResourceDetails + 119, // 108: api.v1.ResourceDetails.pod_disruption_budget_details:type_name -> api.v1.PodDisruptionBudgetDetails + 121, // 109: api.v1.ResourceDetails.resource_quota_details:type_name -> api.v1.ResourceQuotaDetails + 123, // 110: api.v1.ResourceDetails.volcano_job_details:type_name -> api.v1.VolcanoJobDetails + 126, // 111: api.v1.ResourceDetails.spark_application_details:type_name -> api.v1.SparkApplicationDetails + 130, // 112: api.v1.ResourceDetails.scheduled_spark_application_details:type_name -> api.v1.ScheduledSparkApplicationDetails + 46, // 113: api.v1.ResourceDetails.service_ports:type_name -> api.v1.ServicePort + 141, // 114: api.v1.ResourceDetails.service_selector:type_name -> api.v1.ResourceDetails.ServiceSelectorEntry + 142, // 115: api.v1.ResourceDetails.sc_parameters:type_name -> api.v1.ResourceDetails.ScParametersEntry + 66, // 116: api.v1.ResourceDetails.node_taints:type_name -> api.v1.NodeTaint + 32, // 117: api.v1.PodDetails.containers:type_name -> api.v1.ContainerSummary + 34, // 118: api.v1.DeploymentDetails.containers:type_name -> api.v1.ContainerTemplate + 35, // 119: api.v1.DeploymentDetails.conditions:type_name -> api.v1.DeploymentCondition + 34, // 120: api.v1.StatefulSetDetails.containers:type_name -> api.v1.ContainerTemplate + 37, // 121: api.v1.StatefulSetDetails.volume_claim_templates:type_name -> api.v1.VolumeClaimTemplate + 34, // 122: api.v1.DaemonSetDetails.containers:type_name -> api.v1.ContainerTemplate + 73, // 123: api.v1.DaemonSetDetails.tolerations:type_name -> api.v1.TolerationInfo + 74, // 124: api.v1.DaemonSetDetails.node_selector:type_name -> api.v1.NodeSelector + 34, // 125: api.v1.ReplicaSetDetails.containers:type_name -> api.v1.ContainerTemplate + 28, // 126: api.v1.ReplicaSetDetails.selector:type_name -> api.v1.LabelSelector + 34, // 127: api.v1.JobDetails.containers:type_name -> api.v1.ContainerTemplate + 41, // 128: api.v1.JobDetails.conditions:type_name -> api.v1.JobCondition + 28, // 129: api.v1.JobDetails.selector:type_name -> api.v1.LabelSelector + 34, // 130: api.v1.CronJobDetails.containers:type_name -> api.v1.ContainerTemplate + 43, // 131: api.v1.CronJobDetails.active_jobs:type_name -> api.v1.ActiveJobReference + 44, // 132: api.v1.CronJobDetails.job_template:type_name -> api.v1.JobTemplate + 34, // 133: api.v1.JobTemplate.containers:type_name -> api.v1.ContainerTemplate + 46, // 134: api.v1.ServiceDetails.ports:type_name -> api.v1.ServicePort + 143, // 135: api.v1.ServiceDetails.selector:type_name -> api.v1.ServiceDetails.SelectorEntry + 47, // 136: api.v1.ServiceDetails.load_balancer_ingress:type_name -> api.v1.LoadBalancerIngress + 49, // 137: api.v1.IngressDetails.rules:type_name -> api.v1.IngressRule + 52, // 138: api.v1.IngressDetails.tls:type_name -> api.v1.IngressTLS + 51, // 139: api.v1.IngressDetails.default_backend:type_name -> api.v1.IngressBackend + 47, // 140: api.v1.IngressDetails.load_balancer_ingress:type_name -> api.v1.LoadBalancerIngress + 50, // 141: api.v1.IngressRule.paths:type_name -> api.v1.IngressPath + 51, // 142: api.v1.IngressPath.backend:type_name -> api.v1.IngressBackend + 54, // 143: api.v1.PersistentVolumeClaimDetails.resource_requirements:type_name -> api.v1.ResourceRequirements + 28, // 144: api.v1.PersistentVolumeClaimDetails.selector:type_name -> api.v1.LabelSelector + 55, // 145: api.v1.PersistentVolumeClaimDetails.volume_node_affinity:type_name -> api.v1.VolumeNodeAffinity + 56, // 146: api.v1.PersistentVolumeClaimDetails.conditions:type_name -> api.v1.PVCCondition + 144, // 147: api.v1.ResourceRequirements.requests:type_name -> api.v1.ResourceRequirements.RequestsEntry + 145, // 148: api.v1.ResourceRequirements.limits:type_name -> api.v1.ResourceRequirements.LimitsEntry + 76, // 149: api.v1.VolumeNodeAffinity.required:type_name -> api.v1.NodeSelectorRequirement + 76, // 150: api.v1.VolumeNodeAffinity.preferred:type_name -> api.v1.NodeSelectorRequirement + 146, // 151: api.v1.PersistentVolumeDetails.capacity:type_name -> api.v1.PersistentVolumeDetails.CapacityEntry + 58, // 152: api.v1.PersistentVolumeDetails.claim_ref:type_name -> api.v1.PVClaimReference + 59, // 153: api.v1.PersistentVolumeDetails.volume_source:type_name -> api.v1.PVVolumeSource + 74, // 154: api.v1.PersistentVolumeDetails.node_affinity:type_name -> api.v1.NodeSelector + 60, // 155: api.v1.PVVolumeSource.csi:type_name -> api.v1.CSIVolumeSource + 61, // 156: api.v1.PVVolumeSource.host_path:type_name -> api.v1.HostPathVolumeSource + 62, // 157: api.v1.PVVolumeSource.nfs:type_name -> api.v1.NFSVolumeSource + 147, // 158: api.v1.PVVolumeSource.volume_attributes:type_name -> api.v1.PVVolumeSource.VolumeAttributesEntry + 148, // 159: api.v1.CSIVolumeSource.volume_attributes:type_name -> api.v1.CSIVolumeSource.VolumeAttributesEntry + 149, // 160: api.v1.StorageClassDetails.parameters:type_name -> api.v1.StorageClassDetails.ParametersEntry + 71, // 161: api.v1.StorageClassDetails.allowed_topologies:type_name -> api.v1.TopologySelector + 150, // 162: api.v1.NamespaceDetails.conditions:type_name -> api.v1.NamespaceDetails.ConditionsEntry + 67, // 163: api.v1.NodeDetails.addresses:type_name -> api.v1.NodeAddress + 68, // 164: api.v1.NodeDetails.conditions:type_name -> api.v1.NodeCondition + 69, // 165: api.v1.NodeDetails.system_info:type_name -> api.v1.NodeSystemInfo + 151, // 166: api.v1.NodeDetails.capacity:type_name -> api.v1.NodeDetails.CapacityEntry + 152, // 167: api.v1.NodeDetails.allocatable:type_name -> api.v1.NodeDetails.AllocatableEntry + 70, // 168: api.v1.NodeDetails.images:type_name -> api.v1.NodeImage + 72, // 169: api.v1.TopologySelector.match_label_expressions:type_name -> api.v1.TopologySelectorTerm + 153, // 170: api.v1.TopologySelectorTerm.match_labels:type_name -> api.v1.TopologySelectorTerm.MatchLabelsEntry + 75, // 171: api.v1.NodeSelector.terms:type_name -> api.v1.NodeSelectorTerm + 76, // 172: api.v1.NodeSelectorTerm.match_expressions:type_name -> api.v1.NodeSelectorRequirement + 76, // 173: api.v1.NodeSelectorTerm.match_fields:type_name -> api.v1.NodeSelectorRequirement + 78, // 174: api.v1.HPADetails.scale_target_ref:type_name -> api.v1.ScaleTargetRef + 79, // 175: api.v1.HPADetails.metrics:type_name -> api.v1.HPAMetric + 91, // 176: api.v1.HPADetails.conditions:type_name -> api.v1.HPACondition + 92, // 177: api.v1.HPADetails.behavior:type_name -> api.v1.HPABehavior + 86, // 178: api.v1.HPADetails.current_metrics:type_name -> api.v1.HPACurrentMetric + 80, // 179: api.v1.HPAMetric.resource:type_name -> api.v1.HPAResourceMetric + 81, // 180: api.v1.HPAMetric.pods:type_name -> api.v1.HPAPodsMetric + 82, // 181: api.v1.HPAMetric.object:type_name -> api.v1.HPAObjectMetric + 83, // 182: api.v1.HPAMetric.external:type_name -> api.v1.HPAExternalMetric + 84, // 183: api.v1.HPAPodsMetric.metric:type_name -> api.v1.HPAMetricSelector + 85, // 184: api.v1.HPAObjectMetric.described_object:type_name -> api.v1.HPAObjectReference + 84, // 185: api.v1.HPAObjectMetric.metric:type_name -> api.v1.HPAMetricSelector + 84, // 186: api.v1.HPAExternalMetric.metric:type_name -> api.v1.HPAMetricSelector + 154, // 187: api.v1.HPAMetricSelector.selector:type_name -> api.v1.HPAMetricSelector.SelectorEntry + 87, // 188: api.v1.HPACurrentMetric.resource:type_name -> api.v1.HPACurrentResourceMetric + 88, // 189: api.v1.HPACurrentMetric.pods:type_name -> api.v1.HPACurrentPodsMetric + 89, // 190: api.v1.HPACurrentMetric.object:type_name -> api.v1.HPACurrentObjectMetric + 90, // 191: api.v1.HPACurrentMetric.external:type_name -> api.v1.HPACurrentExternalMetric + 84, // 192: api.v1.HPACurrentPodsMetric.metric:type_name -> api.v1.HPAMetricSelector + 85, // 193: api.v1.HPACurrentObjectMetric.described_object:type_name -> api.v1.HPAObjectReference + 84, // 194: api.v1.HPACurrentObjectMetric.metric:type_name -> api.v1.HPAMetricSelector + 84, // 195: api.v1.HPACurrentExternalMetric.metric:type_name -> api.v1.HPAMetricSelector + 93, // 196: api.v1.HPABehavior.scale_up:type_name -> api.v1.HPAScalingRules + 93, // 197: api.v1.HPABehavior.scale_down:type_name -> api.v1.HPAScalingRules + 94, // 198: api.v1.HPAScalingRules.policies:type_name -> api.v1.HPAScalingPolicy + 96, // 199: api.v1.VPADetails.target_ref:type_name -> api.v1.VPATargetRef + 97, // 200: api.v1.VPADetails.update_policy:type_name -> api.v1.VPAUpdatePolicy + 98, // 201: api.v1.VPADetails.resource_policy:type_name -> api.v1.VPAResourcePolicy + 100, // 202: api.v1.VPADetails.recommendation:type_name -> api.v1.VPARecommendation + 102, // 203: api.v1.VPADetails.conditions:type_name -> api.v1.VPACondition + 99, // 204: api.v1.VPAResourcePolicy.container_policies:type_name -> api.v1.VPAContainerResourcePolicy + 155, // 205: api.v1.VPAContainerResourcePolicy.min_allowed:type_name -> api.v1.VPAContainerResourcePolicy.MinAllowedEntry + 156, // 206: api.v1.VPAContainerResourcePolicy.max_allowed:type_name -> api.v1.VPAContainerResourcePolicy.MaxAllowedEntry + 101, // 207: api.v1.VPARecommendation.container_recommendations:type_name -> api.v1.VPAContainerRecommendation + 157, // 208: api.v1.VPAContainerRecommendation.target:type_name -> api.v1.VPAContainerRecommendation.TargetEntry + 158, // 209: api.v1.VPAContainerRecommendation.lower_bound:type_name -> api.v1.VPAContainerRecommendation.LowerBoundEntry + 159, // 210: api.v1.VPAContainerRecommendation.upper_bound:type_name -> api.v1.VPAContainerRecommendation.UpperBoundEntry + 160, // 211: api.v1.VPAContainerRecommendation.uncapped_target:type_name -> api.v1.VPAContainerRecommendation.UncappedTargetEntry + 104, // 212: api.v1.LimitRangeDetails.limits:type_name -> api.v1.LimitRangeItem + 161, // 213: api.v1.LimitRangeItem.default_limits:type_name -> api.v1.LimitRangeItem.DefaultLimitsEntry + 162, // 214: api.v1.LimitRangeItem.default_request:type_name -> api.v1.LimitRangeItem.DefaultRequestEntry + 163, // 215: api.v1.LimitRangeItem.max:type_name -> api.v1.LimitRangeItem.MaxEntry + 164, // 216: api.v1.LimitRangeItem.min:type_name -> api.v1.LimitRangeItem.MinEntry + 165, // 217: api.v1.LimitRangeItem.max_limit_request_ratio:type_name -> api.v1.LimitRangeItem.MaxLimitRequestRatioEntry + 107, // 218: api.v1.RoleDetails.rules:type_name -> api.v1.RoleRule + 109, // 219: api.v1.RoleBindingDetails.subjects:type_name -> api.v1.RoleBindingSubject + 110, // 220: api.v1.RoleBindingDetails.role_ref:type_name -> api.v1.RoleReference + 112, // 221: api.v1.KedaScaledObjectDetails.triggers:type_name -> api.v1.KedaScaledObjectTrigger + 113, // 222: api.v1.KedaScaledObjectDetails.conditions:type_name -> api.v1.KedaScaledObjectCondition + 166, // 223: api.v1.KedaScaledObjectTrigger.metadata:type_name -> api.v1.KedaScaledObjectTrigger.MetadataEntry + 115, // 224: api.v1.KarpenterResourceDetails.conditions:type_name -> api.v1.KarpenterResourceCondition + 116, // 225: api.v1.KarpenterResourceDetails.capacity:type_name -> api.v1.KarpenterCapacity + 117, // 226: api.v1.KarpenterResourceDetails.requirements:type_name -> api.v1.KarpenterRequirement + 167, // 227: api.v1.KarpenterResourceDetails.limits:type_name -> api.v1.KarpenterResourceDetails.LimitsEntry + 168, // 228: api.v1.KarpenterCapacity.other:type_name -> api.v1.KarpenterCapacity.OtherEntry + 28, // 229: api.v1.WorkloadFilters.namespace_selector:type_name -> api.v1.LabelSelector + 28, // 230: api.v1.WorkloadFilters.workload_selector:type_name -> api.v1.LabelSelector + 0, // 231: api.v1.WorkloadFilters.kind_filter:type_name -> api.v1.K8sObjectKind + 29, // 232: api.v1.WorkloadFilters.name_pattern:type_name -> api.v1.RegexPattern + 28, // 233: api.v1.WorkloadFilters.annotation_selector:type_name -> api.v1.LabelSelector + 3, // 234: api.v1.WorkloadFilters.status:type_name -> api.v1.WorkloadStatusFilter + 169, // 235: api.v1.PodDisruptionBudgetDetails.selector_labels:type_name -> api.v1.PodDisruptionBudgetDetails.SelectorLabelsEntry + 120, // 236: api.v1.PodDisruptionBudgetDetails.conditions:type_name -> api.v1.PodDisruptionBudgetCondition + 170, // 237: api.v1.ResourceQuotaDetails.hard_limits:type_name -> api.v1.ResourceQuotaDetails.HardLimitsEntry + 171, // 238: api.v1.ResourceQuotaDetails.used:type_name -> api.v1.ResourceQuotaDetails.UsedEntry + 172, // 239: api.v1.ResourceQuotaDetails.scope_selector:type_name -> api.v1.ResourceQuotaDetails.ScopeSelectorEntry + 122, // 240: api.v1.ResourceQuotaDetails.conditions:type_name -> api.v1.ResourceQuotaCondition + 34, // 241: api.v1.VolcanoJobDetails.containers:type_name -> api.v1.ContainerTemplate + 124, // 242: api.v1.VolcanoJobDetails.conditions:type_name -> api.v1.VolcanoJobCondition + 125, // 243: api.v1.VolcanoJobDetails.tasks:type_name -> api.v1.VolcanoTask + 34, // 244: api.v1.VolcanoTask.containers:type_name -> api.v1.ContainerTemplate + 34, // 245: api.v1.SparkApplicationDetails.containers:type_name -> api.v1.ContainerTemplate + 127, // 246: api.v1.SparkApplicationDetails.spark_driver_info:type_name -> api.v1.SparkDriverInfo + 128, // 247: api.v1.SparkApplicationDetails.restart_policy:type_name -> api.v1.SparkRestartPolicyInfo + 129, // 248: api.v1.SparkApplicationDetails.dynamic_allocation:type_name -> api.v1.SparkDynamicAllocationInfo + 175, // 249: api.v1.ScheduledSparkApplicationDetails.last_run:type_name -> google.protobuf.Timestamp + 175, // 250: api.v1.ScheduledSparkApplicationDetails.next_run:type_name -> google.protobuf.Timestamp + 126, // 251: api.v1.ScheduledSparkApplicationDetails.template_details:type_name -> api.v1.SparkApplicationDetails + 173, // 252: api.v1.Event.annotations:type_name -> api.v1.Event.AnnotationsEntry + 174, // 253: api.v1.Event.labels:type_name -> api.v1.Event.LabelsEntry + 175, // 254: api.v1.Event.created_at:type_name -> google.protobuf.Timestamp + 175, // 255: api.v1.Event.updated_at:type_name -> google.protobuf.Timestamp + 175, // 256: api.v1.Event.last_seen:type_name -> google.protobuf.Timestamp + 175, // 257: api.v1.Event.deleted_at:type_name -> google.protobuf.Timestamp + 132, // 258: api.v1.EventDatapoint.events:type_name -> api.v1.EventDatapointInfo + 175, // 259: api.v1.EventGroup.first_seen:type_name -> google.protobuf.Timestamp + 175, // 260: api.v1.EventGroup.last_seen:type_name -> google.protobuf.Timestamp + 261, // [261:261] is the sub-list for method output_type + 261, // [261:261] is the sub-list for method input_type + 261, // [261:261] is the sub-list for extension type_name + 261, // [261:261] is the sub-list for extension extendee + 0, // [0:261] is the sub-list for field type_name } func init() { file_api_v1_common_proto_init() } @@ -16785,7 +17815,7 @@ func file_api_v1_common_proto_init() { } } file_api_v1_common_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ForecastResourceMetrics); i { + switch v := v.(*MetricPercentiles); i { case 0: return &v.state case 1: @@ -16797,6 +17827,54 @@ func file_api_v1_common_proto_init() { } } file_api_v1_common_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerPercentileSummary); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_common_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerFsPercentileSummary); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_common_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerRequestLimits); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_common_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ForecastResourceMetrics); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_common_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ResourceSummary); i { case 0: return &v.state @@ -16808,7 +17886,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkloadItem); i { case 0: return &v.state @@ -16820,7 +17898,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ContainerRuntimeInfo); i { case 0: return &v.state @@ -16832,7 +17910,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeInfo); i { case 0: return &v.state @@ -16844,7 +17922,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ResourceInfo); i { case 0: return &v.state @@ -16856,7 +17934,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Node); i { case 0: return &v.state @@ -16868,7 +17946,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AttachedVolume); i { case 0: return &v.state @@ -16880,7 +17958,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeGroup); i { case 0: return &v.state @@ -16892,7 +17970,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CostDataPoint); i { case 0: return &v.state @@ -16904,7 +17982,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ResourceDataPoint); i { case 0: return &v.state @@ -16916,7 +17994,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SavingsData); i { case 0: return &v.state @@ -16928,7 +18006,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SavingsDataPoint); i { case 0: return &v.state @@ -16940,7 +18018,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SavingsTimeSeries); i { case 0: return &v.state @@ -16952,7 +18030,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LabelSelectorRequirement); i { case 0: return &v.state @@ -16964,7 +18042,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Label); i { case 0: return &v.state @@ -16976,7 +18054,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LabelSelector); i { case 0: return &v.state @@ -16988,7 +18066,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RegexPattern); i { case 0: return &v.state @@ -17000,7 +18078,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ResourceDetails); i { case 0: return &v.state @@ -17012,7 +18090,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PodDetails); i { case 0: return &v.state @@ -17024,7 +18102,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ContainerSummary); i { case 0: return &v.state @@ -17036,7 +18114,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DeploymentDetails); i { case 0: return &v.state @@ -17048,7 +18126,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ContainerTemplate); i { case 0: return &v.state @@ -17060,7 +18138,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DeploymentCondition); i { case 0: return &v.state @@ -17072,7 +18150,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StatefulSetDetails); i { case 0: return &v.state @@ -17084,7 +18162,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VolumeClaimTemplate); i { case 0: return &v.state @@ -17096,7 +18174,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DaemonSetDetails); i { case 0: return &v.state @@ -17108,7 +18186,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReplicaSetDetails); i { case 0: return &v.state @@ -17120,7 +18198,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*JobDetails); i { case 0: return &v.state @@ -17132,7 +18210,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*JobCondition); i { case 0: return &v.state @@ -17144,7 +18222,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CronJobDetails); i { case 0: return &v.state @@ -17156,7 +18234,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ActiveJobReference); i { case 0: return &v.state @@ -17168,7 +18246,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*JobTemplate); i { case 0: return &v.state @@ -17180,7 +18258,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ServiceDetails); i { case 0: return &v.state @@ -17192,7 +18270,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ServicePort); i { case 0: return &v.state @@ -17204,7 +18282,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LoadBalancerIngress); i { case 0: return &v.state @@ -17216,7 +18294,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*IngressDetails); i { case 0: return &v.state @@ -17228,7 +18306,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*IngressRule); i { case 0: return &v.state @@ -17240,7 +18318,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*IngressPath); i { case 0: return &v.state @@ -17252,7 +18330,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*IngressBackend); i { case 0: return &v.state @@ -17264,7 +18342,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*IngressTLS); i { case 0: return &v.state @@ -17276,7 +18354,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PersistentVolumeClaimDetails); i { case 0: return &v.state @@ -17288,7 +18366,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ResourceRequirements); i { case 0: return &v.state @@ -17300,7 +18378,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VolumeNodeAffinity); i { case 0: return &v.state @@ -17312,7 +18390,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PVCCondition); i { case 0: return &v.state @@ -17324,7 +18402,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PersistentVolumeDetails); i { case 0: return &v.state @@ -17336,7 +18414,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PVClaimReference); i { case 0: return &v.state @@ -17348,7 +18426,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PVVolumeSource); i { case 0: return &v.state @@ -17360,7 +18438,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CSIVolumeSource); i { case 0: return &v.state @@ -17372,7 +18450,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HostPathVolumeSource); i { case 0: return &v.state @@ -17384,7 +18462,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NFSVolumeSource); i { case 0: return &v.state @@ -17396,7 +18474,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StorageClassDetails); i { case 0: return &v.state @@ -17408,7 +18486,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NamespaceDetails); i { case 0: return &v.state @@ -17420,7 +18498,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeDetails); i { case 0: return &v.state @@ -17432,7 +18510,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeTaint); i { case 0: return &v.state @@ -17444,7 +18522,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeAddress); i { case 0: return &v.state @@ -17456,7 +18534,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeCondition); i { case 0: return &v.state @@ -17468,7 +18546,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeSystemInfo); i { case 0: return &v.state @@ -17480,7 +18558,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeImage); i { case 0: return &v.state @@ -17492,7 +18570,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TopologySelector); i { case 0: return &v.state @@ -17504,7 +18582,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TopologySelectorTerm); i { case 0: return &v.state @@ -17516,7 +18594,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TolerationInfo); i { case 0: return &v.state @@ -17528,7 +18606,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeSelector); i { case 0: return &v.state @@ -17540,7 +18618,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeSelectorTerm); i { case 0: return &v.state @@ -17552,7 +18630,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeSelectorRequirement); i { case 0: return &v.state @@ -17564,7 +18642,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPADetails); i { case 0: return &v.state @@ -17576,7 +18654,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ScaleTargetRef); i { case 0: return &v.state @@ -17588,7 +18666,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAMetric); i { case 0: return &v.state @@ -17600,7 +18678,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAResourceMetric); i { case 0: return &v.state @@ -17612,7 +18690,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAPodsMetric); i { case 0: return &v.state @@ -17624,7 +18702,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAObjectMetric); i { case 0: return &v.state @@ -17636,7 +18714,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAExternalMetric); i { case 0: return &v.state @@ -17648,7 +18726,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAMetricSelector); i { case 0: return &v.state @@ -17660,7 +18738,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAObjectReference); i { case 0: return &v.state @@ -17672,7 +18750,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPACurrentMetric); i { case 0: return &v.state @@ -17684,7 +18762,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPACurrentResourceMetric); i { case 0: return &v.state @@ -17696,7 +18774,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPACurrentPodsMetric); i { case 0: return &v.state @@ -17708,7 +18786,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPACurrentObjectMetric); i { case 0: return &v.state @@ -17720,7 +18798,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPACurrentExternalMetric); i { case 0: return &v.state @@ -17732,7 +18810,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPACondition); i { case 0: return &v.state @@ -17744,7 +18822,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPABehavior); i { case 0: return &v.state @@ -17756,7 +18834,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAScalingRules); i { case 0: return &v.state @@ -17768,7 +18846,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HPAScalingPolicy); i { case 0: return &v.state @@ -17780,7 +18858,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VPADetails); i { case 0: return &v.state @@ -17792,7 +18870,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VPATargetRef); i { case 0: return &v.state @@ -17804,7 +18882,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VPAUpdatePolicy); i { case 0: return &v.state @@ -17816,7 +18894,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VPAResourcePolicy); i { case 0: return &v.state @@ -17828,7 +18906,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VPAContainerResourcePolicy); i { case 0: return &v.state @@ -17840,7 +18918,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VPARecommendation); i { case 0: return &v.state @@ -17852,7 +18930,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VPAContainerRecommendation); i { case 0: return &v.state @@ -17864,7 +18942,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VPACondition); i { case 0: return &v.state @@ -17876,7 +18954,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LimitRangeDetails); i { case 0: return &v.state @@ -17888,7 +18966,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LimitRangeItem); i { case 0: return &v.state @@ -17900,7 +18978,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ServiceAccountDetails); i { case 0: return &v.state @@ -17912,7 +18990,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RoleDetails); i { case 0: return &v.state @@ -17924,7 +19002,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RoleRule); i { case 0: return &v.state @@ -17936,7 +19014,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RoleBindingDetails); i { case 0: return &v.state @@ -17948,7 +19026,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RoleBindingSubject); i { case 0: return &v.state @@ -17960,7 +19038,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RoleReference); i { case 0: return &v.state @@ -17972,7 +19050,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KedaScaledObjectDetails); i { case 0: return &v.state @@ -17984,7 +19062,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KedaScaledObjectTrigger); i { case 0: return &v.state @@ -17996,7 +19074,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KedaScaledObjectCondition); i { case 0: return &v.state @@ -18008,7 +19086,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KarpenterResourceDetails); i { case 0: return &v.state @@ -18020,7 +19098,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KarpenterResourceCondition); i { case 0: return &v.state @@ -18032,7 +19110,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KarpenterCapacity); i { case 0: return &v.state @@ -18044,7 +19122,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KarpenterRequirement); i { case 0: return &v.state @@ -18056,7 +19134,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkloadFilters); i { case 0: return &v.state @@ -18068,7 +19146,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PodDisruptionBudgetDetails); i { case 0: return &v.state @@ -18080,7 +19158,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PodDisruptionBudgetCondition); i { case 0: return &v.state @@ -18092,7 +19170,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ResourceQuotaDetails); i { case 0: return &v.state @@ -18104,7 +19182,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ResourceQuotaCondition); i { case 0: return &v.state @@ -18116,7 +19194,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VolcanoJobDetails); i { case 0: return &v.state @@ -18128,7 +19206,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VolcanoJobCondition); i { case 0: return &v.state @@ -18140,7 +19218,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VolcanoTask); i { case 0: return &v.state @@ -18152,7 +19230,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SparkApplicationDetails); i { case 0: return &v.state @@ -18164,7 +19242,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SparkDriverInfo); i { case 0: return &v.state @@ -18176,7 +19254,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SparkRestartPolicyInfo); i { case 0: return &v.state @@ -18188,7 +19266,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SparkDynamicAllocationInfo); i { case 0: return &v.state @@ -18200,7 +19278,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ScheduledSparkApplicationDetails); i { case 0: return &v.state @@ -18212,7 +19290,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[127].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Event); i { case 0: return &v.state @@ -18224,7 +19302,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*EventDatapointInfo); i { case 0: return &v.state @@ -18236,7 +19314,7 @@ func file_api_v1_common_proto_init() { return nil } } - file_api_v1_common_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_common_proto_msgTypes[129].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*EventDatapoint); i { case 0: return &v.state @@ -18248,11 +19326,35 @@ func file_api_v1_common_proto_init() { return nil } } + file_api_v1_common_proto_msgTypes[130].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DimensionCount); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_common_proto_msgTypes[131].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventGroup); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } } file_api_v1_common_proto_msgTypes[3].OneofWrappers = []interface{}{} - file_api_v1_common_proto_msgTypes[6].OneofWrappers = []interface{}{} file_api_v1_common_proto_msgTypes[10].OneofWrappers = []interface{}{} - file_api_v1_common_proto_msgTypes[22].OneofWrappers = []interface{}{ + file_api_v1_common_proto_msgTypes[14].OneofWrappers = []interface{}{} + file_api_v1_common_proto_msgTypes[26].OneofWrappers = []interface{}{ (*ResourceDetails_PodDetails)(nil), (*ResourceDetails_DeploymentDetails)(nil), (*ResourceDetails_StatefulSetDetails)(nil), @@ -18281,14 +19383,14 @@ func file_api_v1_common_proto_init() { (*ResourceDetails_SparkApplicationDetails)(nil), (*ResourceDetails_ScheduledSparkApplicationDetails)(nil), } - file_api_v1_common_proto_msgTypes[110].OneofWrappers = []interface{}{} + file_api_v1_common_proto_msgTypes[114].OneofWrappers = []interface{}{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_api_v1_common_proto_rawDesc, NumEnums: 4, - NumMessages: 163, + NumMessages: 171, NumExtensions: 0, NumServices: 0, }, diff --git a/gen/api/v1/k8s.pb.go b/gen/api/v1/k8s.pb.go index 7eb85b6f..186a7d2a 100644 --- a/gen/api/v1/k8s.pb.go +++ b/gen/api/v1/k8s.pb.go @@ -2920,6 +2920,390 @@ func (x *GetWorkloadResponse) GetResourceDataPoints() []*ResourceDataPoint { return nil } +// GetWorkloadContainerPercentilesRequest requests per-container percentile metrics for a workload. +type GetWorkloadContainerPercentilesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` + ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` + Uid string `protobuf:"bytes,4,opt,name=uid,proto3" json:"uid,omitempty"` + StartTime *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3,oneof" json:"start_time,omitempty"` + EndTime *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3,oneof" json:"end_time,omitempty"` +} + +func (x *GetWorkloadContainerPercentilesRequest) Reset() { + *x = GetWorkloadContainerPercentilesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetWorkloadContainerPercentilesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetWorkloadContainerPercentilesRequest) ProtoMessage() {} + +func (x *GetWorkloadContainerPercentilesRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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) +} + +// Deprecated: Use GetWorkloadContainerPercentilesRequest.ProtoReflect.Descriptor instead. +func (*GetWorkloadContainerPercentilesRequest) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{36} +} + +func (x *GetWorkloadContainerPercentilesRequest) GetTeamId() string { + if x != nil { + return x.TeamId + } + return "" +} + +func (x *GetWorkloadContainerPercentilesRequest) GetClusterId() string { + if x != nil { + return x.ClusterId + } + return "" +} + +func (x *GetWorkloadContainerPercentilesRequest) GetKind() string { + if x != nil { + return x.Kind + } + return "" +} + +func (x *GetWorkloadContainerPercentilesRequest) GetUid() string { + if x != nil { + return x.Uid + } + return "" +} + +func (x *GetWorkloadContainerPercentilesRequest) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *GetWorkloadContainerPercentilesRequest) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +// GetWorkloadContainerPercentilesResponse returns per-container percentile statistics. +type GetWorkloadContainerPercentilesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Containers []*ContainerPercentileSummary `protobuf:"bytes,1,rep,name=containers,proto3" json:"containers,omitempty"` +} + +func (x *GetWorkloadContainerPercentilesResponse) Reset() { + *x = GetWorkloadContainerPercentilesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetWorkloadContainerPercentilesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetWorkloadContainerPercentilesResponse) ProtoMessage() {} + +func (x *GetWorkloadContainerPercentilesResponse) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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) +} + +// Deprecated: Use GetWorkloadContainerPercentilesResponse.ProtoReflect.Descriptor instead. +func (*GetWorkloadContainerPercentilesResponse) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{37} +} + +func (x *GetWorkloadContainerPercentilesResponse) GetContainers() []*ContainerPercentileSummary { + if x != nil { + return x.Containers + } + return nil +} + +// GetWorkloadContainerFsPercentilesRequest requests per-container filesystem I/O percentiles for a workload. +type GetWorkloadContainerFsPercentilesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` + ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + Kind string `protobuf:"bytes,3,opt,name=kind,proto3" json:"kind,omitempty"` + Uid string `protobuf:"bytes,4,opt,name=uid,proto3" json:"uid,omitempty"` + StartTime *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3,oneof" json:"start_time,omitempty"` + EndTime *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3,oneof" json:"end_time,omitempty"` +} + +func (x *GetWorkloadContainerFsPercentilesRequest) Reset() { + *x = GetWorkloadContainerFsPercentilesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetWorkloadContainerFsPercentilesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetWorkloadContainerFsPercentilesRequest) ProtoMessage() {} + +func (x *GetWorkloadContainerFsPercentilesRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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) +} + +// Deprecated: Use GetWorkloadContainerFsPercentilesRequest.ProtoReflect.Descriptor instead. +func (*GetWorkloadContainerFsPercentilesRequest) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{38} +} + +func (x *GetWorkloadContainerFsPercentilesRequest) GetTeamId() string { + if x != nil { + return x.TeamId + } + return "" +} + +func (x *GetWorkloadContainerFsPercentilesRequest) GetClusterId() string { + if x != nil { + return x.ClusterId + } + return "" +} + +func (x *GetWorkloadContainerFsPercentilesRequest) GetKind() string { + if x != nil { + return x.Kind + } + return "" +} + +func (x *GetWorkloadContainerFsPercentilesRequest) GetUid() string { + if x != nil { + return x.Uid + } + return "" +} + +func (x *GetWorkloadContainerFsPercentilesRequest) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *GetWorkloadContainerFsPercentilesRequest) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +// GetWorkloadContainerFsPercentilesResponse returns per-container filesystem I/O percentile statistics. +type GetWorkloadContainerFsPercentilesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Containers []*ContainerFsPercentileSummary `protobuf:"bytes,1,rep,name=containers,proto3" json:"containers,omitempty"` +} + +func (x *GetWorkloadContainerFsPercentilesResponse) Reset() { + *x = GetWorkloadContainerFsPercentilesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetWorkloadContainerFsPercentilesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetWorkloadContainerFsPercentilesResponse) ProtoMessage() {} + +func (x *GetWorkloadContainerFsPercentilesResponse) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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) +} + +// Deprecated: Use GetWorkloadContainerFsPercentilesResponse.ProtoReflect.Descriptor instead. +func (*GetWorkloadContainerFsPercentilesResponse) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{39} +} + +func (x *GetWorkloadContainerFsPercentilesResponse) GetContainers() []*ContainerFsPercentileSummary { + if x != nil { + return x.Containers + } + return nil +} + +// GetLatestContainerRequestLimitsRequest requests the most recent request/limit values per container. +type GetLatestContainerRequestLimitsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` + ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + Uid string `protobuf:"bytes,3,opt,name=uid,proto3" json:"uid,omitempty"` +} + +func (x *GetLatestContainerRequestLimitsRequest) Reset() { + *x = GetLatestContainerRequestLimitsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetLatestContainerRequestLimitsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLatestContainerRequestLimitsRequest) ProtoMessage() {} + +func (x *GetLatestContainerRequestLimitsRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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 mi.MessageOf(x) +} + +// Deprecated: Use GetLatestContainerRequestLimitsRequest.ProtoReflect.Descriptor instead. +func (*GetLatestContainerRequestLimitsRequest) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{40} +} + +func (x *GetLatestContainerRequestLimitsRequest) GetTeamId() string { + if x != nil { + return x.TeamId + } + return "" +} + +func (x *GetLatestContainerRequestLimitsRequest) GetClusterId() string { + if x != nil { + return x.ClusterId + } + return "" +} + +func (x *GetLatestContainerRequestLimitsRequest) GetUid() string { + if x != nil { + return x.Uid + } + return "" +} + +// GetLatestContainerRequestLimitsResponse returns per-container request/limit values. +type GetLatestContainerRequestLimitsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Containers []*ContainerRequestLimits `protobuf:"bytes,1,rep,name=containers,proto3" json:"containers,omitempty"` +} + +func (x *GetLatestContainerRequestLimitsResponse) Reset() { + *x = GetLatestContainerRequestLimitsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetLatestContainerRequestLimitsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLatestContainerRequestLimitsResponse) ProtoMessage() {} + +func (x *GetLatestContainerRequestLimitsResponse) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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) +} + +// Deprecated: Use GetLatestContainerRequestLimitsResponse.ProtoReflect.Descriptor instead. +func (*GetLatestContainerRequestLimitsResponse) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{41} +} + +func (x *GetLatestContainerRequestLimitsResponse) GetContainers() []*ContainerRequestLimits { + if x != nil { + return x.Containers + } + return nil +} + // Request to get forecasted workloads type GetForecastWorkloadsRequest struct { state protoimpl.MessageState @@ -2936,7 +3320,7 @@ type GetForecastWorkloadsRequest struct { func (x *GetForecastWorkloadsRequest) Reset() { *x = GetForecastWorkloadsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[36] + mi := &file_api_v1_k8s_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2949,7 +3333,7 @@ func (x *GetForecastWorkloadsRequest) String() string { func (*GetForecastWorkloadsRequest) ProtoMessage() {} func (x *GetForecastWorkloadsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[36] + mi := &file_api_v1_k8s_proto_msgTypes[42] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2962,7 +3346,7 @@ func (x *GetForecastWorkloadsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetForecastWorkloadsRequest.ProtoReflect.Descriptor instead. func (*GetForecastWorkloadsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{36} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{42} } func (x *GetForecastWorkloadsRequest) GetTeamId() string { @@ -3015,7 +3399,7 @@ type GetForecastWorkloadsResponse struct { func (x *GetForecastWorkloadsResponse) Reset() { *x = GetForecastWorkloadsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[37] + mi := &file_api_v1_k8s_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3028,7 +3412,7 @@ func (x *GetForecastWorkloadsResponse) String() string { func (*GetForecastWorkloadsResponse) ProtoMessage() {} func (x *GetForecastWorkloadsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[37] + mi := &file_api_v1_k8s_proto_msgTypes[43] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3041,7 +3425,7 @@ func (x *GetForecastWorkloadsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetForecastWorkloadsResponse.ProtoReflect.Descriptor instead. func (*GetForecastWorkloadsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{37} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{43} } func (x *GetForecastWorkloadsResponse) GetWorkloadItems() []*WorkloadItem { @@ -3090,7 +3474,7 @@ type GetForecastWorkloadRequest struct { func (x *GetForecastWorkloadRequest) Reset() { *x = GetForecastWorkloadRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[38] + mi := &file_api_v1_k8s_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3103,7 +3487,7 @@ func (x *GetForecastWorkloadRequest) String() string { func (*GetForecastWorkloadRequest) ProtoMessage() {} func (x *GetForecastWorkloadRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[38] + mi := &file_api_v1_k8s_proto_msgTypes[44] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3116,7 +3500,7 @@ func (x *GetForecastWorkloadRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetForecastWorkloadRequest.ProtoReflect.Descriptor instead. func (*GetForecastWorkloadRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{38} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{44} } func (x *GetForecastWorkloadRequest) GetTeamId() string { @@ -3185,7 +3569,7 @@ type GetForecastWorkloadResponse struct { func (x *GetForecastWorkloadResponse) Reset() { *x = GetForecastWorkloadResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[39] + mi := &file_api_v1_k8s_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3198,7 +3582,7 @@ func (x *GetForecastWorkloadResponse) String() string { func (*GetForecastWorkloadResponse) ProtoMessage() {} func (x *GetForecastWorkloadResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[39] + mi := &file_api_v1_k8s_proto_msgTypes[45] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3211,7 +3595,7 @@ func (x *GetForecastWorkloadResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetForecastWorkloadResponse.ProtoReflect.Descriptor instead. func (*GetForecastWorkloadResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{39} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{45} } func (x *GetForecastWorkloadResponse) GetWorkloadItem() *WorkloadItem { @@ -3268,7 +3652,7 @@ type GetClusterMetadataResponse struct { func (x *GetClusterMetadataResponse) Reset() { *x = GetClusterMetadataResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[40] + mi := &file_api_v1_k8s_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3281,7 +3665,7 @@ func (x *GetClusterMetadataResponse) String() string { func (*GetClusterMetadataResponse) ProtoMessage() {} func (x *GetClusterMetadataResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[40] + mi := &file_api_v1_k8s_proto_msgTypes[46] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3294,7 +3678,7 @@ func (x *GetClusterMetadataResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetClusterMetadataResponse.ProtoReflect.Descriptor instead. func (*GetClusterMetadataResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{40} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{46} } func (x *GetClusterMetadataResponse) GetClusters() []*Cluster { @@ -3316,7 +3700,7 @@ type ClusterElement struct { func (x *ClusterElement) Reset() { *x = ClusterElement{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[41] + mi := &file_api_v1_k8s_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3329,7 +3713,7 @@ func (x *ClusterElement) String() string { func (*ClusterElement) ProtoMessage() {} func (x *ClusterElement) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[41] + mi := &file_api_v1_k8s_proto_msgTypes[47] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3342,7 +3726,7 @@ func (x *ClusterElement) ProtoReflect() protoreflect.Message { // Deprecated: Use ClusterElement.ProtoReflect.Descriptor instead. func (*ClusterElement) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{41} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{47} } func (x *ClusterElement) GetClusterId() string { @@ -3373,7 +3757,7 @@ type GetAllNamespacesRequest struct { func (x *GetAllNamespacesRequest) Reset() { *x = GetAllNamespacesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[42] + mi := &file_api_v1_k8s_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3386,7 +3770,7 @@ func (x *GetAllNamespacesRequest) String() string { func (*GetAllNamespacesRequest) ProtoMessage() {} func (x *GetAllNamespacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[42] + mi := &file_api_v1_k8s_proto_msgTypes[48] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3399,7 +3783,7 @@ func (x *GetAllNamespacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAllNamespacesRequest.ProtoReflect.Descriptor instead. func (*GetAllNamespacesRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{42} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{48} } func (x *GetAllNamespacesRequest) GetTeamId() string { @@ -3438,23 +3822,135 @@ type GetAllNamespacesResponse struct { ClusterIdWithNamespaces []*ClusterElement `protobuf:"bytes,1,rep,name=cluster_id_with_namespaces,json=clusterIdWithNamespaces,proto3" json:"cluster_id_with_namespaces,omitempty"` } -func (x *GetAllNamespacesResponse) Reset() { - *x = GetAllNamespacesResponse{} +func (x *GetAllNamespacesResponse) Reset() { + *x = GetAllNamespacesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAllNamespacesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAllNamespacesResponse) ProtoMessage() {} + +func (x *GetAllNamespacesResponse) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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) +} + +// Deprecated: Use GetAllNamespacesResponse.ProtoReflect.Descriptor instead. +func (*GetAllNamespacesResponse) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{49} +} + +func (x *GetAllNamespacesResponse) GetClusterIdWithNamespaces() []*ClusterElement { + if x != nil { + return x.ClusterIdWithNamespaces + } + return nil +} + +// SearchNamespacesByClusterRequest searches namespaces by name within a single cluster. +type SearchNamespacesByClusterRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` + ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + Search string `protobuf:"bytes,3,opt,name=search,proto3" json:"search,omitempty"` +} + +func (x *SearchNamespacesByClusterRequest) Reset() { + *x = SearchNamespacesByClusterRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SearchNamespacesByClusterRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchNamespacesByClusterRequest) ProtoMessage() {} + +func (x *SearchNamespacesByClusterRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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) +} + +// Deprecated: Use SearchNamespacesByClusterRequest.ProtoReflect.Descriptor instead. +func (*SearchNamespacesByClusterRequest) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{50} +} + +func (x *SearchNamespacesByClusterRequest) GetTeamId() string { + if x != nil { + return x.TeamId + } + return "" +} + +func (x *SearchNamespacesByClusterRequest) GetClusterId() string { + if x != nil { + return x.ClusterId + } + return "" +} + +func (x *SearchNamespacesByClusterRequest) GetSearch() string { + if x != nil { + return x.Search + } + return "" +} + +// SearchNamespacesByClusterResponse returns the matching namespace names. +type SearchNamespacesByClusterResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Namespaces []string `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces,omitempty"` +} + +func (x *SearchNamespacesByClusterResponse) Reset() { + *x = SearchNamespacesByClusterResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[43] + mi := &file_api_v1_k8s_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetAllNamespacesResponse) String() string { +func (x *SearchNamespacesByClusterResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetAllNamespacesResponse) ProtoMessage() {} +func (*SearchNamespacesByClusterResponse) ProtoMessage() {} -func (x *GetAllNamespacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[43] +func (x *SearchNamespacesByClusterResponse) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_proto_msgTypes[51] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3465,46 +3961,45 @@ func (x *GetAllNamespacesResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetAllNamespacesResponse.ProtoReflect.Descriptor instead. -func (*GetAllNamespacesResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{43} +// Deprecated: Use SearchNamespacesByClusterResponse.ProtoReflect.Descriptor instead. +func (*SearchNamespacesByClusterResponse) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{51} } -func (x *GetAllNamespacesResponse) GetClusterIdWithNamespaces() []*ClusterElement { +func (x *SearchNamespacesByClusterResponse) GetNamespaces() []string { if x != nil { - return x.ClusterIdWithNamespaces + return x.Namespaces } return nil } -// SearchNamespacesByClusterRequest searches namespaces by name within a single cluster. -type SearchNamespacesByClusterRequest struct { +// ListNamespacesByClusterRequest lists namespaces within a single cluster. +type ListNamespacesByClusterRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` - Search string `protobuf:"bytes,3,opt,name=search,proto3" json:"search,omitempty"` } -func (x *SearchNamespacesByClusterRequest) Reset() { - *x = SearchNamespacesByClusterRequest{} +func (x *ListNamespacesByClusterRequest) Reset() { + *x = ListNamespacesByClusterRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[44] + mi := &file_api_v1_k8s_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *SearchNamespacesByClusterRequest) String() string { +func (x *ListNamespacesByClusterRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SearchNamespacesByClusterRequest) ProtoMessage() {} +func (*ListNamespacesByClusterRequest) ProtoMessage() {} -func (x *SearchNamespacesByClusterRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[44] +func (x *ListNamespacesByClusterRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_proto_msgTypes[52] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3515,58 +4010,100 @@ func (x *SearchNamespacesByClusterRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SearchNamespacesByClusterRequest.ProtoReflect.Descriptor instead. -func (*SearchNamespacesByClusterRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{44} +// Deprecated: Use ListNamespacesByClusterRequest.ProtoReflect.Descriptor instead. +func (*ListNamespacesByClusterRequest) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{52} } -func (x *SearchNamespacesByClusterRequest) GetTeamId() string { +func (x *ListNamespacesByClusterRequest) GetTeamId() string { if x != nil { return x.TeamId } return "" } -func (x *SearchNamespacesByClusterRequest) GetClusterId() string { +func (x *ListNamespacesByClusterRequest) GetClusterId() string { if x != nil { return x.ClusterId } return "" } -func (x *SearchNamespacesByClusterRequest) GetSearch() string { +// ListNamespacesByClusterResponse returns namespace id and name pairs. +type ListNamespacesByClusterResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Namespaces []*NamespaceItem `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces,omitempty"` +} + +func (x *ListNamespacesByClusterResponse) Reset() { + *x = ListNamespacesByClusterResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_api_v1_k8s_proto_msgTypes[53] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListNamespacesByClusterResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListNamespacesByClusterResponse) ProtoMessage() {} + +func (x *ListNamespacesByClusterResponse) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_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) +} + +// Deprecated: Use ListNamespacesByClusterResponse.ProtoReflect.Descriptor instead. +func (*ListNamespacesByClusterResponse) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{53} +} + +func (x *ListNamespacesByClusterResponse) GetNamespaces() []*NamespaceItem { if x != nil { - return x.Search + return x.Namespaces } - return "" + return nil } -// SearchNamespacesByClusterResponse returns the matching namespace names. -type SearchNamespacesByClusterResponse struct { +// NamespaceItem represents a namespace with its id and name. +type NamespaceItem struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Namespaces []string `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` } -func (x *SearchNamespacesByClusterResponse) Reset() { - *x = SearchNamespacesByClusterResponse{} +func (x *NamespaceItem) Reset() { + *x = NamespaceItem{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[45] + mi := &file_api_v1_k8s_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *SearchNamespacesByClusterResponse) String() string { +func (x *NamespaceItem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SearchNamespacesByClusterResponse) ProtoMessage() {} +func (*NamespaceItem) ProtoMessage() {} -func (x *SearchNamespacesByClusterResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[45] +func (x *NamespaceItem) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_k8s_proto_msgTypes[54] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3577,16 +4114,23 @@ func (x *SearchNamespacesByClusterResponse) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use SearchNamespacesByClusterResponse.ProtoReflect.Descriptor instead. -func (*SearchNamespacesByClusterResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{45} +// Deprecated: Use NamespaceItem.ProtoReflect.Descriptor instead. +func (*NamespaceItem) Descriptor() ([]byte, []int) { + return file_api_v1_k8s_proto_rawDescGZIP(), []int{54} } -func (x *SearchNamespacesByClusterResponse) GetNamespaces() []string { +func (x *NamespaceItem) GetId() string { if x != nil { - return x.Namespaces + return x.Id } - return nil + return "" +} + +func (x *NamespaceItem) GetName() string { + if x != nil { + return x.Name + } + return "" } type GetAllWorkloadNamesRequest struct { @@ -3608,7 +4152,7 @@ type GetAllWorkloadNamesRequest struct { func (x *GetAllWorkloadNamesRequest) Reset() { *x = GetAllWorkloadNamesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[46] + mi := &file_api_v1_k8s_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3621,7 +4165,7 @@ func (x *GetAllWorkloadNamesRequest) String() string { func (*GetAllWorkloadNamesRequest) ProtoMessage() {} func (x *GetAllWorkloadNamesRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[46] + mi := &file_api_v1_k8s_proto_msgTypes[55] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3634,7 +4178,7 @@ func (x *GetAllWorkloadNamesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAllWorkloadNamesRequest.ProtoReflect.Descriptor instead. func (*GetAllWorkloadNamesRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{46} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{55} } func (x *GetAllWorkloadNamesRequest) GetTeamId() string { @@ -3711,7 +4255,7 @@ type GetAllWorkloadNamesResponse struct { func (x *GetAllWorkloadNamesResponse) Reset() { *x = GetAllWorkloadNamesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[47] + mi := &file_api_v1_k8s_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3724,7 +4268,7 @@ func (x *GetAllWorkloadNamesResponse) String() string { func (*GetAllWorkloadNamesResponse) ProtoMessage() {} func (x *GetAllWorkloadNamesResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[47] + mi := &file_api_v1_k8s_proto_msgTypes[56] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3737,7 +4281,7 @@ func (x *GetAllWorkloadNamesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAllWorkloadNamesResponse.ProtoReflect.Descriptor instead. func (*GetAllWorkloadNamesResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{47} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{56} } func (x *GetAllWorkloadNamesResponse) GetClusterIdWithWorkloadName() []*ClusterElement { @@ -3765,7 +4309,7 @@ type GetAllWorkloadLabelsRequest struct { func (x *GetAllWorkloadLabelsRequest) Reset() { *x = GetAllWorkloadLabelsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[48] + mi := &file_api_v1_k8s_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3778,7 +4322,7 @@ func (x *GetAllWorkloadLabelsRequest) String() string { func (*GetAllWorkloadLabelsRequest) ProtoMessage() {} func (x *GetAllWorkloadLabelsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[48] + mi := &file_api_v1_k8s_proto_msgTypes[57] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3791,7 +4335,7 @@ func (x *GetAllWorkloadLabelsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAllWorkloadLabelsRequest.ProtoReflect.Descriptor instead. func (*GetAllWorkloadLabelsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{48} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{57} } func (x *GetAllWorkloadLabelsRequest) GetTeamId() string { @@ -3861,7 +4405,7 @@ type GetAllWorkloadLabelsResponse struct { func (x *GetAllWorkloadLabelsResponse) Reset() { *x = GetAllWorkloadLabelsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[49] + mi := &file_api_v1_k8s_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3874,7 +4418,7 @@ func (x *GetAllWorkloadLabelsResponse) String() string { func (*GetAllWorkloadLabelsResponse) ProtoMessage() {} func (x *GetAllWorkloadLabelsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[49] + mi := &file_api_v1_k8s_proto_msgTypes[58] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3887,7 +4431,7 @@ func (x *GetAllWorkloadLabelsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAllWorkloadLabelsResponse.ProtoReflect.Descriptor instead. func (*GetAllWorkloadLabelsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{49} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{58} } func (x *GetAllWorkloadLabelsResponse) GetClusterIdWithLabels() []*ClusterElement { @@ -3912,7 +4456,7 @@ type GetAllNodeGroupNamesRequest struct { func (x *GetAllNodeGroupNamesRequest) Reset() { *x = GetAllNodeGroupNamesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[50] + mi := &file_api_v1_k8s_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3925,7 +4469,7 @@ func (x *GetAllNodeGroupNamesRequest) String() string { func (*GetAllNodeGroupNamesRequest) ProtoMessage() {} func (x *GetAllNodeGroupNamesRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[50] + mi := &file_api_v1_k8s_proto_msgTypes[59] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3938,7 +4482,7 @@ func (x *GetAllNodeGroupNamesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAllNodeGroupNamesRequest.ProtoReflect.Descriptor instead. func (*GetAllNodeGroupNamesRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{50} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{59} } func (x *GetAllNodeGroupNamesRequest) GetTeamId() string { @@ -3987,7 +4531,7 @@ type GetAllNodeGroupNamesResponse struct { func (x *GetAllNodeGroupNamesResponse) Reset() { *x = GetAllNodeGroupNamesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[51] + mi := &file_api_v1_k8s_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4000,7 +4544,7 @@ func (x *GetAllNodeGroupNamesResponse) String() string { func (*GetAllNodeGroupNamesResponse) ProtoMessage() {} func (x *GetAllNodeGroupNamesResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[51] + mi := &file_api_v1_k8s_proto_msgTypes[60] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4013,7 +4557,7 @@ func (x *GetAllNodeGroupNamesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAllNodeGroupNamesResponse.ProtoReflect.Descriptor instead. func (*GetAllNodeGroupNamesResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{51} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{60} } func (x *GetAllNodeGroupNamesResponse) GetClusterIdWithNodeGroupNames() []*ClusterElement { @@ -4065,12 +4609,13 @@ type Cluster struct { Underutilization float64 `protobuf:"fixed64,81,opt,name=underutilization,proto3" json:"underutilization,omitempty"` // Percentage of how much is cluster underutilized that is using combined numbers of cpu, memory and GPU Tags []string `protobuf:"bytes,91,rep,name=tags,proto3" json:"tags,omitempty"` // Tags for the cluster HasArgoWorkloads bool `protobuf:"varint,101,opt,name=has_argo_workloads,json=hasArgoWorkloads,proto3" json:"has_argo_workloads,omitempty"` // Whether any workload on this cluster is managed by Argo CD + KubernetesVersion string `protobuf:"bytes,110,opt,name=kubernetes_version,json=kubernetesVersion,proto3" json:"kubernetes_version,omitempty"` // Kubernetes version of the cluster (e.g. "v1.28.3") } func (x *Cluster) Reset() { *x = Cluster{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[52] + mi := &file_api_v1_k8s_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4083,7 +4628,7 @@ func (x *Cluster) String() string { func (*Cluster) ProtoMessage() {} func (x *Cluster) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[52] + mi := &file_api_v1_k8s_proto_msgTypes[61] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4096,7 +4641,7 @@ func (x *Cluster) ProtoReflect() protoreflect.Message { // Deprecated: Use Cluster.ProtoReflect.Descriptor instead. func (*Cluster) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{52} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{61} } func (x *Cluster) GetId() string { @@ -4351,6 +4896,13 @@ func (x *Cluster) GetHasArgoWorkloads() bool { return false } +func (x *Cluster) GetKubernetesVersion() string { + if x != nil { + return x.KubernetesVersion + } + return "" +} + type OperatorInfo struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -4364,7 +4916,7 @@ type OperatorInfo struct { func (x *OperatorInfo) Reset() { *x = OperatorInfo{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[53] + mi := &file_api_v1_k8s_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4377,7 +4929,7 @@ func (x *OperatorInfo) String() string { func (*OperatorInfo) ProtoMessage() {} func (x *OperatorInfo) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[53] + mi := &file_api_v1_k8s_proto_msgTypes[62] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4390,7 +4942,7 @@ func (x *OperatorInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use OperatorInfo.ProtoReflect.Descriptor instead. func (*OperatorInfo) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{53} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{62} } func (x *OperatorInfo) GetVersion() string { @@ -4428,7 +4980,7 @@ type Container struct { func (x *Container) Reset() { *x = Container{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[54] + mi := &file_api_v1_k8s_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4441,7 +4993,7 @@ func (x *Container) String() string { func (*Container) ProtoMessage() {} func (x *Container) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[54] + mi := &file_api_v1_k8s_proto_msgTypes[63] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4454,7 +5006,7 @@ func (x *Container) ProtoReflect() protoreflect.Message { // Deprecated: Use Container.ProtoReflect.Descriptor instead. func (*Container) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{54} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{63} } func (x *Container) GetId() string { @@ -4487,7 +5039,7 @@ type GetLatestOperatorVersionRequest struct { func (x *GetLatestOperatorVersionRequest) Reset() { *x = GetLatestOperatorVersionRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[55] + mi := &file_api_v1_k8s_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4500,7 +5052,7 @@ func (x *GetLatestOperatorVersionRequest) String() string { func (*GetLatestOperatorVersionRequest) ProtoMessage() {} func (x *GetLatestOperatorVersionRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[55] + mi := &file_api_v1_k8s_proto_msgTypes[64] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4513,7 +5065,7 @@ func (x *GetLatestOperatorVersionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetLatestOperatorVersionRequest.ProtoReflect.Descriptor instead. func (*GetLatestOperatorVersionRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{55} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{64} } type GetLatestOperatorVersionResponse struct { @@ -4538,7 +5090,7 @@ type GetLatestOperatorVersionResponse struct { func (x *GetLatestOperatorVersionResponse) Reset() { *x = GetLatestOperatorVersionResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[56] + mi := &file_api_v1_k8s_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4551,7 +5103,7 @@ func (x *GetLatestOperatorVersionResponse) String() string { func (*GetLatestOperatorVersionResponse) ProtoMessage() {} func (x *GetLatestOperatorVersionResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[56] + mi := &file_api_v1_k8s_proto_msgTypes[65] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4564,7 +5116,7 @@ func (x *GetLatestOperatorVersionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetLatestOperatorVersionResponse.ProtoReflect.Descriptor instead. func (*GetLatestOperatorVersionResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{56} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{65} } func (x *GetLatestOperatorVersionResponse) GetZxpInfo() *OperatorInfo { @@ -4665,7 +5217,7 @@ type GalaxyGetClusterPerspectiveRequest struct { func (x *GalaxyGetClusterPerspectiveRequest) Reset() { *x = GalaxyGetClusterPerspectiveRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[57] + mi := &file_api_v1_k8s_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4678,7 +5230,7 @@ func (x *GalaxyGetClusterPerspectiveRequest) String() string { func (*GalaxyGetClusterPerspectiveRequest) ProtoMessage() {} func (x *GalaxyGetClusterPerspectiveRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[57] + mi := &file_api_v1_k8s_proto_msgTypes[66] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4691,7 +5243,7 @@ func (x *GalaxyGetClusterPerspectiveRequest) ProtoReflect() protoreflect.Message // Deprecated: Use GalaxyGetClusterPerspectiveRequest.ProtoReflect.Descriptor instead. func (*GalaxyGetClusterPerspectiveRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{57} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{66} } func (x *GalaxyGetClusterPerspectiveRequest) GetTeamId() string { @@ -4733,7 +5285,7 @@ type GalaxyGetClusterPerspectiveResponse struct { func (x *GalaxyGetClusterPerspectiveResponse) Reset() { *x = GalaxyGetClusterPerspectiveResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[58] + mi := &file_api_v1_k8s_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4746,7 +5298,7 @@ func (x *GalaxyGetClusterPerspectiveResponse) String() string { func (*GalaxyGetClusterPerspectiveResponse) ProtoMessage() {} func (x *GalaxyGetClusterPerspectiveResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[58] + mi := &file_api_v1_k8s_proto_msgTypes[67] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4759,7 +5311,7 @@ func (x *GalaxyGetClusterPerspectiveResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use GalaxyGetClusterPerspectiveResponse.ProtoReflect.Descriptor instead. func (*GalaxyGetClusterPerspectiveResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{58} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{67} } func (x *GalaxyGetClusterPerspectiveResponse) GetGroupings() []*GalaxyClusterGroup { @@ -4785,7 +5337,7 @@ type GalaxyClusterGroup struct { func (x *GalaxyClusterGroup) Reset() { *x = GalaxyClusterGroup{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[59] + mi := &file_api_v1_k8s_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4798,7 +5350,7 @@ func (x *GalaxyClusterGroup) String() string { func (*GalaxyClusterGroup) ProtoMessage() {} func (x *GalaxyClusterGroup) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[59] + mi := &file_api_v1_k8s_proto_msgTypes[68] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4811,7 +5363,7 @@ func (x *GalaxyClusterGroup) ProtoReflect() protoreflect.Message { // Deprecated: Use GalaxyClusterGroup.ProtoReflect.Descriptor instead. func (*GalaxyClusterGroup) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{59} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{68} } func (x *GalaxyClusterGroup) GetGroupKey() string { @@ -4863,7 +5415,7 @@ type GalaxyGetNodePerspectiveRequest struct { func (x *GalaxyGetNodePerspectiveRequest) Reset() { *x = GalaxyGetNodePerspectiveRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[60] + mi := &file_api_v1_k8s_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4876,7 +5428,7 @@ func (x *GalaxyGetNodePerspectiveRequest) String() string { func (*GalaxyGetNodePerspectiveRequest) ProtoMessage() {} func (x *GalaxyGetNodePerspectiveRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[60] + mi := &file_api_v1_k8s_proto_msgTypes[69] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4889,7 +5441,7 @@ func (x *GalaxyGetNodePerspectiveRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GalaxyGetNodePerspectiveRequest.ProtoReflect.Descriptor instead. func (*GalaxyGetNodePerspectiveRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{60} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{69} } func (x *GalaxyGetNodePerspectiveRequest) GetTeamId() string { @@ -4931,7 +5483,7 @@ type GalaxyGetNodePerspectiveResponse struct { func (x *GalaxyGetNodePerspectiveResponse) Reset() { *x = GalaxyGetNodePerspectiveResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[61] + mi := &file_api_v1_k8s_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4944,7 +5496,7 @@ func (x *GalaxyGetNodePerspectiveResponse) String() string { func (*GalaxyGetNodePerspectiveResponse) ProtoMessage() {} func (x *GalaxyGetNodePerspectiveResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[61] + mi := &file_api_v1_k8s_proto_msgTypes[70] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4957,7 +5509,7 @@ func (x *GalaxyGetNodePerspectiveResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GalaxyGetNodePerspectiveResponse.ProtoReflect.Descriptor instead. func (*GalaxyGetNodePerspectiveResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{61} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{70} } func (x *GalaxyGetNodePerspectiveResponse) GetGroupings() []*GalaxyNodeGroup { @@ -4985,7 +5537,7 @@ type GalaxyNodeGroup struct { func (x *GalaxyNodeGroup) Reset() { *x = GalaxyNodeGroup{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[62] + mi := &file_api_v1_k8s_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4998,7 +5550,7 @@ func (x *GalaxyNodeGroup) String() string { func (*GalaxyNodeGroup) ProtoMessage() {} func (x *GalaxyNodeGroup) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[62] + mi := &file_api_v1_k8s_proto_msgTypes[71] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5011,7 +5563,7 @@ func (x *GalaxyNodeGroup) ProtoReflect() protoreflect.Message { // Deprecated: Use GalaxyNodeGroup.ProtoReflect.Descriptor instead. func (*GalaxyNodeGroup) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{62} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{71} } func (x *GalaxyNodeGroup) GetGroupKey() string { @@ -5070,7 +5622,7 @@ type GalaxyGetWorkloadPerspectiveRequest struct { func (x *GalaxyGetWorkloadPerspectiveRequest) Reset() { *x = GalaxyGetWorkloadPerspectiveRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[63] + mi := &file_api_v1_k8s_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5083,7 +5635,7 @@ func (x *GalaxyGetWorkloadPerspectiveRequest) String() string { func (*GalaxyGetWorkloadPerspectiveRequest) ProtoMessage() {} func (x *GalaxyGetWorkloadPerspectiveRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[63] + mi := &file_api_v1_k8s_proto_msgTypes[72] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5096,7 +5648,7 @@ func (x *GalaxyGetWorkloadPerspectiveRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use GalaxyGetWorkloadPerspectiveRequest.ProtoReflect.Descriptor instead. func (*GalaxyGetWorkloadPerspectiveRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{63} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{72} } func (x *GalaxyGetWorkloadPerspectiveRequest) GetTeamId() string { @@ -5140,7 +5692,7 @@ type GalaxyGetWorkloadPerspectiveResponse struct { func (x *GalaxyGetWorkloadPerspectiveResponse) Reset() { *x = GalaxyGetWorkloadPerspectiveResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[64] + mi := &file_api_v1_k8s_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5153,7 +5705,7 @@ func (x *GalaxyGetWorkloadPerspectiveResponse) String() string { func (*GalaxyGetWorkloadPerspectiveResponse) ProtoMessage() {} func (x *GalaxyGetWorkloadPerspectiveResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[64] + mi := &file_api_v1_k8s_proto_msgTypes[73] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5166,7 +5718,7 @@ func (x *GalaxyGetWorkloadPerspectiveResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use GalaxyGetWorkloadPerspectiveResponse.ProtoReflect.Descriptor instead. func (*GalaxyGetWorkloadPerspectiveResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{64} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{73} } func (x *GalaxyGetWorkloadPerspectiveResponse) GetGroupings() []*GalaxyWorkloadGroup { @@ -5208,7 +5760,7 @@ type GalaxyWorkloadGroup struct { func (x *GalaxyWorkloadGroup) Reset() { *x = GalaxyWorkloadGroup{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[65] + mi := &file_api_v1_k8s_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5221,7 +5773,7 @@ func (x *GalaxyWorkloadGroup) String() string { func (*GalaxyWorkloadGroup) ProtoMessage() {} func (x *GalaxyWorkloadGroup) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[65] + mi := &file_api_v1_k8s_proto_msgTypes[74] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5234,7 +5786,7 @@ func (x *GalaxyWorkloadGroup) ProtoReflect() protoreflect.Message { // Deprecated: Use GalaxyWorkloadGroup.ProtoReflect.Descriptor instead. func (*GalaxyWorkloadGroup) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{65} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{74} } func (x *GalaxyWorkloadGroup) GetGroupKey() string { @@ -5292,7 +5844,7 @@ type PerspectiveDatapointOpts struct { func (x *PerspectiveDatapointOpts) Reset() { *x = PerspectiveDatapointOpts{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[66] + mi := &file_api_v1_k8s_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5305,7 +5857,7 @@ func (x *PerspectiveDatapointOpts) String() string { func (*PerspectiveDatapointOpts) ProtoMessage() {} func (x *PerspectiveDatapointOpts) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[66] + mi := &file_api_v1_k8s_proto_msgTypes[75] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5318,7 +5870,7 @@ func (x *PerspectiveDatapointOpts) ProtoReflect() protoreflect.Message { // Deprecated: Use PerspectiveDatapointOpts.ProtoReflect.Descriptor instead. func (*PerspectiveDatapointOpts) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{66} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{75} } func (x *PerspectiveDatapointOpts) GetTimeStart() int64 { @@ -5348,26 +5900,28 @@ type ListAuditLogsRequest struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` - ClusterId []string `protobuf:"bytes,2,rep,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` - NodeId []string `protobuf:"bytes,3,rep,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` - WorkloadId []string `protobuf:"bytes,4,rep,name=workload_id,json=workloadId,proto3" json:"workload_id,omitempty"` - WorkloadType []K8SObjectKind `protobuf:"varint,5,rep,packed,name=workload_type,json=workloadType,proto3,enum=api.v1.K8SObjectKind" json:"workload_type,omitempty"` - RecommendationPolicyId []string `protobuf:"bytes,6,rep,name=recommendation_policy_id,json=recommendationPolicyId,proto3" json:"recommendation_policy_id,omitempty"` - RecommendationId []string `protobuf:"bytes,7,rep,name=recommendation_id,json=recommendationId,proto3" json:"recommendation_id,omitempty"` - OriginatingUserId []string `protobuf:"bytes,8,rep,name=originating_user_id,json=originatingUserId,proto3" json:"originating_user_id,omitempty"` - EmailContains *string `protobuf:"bytes,9,opt,name=email_contains,json=emailContains,proto3,oneof" json:"email_contains,omitempty"` - Event []string `protobuf:"bytes,10,rep,name=event,proto3" json:"event,omitempty"` - StartTime *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` - EndTime *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` - Pagination *Pagination `protobuf:"bytes,21,opt,name=pagination,proto3" json:"pagination,omitempty"` - AuditLogIds []string `protobuf:"bytes,31,rep,name=audit_log_ids,json=auditLogIds,proto3" json:"audit_log_ids,omitempty"` + TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` + ClusterId []string `protobuf:"bytes,2,rep,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + NodeId []string `protobuf:"bytes,3,rep,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` + WorkloadId []string `protobuf:"bytes,4,rep,name=workload_id,json=workloadId,proto3" json:"workload_id,omitempty"` + WorkloadType []K8SObjectKind `protobuf:"varint,5,rep,packed,name=workload_type,json=workloadType,proto3,enum=api.v1.K8SObjectKind" json:"workload_type,omitempty"` + RecommendationPolicyId []string `protobuf:"bytes,6,rep,name=recommendation_policy_id,json=recommendationPolicyId,proto3" json:"recommendation_policy_id,omitempty"` + RecommendationId []string `protobuf:"bytes,7,rep,name=recommendation_id,json=recommendationId,proto3" json:"recommendation_id,omitempty"` + OriginatingUserId []string `protobuf:"bytes,8,rep,name=originating_user_id,json=originatingUserId,proto3" json:"originating_user_id,omitempty"` + // Deprecated: Marked as deprecated in api/v1/k8s.proto. + EmailContains *string `protobuf:"bytes,9,opt,name=email_contains,json=emailContains,proto3,oneof" json:"email_contains,omitempty"` + Event []string `protobuf:"bytes,10,rep,name=event,proto3" json:"event,omitempty"` + StartTime *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + EndTime *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + EmailMatches []string `protobuf:"bytes,13,rep,name=email_matches,json=emailMatches,proto3" json:"email_matches,omitempty"` // Exact match on originating_user_email (equality with IN clause) + Pagination *Pagination `protobuf:"bytes,21,opt,name=pagination,proto3" json:"pagination,omitempty"` + AuditLogIds []string `protobuf:"bytes,31,rep,name=audit_log_ids,json=auditLogIds,proto3" json:"audit_log_ids,omitempty"` } func (x *ListAuditLogsRequest) Reset() { *x = ListAuditLogsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[67] + mi := &file_api_v1_k8s_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5380,7 +5934,7 @@ func (x *ListAuditLogsRequest) String() string { func (*ListAuditLogsRequest) ProtoMessage() {} func (x *ListAuditLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[67] + mi := &file_api_v1_k8s_proto_msgTypes[76] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5393,7 +5947,7 @@ func (x *ListAuditLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAuditLogsRequest.ProtoReflect.Descriptor instead. func (*ListAuditLogsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{67} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{76} } func (x *ListAuditLogsRequest) GetTeamId() string { @@ -5452,6 +6006,7 @@ func (x *ListAuditLogsRequest) GetOriginatingUserId() []string { return nil } +// Deprecated: Marked as deprecated in api/v1/k8s.proto. func (x *ListAuditLogsRequest) GetEmailContains() string { if x != nil && x.EmailContains != nil { return *x.EmailContains @@ -5480,6 +6035,13 @@ func (x *ListAuditLogsRequest) GetEndTime() *timestamppb.Timestamp { return nil } +func (x *ListAuditLogsRequest) GetEmailMatches() []string { + if x != nil { + return x.EmailMatches + } + return nil +} + func (x *ListAuditLogsRequest) GetPagination() *Pagination { if x != nil { return x.Pagination @@ -5507,7 +6069,7 @@ type ListAuditLogsResponse struct { func (x *ListAuditLogsResponse) Reset() { *x = ListAuditLogsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[68] + mi := &file_api_v1_k8s_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5520,7 +6082,7 @@ func (x *ListAuditLogsResponse) String() string { func (*ListAuditLogsResponse) ProtoMessage() {} func (x *ListAuditLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[68] + mi := &file_api_v1_k8s_proto_msgTypes[77] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5533,7 +6095,7 @@ func (x *ListAuditLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAuditLogsResponse.ProtoReflect.Descriptor instead. func (*ListAuditLogsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{68} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{77} } func (x *ListAuditLogsResponse) GetLogs() []*AuditLogEntry { @@ -5556,24 +6118,26 @@ type ListAuditLogOriginatorsRequest struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` - ClusterId []string `protobuf:"bytes,2,rep,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` - NodeId []string `protobuf:"bytes,3,rep,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` - WorkloadId []string `protobuf:"bytes,4,rep,name=workload_id,json=workloadId,proto3" json:"workload_id,omitempty"` - WorkloadType []K8SObjectKind `protobuf:"varint,5,rep,packed,name=workload_type,json=workloadType,proto3,enum=api.v1.K8SObjectKind" json:"workload_type,omitempty"` - RecommendationPolicyId []string `protobuf:"bytes,6,rep,name=recommendation_policy_id,json=recommendationPolicyId,proto3" json:"recommendation_policy_id,omitempty"` - RecommendationId []string `protobuf:"bytes,7,rep,name=recommendation_id,json=recommendationId,proto3" json:"recommendation_id,omitempty"` - OriginatingUserId []string `protobuf:"bytes,8,rep,name=originating_user_id,json=originatingUserId,proto3" json:"originating_user_id,omitempty"` - EmailContains *string `protobuf:"bytes,9,opt,name=email_contains,json=emailContains,proto3,oneof" json:"email_contains,omitempty"` - Event []string `protobuf:"bytes,10,rep,name=event,proto3" json:"event,omitempty"` - StartTime *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` - EndTime *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` + ClusterId []string `protobuf:"bytes,2,rep,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + NodeId []string `protobuf:"bytes,3,rep,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` + WorkloadId []string `protobuf:"bytes,4,rep,name=workload_id,json=workloadId,proto3" json:"workload_id,omitempty"` + WorkloadType []K8SObjectKind `protobuf:"varint,5,rep,packed,name=workload_type,json=workloadType,proto3,enum=api.v1.K8SObjectKind" json:"workload_type,omitempty"` + RecommendationPolicyId []string `protobuf:"bytes,6,rep,name=recommendation_policy_id,json=recommendationPolicyId,proto3" json:"recommendation_policy_id,omitempty"` + RecommendationId []string `protobuf:"bytes,7,rep,name=recommendation_id,json=recommendationId,proto3" json:"recommendation_id,omitempty"` + OriginatingUserId []string `protobuf:"bytes,8,rep,name=originating_user_id,json=originatingUserId,proto3" json:"originating_user_id,omitempty"` + // Deprecated: Marked as deprecated in api/v1/k8s.proto. + EmailContains *string `protobuf:"bytes,9,opt,name=email_contains,json=emailContains,proto3,oneof" json:"email_contains,omitempty"` + Event []string `protobuf:"bytes,10,rep,name=event,proto3" json:"event,omitempty"` + StartTime *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + EndTime *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + EmailMatches []string `protobuf:"bytes,13,rep,name=email_matches,json=emailMatches,proto3" json:"email_matches,omitempty"` // Exact match on originating_user_email (equality with IN clause) } func (x *ListAuditLogOriginatorsRequest) Reset() { *x = ListAuditLogOriginatorsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[69] + mi := &file_api_v1_k8s_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5586,7 +6150,7 @@ func (x *ListAuditLogOriginatorsRequest) String() string { func (*ListAuditLogOriginatorsRequest) ProtoMessage() {} func (x *ListAuditLogOriginatorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[69] + mi := &file_api_v1_k8s_proto_msgTypes[78] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5599,7 +6163,7 @@ func (x *ListAuditLogOriginatorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAuditLogOriginatorsRequest.ProtoReflect.Descriptor instead. func (*ListAuditLogOriginatorsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{69} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{78} } func (x *ListAuditLogOriginatorsRequest) GetTeamId() string { @@ -5658,6 +6222,7 @@ func (x *ListAuditLogOriginatorsRequest) GetOriginatingUserId() []string { return nil } +// Deprecated: Marked as deprecated in api/v1/k8s.proto. func (x *ListAuditLogOriginatorsRequest) GetEmailContains() string { if x != nil && x.EmailContains != nil { return *x.EmailContains @@ -5686,6 +6251,13 @@ func (x *ListAuditLogOriginatorsRequest) GetEndTime() *timestamppb.Timestamp { return nil } +func (x *ListAuditLogOriginatorsRequest) GetEmailMatches() []string { + if x != nil { + return x.EmailMatches + } + return nil +} + // Response for fetching all audit log originators. type ListAuditLogOriginatorsResponse struct { state protoimpl.MessageState @@ -5698,7 +6270,7 @@ type ListAuditLogOriginatorsResponse struct { func (x *ListAuditLogOriginatorsResponse) Reset() { *x = ListAuditLogOriginatorsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[70] + mi := &file_api_v1_k8s_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5711,7 +6283,7 @@ func (x *ListAuditLogOriginatorsResponse) String() string { func (*ListAuditLogOriginatorsResponse) ProtoMessage() {} func (x *ListAuditLogOriginatorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[70] + mi := &file_api_v1_k8s_proto_msgTypes[79] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5724,7 +6296,7 @@ func (x *ListAuditLogOriginatorsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAuditLogOriginatorsResponse.ProtoReflect.Descriptor instead. func (*ListAuditLogOriginatorsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{70} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{79} } func (x *ListAuditLogOriginatorsResponse) GetEmailAddresses() []string { @@ -5750,7 +6322,7 @@ type SendWorkloadEmailRequest struct { func (x *SendWorkloadEmailRequest) Reset() { *x = SendWorkloadEmailRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[71] + mi := &file_api_v1_k8s_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5763,7 +6335,7 @@ func (x *SendWorkloadEmailRequest) String() string { func (*SendWorkloadEmailRequest) ProtoMessage() {} func (x *SendWorkloadEmailRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[71] + mi := &file_api_v1_k8s_proto_msgTypes[80] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5776,7 +6348,7 @@ func (x *SendWorkloadEmailRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SendWorkloadEmailRequest.ProtoReflect.Descriptor instead. func (*SendWorkloadEmailRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{71} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{80} } func (x *SendWorkloadEmailRequest) GetTeamId() string { @@ -5826,7 +6398,7 @@ type SendWorkloadEmailResponse struct { func (x *SendWorkloadEmailResponse) Reset() { *x = SendWorkloadEmailResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[72] + mi := &file_api_v1_k8s_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5839,7 +6411,7 @@ func (x *SendWorkloadEmailResponse) String() string { func (*SendWorkloadEmailResponse) ProtoMessage() {} func (x *SendWorkloadEmailResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[72] + mi := &file_api_v1_k8s_proto_msgTypes[81] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5852,7 +6424,7 @@ func (x *SendWorkloadEmailResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SendWorkloadEmailResponse.ProtoReflect.Descriptor instead. func (*SendWorkloadEmailResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{72} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{81} } func (x *SendWorkloadEmailResponse) GetMessage() string { @@ -5874,7 +6446,7 @@ type SendWeeklySummaryEmailRequest struct { func (x *SendWeeklySummaryEmailRequest) Reset() { *x = SendWeeklySummaryEmailRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[73] + mi := &file_api_v1_k8s_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5887,7 +6459,7 @@ func (x *SendWeeklySummaryEmailRequest) String() string { func (*SendWeeklySummaryEmailRequest) ProtoMessage() {} func (x *SendWeeklySummaryEmailRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[73] + mi := &file_api_v1_k8s_proto_msgTypes[82] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5900,7 +6472,7 @@ func (x *SendWeeklySummaryEmailRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SendWeeklySummaryEmailRequest.ProtoReflect.Descriptor instead. func (*SendWeeklySummaryEmailRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{73} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{82} } func (x *SendWeeklySummaryEmailRequest) GetRequest() *SendWeeklySummaryEmailRequestData { @@ -5923,7 +6495,7 @@ type SendWeeklySummaryEmailRequestData struct { func (x *SendWeeklySummaryEmailRequestData) Reset() { *x = SendWeeklySummaryEmailRequestData{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[74] + mi := &file_api_v1_k8s_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5936,7 +6508,7 @@ func (x *SendWeeklySummaryEmailRequestData) String() string { func (*SendWeeklySummaryEmailRequestData) ProtoMessage() {} func (x *SendWeeklySummaryEmailRequestData) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[74] + mi := &file_api_v1_k8s_proto_msgTypes[83] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5949,7 +6521,7 @@ func (x *SendWeeklySummaryEmailRequestData) ProtoReflect() protoreflect.Message // Deprecated: Use SendWeeklySummaryEmailRequestData.ProtoReflect.Descriptor instead. func (*SendWeeklySummaryEmailRequestData) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{74} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{83} } func (x *SendWeeklySummaryEmailRequestData) GetTeamId() string { @@ -5978,7 +6550,7 @@ type SendWeeklySummaryEmailResponse struct { func (x *SendWeeklySummaryEmailResponse) Reset() { *x = SendWeeklySummaryEmailResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[75] + mi := &file_api_v1_k8s_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5991,7 +6563,7 @@ func (x *SendWeeklySummaryEmailResponse) String() string { func (*SendWeeklySummaryEmailResponse) ProtoMessage() {} func (x *SendWeeklySummaryEmailResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[75] + mi := &file_api_v1_k8s_proto_msgTypes[84] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6004,7 +6576,7 @@ func (x *SendWeeklySummaryEmailResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SendWeeklySummaryEmailResponse.ProtoReflect.Descriptor instead. func (*SendWeeklySummaryEmailResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{75} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{84} } func (x *SendWeeklySummaryEmailResponse) GetMessage() string { @@ -6032,7 +6604,7 @@ type GetClustersNodeInfoRequest struct { func (x *GetClustersNodeInfoRequest) Reset() { *x = GetClustersNodeInfoRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[76] + mi := &file_api_v1_k8s_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6045,7 +6617,7 @@ func (x *GetClustersNodeInfoRequest) String() string { func (*GetClustersNodeInfoRequest) ProtoMessage() {} func (x *GetClustersNodeInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[76] + mi := &file_api_v1_k8s_proto_msgTypes[85] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6058,7 +6630,7 @@ func (x *GetClustersNodeInfoRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetClustersNodeInfoRequest.ProtoReflect.Descriptor instead. func (*GetClustersNodeInfoRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{76} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{85} } func (x *GetClustersNodeInfoRequest) GetTeamId() string { @@ -6125,7 +6697,7 @@ type GetClustersNodeInfoResponse struct { func (x *GetClustersNodeInfoResponse) Reset() { *x = GetClustersNodeInfoResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[77] + mi := &file_api_v1_k8s_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6138,7 +6710,7 @@ func (x *GetClustersNodeInfoResponse) String() string { func (*GetClustersNodeInfoResponse) ProtoMessage() {} func (x *GetClustersNodeInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[77] + mi := &file_api_v1_k8s_proto_msgTypes[86] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6151,7 +6723,7 @@ func (x *GetClustersNodeInfoResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetClustersNodeInfoResponse.ProtoReflect.Descriptor instead. func (*GetClustersNodeInfoResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{77} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{86} } func (x *GetClustersNodeInfoResponse) GetNodeInfo() *NodeInfo { @@ -6196,7 +6768,7 @@ type SearchK8SResourcesRequest struct { func (x *SearchK8SResourcesRequest) Reset() { *x = SearchK8SResourcesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[78] + mi := &file_api_v1_k8s_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6209,7 +6781,7 @@ func (x *SearchK8SResourcesRequest) String() string { func (*SearchK8SResourcesRequest) ProtoMessage() {} func (x *SearchK8SResourcesRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[78] + mi := &file_api_v1_k8s_proto_msgTypes[87] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6222,7 +6794,7 @@ func (x *SearchK8SResourcesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchK8SResourcesRequest.ProtoReflect.Descriptor instead. func (*SearchK8SResourcesRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{78} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{87} } func (x *SearchK8SResourcesRequest) GetTeamId() string { @@ -6264,7 +6836,7 @@ type SearchK8SResourcesResponse struct { func (x *SearchK8SResourcesResponse) Reset() { *x = SearchK8SResourcesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[79] + mi := &file_api_v1_k8s_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6277,7 +6849,7 @@ func (x *SearchK8SResourcesResponse) String() string { func (*SearchK8SResourcesResponse) ProtoMessage() {} func (x *SearchK8SResourcesResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[79] + mi := &file_api_v1_k8s_proto_msgTypes[88] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6290,7 +6862,7 @@ func (x *SearchK8SResourcesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchK8SResourcesResponse.ProtoReflect.Descriptor instead. func (*SearchK8SResourcesResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{79} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{88} } func (x *SearchK8SResourcesResponse) GetResults() []*K8SSearchResult { @@ -6315,7 +6887,7 @@ type K8SSearchResult struct { func (x *K8SSearchResult) Reset() { *x = K8SSearchResult{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[80] + mi := &file_api_v1_k8s_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6328,7 +6900,7 @@ func (x *K8SSearchResult) String() string { func (*K8SSearchResult) ProtoMessage() {} func (x *K8SSearchResult) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[80] + mi := &file_api_v1_k8s_proto_msgTypes[89] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6341,7 +6913,7 @@ func (x *K8SSearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use K8SSearchResult.ProtoReflect.Descriptor instead. func (*K8SSearchResult) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{80} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{89} } func (x *K8SSearchResult) GetUid() string { @@ -6392,7 +6964,7 @@ type SearchK8SWorkloadsRequest struct { func (x *SearchK8SWorkloadsRequest) Reset() { *x = SearchK8SWorkloadsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[81] + mi := &file_api_v1_k8s_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6405,7 +6977,7 @@ func (x *SearchK8SWorkloadsRequest) String() string { func (*SearchK8SWorkloadsRequest) ProtoMessage() {} func (x *SearchK8SWorkloadsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[81] + mi := &file_api_v1_k8s_proto_msgTypes[90] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6418,7 +6990,7 @@ func (x *SearchK8SWorkloadsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchK8SWorkloadsRequest.ProtoReflect.Descriptor instead. func (*SearchK8SWorkloadsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{81} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{90} } func (x *SearchK8SWorkloadsRequest) GetTeamId() string { @@ -6453,7 +7025,7 @@ type SearchK8SWorkloadsResponse struct { func (x *SearchK8SWorkloadsResponse) Reset() { *x = SearchK8SWorkloadsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[82] + mi := &file_api_v1_k8s_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6466,7 +7038,7 @@ func (x *SearchK8SWorkloadsResponse) String() string { func (*SearchK8SWorkloadsResponse) ProtoMessage() {} func (x *SearchK8SWorkloadsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[82] + mi := &file_api_v1_k8s_proto_msgTypes[91] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6479,7 +7051,7 @@ func (x *SearchK8SWorkloadsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchK8SWorkloadsResponse.ProtoReflect.Descriptor instead. func (*SearchK8SWorkloadsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{82} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{91} } func (x *SearchK8SWorkloadsResponse) GetResults() []*K8SWorkloadSearchResult { @@ -6501,7 +7073,7 @@ type K8SWorkloadSearchResult struct { func (x *K8SWorkloadSearchResult) Reset() { *x = K8SWorkloadSearchResult{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[83] + mi := &file_api_v1_k8s_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6514,7 +7086,7 @@ func (x *K8SWorkloadSearchResult) String() string { func (*K8SWorkloadSearchResult) ProtoMessage() {} func (x *K8SWorkloadSearchResult) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[83] + mi := &file_api_v1_k8s_proto_msgTypes[92] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6527,7 +7099,7 @@ func (x *K8SWorkloadSearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use K8SWorkloadSearchResult.ProtoReflect.Descriptor instead. func (*K8SWorkloadSearchResult) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{83} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{92} } func (x *K8SWorkloadSearchResult) GetKind() string { @@ -6558,7 +7130,7 @@ type MetadataForWorkloadsRequest struct { func (x *MetadataForWorkloadsRequest) Reset() { *x = MetadataForWorkloadsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[84] + mi := &file_api_v1_k8s_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6571,7 +7143,7 @@ func (x *MetadataForWorkloadsRequest) String() string { func (*MetadataForWorkloadsRequest) ProtoMessage() {} func (x *MetadataForWorkloadsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[84] + mi := &file_api_v1_k8s_proto_msgTypes[93] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6584,7 +7156,7 @@ func (x *MetadataForWorkloadsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MetadataForWorkloadsRequest.ProtoReflect.Descriptor instead. func (*MetadataForWorkloadsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{84} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{93} } func (x *MetadataForWorkloadsRequest) GetTeamId() string { @@ -6626,7 +7198,7 @@ type MetadataForWorkloadsResponse struct { func (x *MetadataForWorkloadsResponse) Reset() { *x = MetadataForWorkloadsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[85] + mi := &file_api_v1_k8s_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6639,7 +7211,7 @@ func (x *MetadataForWorkloadsResponse) String() string { func (*MetadataForWorkloadsResponse) ProtoMessage() {} func (x *MetadataForWorkloadsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[85] + mi := &file_api_v1_k8s_proto_msgTypes[94] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6652,7 +7224,7 @@ func (x *MetadataForWorkloadsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MetadataForWorkloadsResponse.ProtoReflect.Descriptor instead. func (*MetadataForWorkloadsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{85} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{94} } func (x *MetadataForWorkloadsResponse) GetWorkloadUidToMetadata() map[string]*WorkloadMetadata { @@ -6675,7 +7247,7 @@ type AddClusterTagsRequest struct { func (x *AddClusterTagsRequest) Reset() { *x = AddClusterTagsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[86] + mi := &file_api_v1_k8s_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6688,7 +7260,7 @@ func (x *AddClusterTagsRequest) String() string { func (*AddClusterTagsRequest) ProtoMessage() {} func (x *AddClusterTagsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[86] + mi := &file_api_v1_k8s_proto_msgTypes[95] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6701,7 +7273,7 @@ func (x *AddClusterTagsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddClusterTagsRequest.ProtoReflect.Descriptor instead. func (*AddClusterTagsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{86} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{95} } func (x *AddClusterTagsRequest) GetTeamId() string { @@ -6736,7 +7308,7 @@ type AddClusterTagsResponse struct { func (x *AddClusterTagsResponse) Reset() { *x = AddClusterTagsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[87] + mi := &file_api_v1_k8s_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6749,7 +7321,7 @@ func (x *AddClusterTagsResponse) String() string { func (*AddClusterTagsResponse) ProtoMessage() {} func (x *AddClusterTagsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[87] + mi := &file_api_v1_k8s_proto_msgTypes[96] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6762,7 +7334,7 @@ func (x *AddClusterTagsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddClusterTagsResponse.ProtoReflect.Descriptor instead. func (*AddClusterTagsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{87} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{96} } func (x *AddClusterTagsResponse) GetCluster() *Cluster { @@ -6785,7 +7357,7 @@ type RemoveClusterTagsRequest struct { func (x *RemoveClusterTagsRequest) Reset() { *x = RemoveClusterTagsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[88] + mi := &file_api_v1_k8s_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6798,7 +7370,7 @@ func (x *RemoveClusterTagsRequest) String() string { func (*RemoveClusterTagsRequest) ProtoMessage() {} func (x *RemoveClusterTagsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[88] + mi := &file_api_v1_k8s_proto_msgTypes[97] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6811,7 +7383,7 @@ func (x *RemoveClusterTagsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveClusterTagsRequest.ProtoReflect.Descriptor instead. func (*RemoveClusterTagsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{88} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{97} } func (x *RemoveClusterTagsRequest) GetTeamId() string { @@ -6846,7 +7418,7 @@ type RemoveClusterTagsResponse struct { func (x *RemoveClusterTagsResponse) Reset() { *x = RemoveClusterTagsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[89] + mi := &file_api_v1_k8s_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6859,7 +7431,7 @@ func (x *RemoveClusterTagsResponse) String() string { func (*RemoveClusterTagsResponse) ProtoMessage() {} func (x *RemoveClusterTagsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[89] + mi := &file_api_v1_k8s_proto_msgTypes[98] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6872,7 +7444,7 @@ func (x *RemoveClusterTagsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveClusterTagsResponse.ProtoReflect.Descriptor instead. func (*RemoveClusterTagsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{89} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{98} } func (x *RemoveClusterTagsResponse) GetCluster() *Cluster { @@ -6893,7 +7465,7 @@ type ListTagsRequest struct { func (x *ListTagsRequest) Reset() { *x = ListTagsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[90] + mi := &file_api_v1_k8s_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6906,7 +7478,7 @@ func (x *ListTagsRequest) String() string { func (*ListTagsRequest) ProtoMessage() {} func (x *ListTagsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[90] + mi := &file_api_v1_k8s_proto_msgTypes[99] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6919,7 +7491,7 @@ func (x *ListTagsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListTagsRequest.ProtoReflect.Descriptor instead. func (*ListTagsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{90} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{99} } func (x *ListTagsRequest) GetTeamId() string { @@ -6941,7 +7513,7 @@ type TagSummary struct { func (x *TagSummary) Reset() { *x = TagSummary{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[91] + mi := &file_api_v1_k8s_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6954,7 +7526,7 @@ func (x *TagSummary) String() string { func (*TagSummary) ProtoMessage() {} func (x *TagSummary) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[91] + mi := &file_api_v1_k8s_proto_msgTypes[100] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6967,7 +7539,7 @@ func (x *TagSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use TagSummary.ProtoReflect.Descriptor instead. func (*TagSummary) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{91} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{100} } func (x *TagSummary) GetTag() string { @@ -6995,7 +7567,7 @@ type ListTagsResponse struct { func (x *ListTagsResponse) Reset() { *x = ListTagsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[92] + mi := &file_api_v1_k8s_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7008,7 +7580,7 @@ func (x *ListTagsResponse) String() string { func (*ListTagsResponse) ProtoMessage() {} func (x *ListTagsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[92] + mi := &file_api_v1_k8s_proto_msgTypes[101] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7021,7 +7593,7 @@ func (x *ListTagsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListTagsResponse.ProtoReflect.Descriptor instead. func (*ListTagsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{92} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{101} } func (x *ListTagsResponse) GetTags() []*TagSummary { @@ -7049,7 +7621,7 @@ type WorkloadMetadata struct { func (x *WorkloadMetadata) Reset() { *x = WorkloadMetadata{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[93] + mi := &file_api_v1_k8s_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7062,7 +7634,7 @@ func (x *WorkloadMetadata) String() string { func (*WorkloadMetadata) ProtoMessage() {} func (x *WorkloadMetadata) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[93] + mi := &file_api_v1_k8s_proto_msgTypes[102] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7075,7 +7647,7 @@ func (x *WorkloadMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkloadMetadata.ProtoReflect.Descriptor instead. func (*WorkloadMetadata) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{93} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{102} } func (x *WorkloadMetadata) GetPodUidToNodeMetadata() map[string]*NodeMetadata { @@ -7150,7 +7722,7 @@ type PodMetadata struct { func (x *PodMetadata) Reset() { *x = PodMetadata{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[94] + mi := &file_api_v1_k8s_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7163,7 +7735,7 @@ func (x *PodMetadata) String() string { func (*PodMetadata) ProtoMessage() {} func (x *PodMetadata) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[94] + mi := &file_api_v1_k8s_proto_msgTypes[103] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7176,7 +7748,7 @@ func (x *PodMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use PodMetadata.ProtoReflect.Descriptor instead. func (*PodMetadata) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{94} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{103} } func (x *PodMetadata) GetName() string { @@ -7240,7 +7812,7 @@ type NodeMetadata struct { func (x *NodeMetadata) Reset() { *x = NodeMetadata{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[95] + mi := &file_api_v1_k8s_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7253,7 +7825,7 @@ func (x *NodeMetadata) String() string { func (*NodeMetadata) ProtoMessage() {} func (x *NodeMetadata) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[95] + mi := &file_api_v1_k8s_proto_msgTypes[104] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7266,7 +7838,7 @@ func (x *NodeMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeMetadata.ProtoReflect.Descriptor instead. func (*NodeMetadata) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{95} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{104} } func (x *NodeMetadata) GetNodeName() string { @@ -7348,7 +7920,7 @@ type GetRelatedResourcesRequest struct { func (x *GetRelatedResourcesRequest) Reset() { *x = GetRelatedResourcesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[96] + mi := &file_api_v1_k8s_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7361,7 +7933,7 @@ func (x *GetRelatedResourcesRequest) String() string { func (*GetRelatedResourcesRequest) ProtoMessage() {} func (x *GetRelatedResourcesRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[96] + mi := &file_api_v1_k8s_proto_msgTypes[105] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7374,7 +7946,7 @@ func (x *GetRelatedResourcesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRelatedResourcesRequest.ProtoReflect.Descriptor instead. func (*GetRelatedResourcesRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{96} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{105} } func (x *GetRelatedResourcesRequest) GetTeamId() string { @@ -7426,7 +7998,7 @@ type GetWorkloadPodHistoryResponse struct { func (x *GetWorkloadPodHistoryResponse) Reset() { *x = GetWorkloadPodHistoryResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[97] + mi := &file_api_v1_k8s_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7439,7 +8011,7 @@ func (x *GetWorkloadPodHistoryResponse) String() string { func (*GetWorkloadPodHistoryResponse) ProtoMessage() {} func (x *GetWorkloadPodHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[97] + mi := &file_api_v1_k8s_proto_msgTypes[106] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7452,7 +8024,7 @@ func (x *GetWorkloadPodHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkloadPodHistoryResponse.ProtoReflect.Descriptor instead. func (*GetWorkloadPodHistoryResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{97} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{106} } func (x *GetWorkloadPodHistoryResponse) GetWorkloadUid() string { @@ -7499,7 +8071,7 @@ type JobHistory struct { func (x *JobHistory) Reset() { *x = JobHistory{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[98] + mi := &file_api_v1_k8s_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7512,7 +8084,7 @@ func (x *JobHistory) String() string { func (*JobHistory) ProtoMessage() {} func (x *JobHistory) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[98] + mi := &file_api_v1_k8s_proto_msgTypes[107] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7525,7 +8097,7 @@ func (x *JobHistory) ProtoReflect() protoreflect.Message { // Deprecated: Use JobHistory.ProtoReflect.Descriptor instead. func (*JobHistory) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{98} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{107} } func (x *JobHistory) GetUid() string { @@ -7586,7 +8158,7 @@ type ReplicaSetHistory struct { func (x *ReplicaSetHistory) Reset() { *x = ReplicaSetHistory{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[99] + mi := &file_api_v1_k8s_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7599,7 +8171,7 @@ func (x *ReplicaSetHistory) String() string { func (*ReplicaSetHistory) ProtoMessage() {} func (x *ReplicaSetHistory) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[99] + mi := &file_api_v1_k8s_proto_msgTypes[108] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7612,7 +8184,7 @@ func (x *ReplicaSetHistory) ProtoReflect() protoreflect.Message { // Deprecated: Use ReplicaSetHistory.ProtoReflect.Descriptor instead. func (*ReplicaSetHistory) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{99} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{108} } func (x *ReplicaSetHistory) GetUid() string { @@ -7674,7 +8246,7 @@ type PodHistory struct { func (x *PodHistory) Reset() { *x = PodHistory{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[100] + mi := &file_api_v1_k8s_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7687,7 +8259,7 @@ func (x *PodHistory) String() string { func (*PodHistory) ProtoMessage() {} func (x *PodHistory) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[100] + mi := &file_api_v1_k8s_proto_msgTypes[109] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7700,7 +8272,7 @@ func (x *PodHistory) ProtoReflect() protoreflect.Message { // Deprecated: Use PodHistory.ProtoReflect.Descriptor instead. func (*PodHistory) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{100} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{109} } func (x *PodHistory) GetUid() string { @@ -7765,7 +8337,7 @@ type GetRelatedResourcesResponse struct { func (x *GetRelatedResourcesResponse) Reset() { *x = GetRelatedResourcesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[101] + mi := &file_api_v1_k8s_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7778,7 +8350,7 @@ func (x *GetRelatedResourcesResponse) String() string { func (*GetRelatedResourcesResponse) ProtoMessage() {} func (x *GetRelatedResourcesResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[101] + mi := &file_api_v1_k8s_proto_msgTypes[110] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7791,7 +8363,7 @@ func (x *GetRelatedResourcesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRelatedResourcesResponse.ProtoReflect.Descriptor instead. func (*GetRelatedResourcesResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{101} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{110} } func (x *GetRelatedResourcesResponse) GetRelations() []*K8SRelatedResource { @@ -7833,7 +8405,7 @@ type K8SRelatedResource struct { func (x *K8SRelatedResource) Reset() { *x = K8SRelatedResource{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[102] + mi := &file_api_v1_k8s_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7846,7 +8418,7 @@ func (x *K8SRelatedResource) String() string { func (*K8SRelatedResource) ProtoMessage() {} func (x *K8SRelatedResource) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[102] + mi := &file_api_v1_k8s_proto_msgTypes[111] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7859,7 +8431,7 @@ func (x *K8SRelatedResource) ProtoReflect() protoreflect.Message { // Deprecated: Use K8SRelatedResource.ProtoReflect.Descriptor instead. func (*K8SRelatedResource) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{102} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{111} } func (x *K8SRelatedResource) GetSourceKind() string { @@ -7925,7 +8497,7 @@ type K8SResourceNode struct { func (x *K8SResourceNode) Reset() { *x = K8SResourceNode{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[103] + mi := &file_api_v1_k8s_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7938,7 +8510,7 @@ func (x *K8SResourceNode) String() string { func (*K8SResourceNode) ProtoMessage() {} func (x *K8SResourceNode) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[103] + mi := &file_api_v1_k8s_proto_msgTypes[112] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7951,7 +8523,7 @@ func (x *K8SResourceNode) ProtoReflect() protoreflect.Message { // Deprecated: Use K8SResourceNode.ProtoReflect.Descriptor instead. func (*K8SResourceNode) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{103} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{112} } func (x *K8SResourceNode) GetId() string { @@ -7990,7 +8562,7 @@ type K8SResourceEdge struct { func (x *K8SResourceEdge) Reset() { *x = K8SResourceEdge{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[104] + mi := &file_api_v1_k8s_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8003,7 +8575,7 @@ func (x *K8SResourceEdge) String() string { func (*K8SResourceEdge) ProtoMessage() {} func (x *K8SResourceEdge) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[104] + mi := &file_api_v1_k8s_proto_msgTypes[113] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8016,7 +8588,7 @@ func (x *K8SResourceEdge) ProtoReflect() protoreflect.Message { // Deprecated: Use K8SResourceEdge.ProtoReflect.Descriptor instead. func (*K8SResourceEdge) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{104} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{113} } func (x *K8SResourceEdge) GetId() string { @@ -8060,7 +8632,7 @@ type GetClusterTypeRequest struct { func (x *GetClusterTypeRequest) Reset() { *x = GetClusterTypeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[105] + mi := &file_api_v1_k8s_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8073,7 +8645,7 @@ func (x *GetClusterTypeRequest) String() string { func (*GetClusterTypeRequest) ProtoMessage() {} func (x *GetClusterTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[105] + mi := &file_api_v1_k8s_proto_msgTypes[114] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8086,7 +8658,7 @@ func (x *GetClusterTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetClusterTypeRequest.ProtoReflect.Descriptor instead. func (*GetClusterTypeRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{105} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{114} } func (x *GetClusterTypeRequest) GetTeamId() string { @@ -8116,7 +8688,7 @@ type GetClusterTypeResponse struct { func (x *GetClusterTypeResponse) Reset() { *x = GetClusterTypeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[106] + mi := &file_api_v1_k8s_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8129,7 +8701,7 @@ func (x *GetClusterTypeResponse) String() string { func (*GetClusterTypeResponse) ProtoMessage() {} func (x *GetClusterTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[106] + mi := &file_api_v1_k8s_proto_msgTypes[115] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8142,7 +8714,7 @@ func (x *GetClusterTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetClusterTypeResponse.ProtoReflect.Descriptor instead. func (*GetClusterTypeResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{106} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{115} } func (x *GetClusterTypeResponse) GetClusterType() ClusterType { @@ -8173,7 +8745,7 @@ type GetWorkloadsStatsRequest struct { func (x *GetWorkloadsStatsRequest) Reset() { *x = GetWorkloadsStatsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[107] + mi := &file_api_v1_k8s_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8186,7 +8758,7 @@ func (x *GetWorkloadsStatsRequest) String() string { func (*GetWorkloadsStatsRequest) ProtoMessage() {} func (x *GetWorkloadsStatsRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[107] + mi := &file_api_v1_k8s_proto_msgTypes[116] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8199,7 +8771,7 @@ func (x *GetWorkloadsStatsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkloadsStatsRequest.ProtoReflect.Descriptor instead. func (*GetWorkloadsStatsRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{107} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{116} } func (x *GetWorkloadsStatsRequest) GetTeamId() string { @@ -8245,7 +8817,7 @@ type GetWorkloadsStatsResponse struct { func (x *GetWorkloadsStatsResponse) Reset() { *x = GetWorkloadsStatsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[108] + mi := &file_api_v1_k8s_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8258,7 +8830,7 @@ func (x *GetWorkloadsStatsResponse) String() string { func (*GetWorkloadsStatsResponse) ProtoMessage() {} func (x *GetWorkloadsStatsResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[108] + mi := &file_api_v1_k8s_proto_msgTypes[117] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8271,7 +8843,7 @@ func (x *GetWorkloadsStatsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkloadsStatsResponse.ProtoReflect.Descriptor instead. func (*GetWorkloadsStatsResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{108} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{117} } func (x *GetWorkloadsStatsResponse) GetTotal() int32 { @@ -8323,7 +8895,7 @@ type DailyUtilizationRequest struct { func (x *DailyUtilizationRequest) Reset() { *x = DailyUtilizationRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[109] + mi := &file_api_v1_k8s_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8336,7 +8908,7 @@ func (x *DailyUtilizationRequest) String() string { func (*DailyUtilizationRequest) ProtoMessage() {} func (x *DailyUtilizationRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[109] + mi := &file_api_v1_k8s_proto_msgTypes[118] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8349,7 +8921,7 @@ func (x *DailyUtilizationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DailyUtilizationRequest.ProtoReflect.Descriptor instead. func (*DailyUtilizationRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{109} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{118} } func (x *DailyUtilizationRequest) GetTeamId() string { @@ -8393,7 +8965,7 @@ type DailyUtilizationResponse struct { func (x *DailyUtilizationResponse) Reset() { *x = DailyUtilizationResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[110] + mi := &file_api_v1_k8s_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8406,7 +8978,7 @@ func (x *DailyUtilizationResponse) String() string { func (*DailyUtilizationResponse) ProtoMessage() {} func (x *DailyUtilizationResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[110] + mi := &file_api_v1_k8s_proto_msgTypes[119] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8419,7 +8991,7 @@ func (x *DailyUtilizationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DailyUtilizationResponse.ProtoReflect.Descriptor instead. func (*DailyUtilizationResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{110} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{119} } func (x *DailyUtilizationResponse) GetClusterIdToDailyTotalCoreMinutes() map[string]*DailyUtilizationResponse_Datapoints { @@ -8457,7 +9029,7 @@ type DailyUtilizationInstanceTypeRequest struct { func (x *DailyUtilizationInstanceTypeRequest) Reset() { *x = DailyUtilizationInstanceTypeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[111] + mi := &file_api_v1_k8s_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8470,7 +9042,7 @@ func (x *DailyUtilizationInstanceTypeRequest) String() string { func (*DailyUtilizationInstanceTypeRequest) ProtoMessage() {} func (x *DailyUtilizationInstanceTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[111] + mi := &file_api_v1_k8s_proto_msgTypes[120] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8483,7 +9055,7 @@ func (x *DailyUtilizationInstanceTypeRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use DailyUtilizationInstanceTypeRequest.ProtoReflect.Descriptor instead. func (*DailyUtilizationInstanceTypeRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{111} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{120} } func (x *DailyUtilizationInstanceTypeRequest) GetTeamId() string { @@ -8526,7 +9098,7 @@ type DailyUtilizationInstanceTypeResponse struct { func (x *DailyUtilizationInstanceTypeResponse) Reset() { *x = DailyUtilizationInstanceTypeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[112] + mi := &file_api_v1_k8s_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8539,7 +9111,7 @@ func (x *DailyUtilizationInstanceTypeResponse) String() string { func (*DailyUtilizationInstanceTypeResponse) ProtoMessage() {} func (x *DailyUtilizationInstanceTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[112] + mi := &file_api_v1_k8s_proto_msgTypes[121] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8552,7 +9124,7 @@ func (x *DailyUtilizationInstanceTypeResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use DailyUtilizationInstanceTypeResponse.ProtoReflect.Descriptor instead. func (*DailyUtilizationInstanceTypeResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{112} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{121} } func (x *DailyUtilizationInstanceTypeResponse) GetClusterIdToDatapoints() map[string]*DailyUtilizationInstanceTypeResponse_Datapoints { @@ -8583,7 +9155,7 @@ type DailyUtilizationNodeTypeRequest struct { func (x *DailyUtilizationNodeTypeRequest) Reset() { *x = DailyUtilizationNodeTypeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[113] + mi := &file_api_v1_k8s_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8596,7 +9168,7 @@ func (x *DailyUtilizationNodeTypeRequest) String() string { func (*DailyUtilizationNodeTypeRequest) ProtoMessage() {} func (x *DailyUtilizationNodeTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[113] + mi := &file_api_v1_k8s_proto_msgTypes[122] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8609,7 +9181,7 @@ func (x *DailyUtilizationNodeTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DailyUtilizationNodeTypeRequest.ProtoReflect.Descriptor instead. func (*DailyUtilizationNodeTypeRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{113} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{122} } func (x *DailyUtilizationNodeTypeRequest) GetTeamId() string { @@ -8652,7 +9224,7 @@ type DailyUtilizationNodeTypeResponse struct { func (x *DailyUtilizationNodeTypeResponse) Reset() { *x = DailyUtilizationNodeTypeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[114] + mi := &file_api_v1_k8s_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8665,7 +9237,7 @@ func (x *DailyUtilizationNodeTypeResponse) String() string { func (*DailyUtilizationNodeTypeResponse) ProtoMessage() {} func (x *DailyUtilizationNodeTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[114] + mi := &file_api_v1_k8s_proto_msgTypes[123] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8678,7 +9250,7 @@ func (x *DailyUtilizationNodeTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DailyUtilizationNodeTypeResponse.ProtoReflect.Descriptor instead. func (*DailyUtilizationNodeTypeResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{114} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{123} } func (x *DailyUtilizationNodeTypeResponse) GetClusterIdToDatapoints() map[string]*DailyUtilizationNodeTypeResponse_Datapoints { @@ -8709,7 +9281,7 @@ type LookupNodeInstanceRequest struct { func (x *LookupNodeInstanceRequest) Reset() { *x = LookupNodeInstanceRequest{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[115] + mi := &file_api_v1_k8s_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8722,7 +9294,7 @@ func (x *LookupNodeInstanceRequest) String() string { func (*LookupNodeInstanceRequest) ProtoMessage() {} func (x *LookupNodeInstanceRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[115] + mi := &file_api_v1_k8s_proto_msgTypes[124] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8735,7 +9307,7 @@ func (x *LookupNodeInstanceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupNodeInstanceRequest.ProtoReflect.Descriptor instead. func (*LookupNodeInstanceRequest) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{115} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{124} } func (x *LookupNodeInstanceRequest) GetTeamId() string { @@ -8775,7 +9347,7 @@ type InstanceLookupParams struct { func (x *InstanceLookupParams) Reset() { *x = InstanceLookupParams{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[116] + mi := &file_api_v1_k8s_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8788,7 +9360,7 @@ func (x *InstanceLookupParams) String() string { func (*InstanceLookupParams) ProtoMessage() {} func (x *InstanceLookupParams) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[116] + mi := &file_api_v1_k8s_proto_msgTypes[125] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8801,7 +9373,7 @@ func (x *InstanceLookupParams) ProtoReflect() protoreflect.Message { // Deprecated: Use InstanceLookupParams.ProtoReflect.Descriptor instead. func (*InstanceLookupParams) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{116} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{125} } func (x *InstanceLookupParams) GetCloudProviderId() int64 { @@ -8855,7 +9427,7 @@ type LookupNodeInstanceResponse struct { func (x *LookupNodeInstanceResponse) Reset() { *x = LookupNodeInstanceResponse{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[117] + mi := &file_api_v1_k8s_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8868,7 +9440,7 @@ func (x *LookupNodeInstanceResponse) String() string { func (*LookupNodeInstanceResponse) ProtoMessage() {} func (x *LookupNodeInstanceResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[117] + mi := &file_api_v1_k8s_proto_msgTypes[126] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8881,7 +9453,7 @@ func (x *LookupNodeInstanceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupNodeInstanceResponse.ProtoReflect.Descriptor instead. func (*LookupNodeInstanceResponse) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{117} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{126} } func (x *LookupNodeInstanceResponse) GetDynamicInstance() *Instance { @@ -8930,7 +9502,7 @@ type GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics struct { func (x *GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics) Reset() { *x = GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[119] + mi := &file_api_v1_k8s_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8943,7 +9515,7 @@ func (x *GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics) String() string func (*GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics) ProtoMessage() {} func (x *GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[119] + mi := &file_api_v1_k8s_proto_msgTypes[128] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8977,7 +9549,7 @@ type DailyUtilizationResponse_Datapoints struct { func (x *DailyUtilizationResponse_Datapoints) Reset() { *x = DailyUtilizationResponse_Datapoints{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[130] + mi := &file_api_v1_k8s_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8990,7 +9562,7 @@ func (x *DailyUtilizationResponse_Datapoints) String() string { func (*DailyUtilizationResponse_Datapoints) ProtoMessage() {} func (x *DailyUtilizationResponse_Datapoints) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[130] + mi := &file_api_v1_k8s_proto_msgTypes[139] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9003,7 +9575,7 @@ func (x *DailyUtilizationResponse_Datapoints) ProtoReflect() protoreflect.Messag // Deprecated: Use DailyUtilizationResponse_Datapoints.ProtoReflect.Descriptor instead. func (*DailyUtilizationResponse_Datapoints) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{110, 0} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{119, 0} } func (x *DailyUtilizationResponse_Datapoints) GetDatapoints() []*DailyUtilizationResponse_Datapoint { @@ -9025,7 +9597,7 @@ type DailyUtilizationResponse_Datapoint struct { func (x *DailyUtilizationResponse_Datapoint) Reset() { *x = DailyUtilizationResponse_Datapoint{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[131] + mi := &file_api_v1_k8s_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9038,7 +9610,7 @@ func (x *DailyUtilizationResponse_Datapoint) String() string { func (*DailyUtilizationResponse_Datapoint) ProtoMessage() {} func (x *DailyUtilizationResponse_Datapoint) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[131] + mi := &file_api_v1_k8s_proto_msgTypes[140] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9051,7 +9623,7 @@ func (x *DailyUtilizationResponse_Datapoint) ProtoReflect() protoreflect.Message // Deprecated: Use DailyUtilizationResponse_Datapoint.ProtoReflect.Descriptor instead. func (*DailyUtilizationResponse_Datapoint) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{110, 1} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{119, 1} } func (x *DailyUtilizationResponse_Datapoint) GetTimestamp() int64 { @@ -9079,7 +9651,7 @@ type DailyUtilizationInstanceTypeResponse_Datapoints struct { func (x *DailyUtilizationInstanceTypeResponse_Datapoints) Reset() { *x = DailyUtilizationInstanceTypeResponse_Datapoints{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[134] + mi := &file_api_v1_k8s_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9092,7 +9664,7 @@ func (x *DailyUtilizationInstanceTypeResponse_Datapoints) String() string { func (*DailyUtilizationInstanceTypeResponse_Datapoints) ProtoMessage() {} func (x *DailyUtilizationInstanceTypeResponse_Datapoints) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[134] + mi := &file_api_v1_k8s_proto_msgTypes[143] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9105,7 +9677,7 @@ func (x *DailyUtilizationInstanceTypeResponse_Datapoints) ProtoReflect() protore // Deprecated: Use DailyUtilizationInstanceTypeResponse_Datapoints.ProtoReflect.Descriptor instead. func (*DailyUtilizationInstanceTypeResponse_Datapoints) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{112, 0} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{121, 0} } func (x *DailyUtilizationInstanceTypeResponse_Datapoints) GetDatapoints() []*DailyUtilizationInstanceTypeResponse_Datapoint { @@ -9127,7 +9699,7 @@ type DailyUtilizationInstanceTypeResponse_Datapoint struct { func (x *DailyUtilizationInstanceTypeResponse_Datapoint) Reset() { *x = DailyUtilizationInstanceTypeResponse_Datapoint{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[135] + mi := &file_api_v1_k8s_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9140,7 +9712,7 @@ func (x *DailyUtilizationInstanceTypeResponse_Datapoint) String() string { func (*DailyUtilizationInstanceTypeResponse_Datapoint) ProtoMessage() {} func (x *DailyUtilizationInstanceTypeResponse_Datapoint) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[135] + mi := &file_api_v1_k8s_proto_msgTypes[144] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9153,7 +9725,7 @@ func (x *DailyUtilizationInstanceTypeResponse_Datapoint) ProtoReflect() protoref // Deprecated: Use DailyUtilizationInstanceTypeResponse_Datapoint.ProtoReflect.Descriptor instead. func (*DailyUtilizationInstanceTypeResponse_Datapoint) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{112, 1} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{121, 1} } func (x *DailyUtilizationInstanceTypeResponse_Datapoint) GetTimestamp() int64 { @@ -9181,7 +9753,7 @@ type DailyUtilizationNodeTypeResponse_Datapoints struct { func (x *DailyUtilizationNodeTypeResponse_Datapoints) Reset() { *x = DailyUtilizationNodeTypeResponse_Datapoints{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[139] + mi := &file_api_v1_k8s_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9194,7 +9766,7 @@ func (x *DailyUtilizationNodeTypeResponse_Datapoints) String() string { func (*DailyUtilizationNodeTypeResponse_Datapoints) ProtoMessage() {} func (x *DailyUtilizationNodeTypeResponse_Datapoints) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[139] + mi := &file_api_v1_k8s_proto_msgTypes[148] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9207,7 +9779,7 @@ func (x *DailyUtilizationNodeTypeResponse_Datapoints) ProtoReflect() protoreflec // Deprecated: Use DailyUtilizationNodeTypeResponse_Datapoints.ProtoReflect.Descriptor instead. func (*DailyUtilizationNodeTypeResponse_Datapoints) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{114, 0} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{123, 0} } func (x *DailyUtilizationNodeTypeResponse_Datapoints) GetDatapoints() []*DailyUtilizationNodeTypeResponse_Datapoint { @@ -9229,7 +9801,7 @@ type DailyUtilizationNodeTypeResponse_Datapoint struct { func (x *DailyUtilizationNodeTypeResponse_Datapoint) Reset() { *x = DailyUtilizationNodeTypeResponse_Datapoint{} if protoimpl.UnsafeEnabled { - mi := &file_api_v1_k8s_proto_msgTypes[140] + mi := &file_api_v1_k8s_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9242,7 +9814,7 @@ func (x *DailyUtilizationNodeTypeResponse_Datapoint) String() string { func (*DailyUtilizationNodeTypeResponse_Datapoint) ProtoMessage() {} func (x *DailyUtilizationNodeTypeResponse_Datapoint) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_k8s_proto_msgTypes[140] + mi := &file_api_v1_k8s_proto_msgTypes[149] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9255,7 +9827,7 @@ func (x *DailyUtilizationNodeTypeResponse_Datapoint) ProtoReflect() protoreflect // Deprecated: Use DailyUtilizationNodeTypeResponse_Datapoint.ProtoReflect.Descriptor instead. func (*DailyUtilizationNodeTypeResponse_Datapoint) Descriptor() ([]byte, []int) { - return file_api_v1_k8s_proto_rawDescGZIP(), []int{114, 1} + return file_api_v1_k8s_proto_rawDescGZIP(), []int{123, 1} } func (x *DailyUtilizationNodeTypeResponse_Datapoint) GetTimestamp() int64 { @@ -9843,15 +10415,117 @@ var file_api_v1_k8s_proto_rawDesc = []byte{ 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x12, 0x72, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x90, - 0x02, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x57, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, + 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x9e, + 0x02, 0x0a, 0x26, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, + 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, + 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, + 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, + 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 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, 0x48, 0x00, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x0c, 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, 0x48, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x88, 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, + 0x6d, 0x0a, 0x27, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, + 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x0a, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x22, 0xa0, + 0x02, 0x0a, 0x28, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x46, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, + 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, + 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, + 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, + 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x0a, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 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, 0x48, 0x00, 0x52, 0x09, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 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, 0x48, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, + 0x6d, 0x65, 0x88, 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, + 0x65, 0x22, 0x71, 0x0a, 0x29, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x46, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, + 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, + 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x46, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, + 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x73, 0x22, 0x72, 0x0a, 0x26, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, + 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x68, 0x6f, 0x77, 0x5f, 0x64, - 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x73, 0x68, - 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x12, 0x3e, 0x0a, 0x0a, 0x73, 0x74, 0x61, + 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x22, 0x69, 0x0a, 0x27, 0x47, 0x65, 0x74, 0x4c, + 0x61, 0x74, 0x65, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x73, 0x22, 0x90, 0x02, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, + 0x61, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, + 0x68, 0x6f, 0x77, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0b, 0x73, 0x68, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x12, 0x3e, + 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x15, 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, 0x48, 0x00, + 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x3a, + 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x16, 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, 0x48, 0x01, 0x52, 0x07, + 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, + 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, 0x9a, 0x02, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x46, 0x6f, + 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, + 0x74, 0x65, 0x6d, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, + 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, + 0x6e, 0x66, 0x6f, 0x12, 0x4a, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, + 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, + 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x22, 0xbb, 0x02, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, + 0x61, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, + 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x10, + 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, + 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x12, 0x3e, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x15, 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, 0x48, 0x00, 0x52, 0x09, 0x73, 0x74, 0x61, @@ -9861,1174 +10535,1091 @@ var file_api_v1_k8s_proto_rawDesc = []byte{ 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x22, 0x9a, 0x02, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, - 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, - 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, - 0x52, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x12, - 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x4a, - 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, - 0x63, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x0f, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0xbb, - 0x02, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x57, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, - 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x0b, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x44, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x64, 0x12, 0x3e, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, - 0x6d, 0x65, 0x18, 0x15, 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, 0x48, 0x00, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, - 0x65, 0x88, 0x01, 0x01, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, - 0x18, 0x16, 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, 0x48, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, - 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, - 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, 0xa5, 0x03, 0x0a, - 0x1b, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0d, - 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x6c, - 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, - 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, - 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x4a, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, - 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, - 0x63, 0x73, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, - 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, - 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, - 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x3f, 0x0a, 0x10, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x64, - 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x44, 0x61, - 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0e, 0x63, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, - 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x4b, 0x0a, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, - 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, - 0x52, 0x12, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, - 0x69, 0x6e, 0x74, 0x73, 0x22, 0x49, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x08, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x08, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x22, - 0x49, 0x0a, 0x0e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, - 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, - 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x8f, 0x01, 0x0a, 0x17, 0x47, - 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, - 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, - 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, - 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x08, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x6f, 0x0a, 0x18, - 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x1a, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x6c, 0x65, - 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x17, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x57, - 0x69, 0x74, 0x68, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x22, 0x72, 0x0a, - 0x20, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x61, - 0x72, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x61, 0x72, 0x63, - 0x68, 0x22, 0x43, 0x0a, 0x21, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x22, 0xdb, 0x02, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x41, 0x6c, - 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, - 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, - 0x1e, 0x0a, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x06, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, - 0x2b, 0x0a, 0x05, 0x6b, 0x69, 0x6e, 0x64, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x15, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x05, 0x6b, 0x69, 0x6e, 0x64, 0x73, 0x12, 0x27, 0x0a, 0x0f, - 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, - 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4c, - 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, - 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1b, - 0x0a, 0x09, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x08, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x15, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x44, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x64, 0x22, 0x77, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x1d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, - 0x64, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x6c, 0x65, 0x6d, 0x65, - 0x6e, 0x74, 0x52, 0x19, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x57, 0x69, 0x74, - 0x68, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xb1, 0x02, - 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, - 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, - 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x6e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x05, 0x6b, 0x69, 0x6e, 0x64, 0x73, - 0x18, 0x07, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x05, 0x6b, - 0x69, 0x6e, 0x64, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, - 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x77, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, - 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, - 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, + 0x65, 0x22, 0xa5, 0x03, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, + 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x39, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x74, + 0x65, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x0c, + 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x2d, 0x0a, 0x09, + 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x4a, 0x0a, 0x10, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x46, + 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x3f, 0x0a, 0x10, 0x63, + 0x6f, 0x73, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0e, 0x63, 0x6f, + 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x4b, 0x0a, 0x14, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, + 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x12, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, + 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x49, 0x0a, 0x1a, 0x47, 0x65, 0x74, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x08, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x08, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x73, 0x22, 0x49, 0x0a, 0x0e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, + 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x22, + 0x8f, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, + 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, + 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, + 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, - 0x65, 0x22, 0x6b, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, - 0x6f, 0x61, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x4b, 0x0a, 0x16, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, - 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x65, 0x22, 0x6f, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, + 0x1a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x77, 0x69, 0x74, 0x68, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x13, 0x63, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x49, 0x64, 0x57, 0x69, 0x74, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x22, 0xbc, - 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, - 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x6f, 0x70, 0x5f, - 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x73, 0x74, 0x6f, 0x70, - 0x54, 0x69, 0x6d, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, - 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, 0x7d, 0x0a, - 0x1c, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5d, 0x0a, - 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x77, 0x69, 0x74, 0x68, - 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, - 0x1b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, - 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0xa4, 0x0d, 0x0a, - 0x07, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x17, 0x0a, 0x07, - 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, - 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x5f, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x49, - 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x25, - 0x0a, 0x0e, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, - 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1d, 0x0a, 0x0a, - 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x42, 0x0a, 0x10, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, - 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, - 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, - 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x0b, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, - 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x0c, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3f, 0x0a, - 0x10, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, - 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0e, - 0x63, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x4b, - 0x0a, 0x14, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, - 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x12, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x3c, 0x0a, 0x13, 0x6d, - 0x6f, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6e, 0x6f, - 0x64, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x11, 0x6d, 0x6f, 0x73, 0x74, 0x45, 0x78, 0x70, 0x65, - 0x6e, 0x73, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x3e, 0x0a, 0x14, 0x6c, 0x65, 0x61, - 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6e, 0x6f, 0x64, - 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x12, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x45, 0x78, 0x70, 0x65, - 0x6e, 0x73, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x44, 0x0a, 0x17, 0x6d, 0x6f, 0x73, - 0x74, 0x5f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, - 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x15, 0x6d, 0x6f, 0x73, 0x74, 0x55, 0x6e, - 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x12, - 0x53, 0x0a, 0x1c, 0x6d, 0x6f, 0x73, 0x74, 0x5f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, - 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, - 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x1a, 0x6d, 0x6f, 0x73, 0x74, 0x55, 0x6e, - 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x12, 0x29, 0x0a, 0x11, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, - 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x13, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x0e, 0x63, 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, 0x12, - 0x2f, 0x0a, 0x14, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x70, - 0x65, 0x72, 0x5f, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x14, 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x6d, - 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x43, 0x6f, 0x73, 0x74, 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, - 0x12, 0x28, 0x0a, 0x10, 0x68, 0x61, 0x73, 0x5f, 0x62, 0x65, 0x65, 0x6e, 0x5f, 0x75, 0x70, 0x64, - 0x61, 0x74, 0x65, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x68, 0x61, 0x73, 0x42, - 0x65, 0x65, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x75, - 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x64, - 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x17, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0b, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2c, - 0x0a, 0x12, 0x69, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, - 0x61, 0x62, 0x6c, 0x65, 0x18, 0x18, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x73, 0x50, 0x72, - 0x69, 0x63, 0x65, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x29, 0x0a, 0x11, - 0x67, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x68, 0x6f, 0x75, - 0x72, 0x18, 0x19, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x67, 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, - 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, 0x12, 0x2c, 0x0a, 0x0f, 0x69, 0x73, 0x5f, 0x64, 0x69, - 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x18, 0x28, 0x20, 0x01, 0x28, 0x08, - 0x48, 0x00, 0x52, 0x0e, 0x69, 0x73, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, - 0x65, 0x64, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x08, 0x7a, 0x78, 0x70, 0x5f, 0x69, 0x6e, 0x66, - 0x6f, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x7a, - 0x78, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x38, 0x0a, 0x0d, 0x7a, 0x78, 0x70, 0x5f, 0x68, 0x65, - 0x6c, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x33, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x0b, 0x7a, 0x78, 0x70, 0x48, 0x65, 0x6c, 0x6d, 0x49, 0x6e, 0x66, 0x6f, - 0x12, 0x36, 0x0a, 0x0c, 0x64, 0x61, 0x6b, 0x72, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, - 0x18, 0x3c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x64, 0x61, - 0x6b, 0x72, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x36, 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, - 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x3d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, - 0x12, 0x3e, 0x0a, 0x10, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6f, 0x70, 0x5f, - 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x3e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x0e, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, - 0x12, 0x3c, 0x0a, 0x0f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x6f, 0x70, 0x5f, 0x69, - 0x6e, 0x66, 0x6f, 0x18, 0x3f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x0d, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x21, - 0x0a, 0x0c, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x46, - 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x53, 0x63, 0x6f, 0x72, - 0x65, 0x12, 0x2a, 0x0a, 0x10, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x51, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x75, 0x6e, 0x64, - 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, - 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x5b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, - 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x68, 0x61, 0x73, 0x5f, 0x61, 0x72, 0x67, 0x6f, 0x5f, 0x77, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x18, 0x65, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x68, - 0x61, 0x73, 0x41, 0x72, 0x67, 0x6f, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x42, - 0x12, 0x0a, 0x10, 0x5f, 0x69, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, - 0x74, 0x65, 0x64, 0x22, 0x54, 0x0a, 0x0c, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, - 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, - 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, - 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x65, 0x18, 0x15, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x22, 0x73, 0x0a, 0x09, 0x43, 0x6f, 0x6e, - 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x22, 0x21, - 0x0a, 0x1f, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, - 0x74, 0x6f, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x22, 0x94, 0x06, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x4f, - 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x08, 0x7a, 0x78, 0x70, 0x5f, 0x69, 0x6e, - 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, - 0x7a, 0x78, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x38, 0x0a, 0x0d, 0x7a, 0x78, 0x70, 0x5f, 0x68, - 0x65, 0x6c, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0b, 0x7a, 0x78, 0x70, 0x48, 0x65, 0x6c, 0x6d, 0x49, 0x6e, 0x66, - 0x6f, 0x12, 0x3c, 0x0a, 0x0f, 0x7a, 0x78, 0x70, 0x5f, 0x6e, 0x65, 0x74, 0x6d, 0x6f, 0x6e, 0x5f, - 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x0d, 0x7a, 0x78, 0x70, 0x4e, 0x65, 0x74, 0x6d, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, - 0x45, 0x0a, 0x14, 0x7a, 0x78, 0x70, 0x5f, 0x6e, 0x65, 0x74, 0x6d, 0x6f, 0x6e, 0x5f, 0x68, 0x65, - 0x6c, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x11, 0x7a, 0x78, 0x70, 0x4e, 0x65, 0x74, 0x6d, 0x6f, 0x6e, 0x48, 0x65, - 0x6c, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x36, 0x0a, 0x0c, 0x64, 0x61, 0x6b, 0x72, 0x5f, 0x6f, - 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, - 0x66, 0x6f, 0x52, 0x0a, 0x64, 0x61, 0x6b, 0x72, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3f, - 0x0a, 0x11, 0x64, 0x61, 0x6b, 0x72, 0x5f, 0x6f, 0x70, 0x5f, 0x68, 0x65, 0x6c, 0x6d, 0x5f, 0x69, - 0x6e, 0x66, 0x6f, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x0e, 0x64, 0x61, 0x6b, 0x72, 0x4f, 0x70, 0x48, 0x65, 0x6c, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, - 0x3d, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, - 0x61, 0x77, 0x73, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x41, 0x77, 0x73, 0x12, 0x41, - 0x0a, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x61, - 0x7a, 0x75, 0x72, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x41, 0x7a, 0x75, 0x72, - 0x65, 0x12, 0x3d, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, - 0x6f, 0x5f, 0x67, 0x63, 0x70, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, - 0x6f, 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x47, 0x63, 0x70, - 0x12, 0x3d, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, - 0x5f, 0x6f, 0x63, 0x69, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x4f, 0x63, 0x69, 0x12, - 0x3e, 0x0a, 0x10, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6f, 0x70, 0x5f, 0x69, - 0x6e, 0x66, 0x6f, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x0e, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, - 0x47, 0x0a, 0x15, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6f, 0x70, 0x5f, 0x68, - 0x65, 0x6c, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x12, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4f, 0x70, - 0x48, 0x65, 0x6c, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0xe3, 0x01, 0x0a, 0x22, 0x47, 0x61, 0x6c, - 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x50, 0x65, 0x72, - 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, - 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x3a, 0x0a, 0x08, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x5f, 0x62, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x43, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x52, 0x07, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x47, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, - 0x6e, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, - 0x76, 0x65, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x52, - 0x0d, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x22, 0x5f, - 0x0a, 0x23, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, - 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x22, - 0xf4, 0x01, 0x0a, 0x12, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, - 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, - 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, - 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x49, 0x64, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, - 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, - 0x6e, 0x66, 0x6f, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, - 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, - 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, - 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, - 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0xdd, 0x01, 0x0a, 0x1f, 0x47, 0x61, 0x6c, 0x61, 0x78, - 0x79, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, - 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, - 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, - 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, - 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x49, 0x64, 0x73, 0x12, 0x37, 0x0a, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x62, 0x79, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x42, 0x79, 0x52, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x47, 0x0a, - 0x0e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x73, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, - 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, - 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, - 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x22, 0x59, 0x0a, 0x20, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, - 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, - 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x09, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x4e, 0x6f, 0x64, - 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, - 0x73, 0x22, 0x8c, 0x02, 0x0a, 0x0f, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x4e, 0x6f, 0x64, 0x65, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, - 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x73, 0x12, 0x1f, 0x0a, - 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x2d, - 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x42, 0x0a, - 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, - 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, - 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, - 0x22, 0xe5, 0x01, 0x0a, 0x23, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x57, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, - 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, - 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, - 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, - 0x64, 0x73, 0x12, 0x3b, 0x0a, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x62, 0x79, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, - 0x6c, 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x52, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, - 0x47, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x6f, 0x70, 0x74, - 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x44, 0x61, 0x74, 0x61, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x61, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x22, 0xb6, 0x03, 0x0a, 0x24, 0x47, 0x61, 0x6c, - 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x65, - 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x39, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, - 0x6c, 0x61, 0x78, 0x79, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x56, 0x0a, 0x08, - 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, - 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, - 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x73, 0x12, 0x59, 0x0a, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, - 0x61, 0x64, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x1a, - 0x4c, 0x0a, 0x0d, 0x43, 0x6c, 0x75, 0x73, 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, 0x25, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x52, 0x0a, - 0x0e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 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, 0x2a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, - 0x61, 0x64, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, - 0x01, 0x22, 0xaf, 0x02, 0x0a, 0x13, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x57, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, - 0x61, 0x64, 0x5f, 0x75, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x77, - 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x63, - 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x2d, 0x0a, 0x09, - 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, - 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x42, 0x0a, 0x10, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, - 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, - 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, - 0x61, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, - 0x72, 0x79, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, - 0x61, 0x72, 0x79, 0x22, 0x98, 0x01, 0x0a, 0x18, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, - 0x69, 0x76, 0x65, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, - 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, - 0x1b, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x74, 0x6f, 0x70, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x12, 0x40, 0x0a, 0x1d, - 0x6e, 0x75, 0x6d, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x5f, 0x69, - 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x19, 0x6e, 0x75, 0x6d, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, - 0x74, 0x73, 0x49, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0xfa, - 0x04, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, - 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, - 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, - 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x77, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x77, - 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x12, 0x3a, 0x0a, 0x0d, 0x77, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0e, - 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, - 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, - 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x69, - 0x64, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, - 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x64, 0x12, - 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x72, 0x65, 0x63, 0x6f, - 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x13, - 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x75, 0x73, 0x65, 0x72, - 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x11, 0x6f, 0x72, 0x69, 0x67, 0x69, - 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x2a, 0x0a, 0x0e, - 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x18, 0x09, - 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x43, 0x6f, 0x6e, - 0x74, 0x61, 0x69, 0x6e, 0x73, 0x88, 0x01, 0x01, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, - 0x74, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x39, - 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 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, 0x09, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, - 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 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, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, - 0x12, 0x32, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x15, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, - 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x0d, 0x61, 0x75, 0x64, 0x69, 0x74, 0x5f, 0x6c, 0x6f, - 0x67, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x75, 0x64, - 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x49, 0x64, 0x73, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x65, 0x6d, 0x61, - 0x69, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x22, 0x76, 0x0a, 0x15, 0x4c, - 0x69, 0x73, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x64, 0x69, - 0x74, 0x4c, 0x6f, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x12, - 0x32, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x15, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x67, - 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x22, 0xac, 0x04, 0x0a, 0x1e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x75, 0x64, 0x69, - 0x74, 0x4c, 0x6f, 0x67, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, + 0x65, 0x72, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x17, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x49, 0x64, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x73, 0x22, 0x72, 0x0a, 0x20, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4e, 0x61, 0x6d, 0x65, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x17, - 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x77, 0x6f, 0x72, 0x6b, 0x6c, - 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x77, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x12, 0x3a, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0e, 0x32, - 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, - 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, - 0x54, 0x79, 0x70, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, - 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x69, 0x64, - 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, - 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x64, 0x12, 0x2b, - 0x0a, 0x11, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x72, 0x65, 0x63, 0x6f, 0x6d, - 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x13, 0x6f, - 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x75, 0x73, 0x65, 0x72, 0x5f, - 0x69, 0x64, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x11, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, - 0x61, 0x74, 0x69, 0x6e, 0x67, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x2a, 0x0a, 0x0e, 0x65, - 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x18, 0x09, 0x20, - 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x43, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x73, 0x88, 0x01, 0x01, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, - 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x39, 0x0a, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x16, + 0x0a, 0x06, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x22, 0x43, 0x0a, 0x21, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x22, 0x58, 0x0a, 0x1e, 0x4c, + 0x69, 0x73, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, + 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x64, 0x22, 0x58, 0x0a, 0x1f, 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x61, 0x6d, + 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x0a, 0x6e, 0x61, 0x6d, 0x65, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, + 0x74, 0x65, 0x6d, 0x52, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x22, + 0x33, 0x0a, 0x0d, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x74, 0x65, 0x6d, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xdb, 0x02, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, + 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x1e, 0x0a, + 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, 0x2b, 0x0a, + 0x05, 0x6b, 0x69, 0x6e, 0x64, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, + 0x69, 0x6e, 0x64, 0x52, 0x05, 0x6b, 0x69, 0x6e, 0x64, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x77, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x08, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x61, 0x62, + 0x65, 0x6c, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6e, + 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 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, 0x09, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, - 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 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, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x42, - 0x11, 0x0a, 0x0f, 0x5f, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, - 0x6e, 0x73, 0x22, 0x4a, 0x0a, 0x1f, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x4c, - 0x6f, 0x67, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x61, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, - 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x9e, - 0x01, 0x0a, 0x18, 0x53, 0x65, 0x6e, 0x64, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x45, - 0x6d, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, + 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, + 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x08, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x15, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x64, 0x22, 0x77, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x58, 0x0a, 0x1d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, + 0x77, 0x69, 0x74, 0x68, 0x5f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x52, 0x19, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x57, 0x69, 0x74, 0x68, 0x57, + 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xb1, 0x02, 0x0a, 0x1b, + 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, - 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, - 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, + 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, + 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x05, 0x6b, 0x69, 0x6e, 0x64, 0x73, 0x18, 0x07, + 0x20, 0x03, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, + 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x05, 0x6b, 0x69, 0x6e, + 0x64, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x77, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x6f, 0x64, + 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x09, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, + 0x6d, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, - 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x12, - 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x15, 0x20, 0x03, 0x28, 0x09, 0x52, 0x02, 0x74, 0x6f, 0x22, - 0x35, 0x0a, 0x19, 0x53, 0x65, 0x6e, 0x64, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x45, - 0x6d, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x64, 0x0a, 0x1d, 0x53, 0x65, 0x6e, 0x64, 0x57, 0x65, - 0x65, 0x6b, 0x6c, 0x79, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x45, 0x6d, 0x61, 0x69, 0x6c, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x43, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x57, 0x65, 0x65, 0x6b, 0x6c, 0x79, 0x53, 0x75, 0x6d, 0x6d, - 0x61, 0x72, 0x79, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x44, - 0x61, 0x74, 0x61, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x5c, 0x0a, 0x21, - 0x53, 0x65, 0x6e, 0x64, 0x57, 0x65, 0x65, 0x6b, 0x6c, 0x79, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, - 0x79, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x44, 0x61, 0x74, - 0x61, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, - 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, - 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3a, 0x0a, 0x1e, 0x53, 0x65, - 0x6e, 0x64, 0x57, 0x65, 0x65, 0x6b, 0x6c, 0x79, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x45, - 0x6d, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x95, 0x03, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x43, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, + 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x22, + 0x6b, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x4b, 0x0a, 0x16, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x77, 0x69, + 0x74, 0x68, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x13, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x49, 0x64, 0x57, 0x69, 0x74, 0x68, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x22, 0xbc, 0x01, 0x0a, + 0x1b, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, + 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, + 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, + 0x6d, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, 0x7d, 0x0a, 0x1c, 0x47, + 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, + 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5d, 0x0a, 0x20, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6e, + 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x1b, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x64, 0x65, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0xd3, 0x0d, 0x0a, 0x07, 0x43, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, + 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, + 0x6d, 0x49, 0x64, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x5f, 0x70, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, + 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, + 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x25, 0x0a, 0x0e, + 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x0a, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, 0x0a, + 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x09, + 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3f, 0x0a, 0x10, 0x63, + 0x6f, 0x73, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, + 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0e, 0x63, 0x6f, + 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x4b, 0x0a, 0x14, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, + 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x12, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x44, + 0x61, 0x74, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x3c, 0x0a, 0x13, 0x6d, 0x6f, 0x73, + 0x74, 0x5f, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, + 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x11, 0x6d, 0x6f, 0x73, 0x74, 0x45, 0x78, 0x70, 0x65, 0x6e, 0x73, + 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x3e, 0x0a, 0x14, 0x6c, 0x65, 0x61, 0x73, 0x74, + 0x5f, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, + 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, + 0x6f, 0x64, 0x65, 0x52, 0x12, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x45, 0x78, 0x70, 0x65, 0x6e, 0x73, + 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x44, 0x0a, 0x17, 0x6d, 0x6f, 0x73, 0x74, 0x5f, + 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x6e, 0x6f, + 0x64, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x15, 0x6d, 0x6f, 0x73, 0x74, 0x55, 0x6e, 0x64, 0x65, + 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x53, 0x0a, + 0x1c, 0x6d, 0x6f, 0x73, 0x74, 0x5f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, + 0x7a, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x12, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x1a, 0x6d, 0x6f, 0x73, 0x74, 0x55, 0x6e, 0x64, 0x65, + 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x12, 0x29, 0x0a, 0x11, 0x63, 0x70, 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x70, + 0x65, 0x72, 0x5f, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x13, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x63, + 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, 0x12, 0x2f, 0x0a, + 0x14, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x70, 0x65, 0x72, + 0x5f, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x14, 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x6d, 0x65, 0x6d, + 0x6f, 0x72, 0x79, 0x43, 0x6f, 0x73, 0x74, 0x50, 0x65, 0x72, 0x48, 0x6f, 0x75, 0x72, 0x12, 0x28, + 0x0a, 0x10, 0x68, 0x61, 0x73, 0x5f, 0x62, 0x65, 0x65, 0x6e, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x68, 0x61, 0x73, 0x42, 0x65, 0x65, + 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x75, 0x73, 0x74, + 0x6f, 0x6d, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x69, 0x73, + 0x70, 0x6c, 0x61, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x17, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x12, + 0x69, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, + 0x6c, 0x65, 0x18, 0x18, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x73, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x29, 0x0a, 0x11, 0x67, 0x70, + 0x75, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x68, 0x6f, 0x75, 0x72, 0x18, + 0x19, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x67, 0x70, 0x75, 0x43, 0x6f, 0x73, 0x74, 0x50, 0x65, + 0x72, 0x48, 0x6f, 0x75, 0x72, 0x12, 0x2c, 0x0a, 0x0f, 0x69, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x18, 0x28, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, + 0x52, 0x0e, 0x69, 0x73, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x08, 0x7a, 0x78, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, + 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x7a, 0x78, 0x70, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x38, 0x0a, 0x0d, 0x7a, 0x78, 0x70, 0x5f, 0x68, 0x65, 0x6c, 0x6d, + 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x33, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x0b, 0x7a, 0x78, 0x70, 0x48, 0x65, 0x6c, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x36, + 0x0a, 0x0c, 0x64, 0x61, 0x6b, 0x72, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x3c, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x64, 0x61, 0x6b, 0x72, + 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x36, 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, + 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x3d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3e, + 0x0a, 0x10, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, + 0x66, 0x6f, 0x18, 0x3e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0e, + 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3c, + 0x0a, 0x0f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, + 0x6f, 0x18, 0x3f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x6e, + 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x21, 0x0a, 0x0c, + 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x46, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x0b, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x12, + 0x2a, 0x0a, 0x10, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x51, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x75, 0x6e, 0x64, 0x65, 0x72, + 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, + 0x61, 0x67, 0x73, 0x18, 0x5b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x12, + 0x2c, 0x0a, 0x12, 0x68, 0x61, 0x73, 0x5f, 0x61, 0x72, 0x67, 0x6f, 0x5f, 0x77, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x18, 0x65, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x68, 0x61, 0x73, + 0x41, 0x72, 0x67, 0x6f, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x12, 0x2d, 0x0a, + 0x12, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x6e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6b, 0x75, 0x62, 0x65, 0x72, + 0x6e, 0x65, 0x74, 0x65, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x12, 0x0a, 0x10, + 0x5f, 0x69, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x22, 0x54, 0x0a, 0x0c, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x65, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x22, 0x73, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x22, 0x21, 0x0a, 0x1f, 0x47, + 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x94, + 0x06, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x6f, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x08, 0x7a, 0x78, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x7a, 0x78, 0x70, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x38, 0x0a, 0x0d, 0x7a, 0x78, 0x70, 0x5f, 0x68, 0x65, 0x6c, 0x6d, + 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x0b, 0x7a, 0x78, 0x70, 0x48, 0x65, 0x6c, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3c, + 0x0a, 0x0f, 0x7a, 0x78, 0x70, 0x5f, 0x6e, 0x65, 0x74, 0x6d, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x66, + 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x7a, + 0x78, 0x70, 0x4e, 0x65, 0x74, 0x6d, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x45, 0x0a, 0x14, + 0x7a, 0x78, 0x70, 0x5f, 0x6e, 0x65, 0x74, 0x6d, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x6c, 0x6d, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x11, 0x7a, 0x78, 0x70, 0x4e, 0x65, 0x74, 0x6d, 0x6f, 0x6e, 0x48, 0x65, 0x6c, 0x6d, 0x49, + 0x6e, 0x66, 0x6f, 0x12, 0x36, 0x0a, 0x0c, 0x64, 0x61, 0x6b, 0x72, 0x5f, 0x6f, 0x70, 0x5f, 0x69, + 0x6e, 0x66, 0x6f, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x0a, 0x64, 0x61, 0x6b, 0x72, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3f, 0x0a, 0x11, 0x64, + 0x61, 0x6b, 0x72, 0x5f, 0x6f, 0x70, 0x5f, 0x68, 0x65, 0x6c, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0e, 0x64, 0x61, + 0x6b, 0x72, 0x4f, 0x70, 0x48, 0x65, 0x6c, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3d, 0x0a, 0x10, + 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x61, 0x77, 0x73, + 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x6e, 0x6f, + 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x41, 0x77, 0x73, 0x12, 0x41, 0x0a, 0x12, 0x6e, + 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x61, 0x7a, 0x75, 0x72, + 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0f, 0x6e, + 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x41, 0x7a, 0x75, 0x72, 0x65, 0x12, 0x3d, + 0x0a, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x67, + 0x63, 0x70, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, + 0x6e, 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x47, 0x63, 0x70, 0x12, 0x3d, 0x0a, + 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x6f, 0x63, + 0x69, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x6e, + 0x6f, 0x64, 0x65, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x4f, 0x63, 0x69, 0x12, 0x3e, 0x0a, 0x10, + 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6f, 0x70, 0x5f, 0x69, 0x6e, 0x66, 0x6f, + 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0e, 0x73, 0x65, + 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x47, 0x0a, 0x15, + 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6f, 0x70, 0x5f, 0x68, 0x65, 0x6c, 0x6d, + 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x12, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4f, 0x70, 0x48, 0x65, 0x6c, + 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0xe3, 0x01, 0x0a, 0x22, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, + 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, + 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, + 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, + 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x3a, 0x0a, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, + 0x62, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x52, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x42, 0x79, 0x12, 0x47, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, + 0x6f, 0x70, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x44, + 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x52, 0x0d, 0x64, 0x61, + 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x22, 0x5f, 0x0a, 0x23, 0x47, + 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x50, + 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x61, 0x6c, 0x61, 0x78, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x22, 0xf4, 0x01, 0x0a, + 0x12, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, + 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, + 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, + 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, + 0x6f, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, + 0x6e, 0x66, 0x6f, 0x22, 0xdd, 0x01, 0x0a, 0x1f, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, + 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, + 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, + 0x73, 0x12, 0x37, 0x0a, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x62, 0x79, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, 0x6c, + 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, + 0x79, 0x52, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x47, 0x0a, 0x0e, 0x64, 0x61, + 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, + 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x4f, 0x70, 0x74, 0x73, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x4f, + 0x70, 0x74, 0x73, 0x22, 0x59, 0x0a, 0x20, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, + 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x22, 0x8c, + 0x02, 0x0a, 0x0f, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, + 0x19, 0x0a, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, + 0x6f, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x08, 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, + 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0xe5, 0x01, + 0x0a, 0x23, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, - 0x3e, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 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, 0x48, - 0x00, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, - 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 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, 0x48, 0x01, 0x52, - 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x31, 0x0a, 0x15, 0x65, - 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6d, 0x6f, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70, 0x5f, - 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x29, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x65, 0x78, 0x63, 0x6c, - 0x75, 0x64, 0x65, 0x4d, 0x6f, 0x73, 0x74, 0x45, 0x78, 0x70, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x33, - 0x0a, 0x16, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x5f, - 0x65, 0x78, 0x70, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, - 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4c, 0x65, 0x61, 0x73, 0x74, 0x45, 0x78, 0x70, 0x4e, - 0x6f, 0x64, 0x65, 0x12, 0x3d, 0x0a, 0x1b, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6d, - 0x6f, 0x73, 0x74, 0x5f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x5f, 0x6e, 0x6f, - 0x64, 0x65, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, - 0x65, 0x4d, 0x6f, 0x73, 0x74, 0x55, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x4e, 0x6f, - 0x64, 0x65, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, 0x90, - 0x02, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x4e, 0x6f, - 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2d, - 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3c, 0x0a, - 0x13, 0x6d, 0x6f, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f, - 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x11, 0x6d, 0x6f, 0x73, 0x74, 0x45, 0x78, - 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x3e, 0x0a, 0x14, 0x6c, - 0x65, 0x61, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6e, - 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x12, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x45, 0x78, - 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x44, 0x0a, 0x17, 0x6d, - 0x6f, 0x73, 0x74, 0x5f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, - 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x15, 0x6d, 0x6f, 0x73, 0x74, - 0x55, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x4e, 0x6f, 0x64, - 0x65, 0x22, 0x9f, 0x01, 0x0a, 0x19, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4b, 0x38, 0x73, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x61, 0x72, 0x63, - 0x68, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, - 0x65, 0x61, 0x72, 0x63, 0x68, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, - 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x64, 0x22, 0x4f, 0x0a, 0x1a, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4b, 0x38, 0x73, - 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x31, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x53, - 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, 0x72, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x73, 0x22, 0x8e, 0x01, 0x0a, 0x0f, 0x4b, 0x38, 0x73, 0x53, 0x65, 0x61, 0x72, - 0x63, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, - 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, - 0x6e, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x66, 0x69, - 0x65, 0x6c, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6d, 0x61, 0x74, 0x63, 0x68, - 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x78, 0x0a, 0x19, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4b, - 0x38, 0x73, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, - 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x0c, - 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x51, 0x75, 0x65, 0x72, 0x79, 0x22, - 0x57, 0x0a, 0x1a, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4b, 0x38, 0x73, 0x57, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, - 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x57, 0x6f, 0x72, 0x6b, 0x6c, - 0x6f, 0x61, 0x64, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, - 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x41, 0x0a, 0x17, 0x4b, 0x38, 0x73, 0x57, - 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xc8, 0x02, 0x0a, 0x1b, - 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, - 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, - 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, - 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, - 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x49, 0x64, 0x12, 0x6b, 0x0a, 0x14, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, - 0x75, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x06, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x3a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, - 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, - 0x69, 0x64, 0x54, 0x6f, 0x4b, 0x69, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x77, - 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4b, 0x69, 0x6e, 0x64, - 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, - 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x1a, 0x5b, 0x0a, 0x16, 0x57, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4b, 0x69, 0x6e, 0x64, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, - 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xfc, 0x01, 0x0a, 0x1c, 0x4d, 0x65, 0x74, 0x61, 0x64, - 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x78, 0x0a, 0x18, 0x77, 0x6f, 0x72, 0x6b, 0x6c, - 0x6f, 0x61, 0x64, 0x5f, 0x75, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, - 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, - 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, - 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x15, 0x77, 0x6f, 0x72, 0x6b, - 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, - 0x61, 0x1a, 0x62, 0x0a, 0x1a, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, - 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, - 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, - 0x79, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, - 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x63, 0x0a, 0x15, 0x41, 0x64, 0x64, 0x43, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, - 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x03, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x22, 0x43, 0x0a, 0x16, 0x41, 0x64, - 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, - 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x22, - 0x66, 0x0a, 0x18, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, - 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, - 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, - 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x22, 0x46, 0x0a, 0x19, 0x52, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, - 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x22, - 0x2a, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x22, 0x3f, 0x0a, 0x0a, 0x54, - 0x61, 0x67, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x63, - 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x22, 0x3a, 0x0a, 0x10, - 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x26, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x61, 0x67, 0x53, 0x75, 0x6d, 0x6d, 0x61, - 0x72, 0x79, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x22, 0xcc, 0x04, 0x0a, 0x10, 0x57, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x6a, 0x0a, - 0x18, 0x70, 0x6f, 0x64, 0x5f, 0x75, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6e, 0x6f, 0x64, 0x65, - 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x32, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, - 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x6f, 0x64, 0x55, 0x69, 0x64, - 0x54, 0x6f, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x14, 0x70, 0x6f, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4e, 0x6f, 0x64, - 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x67, 0x0a, 0x17, 0x70, 0x6f, 0x64, - 0x5f, 0x75, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, - 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x6f, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x50, 0x6f, 0x64, - 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x70, - 0x6f, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x50, 0x6f, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, - 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x1e, 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, - 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6e, - 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, - 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, - 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, - 0x12, 0x29, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x1a, 0x5d, 0x0a, 0x19, 0x50, - 0x6f, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, - 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2a, 0x0a, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x5b, 0x0a, 0x18, 0x50, 0x6f, - 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x50, 0x6f, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, - 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x50, 0x6f, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9f, 0x01, 0x0a, 0x0b, 0x50, 0x6f, 0x64, 0x4d, - 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6c, - 0x61, 0x62, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, - 0x6c, 0x12, 0x1e, 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1a, 0x0a, - 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0xaa, 0x02, 0x0a, 0x0c, 0x4e, 0x6f, - 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, - 0x64, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, - 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, - 0x26, 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2f, 0x0a, 0x14, 0x63, 0x6c, 0x6f, 0x75, 0x64, - 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x49, 0x6e, 0x73, 0x74, - 0x54, 0x79, 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, - 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x1e, - 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, - 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x70, - 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, - 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, - 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0xce, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x52, 0x65, - 0x6c, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, - 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x29, 0x0a, - 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, - 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x0d, 0x6b, 0x61, - 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x09, 0x48, 0x00, 0x52, 0x0d, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x4b, 0x69, - 0x6e, 0x64, 0x88, 0x01, 0x01, 0x42, 0x10, 0x0a, 0x0e, 0x5f, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, - 0x74, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x22, 0xdd, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x57, - 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x6f, 0x64, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x77, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0b, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x12, 0x3c, 0x0a, 0x0c, - 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x73, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x0b, 0x72, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x73, 0x12, 0x33, 0x0a, 0x0b, 0x64, 0x69, - 0x72, 0x65, 0x63, 0x74, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x48, 0x69, 0x73, 0x74, - 0x6f, 0x72, 0x79, 0x52, 0x0a, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x50, 0x6f, 0x64, 0x73, 0x12, - 0x26, 0x0a, 0x04, 0x6a, 0x6f, 0x62, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4a, 0x6f, 0x62, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x52, 0x04, 0x6a, 0x6f, 0x62, 0x73, 0x22, 0xe8, 0x01, 0x0a, 0x0a, 0x4a, 0x6f, 0x62, 0x48, - 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, - 0x61, 0x74, 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, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, - 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, 0x20, + 0x3b, 0x0a, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x62, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, + 0x79, 0x50, 0x4f, 0x56, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x42, 0x79, 0x52, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x47, 0x0a, 0x0e, + 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x73, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, + 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x4f, 0x70, 0x74, 0x73, 0x22, 0xb6, 0x03, 0x0a, 0x24, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, + 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x65, 0x72, 0x73, 0x70, + 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, + 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, + 0x79, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x09, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x56, 0x0a, 0x08, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x73, 0x12, 0x59, 0x0a, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x61, + 0x6c, 0x61, 0x78, 0x79, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x50, + 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x1a, 0x4c, 0x0a, 0x0d, + 0x43, 0x6c, 0x75, 0x73, 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, + 0x25, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x52, 0x0a, 0x0e, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 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, 0x2a, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, + 0x74, 0x65, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xaf, + 0x02, 0x0a, 0x13, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x4b, 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, + 0x75, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x63, 0x6f, 0x73, + 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, + 0x63, 0x6f, 0x73, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x0f, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x42, 0x0a, 0x10, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, + 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, + 0x22, 0x98, 0x01, 0x0a, 0x18, 0x50, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, + 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x73, 0x12, 0x1d, 0x0a, + 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, 0x1b, 0x0a, 0x09, + 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x74, 0x6f, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x08, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x12, 0x40, 0x0a, 0x1d, 0x6e, 0x75, 0x6d, + 0x5f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x5f, 0x69, 0x6e, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x19, 0x6e, 0x75, 0x6d, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x49, + 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0xa3, 0x05, 0x0a, 0x14, + 0x4c, 0x69, 0x73, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, + 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, + 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x6e, + 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x77, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x12, 0x3a, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x15, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x64, 0x12, 0x2b, 0x0a, 0x11, + 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, + 0x64, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, + 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x13, 0x6f, 0x72, 0x69, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x64, + 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x11, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6e, 0x67, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x0e, 0x65, 0x6d, 0x61, + 0x69, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x0d, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x88, 0x01, 0x01, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, + 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 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, - 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x26, 0x0a, 0x04, 0x70, 0x6f, - 0x64, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x04, 0x70, 0x6f, - 0x64, 0x73, 0x22, 0xf3, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, - 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x39, - 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 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, 0x09, - 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 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, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, - 0x65, 0x64, 0x41, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, - 0x12, 0x26, 0x0a, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x48, 0x69, 0x73, 0x74, 0x6f, - 0x72, 0x79, 0x52, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x22, 0xf9, 0x01, 0x0a, 0x0a, 0x50, 0x6f, 0x64, - 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, - 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, - 0x68, 0x61, 0x73, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, - 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x39, - 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x06, 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, 0x09, - 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x07, 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, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, - 0x65, 0x64, 0x41, 0x74, 0x22, 0xb5, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x6c, 0x61, - 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x52, 0x09, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2d, - 0x0a, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x2d, 0x0a, - 0x05, 0x65, 0x64, 0x67, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x45, 0x64, 0x67, 0x65, 0x52, 0x05, 0x65, 0x64, 0x67, 0x65, 0x73, 0x22, 0x83, 0x02, 0x0a, - 0x12, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6b, 0x69, - 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x75, - 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x55, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, - 0x69, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, - 0x75, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x55, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x68, 0x69, 0x70, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x54, 0x79, - 0x70, 0x65, 0x22, 0x49, 0x0a, 0x0f, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, - 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x67, 0x0a, - 0x0f, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x64, 0x67, 0x65, - 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, - 0x12, 0x16, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, - 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x22, 0x4f, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x22, 0x79, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x43, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x36, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6b, 0x75, 0x62, - 0x65, 0x6c, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0e, 0x6b, 0x75, 0x62, 0x65, 0x6c, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x22, 0xea, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, - 0x61, 0x64, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x15, 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, 0x48, 0x00, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, - 0x69, 0x6d, 0x65, 0x18, 0x16, 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, 0x48, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, - 0x88, 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, - 0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, - 0xcf, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, - 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, - 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x74, 0x6f, - 0x74, 0x61, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, - 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x75, 0x6e, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x75, 0x6e, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, - 0x7a, 0x65, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x5f, 0x72, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x77, - 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x31, - 0x0a, 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x63, - 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x6f, 0x70, - 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, - 0x65, 0x22, 0xc5, 0x01, 0x0a, 0x17, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, - 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, - 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, + 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 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, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, + 0x65, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x4d, + 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, + 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x0d, 0x61, 0x75, + 0x64, 0x69, 0x74, 0x5f, 0x6c, 0x6f, 0x67, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x1f, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x0b, 0x61, 0x75, 0x64, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x49, 0x64, 0x73, 0x42, 0x11, + 0x0a, 0x0f, 0x5f, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x73, 0x22, 0x76, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x4c, 0x6f, + 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x04, 0x6c, 0x6f, + 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x41, 0x75, 0x64, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x12, 0x32, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x70, + 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xd5, 0x04, 0x0a, 0x1e, 0x4c, 0x69, + 0x73, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, + 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, + 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, + 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, + 0x0b, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x0a, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x12, 0x3a, + 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, + 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x0c, 0x77, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x72, 0x65, + 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, 0x72, 0x65, + 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x49, 0x64, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x10, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x12, 0x2e, 0x0a, 0x13, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, + 0x5f, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x11, + 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x64, 0x12, 0x2e, 0x0a, 0x0e, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, + 0x0d, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x88, 0x01, + 0x01, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 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, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, - 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x16, + 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 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, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xcc, 0x05, 0x0a, 0x18, 0x44, 0x61, - 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x98, 0x01, 0x0a, 0x26, 0x63, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x64, 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x74, - 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x72, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, - 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, - 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, - 0x73, 0x12, 0x62, 0x0a, 0x12, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, - 0x74, 0x6f, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, - 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, - 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, - 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x3e, 0x0a, 0x1c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, - 0x6f, 0x72, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x5f, 0x69, 0x6e, 0x5f, 0x70, - 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x05, 0x52, 0x18, 0x74, 0x6f, 0x74, - 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x49, 0x6e, 0x50, - 0x65, 0x72, 0x69, 0x6f, 0x64, 0x1a, 0x58, 0x0a, 0x0a, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, - 0x6e, 0x74, 0x73, 0x12, 0x4a, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, - 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x1a, - 0x3f, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, - 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x1a, 0x80, 0x01, 0x0a, 0x25, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, - 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, - 0x6e, 0x75, 0x74, 0x65, 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, 0x41, 0x0a, 0x05, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, - 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, - 0x02, 0x38, 0x01, 0x1a, 0x53, 0x0a, 0x14, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, - 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x25, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd1, 0x01, 0x0a, 0x23, 0x44, 0x61, 0x69, - 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, - 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6d, 0x61, + 0x69, 0x6c, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0c, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x42, 0x11, + 0x0a, 0x0f, 0x5f, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x73, 0x22, 0x4a, 0x0a, 0x1f, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x4c, 0x6f, + 0x67, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x5f, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x65, + 0x6d, 0x61, 0x69, 0x6c, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x9e, 0x01, + 0x0a, 0x18, 0x53, 0x65, 0x6e, 0x64, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x45, 0x6d, + 0x61, 0x69, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, + 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, + 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x15, 0x20, 0x03, 0x28, 0x09, 0x52, 0x02, 0x74, 0x6f, 0x22, 0x35, + 0x0a, 0x19, 0x53, 0x65, 0x6e, 0x64, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x45, 0x6d, + 0x61, 0x69, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x64, 0x0a, 0x1d, 0x53, 0x65, 0x6e, 0x64, 0x57, 0x65, 0x65, + 0x6b, 0x6c, 0x79, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x43, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x57, 0x65, 0x65, 0x6b, 0x6c, 0x79, 0x53, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x44, 0x61, + 0x74, 0x61, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x5c, 0x0a, 0x21, 0x53, + 0x65, 0x6e, 0x64, 0x57, 0x65, 0x65, 0x6b, 0x6c, 0x79, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, + 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, - 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x15, 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, 0x09, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x18, 0x16, 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, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x96, 0x07, 0x0a, - 0x24, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x18, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, - 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x47, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, - 0x54, 0x6f, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x15, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, - 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x6e, 0x0a, 0x12, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x0b, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, - 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, - 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, 0x65, - 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x49, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x1a, 0x64, 0x0a, 0x0a, 0x44, 0x61, 0x74, 0x61, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x56, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, - 0x69, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, - 0x6e, 0x74, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x1a, 0xbb, - 0x02, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, - 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0xb7, 0x01, 0x0a, 0x29, 0x69, - 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x74, 0x6f, 0x5f, - 0x64, 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x72, 0x65, - 0x5f, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x5f, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, - 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, - 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, - 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, - 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, - 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x23, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, - 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, - 0x75, 0x74, 0x65, 0x73, 0x1a, 0x56, 0x0a, 0x28, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, - 0x54, 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, - 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 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, - 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x81, 0x01, 0x0a, - 0x1a, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, 0x74, 0x61, - 0x70, 0x6f, 0x69, 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, 0x4d, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, - 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, - 0x1a, 0x53, 0x0a, 0x14, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, - 0x65, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x25, 0x0a, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xcd, 0x01, 0x0a, 0x1f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, - 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, - 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, - 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, - 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x49, 0x64, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x18, 0x15, 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, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, - 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, + 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x63, + 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x72, + 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3a, 0x0a, 0x1e, 0x53, 0x65, 0x6e, + 0x64, 0x57, 0x65, 0x65, 0x6b, 0x6c, 0x79, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x45, 0x6d, + 0x61, 0x69, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x95, 0x03, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, + 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x3e, + 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0b, 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, 0x48, 0x00, + 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x3a, + 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, 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, 0x07, 0x65, 0x6e, - 0x64, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xec, 0x06, 0x0a, 0x20, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, - 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7c, 0x0a, 0x18, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x64, 0x61, 0x74, 0x61, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x43, 0x2e, 0x61, + 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x01, 0x52, 0x07, + 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x31, 0x0a, 0x15, 0x65, 0x78, + 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6d, 0x6f, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70, 0x5f, 0x6e, + 0x6f, 0x64, 0x65, 0x18, 0x29, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x65, 0x78, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x4d, 0x6f, 0x73, 0x74, 0x45, 0x78, 0x70, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x33, 0x0a, + 0x16, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x5f, 0x65, + 0x78, 0x70, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4c, 0x65, 0x61, 0x73, 0x74, 0x45, 0x78, 0x70, 0x4e, 0x6f, + 0x64, 0x65, 0x12, 0x3d, 0x0a, 0x1b, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6d, 0x6f, + 0x73, 0x74, 0x5f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x5f, 0x6e, 0x6f, 0x64, + 0x65, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, + 0x4d, 0x6f, 0x73, 0x74, 0x55, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x4e, 0x6f, 0x64, + 0x65, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, 0x90, 0x02, + 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x4e, 0x6f, 0x64, + 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2d, 0x0a, + 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3c, 0x0a, 0x13, + 0x6d, 0x6f, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6e, + 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x11, 0x6d, 0x6f, 0x73, 0x74, 0x45, 0x78, 0x70, + 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x3e, 0x0a, 0x14, 0x6c, 0x65, + 0x61, 0x73, 0x74, 0x5f, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x6e, 0x6f, + 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x12, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x45, 0x78, 0x70, + 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x44, 0x0a, 0x17, 0x6d, 0x6f, + 0x73, 0x74, 0x5f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, + 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x15, 0x6d, 0x6f, 0x73, 0x74, 0x55, + 0x6e, 0x64, 0x65, 0x72, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, + 0x22, 0x9f, 0x01, 0x0a, 0x19, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4b, 0x38, 0x73, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, + 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, + 0x61, 0x72, 0x63, 0x68, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x64, 0x22, 0x4f, 0x0a, 0x1a, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4b, 0x38, 0x73, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x31, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x53, 0x65, + 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x73, 0x22, 0x8e, 0x01, 0x0a, 0x0f, 0x4b, 0x38, 0x73, 0x53, 0x65, 0x61, 0x72, 0x63, + 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, + 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, + 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, + 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x22, 0x78, 0x0a, 0x19, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4b, 0x38, + 0x73, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x73, + 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x51, 0x75, 0x65, 0x72, 0x79, 0x22, 0x57, + 0x0a, 0x1a, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4b, 0x38, 0x73, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x07, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x41, 0x0a, 0x17, 0x4b, 0x38, 0x73, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xc8, 0x02, 0x0a, 0x1b, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, + 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, + 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x49, 0x64, 0x12, 0x6b, 0x0a, 0x14, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x75, + 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x3a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, + 0x64, 0x54, 0x6f, 0x4b, 0x69, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x77, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4b, 0x69, 0x6e, 0x64, 0x12, + 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x1a, 0x5b, 0x0a, 0x16, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4b, 0x69, 0x6e, 0x64, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, + 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xfc, 0x01, 0x0a, 0x1c, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x78, 0x0a, 0x18, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x5f, 0x75, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, + 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x57, + 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x15, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x1a, 0x62, 0x0a, 0x1a, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x54, + 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x22, 0x63, 0x0a, 0x15, 0x41, 0x64, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, + 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x22, 0x43, 0x0a, 0x16, 0x41, 0x64, 0x64, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x22, 0x66, + 0x0a, 0x18, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, + 0x61, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, + 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, + 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x22, 0x46, 0x0a, 0x19, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x22, 0x2a, + 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x22, 0x3f, 0x0a, 0x0a, 0x54, 0x61, + 0x67, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x22, 0x3a, 0x0a, 0x10, 0x4c, + 0x69, 0x73, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x26, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x61, 0x67, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, + 0x79, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x22, 0xcc, 0x04, 0x0a, 0x10, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x6a, 0x0a, 0x18, + 0x70, 0x6f, 0x64, 0x5f, 0x75, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x6f, 0x64, 0x55, 0x69, 0x64, 0x54, + 0x6f, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x14, 0x70, 0x6f, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4e, 0x6f, 0x64, 0x65, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x67, 0x0a, 0x17, 0x70, 0x6f, 0x64, 0x5f, + 0x75, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x50, 0x6f, 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x50, 0x6f, 0x64, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x70, 0x6f, + 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x50, 0x6f, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x1e, 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6e, 0x6e, + 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x29, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x1a, 0x5d, 0x0a, 0x19, 0x50, 0x6f, + 0x64, 0x55, 0x69, 0x64, 0x54, 0x6f, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2a, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x5b, 0x0a, 0x18, 0x50, 0x6f, 0x64, + 0x55, 0x69, 0x64, 0x54, 0x6f, 0x50, 0x6f, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x50, 0x6f, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9f, 0x01, 0x0a, 0x0b, 0x50, 0x6f, 0x64, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, + 0x62, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, + 0x12, 0x1e, 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x12, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x73, 0x70, 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1a, 0x0a, 0x08, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0xaa, 0x02, 0x0a, 0x0c, 0x4e, 0x6f, 0x64, + 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, + 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, + 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x26, + 0x0a, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2f, 0x0a, 0x14, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x5f, + 0x69, 0x6e, 0x73, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x49, 0x6e, 0x73, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x1e, 0x0a, + 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, + 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x70, 0x65, + 0x63, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0xce, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x52, 0x65, 0x6c, + 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, + 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x04, + 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4b, 0x69, 0x6e, + 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x0d, 0x6b, 0x61, 0x72, + 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x48, 0x00, 0x52, 0x0d, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x4b, 0x69, 0x6e, + 0x64, 0x88, 0x01, 0x01, 0x42, 0x10, 0x0a, 0x0e, 0x5f, 0x6b, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, + 0x65, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x22, 0xdd, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x6f, 0x64, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x77, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x55, 0x69, 0x64, 0x12, 0x3c, 0x0a, 0x0c, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x73, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x53, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x0b, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, 0x73, 0x12, 0x33, 0x0a, 0x0b, 0x64, 0x69, 0x72, + 0x65, 0x63, 0x74, 0x5f, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x52, 0x0a, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x50, 0x6f, 0x64, 0x73, 0x12, 0x26, + 0x0a, 0x04, 0x6a, 0x6f, 0x62, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4a, 0x6f, 0x62, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, + 0x52, 0x04, 0x6a, 0x6f, 0x62, 0x73, 0x22, 0xe8, 0x01, 0x0a, 0x0a, 0x4a, 0x6f, 0x62, 0x48, 0x69, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, + 0x74, 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, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, + 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, 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, 0x09, + 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x26, 0x0a, 0x04, 0x70, 0x6f, 0x64, + 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x6f, 0x64, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x04, 0x70, 0x6f, 0x64, + 0x73, 0x22, 0xf3, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x74, + 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, + 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 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, 0x09, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 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, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x64, 0x41, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x26, 0x0a, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6f, 0x64, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, + 0x79, 0x52, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x22, 0xf9, 0x01, 0x0a, 0x0a, 0x50, 0x6f, 0x64, 0x48, + 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, + 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x68, + 0x61, 0x73, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, + 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x06, 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, 0x09, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x07, 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, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x64, 0x41, 0x74, 0x22, 0xb5, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x6c, 0x61, 0x74, + 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4b, 0x38, 0x73, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x52, 0x09, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2d, 0x0a, + 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x05, + 0x65, 0x64, 0x67, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x45, 0x64, 0x67, 0x65, 0x52, 0x05, 0x65, 0x64, 0x67, 0x65, 0x73, 0x22, 0x83, 0x02, 0x0a, 0x12, + 0x4b, 0x38, 0x73, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6b, 0x69, 0x6e, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b, + 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x75, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x55, + 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x69, + 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x75, + 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x55, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x68, 0x69, 0x70, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x54, 0x79, 0x70, + 0x65, 0x22, 0x49, 0x0a, 0x0f, 0x4b, 0x38, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x67, 0x0a, 0x0f, + 0x4b, 0x38, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x64, 0x67, 0x65, 0x12, + 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, + 0x16, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, + 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x22, 0x4f, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, + 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x22, 0x79, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x36, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6b, 0x75, 0x62, 0x65, + 0x6c, 0x65, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0e, 0x6b, 0x75, 0x62, 0x65, 0x6c, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x22, 0xea, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, + 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x15, 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, 0x48, 0x00, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x16, 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, 0x48, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, + 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, + 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, 0xcf, + 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x74, 0x6f, 0x74, + 0x61, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, + 0x12, 0x20, 0x0a, 0x0b, 0x75, 0x6e, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x75, 0x6e, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, + 0x65, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x5f, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x77, 0x69, + 0x74, 0x68, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x31, 0x0a, + 0x14, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, + 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x6f, 0x70, 0x74, + 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, + 0x22, 0xc5, 0x01, 0x0a, 0x17, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, + 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, + 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x15, 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, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x16, 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, + 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xcc, 0x05, 0x0a, 0x18, 0x44, 0x61, 0x69, + 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x98, 0x01, 0x0a, 0x26, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x64, 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x74, 0x6f, + 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x72, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x46, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, + 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x20, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, + 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, + 0x12, 0x62, 0x0a, 0x12, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, + 0x6f, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, - 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, - 0x54, 0x6f, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x15, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, - 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x6a, 0x0a, 0x12, 0x63, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x0b, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, - 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, - 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, + 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, - 0x4d, 0x65, 0x74, 0x61, 0x1a, 0x60, 0x0a, 0x0a, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, - 0x74, 0x73, 0x12, 0x52, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, - 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x4d, 0x65, 0x74, 0x61, 0x12, 0x3e, 0x0a, 0x1c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, + 0x72, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x5f, 0x69, 0x6e, 0x5f, 0x70, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x05, 0x52, 0x18, 0x74, 0x6f, 0x74, 0x61, + 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x49, 0x6e, 0x50, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x1a, 0x58, 0x0a, 0x0a, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x73, 0x12, 0x4a, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x1a, 0xa7, 0x02, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, - 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 0x12, 0xa7, 0x01, 0x0a, 0x25, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x5f, 0x74, 0x6f, 0x5f, 0x64, 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, - 0x63, 0x6f, 0x72, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x57, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, - 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, - 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, - 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x54, - 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, - 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x1f, 0x6e, 0x6f, 0x64, - 0x65, 0x54, 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, - 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x1a, 0x52, 0x0a, 0x24, - 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, - 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 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, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, - 0x1a, 0x7d, 0x0a, 0x1a, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, - 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 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, 0x49, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x33, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, - 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x1a, 0x3f, + 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x1a, + 0x80, 0x01, 0x0a, 0x25, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, + 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, + 0x75, 0x74, 0x65, 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, 0x41, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, + 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x1a, 0x53, 0x0a, 0x14, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, + 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x25, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd1, 0x01, 0x0a, 0x23, 0x44, 0x61, 0x69, 0x6c, + 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x15, 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, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x16, 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, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x96, 0x07, 0x0a, 0x24, + 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x18, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x47, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, + 0x6f, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x15, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, 0x74, + 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x6e, 0x0a, 0x12, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x0b, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, + 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, + 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, + 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, + 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x1a, 0x64, 0x0a, 0x0a, 0x44, 0x61, 0x74, 0x61, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x56, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x1a, 0xbb, 0x02, + 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0xb7, 0x01, 0x0a, 0x29, 0x69, 0x6e, + 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x64, + 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x72, 0x65, 0x5f, + 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x5f, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, + 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x23, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, + 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, + 0x74, 0x65, 0x73, 0x1a, 0x56, 0x0a, 0x28, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, + 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 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, 0x05, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x81, 0x01, 0x0a, 0x1a, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, 0x74, 0x61, 0x70, + 0x6f, 0x69, 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, 0x4d, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x53, 0x0a, 0x14, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, 0x65, @@ -11036,255 +11627,355 @@ var file_api_v1_k8s_proto_rawDesc = []byte{ 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x25, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x3a, 0x02, 0x38, 0x01, 0x22, 0x6c, 0x0a, 0x19, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x4e, 0x6f, - 0x64, 0x65, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, - 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, - 0x49, 0x64, 0x22, 0xe1, 0x01, 0x0a, 0x14, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x4c, - 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x63, - 0x6c, 0x6f, 0x75, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x67, 0x69, 0x6f, - 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x72, 0x65, 0x67, 0x69, - 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x69, - 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x10, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5a, 0x6f, 0x6e, - 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, - 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, - 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x11, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x53, 0x79, - 0x73, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x22, 0xc1, 0x02, 0x0a, 0x1a, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, - 0x70, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x10, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, - 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, - 0x65, 0x52, 0x0f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, - 0x63, 0x65, 0x12, 0x39, 0x0a, 0x0f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x73, - 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x0e, 0x63, - 0x61, 0x63, 0x68, 0x65, 0x64, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x41, 0x0a, - 0x0d, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, - 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x50, 0x61, 0x72, 0x61, - 0x6d, 0x73, 0x52, 0x0c, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, - 0x12, 0x34, 0x0a, 0x16, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x69, 0x6e, 0x73, 0x74, - 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x14, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, - 0x65, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, - 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x49, 0x6e, 0x73, - 0x74, 0x61, 0x6e, 0x63, 0x65, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x2a, 0xd5, 0x02, 0x0a, 0x17, 0x47, - 0x61, 0x6c, 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x2b, 0x0a, 0x27, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, - 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, - 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, - 0x44, 0x10, 0x00, 0x12, 0x26, 0x0a, 0x22, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, - 0x56, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, - 0x42, 0x59, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x4f, 0x4e, 0x10, 0x01, 0x12, 0x28, 0x0a, 0x24, 0x47, - 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, - 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, - 0x44, 0x45, 0x52, 0x10, 0x02, 0x12, 0x2d, 0x0a, 0x29, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, + 0x3a, 0x02, 0x38, 0x01, 0x22, 0xcd, 0x01, 0x0a, 0x1f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, + 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, + 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x73, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, + 0x64, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x15, 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, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, + 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x16, 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, 0x07, 0x65, 0x6e, 0x64, + 0x54, 0x69, 0x6d, 0x65, 0x22, 0xec, 0x06, 0x0a, 0x20, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, + 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7c, 0x0a, 0x18, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x43, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, + 0x6f, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x15, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, 0x74, + 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x6a, 0x0a, 0x12, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x0b, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, + 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, 0x61, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, + 0x65, 0x74, 0x61, 0x1a, 0x60, 0x0a, 0x0a, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x73, 0x12, 0x52, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, + 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, + 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, + 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x1a, 0xa7, 0x02, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x12, 0xa7, 0x01, 0x0a, 0x25, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, + 0x74, 0x6f, 0x5f, 0x64, 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, + 0x6f, 0x72, 0x65, 0x5f, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x57, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, + 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x54, 0x6f, + 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, + 0x6e, 0x75, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x1f, 0x6e, 0x6f, 0x64, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, + 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x1a, 0x52, 0x0a, 0x24, 0x4e, + 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x54, 0x6f, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x54, 0x6f, + 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x72, 0x65, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 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, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, + 0x7d, 0x0a, 0x1a, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x44, 0x61, + 0x74, 0x61, 0x70, 0x6f, 0x69, 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, + 0x49, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x55, 0x74, 0x69, + 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x53, + 0x0a, 0x14, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x54, 0x6f, 0x4d, 0x65, 0x74, + 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x25, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x6c, 0x0a, 0x19, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x4e, 0x6f, 0x64, + 0x65, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, + 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, + 0x64, 0x22, 0xe1, 0x01, 0x0a, 0x14, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x6f, + 0x6f, 0x6b, 0x75, 0x70, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x6c, + 0x6f, 0x75, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x72, 0x65, 0x67, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x69, 0x6c, + 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, + 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5a, 0x6f, 0x6e, 0x65, + 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6e, 0x67, 0x5f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x11, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x53, 0x79, 0x73, + 0x74, 0x65, 0x6d, 0x49, 0x64, 0x22, 0xc1, 0x02, 0x0a, 0x1a, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, + 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x10, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x52, 0x0f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, + 0x65, 0x12, 0x39, 0x0a, 0x0f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x0e, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x64, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x41, 0x0a, 0x0d, + 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x73, + 0x74, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x52, 0x0c, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, + 0x34, 0x0a, 0x16, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, + 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x14, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x5f, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x49, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x2a, 0xd5, 0x02, 0x0a, 0x17, 0x47, 0x61, + 0x6c, 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x2b, 0x0a, 0x27, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, - 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x50, 0x43, 0x54, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4d, 0x49, 0x5a, - 0x45, 0x44, 0x10, 0x03, 0x12, 0x2d, 0x0a, 0x29, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, + 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x26, 0x0a, 0x22, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, + 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, + 0x59, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x4f, 0x4e, 0x10, 0x01, 0x12, 0x28, 0x0a, 0x24, 0x47, 0x41, + 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, + 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, + 0x45, 0x52, 0x10, 0x02, 0x12, 0x2d, 0x0a, 0x29, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, - 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x53, 0x54, 0x5f, 0x50, 0x45, 0x52, 0x5f, 0x48, 0x4f, 0x55, - 0x52, 0x10, 0x04, 0x12, 0x2b, 0x0a, 0x27, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, + 0x5f, 0x42, 0x59, 0x5f, 0x50, 0x43, 0x54, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4d, 0x49, 0x5a, 0x45, + 0x44, 0x10, 0x03, 0x12, 0x2d, 0x0a, 0x29, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, - 0x42, 0x59, 0x5f, 0x4b, 0x38, 0x53, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x10, 0x05, - 0x12, 0x30, 0x0a, 0x2c, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x43, - 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, - 0x5a, 0x58, 0x50, 0x4f, 0x52, 0x54, 0x45, 0x52, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, - 0x10, 0x06, 0x2a, 0xb3, 0x04, 0x0a, 0x14, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, - 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x28, 0x0a, 0x24, 0x47, + 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x53, 0x54, 0x5f, 0x50, 0x45, 0x52, 0x5f, 0x48, 0x4f, 0x55, 0x52, + 0x10, 0x04, 0x12, 0x2b, 0x0a, 0x27, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, + 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, + 0x59, 0x5f, 0x4b, 0x38, 0x53, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x10, 0x05, 0x12, + 0x30, 0x0a, 0x2c, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x43, 0x4c, + 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x5a, + 0x58, 0x50, 0x4f, 0x52, 0x54, 0x45, 0x52, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x10, + 0x06, 0x2a, 0xb3, 0x04, 0x0a, 0x14, 0x47, 0x61, 0x6c, 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x4e, + 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x28, 0x0a, 0x24, 0x47, 0x41, + 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, + 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, + 0x45, 0x44, 0x10, 0x00, 0x12, 0x22, 0x0a, 0x1e, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, + 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, + 0x5f, 0x54, 0x41, 0x49, 0x4e, 0x54, 0x10, 0x01, 0x12, 0x21, 0x0a, 0x1d, 0x47, 0x41, 0x4c, 0x41, + 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, + 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x52, 0x43, 0x48, 0x10, 0x02, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, - 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, - 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x22, 0x0a, 0x1e, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, + 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x41, 0x50, 0x41, 0x43, 0x49, 0x54, 0x59, + 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x03, 0x12, 0x26, 0x0a, 0x22, 0x47, 0x41, 0x4c, 0x41, 0x58, + 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, + 0x5f, 0x42, 0x59, 0x5f, 0x47, 0x50, 0x55, 0x5f, 0x4d, 0x4f, 0x44, 0x45, 0x4c, 0x10, 0x04, 0x12, + 0x2e, 0x0a, 0x2a, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, + 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x4e, 0x54, + 0x41, 0x49, 0x4e, 0x45, 0x52, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x05, 0x12, + 0x24, 0x0a, 0x20, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, + 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4c, 0x55, 0x53, + 0x54, 0x45, 0x52, 0x10, 0x06, 0x12, 0x23, 0x0a, 0x1f, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, - 0x59, 0x5f, 0x54, 0x41, 0x49, 0x4e, 0x54, 0x10, 0x01, 0x12, 0x21, 0x0a, 0x1d, 0x47, 0x41, 0x4c, - 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, - 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x52, 0x43, 0x48, 0x10, 0x02, 0x12, 0x2a, 0x0a, 0x26, - 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, - 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x41, 0x50, 0x41, 0x43, 0x49, 0x54, - 0x59, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x03, 0x12, 0x26, 0x0a, 0x22, 0x47, 0x41, 0x4c, 0x41, - 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, - 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x47, 0x50, 0x55, 0x5f, 0x4d, 0x4f, 0x44, 0x45, 0x4c, 0x10, 0x04, - 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, - 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x4e, - 0x54, 0x41, 0x49, 0x4e, 0x45, 0x52, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x05, - 0x12, 0x24, 0x0a, 0x20, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, - 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4c, 0x55, - 0x53, 0x54, 0x45, 0x52, 0x10, 0x06, 0x12, 0x23, 0x0a, 0x1f, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, + 0x59, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x4f, 0x4e, 0x10, 0x07, 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, + 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, + 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x49, 0x4c, + 0x49, 0x54, 0x59, 0x5f, 0x5a, 0x4f, 0x4e, 0x45, 0x10, 0x08, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, + 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, + 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x50, 0x43, 0x54, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4d, + 0x49, 0x5a, 0x45, 0x44, 0x10, 0x09, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, - 0x42, 0x59, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x4f, 0x4e, 0x10, 0x07, 0x12, 0x2e, 0x0a, 0x2a, 0x47, - 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, - 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x49, - 0x4c, 0x49, 0x54, 0x59, 0x5f, 0x5a, 0x4f, 0x4e, 0x45, 0x10, 0x08, 0x12, 0x2a, 0x0a, 0x26, 0x47, + 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x53, 0x54, 0x5f, 0x50, 0x45, 0x52, 0x5f, 0x48, 0x4f, 0x55, 0x52, + 0x10, 0x0a, 0x12, 0x27, 0x0a, 0x23, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, + 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x4e, + 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x0b, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, + 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x49, 0x4e, 0x53, 0x54, 0x41, 0x4e, 0x43, 0x45, + 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x0c, 0x2a, 0xca, 0x05, 0x0a, 0x18, 0x47, 0x61, 0x6c, 0x61, + 0x78, 0x79, 0x50, 0x4f, 0x56, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x42, 0x79, 0x12, 0x2c, 0x0a, 0x28, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, + 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, + 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x29, 0x0a, 0x25, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, + 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, + 0x42, 0x59, 0x5f, 0x4b, 0x38, 0x53, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x01, 0x12, 0x28, 0x0a, + 0x24, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, + 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4c, + 0x55, 0x53, 0x54, 0x45, 0x52, 0x10, 0x02, 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, 0x4c, 0x41, 0x58, + 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x50, 0x43, 0x54, 0x5f, 0x4f, 0x50, 0x54, 0x49, - 0x4d, 0x49, 0x5a, 0x45, 0x44, 0x10, 0x09, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, 0x4c, 0x41, 0x58, - 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, - 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x53, 0x54, 0x5f, 0x50, 0x45, 0x52, 0x5f, 0x48, 0x4f, 0x55, - 0x52, 0x10, 0x0a, 0x12, 0x27, 0x0a, 0x23, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, - 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, - 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x0b, 0x12, 0x2a, 0x0a, 0x26, - 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, - 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x49, 0x4e, 0x53, 0x54, 0x41, 0x4e, 0x43, - 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x0c, 0x2a, 0xca, 0x05, 0x0a, 0x18, 0x47, 0x61, 0x6c, - 0x61, 0x78, 0x79, 0x50, 0x4f, 0x56, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x42, 0x79, 0x12, 0x2c, 0x0a, 0x28, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, - 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, - 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, - 0x44, 0x10, 0x00, 0x12, 0x29, 0x0a, 0x25, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, + 0x4d, 0x49, 0x5a, 0x45, 0x44, 0x10, 0x03, 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, 0x4c, 0x41, 0x58, + 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, + 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x53, 0x54, 0x5f, 0x50, 0x45, 0x52, + 0x5f, 0x48, 0x4f, 0x55, 0x52, 0x10, 0x04, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, 0x4c, 0x41, 0x58, + 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, + 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x47, 0x50, 0x55, 0x5f, 0x4d, 0x4f, 0x44, 0x45, + 0x4c, 0x10, 0x05, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, - 0x5f, 0x42, 0x59, 0x5f, 0x4b, 0x38, 0x53, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x01, 0x12, 0x28, - 0x0a, 0x24, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, - 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, - 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x10, 0x02, 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, 0x4c, 0x41, - 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, - 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x50, 0x43, 0x54, 0x5f, 0x4f, 0x50, 0x54, - 0x49, 0x4d, 0x49, 0x5a, 0x45, 0x44, 0x10, 0x03, 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, 0x4c, 0x41, - 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, - 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x43, 0x4f, 0x53, 0x54, 0x5f, 0x50, 0x45, - 0x52, 0x5f, 0x48, 0x4f, 0x55, 0x52, 0x10, 0x04, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, 0x4c, 0x41, - 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, - 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x47, 0x50, 0x55, 0x5f, 0x4d, 0x4f, 0x44, - 0x45, 0x4c, 0x10, 0x05, 0x12, 0x2a, 0x0a, 0x26, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, - 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, - 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x53, 0x50, 0x41, 0x43, 0x45, 0x10, 0x06, - 0x12, 0x29, 0x0a, 0x25, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, + 0x5f, 0x42, 0x59, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x53, 0x50, 0x41, 0x43, 0x45, 0x10, 0x06, 0x12, + 0x29, 0x0a, 0x25, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, + 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, + 0x41, 0x46, 0x46, 0x49, 0x4e, 0x49, 0x54, 0x59, 0x10, 0x07, 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, + 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, + 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, + 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x10, 0x08, 0x12, 0x26, 0x0a, 0x22, 0x47, 0x41, + 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, + 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x4c, 0x41, 0x42, 0x45, 0x4c, + 0x10, 0x09, 0x12, 0x2c, 0x0a, 0x28, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, + 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, + 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x4c, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x10, 0x0a, + 0x12, 0x2f, 0x0a, 0x2b, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, - 0x5f, 0x41, 0x46, 0x46, 0x49, 0x4e, 0x49, 0x54, 0x59, 0x10, 0x07, 0x12, 0x2e, 0x0a, 0x2a, 0x47, - 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, - 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x4e, 0x4f, 0x44, 0x45, - 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x4f, 0x52, 0x10, 0x08, 0x12, 0x26, 0x0a, 0x22, 0x47, - 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, - 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x4c, 0x41, 0x42, 0x45, - 0x4c, 0x10, 0x09, 0x12, 0x2c, 0x0a, 0x28, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, - 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, - 0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x4c, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x10, - 0x0a, 0x12, 0x2f, 0x0a, 0x2b, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, + 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x10, + 0x0b, 0x12, 0x30, 0x0a, 0x2c, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, 0x42, - 0x59, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, - 0x10, 0x0b, 0x12, 0x30, 0x0a, 0x2c, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, - 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x5f, - 0x42, 0x59, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x41, 0x43, 0x43, 0x4f, 0x55, - 0x4e, 0x54, 0x10, 0x0c, 0x12, 0x2f, 0x0a, 0x2b, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, + 0x59, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x41, 0x43, 0x43, 0x4f, 0x55, 0x4e, + 0x54, 0x10, 0x0c, 0x12, 0x2f, 0x0a, 0x2b, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, + 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, + 0x5f, 0x42, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x41, 0x52, 0x54, 0x5f, 0x50, 0x4f, 0x4c, 0x49, + 0x43, 0x59, 0x10, 0x0d, 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, 0x55, - 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x41, 0x52, 0x54, 0x5f, 0x50, 0x4f, 0x4c, - 0x49, 0x43, 0x59, 0x10, 0x0d, 0x12, 0x2e, 0x0a, 0x2a, 0x47, 0x41, 0x4c, 0x41, 0x58, 0x59, 0x5f, - 0x50, 0x4f, 0x56, 0x5f, 0x57, 0x4f, 0x52, 0x4b, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x47, 0x52, 0x4f, - 0x55, 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x5f, 0x43, 0x4c, - 0x41, 0x53, 0x53, 0x10, 0x0e, 0x2a, 0x75, 0x0a, 0x0b, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x18, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, - 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, - 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, - 0x50, 0x45, 0x5f, 0x4b, 0x33, 0x53, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x43, 0x4c, 0x55, 0x53, - 0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x4b, 0x45, 0x32, 0x10, 0x02, 0x12, - 0x1b, 0x0a, 0x17, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x43, 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x45, 0x52, 0x44, 0x10, 0x03, 0x32, 0xba, 0x1c, 0x0a, - 0x0a, 0x4b, 0x38, 0x53, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x47, - 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x12, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, - 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x73, 0x12, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, - 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, - 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x12, 0x1b, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x12, 0x43, 0x0a, - 0x0a, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x19, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x5b, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, - 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4d, - 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x55, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, - 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, - 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x70, 0x0a, 0x19, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x50, 0x5f, 0x42, 0x59, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x5f, 0x43, 0x4c, 0x41, + 0x53, 0x53, 0x10, 0x0e, 0x2a, 0x75, 0x0a, 0x0b, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x18, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, + 0x00, 0x12, 0x14, 0x0a, 0x10, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x4b, 0x33, 0x53, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x43, 0x4c, 0x55, 0x53, 0x54, + 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x4b, 0x45, 0x32, 0x10, 0x02, 0x12, 0x1b, + 0x0a, 0x17, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, + 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x45, 0x52, 0x44, 0x10, 0x03, 0x32, 0xbb, 0x20, 0x0a, 0x0a, + 0x4b, 0x38, 0x53, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x47, 0x65, + 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, + 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x21, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x73, 0x12, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x0c, + 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x12, 0x1b, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x12, 0x43, 0x0a, 0x0a, + 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x19, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x5b, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x55, + 0x0a, 0x10, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, + 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, + 0x41, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x70, 0x0a, 0x19, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4e, + 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x12, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, + 0x63, 0x68, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4e, 0x61, 0x6d, 0x65, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6a, 0x0a, 0x17, 0x4c, 0x69, 0x73, 0x74, 0x4e, + 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x12, 0x26, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x12, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x61, - 0x72, 0x63, 0x68, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, - 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x4e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x41, - 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, - 0x22, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, - 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, - 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x41, - 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, - 0x12, 0x23, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, + 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x73, 0x42, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, + 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x22, 0x2e, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, + 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x23, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x61, 0x62, - 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x47, - 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x12, 0x23, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, + 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x23, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, + 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, - 0x0a, 0x14, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, - 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x12, 0x23, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, + 0x73, 0x12, 0x23, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x57, 0x6f, 0x72, 0x6b, 0x6c, - 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, - 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x4c, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x73, 0x12, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, - 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, - 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x55, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x73, 0x12, 0x1f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, - 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, - 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6d, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, - 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x12, 0x27, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, - 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x61, 0x70, + 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0d, + 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x1c, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x73, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, - 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x3a, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x2e, 0x61, 0x70, - 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, - 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x0c, - 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x12, 0x1b, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, - 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x57, 0x6f, - 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, - 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x55, 0x0a, 0x10, 0x47, 0x65, + 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x1f, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, + 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4e, + 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x6d, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x73, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x55, 0x74, 0x69, + 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x49, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, + 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x07, 0x47, + 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x12, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, + 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x12, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x82, 0x01, 0x0a, 0x1f, 0x47, + 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x2e, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x65, 0x72, 0x63, + 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x65, 0x72, 0x63, + 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x88, 0x01, 0x0a, 0x21, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x43, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x46, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, + 0x74, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x30, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x46, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x46, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, + 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x82, 0x01, 0x0a, 0x1f, 0x47, + 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x2e, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, + 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, + 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x66, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x12, 0x23, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x63, 0x61, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, @@ -11482,7 +12173,7 @@ func file_api_v1_k8s_proto_rawDescGZIP() []byte { } var file_api_v1_k8s_proto_enumTypes = make([]protoimpl.EnumInfo, 4) -var file_api_v1_k8s_proto_msgTypes = make([]protoimpl.MessageInfo, 144) +var file_api_v1_k8s_proto_msgTypes = make([]protoimpl.MessageInfo, 153) var file_api_v1_k8s_proto_goTypes = []interface{}{ (GalaxyPOVClusterGroupBy)(0), // 0: api.v1.GalaxyPOVClusterGroupBy (GalaxyPOVNodeGroupBy)(0), // 1: api.v1.GalaxyPOVNodeGroupBy @@ -11524,451 +12215,479 @@ var file_api_v1_k8s_proto_goTypes = []interface{}{ (*GetNodeResponse)(nil), // 37: api.v1.GetNodeResponse (*GetWorkloadsResponse)(nil), // 38: api.v1.GetWorkloadsResponse (*GetWorkloadResponse)(nil), // 39: api.v1.GetWorkloadResponse - (*GetForecastWorkloadsRequest)(nil), // 40: api.v1.GetForecastWorkloadsRequest - (*GetForecastWorkloadsResponse)(nil), // 41: api.v1.GetForecastWorkloadsResponse - (*GetForecastWorkloadRequest)(nil), // 42: api.v1.GetForecastWorkloadRequest - (*GetForecastWorkloadResponse)(nil), // 43: api.v1.GetForecastWorkloadResponse - (*GetClusterMetadataResponse)(nil), // 44: api.v1.GetClusterMetadataResponse - (*ClusterElement)(nil), // 45: api.v1.ClusterElement - (*GetAllNamespacesRequest)(nil), // 46: api.v1.GetAllNamespacesRequest - (*GetAllNamespacesResponse)(nil), // 47: api.v1.GetAllNamespacesResponse - (*SearchNamespacesByClusterRequest)(nil), // 48: api.v1.SearchNamespacesByClusterRequest - (*SearchNamespacesByClusterResponse)(nil), // 49: api.v1.SearchNamespacesByClusterResponse - (*GetAllWorkloadNamesRequest)(nil), // 50: api.v1.GetAllWorkloadNamesRequest - (*GetAllWorkloadNamesResponse)(nil), // 51: api.v1.GetAllWorkloadNamesResponse - (*GetAllWorkloadLabelsRequest)(nil), // 52: api.v1.GetAllWorkloadLabelsRequest - (*GetAllWorkloadLabelsResponse)(nil), // 53: api.v1.GetAllWorkloadLabelsResponse - (*GetAllNodeGroupNamesRequest)(nil), // 54: api.v1.GetAllNodeGroupNamesRequest - (*GetAllNodeGroupNamesResponse)(nil), // 55: api.v1.GetAllNodeGroupNamesResponse - (*Cluster)(nil), // 56: api.v1.Cluster - (*OperatorInfo)(nil), // 57: api.v1.OperatorInfo - (*Container)(nil), // 58: api.v1.Container - (*GetLatestOperatorVersionRequest)(nil), // 59: api.v1.GetLatestOperatorVersionRequest - (*GetLatestOperatorVersionResponse)(nil), // 60: api.v1.GetLatestOperatorVersionResponse - (*GalaxyGetClusterPerspectiveRequest)(nil), // 61: api.v1.GalaxyGetClusterPerspectiveRequest - (*GalaxyGetClusterPerspectiveResponse)(nil), // 62: api.v1.GalaxyGetClusterPerspectiveResponse - (*GalaxyClusterGroup)(nil), // 63: api.v1.GalaxyClusterGroup - (*GalaxyGetNodePerspectiveRequest)(nil), // 64: api.v1.GalaxyGetNodePerspectiveRequest - (*GalaxyGetNodePerspectiveResponse)(nil), // 65: api.v1.GalaxyGetNodePerspectiveResponse - (*GalaxyNodeGroup)(nil), // 66: api.v1.GalaxyNodeGroup - (*GalaxyGetWorkloadPerspectiveRequest)(nil), // 67: api.v1.GalaxyGetWorkloadPerspectiveRequest - (*GalaxyGetWorkloadPerspectiveResponse)(nil), // 68: api.v1.GalaxyGetWorkloadPerspectiveResponse - (*GalaxyWorkloadGroup)(nil), // 69: api.v1.GalaxyWorkloadGroup - (*PerspectiveDatapointOpts)(nil), // 70: api.v1.PerspectiveDatapointOpts - (*ListAuditLogsRequest)(nil), // 71: api.v1.ListAuditLogsRequest - (*ListAuditLogsResponse)(nil), // 72: api.v1.ListAuditLogsResponse - (*ListAuditLogOriginatorsRequest)(nil), // 73: api.v1.ListAuditLogOriginatorsRequest - (*ListAuditLogOriginatorsResponse)(nil), // 74: api.v1.ListAuditLogOriginatorsResponse - (*SendWorkloadEmailRequest)(nil), // 75: api.v1.SendWorkloadEmailRequest - (*SendWorkloadEmailResponse)(nil), // 76: api.v1.SendWorkloadEmailResponse - (*SendWeeklySummaryEmailRequest)(nil), // 77: api.v1.SendWeeklySummaryEmailRequest - (*SendWeeklySummaryEmailRequestData)(nil), // 78: api.v1.SendWeeklySummaryEmailRequestData - (*SendWeeklySummaryEmailResponse)(nil), // 79: api.v1.SendWeeklySummaryEmailResponse - (*GetClustersNodeInfoRequest)(nil), // 80: api.v1.GetClustersNodeInfoRequest - (*GetClustersNodeInfoResponse)(nil), // 81: api.v1.GetClustersNodeInfoResponse - (*SearchK8SResourcesRequest)(nil), // 82: api.v1.SearchK8sResourcesRequest - (*SearchK8SResourcesResponse)(nil), // 83: api.v1.SearchK8sResourcesResponse - (*K8SSearchResult)(nil), // 84: api.v1.K8sSearchResult - (*SearchK8SWorkloadsRequest)(nil), // 85: api.v1.SearchK8sWorkloadsRequest - (*SearchK8SWorkloadsResponse)(nil), // 86: api.v1.SearchK8sWorkloadsResponse - (*K8SWorkloadSearchResult)(nil), // 87: api.v1.K8sWorkloadSearchResult - (*MetadataForWorkloadsRequest)(nil), // 88: api.v1.MetadataForWorkloadsRequest - (*MetadataForWorkloadsResponse)(nil), // 89: api.v1.MetadataForWorkloadsResponse - (*AddClusterTagsRequest)(nil), // 90: api.v1.AddClusterTagsRequest - (*AddClusterTagsResponse)(nil), // 91: api.v1.AddClusterTagsResponse - (*RemoveClusterTagsRequest)(nil), // 92: api.v1.RemoveClusterTagsRequest - (*RemoveClusterTagsResponse)(nil), // 93: api.v1.RemoveClusterTagsResponse - (*ListTagsRequest)(nil), // 94: api.v1.ListTagsRequest - (*TagSummary)(nil), // 95: api.v1.TagSummary - (*ListTagsResponse)(nil), // 96: api.v1.ListTagsResponse - (*WorkloadMetadata)(nil), // 97: api.v1.WorkloadMetadata - (*PodMetadata)(nil), // 98: api.v1.PodMetadata - (*NodeMetadata)(nil), // 99: api.v1.NodeMetadata - (*GetRelatedResourcesRequest)(nil), // 100: api.v1.GetRelatedResourcesRequest - (*GetWorkloadPodHistoryResponse)(nil), // 101: api.v1.GetWorkloadPodHistoryResponse - (*JobHistory)(nil), // 102: api.v1.JobHistory - (*ReplicaSetHistory)(nil), // 103: api.v1.ReplicaSetHistory - (*PodHistory)(nil), // 104: api.v1.PodHistory - (*GetRelatedResourcesResponse)(nil), // 105: api.v1.GetRelatedResourcesResponse - (*K8SRelatedResource)(nil), // 106: api.v1.K8sRelatedResource - (*K8SResourceNode)(nil), // 107: api.v1.K8sResourceNode - (*K8SResourceEdge)(nil), // 108: api.v1.K8sResourceEdge - (*GetClusterTypeRequest)(nil), // 109: api.v1.GetClusterTypeRequest - (*GetClusterTypeResponse)(nil), // 110: api.v1.GetClusterTypeResponse - (*GetWorkloadsStatsRequest)(nil), // 111: api.v1.GetWorkloadsStatsRequest - (*GetWorkloadsStatsResponse)(nil), // 112: api.v1.GetWorkloadsStatsResponse - (*DailyUtilizationRequest)(nil), // 113: api.v1.DailyUtilizationRequest - (*DailyUtilizationResponse)(nil), // 114: api.v1.DailyUtilizationResponse - (*DailyUtilizationInstanceTypeRequest)(nil), // 115: api.v1.DailyUtilizationInstanceTypeRequest - (*DailyUtilizationInstanceTypeResponse)(nil), // 116: api.v1.DailyUtilizationInstanceTypeResponse - (*DailyUtilizationNodeTypeRequest)(nil), // 117: api.v1.DailyUtilizationNodeTypeRequest - (*DailyUtilizationNodeTypeResponse)(nil), // 118: api.v1.DailyUtilizationNodeTypeResponse - (*LookupNodeInstanceRequest)(nil), // 119: api.v1.LookupNodeInstanceRequest - (*InstanceLookupParams)(nil), // 120: api.v1.InstanceLookupParams - (*LookupNodeInstanceResponse)(nil), // 121: api.v1.LookupNodeInstanceResponse - nil, // 122: api.v1.GetAllNodeGroupsResponse.NodeGroupMapEntry - (*GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics)(nil), // 123: api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics - nil, // 124: api.v1.GetNodeGroupsUtilizationResponse.NodeGroupToUtilMetricsEntry - nil, // 125: api.v1.GetNodeGroupsUtilizationResponse.InstanceTypeToUtilMetricsEntry - nil, // 126: api.v1.GetNodeGroupsUtilizationResponse.ReservationTypeToUtilMetricsEntry - nil, // 127: api.v1.GetNodeGroupsUtilizationResponse.LogicalAzToUtilMetricsEntry - nil, // 128: api.v1.GalaxyGetWorkloadPerspectiveResponse.ClustersEntry - nil, // 129: api.v1.GalaxyGetWorkloadPerspectiveResponse.WorkloadsEntry - nil, // 130: api.v1.MetadataForWorkloadsRequest.WorkloadUidToKindEntry - nil, // 131: api.v1.MetadataForWorkloadsResponse.WorkloadUidToMetadataEntry - nil, // 132: api.v1.WorkloadMetadata.PodUidToNodeMetadataEntry - nil, // 133: api.v1.WorkloadMetadata.PodUidToPodMetadataEntry - (*DailyUtilizationResponse_Datapoints)(nil), // 134: api.v1.DailyUtilizationResponse.Datapoints - (*DailyUtilizationResponse_Datapoint)(nil), // 135: api.v1.DailyUtilizationResponse.Datapoint - nil, // 136: api.v1.DailyUtilizationResponse.ClusterIdToDailyTotalCoreMinutesEntry - nil, // 137: api.v1.DailyUtilizationResponse.ClusterIdToMetaEntry - (*DailyUtilizationInstanceTypeResponse_Datapoints)(nil), // 138: api.v1.DailyUtilizationInstanceTypeResponse.Datapoints - (*DailyUtilizationInstanceTypeResponse_Datapoint)(nil), // 139: api.v1.DailyUtilizationInstanceTypeResponse.Datapoint - nil, // 140: api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToDatapointsEntry - nil, // 141: api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToMetaEntry - nil, // 142: api.v1.DailyUtilizationInstanceTypeResponse.Datapoint.InstanceTypeToDailyTotalCoreMinutesEntry - (*DailyUtilizationNodeTypeResponse_Datapoints)(nil), // 143: api.v1.DailyUtilizationNodeTypeResponse.Datapoints - (*DailyUtilizationNodeTypeResponse_Datapoint)(nil), // 144: api.v1.DailyUtilizationNodeTypeResponse.Datapoint - nil, // 145: api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToDatapointsEntry - nil, // 146: api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToMetaEntry - nil, // 147: api.v1.DailyUtilizationNodeTypeResponse.Datapoint.NodeTypeToDailyTotalCoreMinutesEntry - (*timestamppb.Timestamp)(nil), // 148: google.protobuf.Timestamp - (*WorkloadFilters)(nil), // 149: api.v1.WorkloadFilters - (K8SObjectKind)(0), // 150: api.v1.K8sObjectKind - (*Pagination)(nil), // 151: api.v1.Pagination - (*WorkloadItem)(nil), // 152: api.v1.WorkloadItem - (*NodeGroup)(nil), // 153: api.v1.NodeGroup - (*money.Money)(nil), // 154: google.type.Money - (*ResourceMetrics)(nil), // 155: api.v1.ResourceMetrics - (*CostInfo)(nil), // 156: api.v1.CostInfo - (*NodeInfo)(nil), // 157: api.v1.NodeInfo - (*CostDataPoint)(nil), // 158: api.v1.CostDataPoint - (*ResourceDataPoint)(nil), // 159: api.v1.ResourceDataPoint - (*Node)(nil), // 160: api.v1.Node - (*ResourceSummary)(nil), // 161: api.v1.ResourceSummary - (*ForecastResourceMetrics)(nil), // 162: api.v1.ForecastResourceMetrics - (*AuditLogEntry)(nil), // 163: api.v1.AuditLogEntry - (*Instance)(nil), // 164: api.v1.Instance + (*GetWorkloadContainerPercentilesRequest)(nil), // 40: api.v1.GetWorkloadContainerPercentilesRequest + (*GetWorkloadContainerPercentilesResponse)(nil), // 41: api.v1.GetWorkloadContainerPercentilesResponse + (*GetWorkloadContainerFsPercentilesRequest)(nil), // 42: api.v1.GetWorkloadContainerFsPercentilesRequest + (*GetWorkloadContainerFsPercentilesResponse)(nil), // 43: api.v1.GetWorkloadContainerFsPercentilesResponse + (*GetLatestContainerRequestLimitsRequest)(nil), // 44: api.v1.GetLatestContainerRequestLimitsRequest + (*GetLatestContainerRequestLimitsResponse)(nil), // 45: api.v1.GetLatestContainerRequestLimitsResponse + (*GetForecastWorkloadsRequest)(nil), // 46: api.v1.GetForecastWorkloadsRequest + (*GetForecastWorkloadsResponse)(nil), // 47: api.v1.GetForecastWorkloadsResponse + (*GetForecastWorkloadRequest)(nil), // 48: api.v1.GetForecastWorkloadRequest + (*GetForecastWorkloadResponse)(nil), // 49: api.v1.GetForecastWorkloadResponse + (*GetClusterMetadataResponse)(nil), // 50: api.v1.GetClusterMetadataResponse + (*ClusterElement)(nil), // 51: api.v1.ClusterElement + (*GetAllNamespacesRequest)(nil), // 52: api.v1.GetAllNamespacesRequest + (*GetAllNamespacesResponse)(nil), // 53: api.v1.GetAllNamespacesResponse + (*SearchNamespacesByClusterRequest)(nil), // 54: api.v1.SearchNamespacesByClusterRequest + (*SearchNamespacesByClusterResponse)(nil), // 55: api.v1.SearchNamespacesByClusterResponse + (*ListNamespacesByClusterRequest)(nil), // 56: api.v1.ListNamespacesByClusterRequest + (*ListNamespacesByClusterResponse)(nil), // 57: api.v1.ListNamespacesByClusterResponse + (*NamespaceItem)(nil), // 58: api.v1.NamespaceItem + (*GetAllWorkloadNamesRequest)(nil), // 59: api.v1.GetAllWorkloadNamesRequest + (*GetAllWorkloadNamesResponse)(nil), // 60: api.v1.GetAllWorkloadNamesResponse + (*GetAllWorkloadLabelsRequest)(nil), // 61: api.v1.GetAllWorkloadLabelsRequest + (*GetAllWorkloadLabelsResponse)(nil), // 62: api.v1.GetAllWorkloadLabelsResponse + (*GetAllNodeGroupNamesRequest)(nil), // 63: api.v1.GetAllNodeGroupNamesRequest + (*GetAllNodeGroupNamesResponse)(nil), // 64: api.v1.GetAllNodeGroupNamesResponse + (*Cluster)(nil), // 65: api.v1.Cluster + (*OperatorInfo)(nil), // 66: api.v1.OperatorInfo + (*Container)(nil), // 67: api.v1.Container + (*GetLatestOperatorVersionRequest)(nil), // 68: api.v1.GetLatestOperatorVersionRequest + (*GetLatestOperatorVersionResponse)(nil), // 69: api.v1.GetLatestOperatorVersionResponse + (*GalaxyGetClusterPerspectiveRequest)(nil), // 70: api.v1.GalaxyGetClusterPerspectiveRequest + (*GalaxyGetClusterPerspectiveResponse)(nil), // 71: api.v1.GalaxyGetClusterPerspectiveResponse + (*GalaxyClusterGroup)(nil), // 72: api.v1.GalaxyClusterGroup + (*GalaxyGetNodePerspectiveRequest)(nil), // 73: api.v1.GalaxyGetNodePerspectiveRequest + (*GalaxyGetNodePerspectiveResponse)(nil), // 74: api.v1.GalaxyGetNodePerspectiveResponse + (*GalaxyNodeGroup)(nil), // 75: api.v1.GalaxyNodeGroup + (*GalaxyGetWorkloadPerspectiveRequest)(nil), // 76: api.v1.GalaxyGetWorkloadPerspectiveRequest + (*GalaxyGetWorkloadPerspectiveResponse)(nil), // 77: api.v1.GalaxyGetWorkloadPerspectiveResponse + (*GalaxyWorkloadGroup)(nil), // 78: api.v1.GalaxyWorkloadGroup + (*PerspectiveDatapointOpts)(nil), // 79: api.v1.PerspectiveDatapointOpts + (*ListAuditLogsRequest)(nil), // 80: api.v1.ListAuditLogsRequest + (*ListAuditLogsResponse)(nil), // 81: api.v1.ListAuditLogsResponse + (*ListAuditLogOriginatorsRequest)(nil), // 82: api.v1.ListAuditLogOriginatorsRequest + (*ListAuditLogOriginatorsResponse)(nil), // 83: api.v1.ListAuditLogOriginatorsResponse + (*SendWorkloadEmailRequest)(nil), // 84: api.v1.SendWorkloadEmailRequest + (*SendWorkloadEmailResponse)(nil), // 85: api.v1.SendWorkloadEmailResponse + (*SendWeeklySummaryEmailRequest)(nil), // 86: api.v1.SendWeeklySummaryEmailRequest + (*SendWeeklySummaryEmailRequestData)(nil), // 87: api.v1.SendWeeklySummaryEmailRequestData + (*SendWeeklySummaryEmailResponse)(nil), // 88: api.v1.SendWeeklySummaryEmailResponse + (*GetClustersNodeInfoRequest)(nil), // 89: api.v1.GetClustersNodeInfoRequest + (*GetClustersNodeInfoResponse)(nil), // 90: api.v1.GetClustersNodeInfoResponse + (*SearchK8SResourcesRequest)(nil), // 91: api.v1.SearchK8sResourcesRequest + (*SearchK8SResourcesResponse)(nil), // 92: api.v1.SearchK8sResourcesResponse + (*K8SSearchResult)(nil), // 93: api.v1.K8sSearchResult + (*SearchK8SWorkloadsRequest)(nil), // 94: api.v1.SearchK8sWorkloadsRequest + (*SearchK8SWorkloadsResponse)(nil), // 95: api.v1.SearchK8sWorkloadsResponse + (*K8SWorkloadSearchResult)(nil), // 96: api.v1.K8sWorkloadSearchResult + (*MetadataForWorkloadsRequest)(nil), // 97: api.v1.MetadataForWorkloadsRequest + (*MetadataForWorkloadsResponse)(nil), // 98: api.v1.MetadataForWorkloadsResponse + (*AddClusterTagsRequest)(nil), // 99: api.v1.AddClusterTagsRequest + (*AddClusterTagsResponse)(nil), // 100: api.v1.AddClusterTagsResponse + (*RemoveClusterTagsRequest)(nil), // 101: api.v1.RemoveClusterTagsRequest + (*RemoveClusterTagsResponse)(nil), // 102: api.v1.RemoveClusterTagsResponse + (*ListTagsRequest)(nil), // 103: api.v1.ListTagsRequest + (*TagSummary)(nil), // 104: api.v1.TagSummary + (*ListTagsResponse)(nil), // 105: api.v1.ListTagsResponse + (*WorkloadMetadata)(nil), // 106: api.v1.WorkloadMetadata + (*PodMetadata)(nil), // 107: api.v1.PodMetadata + (*NodeMetadata)(nil), // 108: api.v1.NodeMetadata + (*GetRelatedResourcesRequest)(nil), // 109: api.v1.GetRelatedResourcesRequest + (*GetWorkloadPodHistoryResponse)(nil), // 110: api.v1.GetWorkloadPodHistoryResponse + (*JobHistory)(nil), // 111: api.v1.JobHistory + (*ReplicaSetHistory)(nil), // 112: api.v1.ReplicaSetHistory + (*PodHistory)(nil), // 113: api.v1.PodHistory + (*GetRelatedResourcesResponse)(nil), // 114: api.v1.GetRelatedResourcesResponse + (*K8SRelatedResource)(nil), // 115: api.v1.K8sRelatedResource + (*K8SResourceNode)(nil), // 116: api.v1.K8sResourceNode + (*K8SResourceEdge)(nil), // 117: api.v1.K8sResourceEdge + (*GetClusterTypeRequest)(nil), // 118: api.v1.GetClusterTypeRequest + (*GetClusterTypeResponse)(nil), // 119: api.v1.GetClusterTypeResponse + (*GetWorkloadsStatsRequest)(nil), // 120: api.v1.GetWorkloadsStatsRequest + (*GetWorkloadsStatsResponse)(nil), // 121: api.v1.GetWorkloadsStatsResponse + (*DailyUtilizationRequest)(nil), // 122: api.v1.DailyUtilizationRequest + (*DailyUtilizationResponse)(nil), // 123: api.v1.DailyUtilizationResponse + (*DailyUtilizationInstanceTypeRequest)(nil), // 124: api.v1.DailyUtilizationInstanceTypeRequest + (*DailyUtilizationInstanceTypeResponse)(nil), // 125: api.v1.DailyUtilizationInstanceTypeResponse + (*DailyUtilizationNodeTypeRequest)(nil), // 126: api.v1.DailyUtilizationNodeTypeRequest + (*DailyUtilizationNodeTypeResponse)(nil), // 127: api.v1.DailyUtilizationNodeTypeResponse + (*LookupNodeInstanceRequest)(nil), // 128: api.v1.LookupNodeInstanceRequest + (*InstanceLookupParams)(nil), // 129: api.v1.InstanceLookupParams + (*LookupNodeInstanceResponse)(nil), // 130: api.v1.LookupNodeInstanceResponse + nil, // 131: api.v1.GetAllNodeGroupsResponse.NodeGroupMapEntry + (*GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics)(nil), // 132: api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics + nil, // 133: api.v1.GetNodeGroupsUtilizationResponse.NodeGroupToUtilMetricsEntry + nil, // 134: api.v1.GetNodeGroupsUtilizationResponse.InstanceTypeToUtilMetricsEntry + nil, // 135: api.v1.GetNodeGroupsUtilizationResponse.ReservationTypeToUtilMetricsEntry + nil, // 136: api.v1.GetNodeGroupsUtilizationResponse.LogicalAzToUtilMetricsEntry + nil, // 137: api.v1.GalaxyGetWorkloadPerspectiveResponse.ClustersEntry + nil, // 138: api.v1.GalaxyGetWorkloadPerspectiveResponse.WorkloadsEntry + nil, // 139: api.v1.MetadataForWorkloadsRequest.WorkloadUidToKindEntry + nil, // 140: api.v1.MetadataForWorkloadsResponse.WorkloadUidToMetadataEntry + nil, // 141: api.v1.WorkloadMetadata.PodUidToNodeMetadataEntry + nil, // 142: api.v1.WorkloadMetadata.PodUidToPodMetadataEntry + (*DailyUtilizationResponse_Datapoints)(nil), // 143: api.v1.DailyUtilizationResponse.Datapoints + (*DailyUtilizationResponse_Datapoint)(nil), // 144: api.v1.DailyUtilizationResponse.Datapoint + nil, // 145: api.v1.DailyUtilizationResponse.ClusterIdToDailyTotalCoreMinutesEntry + nil, // 146: api.v1.DailyUtilizationResponse.ClusterIdToMetaEntry + (*DailyUtilizationInstanceTypeResponse_Datapoints)(nil), // 147: api.v1.DailyUtilizationInstanceTypeResponse.Datapoints + (*DailyUtilizationInstanceTypeResponse_Datapoint)(nil), // 148: api.v1.DailyUtilizationInstanceTypeResponse.Datapoint + nil, // 149: api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToDatapointsEntry + nil, // 150: api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToMetaEntry + nil, // 151: api.v1.DailyUtilizationInstanceTypeResponse.Datapoint.InstanceTypeToDailyTotalCoreMinutesEntry + (*DailyUtilizationNodeTypeResponse_Datapoints)(nil), // 152: api.v1.DailyUtilizationNodeTypeResponse.Datapoints + (*DailyUtilizationNodeTypeResponse_Datapoint)(nil), // 153: api.v1.DailyUtilizationNodeTypeResponse.Datapoint + nil, // 154: api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToDatapointsEntry + nil, // 155: api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToMetaEntry + nil, // 156: api.v1.DailyUtilizationNodeTypeResponse.Datapoint.NodeTypeToDailyTotalCoreMinutesEntry + (*timestamppb.Timestamp)(nil), // 157: google.protobuf.Timestamp + (*WorkloadFilters)(nil), // 158: api.v1.WorkloadFilters + (K8SObjectKind)(0), // 159: api.v1.K8sObjectKind + (*Pagination)(nil), // 160: api.v1.Pagination + (*WorkloadItem)(nil), // 161: api.v1.WorkloadItem + (*NodeGroup)(nil), // 162: api.v1.NodeGroup + (*money.Money)(nil), // 163: google.type.Money + (*ResourceMetrics)(nil), // 164: api.v1.ResourceMetrics + (*CostInfo)(nil), // 165: api.v1.CostInfo + (*NodeInfo)(nil), // 166: api.v1.NodeInfo + (*CostDataPoint)(nil), // 167: api.v1.CostDataPoint + (*ResourceDataPoint)(nil), // 168: api.v1.ResourceDataPoint + (*Node)(nil), // 169: api.v1.Node + (*ResourceSummary)(nil), // 170: api.v1.ResourceSummary + (*ContainerPercentileSummary)(nil), // 171: api.v1.ContainerPercentileSummary + (*ContainerFsPercentileSummary)(nil), // 172: api.v1.ContainerFsPercentileSummary + (*ContainerRequestLimits)(nil), // 173: api.v1.ContainerRequestLimits + (*ForecastResourceMetrics)(nil), // 174: api.v1.ForecastResourceMetrics + (*AuditLogEntry)(nil), // 175: api.v1.AuditLogEntry + (*Instance)(nil), // 176: api.v1.Instance } var file_api_v1_k8s_proto_depIdxs = []int32{ - 148, // 0: api.v1.GetNodeRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 1: api.v1.GetNodeRequest.end_time:type_name -> google.protobuf.Timestamp - 148, // 2: api.v1.GetWorkloadPodHistoryRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 3: api.v1.GetWorkloadPodHistoryRequest.end_time:type_name -> google.protobuf.Timestamp - 148, // 4: api.v1.GetNodeGroupRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 5: api.v1.GetNodeGroupRequest.end_time:type_name -> google.protobuf.Timestamp - 148, // 6: api.v1.GetWorkloadsRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 7: api.v1.GetWorkloadsRequest.end_time:type_name -> google.protobuf.Timestamp - 149, // 8: api.v1.GetWorkloadsRequest.filters:type_name -> api.v1.WorkloadFilters - 150, // 9: api.v1.GetResourcesRequest.kind:type_name -> api.v1.K8sObjectKind - 151, // 10: api.v1.GetResourcesRequest.pagination:type_name -> api.v1.Pagination - 151, // 11: api.v1.GetPodsRequest.pagination:type_name -> api.v1.Pagination - 148, // 12: api.v1.GetPodsRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 13: api.v1.GetPodsRequest.end_time:type_name -> google.protobuf.Timestamp - 152, // 14: api.v1.GetPodsResponse.workload_items:type_name -> api.v1.WorkloadItem - 151, // 15: api.v1.GetPodsResponse.pagination:type_name -> api.v1.Pagination - 148, // 16: api.v1.GetWorkloadRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 17: api.v1.GetWorkloadRequest.end_time:type_name -> google.protobuf.Timestamp - 148, // 18: api.v1.GetClustersRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 19: api.v1.GetClustersRequest.end_time:type_name -> google.protobuf.Timestamp - 151, // 20: api.v1.ListClustersRequest.pagination:type_name -> api.v1.Pagination - 148, // 21: api.v1.GetClusterRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 22: api.v1.GetClusterRequest.end_time:type_name -> google.protobuf.Timestamp - 56, // 23: api.v1.UpdateClusterResponse.cluster:type_name -> api.v1.Cluster - 152, // 24: api.v1.GetResourcesResponse.workload_items:type_name -> api.v1.WorkloadItem - 151, // 25: api.v1.GetResourcesResponse.pagination:type_name -> api.v1.Pagination - 56, // 26: api.v1.CreateClusterResponse.cluster:type_name -> api.v1.Cluster - 148, // 27: api.v1.GetNodeGroupsRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 28: api.v1.GetNodeGroupsRequest.end_time:type_name -> google.protobuf.Timestamp - 153, // 29: api.v1.GetNodeGroupsResponse.node_groups:type_name -> api.v1.NodeGroup - 122, // 30: api.v1.GetAllNodeGroupsResponse.node_group_map:type_name -> api.v1.GetAllNodeGroupsResponse.NodeGroupMapEntry - 153, // 31: api.v1.NodeGroupSet.node_groups:type_name -> api.v1.NodeGroup - 148, // 32: api.v1.GetNodeGroupsUtilizationRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 33: api.v1.GetNodeGroupsUtilizationRequest.end_time:type_name -> google.protobuf.Timestamp - 124, // 34: api.v1.GetNodeGroupsUtilizationResponse.node_group_to_util_metrics:type_name -> api.v1.GetNodeGroupsUtilizationResponse.NodeGroupToUtilMetricsEntry - 125, // 35: api.v1.GetNodeGroupsUtilizationResponse.instance_type_to_util_metrics:type_name -> api.v1.GetNodeGroupsUtilizationResponse.InstanceTypeToUtilMetricsEntry - 126, // 36: api.v1.GetNodeGroupsUtilizationResponse.reservation_type_to_util_metrics:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ReservationTypeToUtilMetricsEntry - 127, // 37: api.v1.GetNodeGroupsUtilizationResponse.logical_az_to_util_metrics:type_name -> api.v1.GetNodeGroupsUtilizationResponse.LogicalAzToUtilMetricsEntry - 154, // 38: api.v1.NodeGroupMetric.hourly_cost:type_name -> google.type.Money - 154, // 39: api.v1.NodeGroupMetric.hourly_cpu_cost:type_name -> google.type.Money - 154, // 40: api.v1.NodeGroupMetric.hourly_memory_cost:type_name -> google.type.Money - 154, // 41: api.v1.NodeGroupMetric.hourly_gpu_cost:type_name -> google.type.Money - 148, // 42: api.v1.NodeGroupMetric.bucket_time:type_name -> google.protobuf.Timestamp - 153, // 43: api.v1.GetNodeGroupResponse.node_group:type_name -> api.v1.NodeGroup - 56, // 44: api.v1.GetClusterResponse.cluster:type_name -> api.v1.Cluster - 56, // 45: api.v1.GetClustersResponse.clusters:type_name -> api.v1.Cluster - 155, // 46: api.v1.GetClustersResponse.resource_metrics:type_name -> api.v1.ResourceMetrics - 156, // 47: api.v1.GetClustersResponse.cost_info:type_name -> api.v1.CostInfo - 157, // 48: api.v1.GetClustersResponse.node_info:type_name -> api.v1.NodeInfo - 158, // 49: api.v1.GetClustersResponse.cost_data_points:type_name -> api.v1.CostDataPoint - 159, // 50: api.v1.GetClustersResponse.resource_data_points:type_name -> api.v1.ResourceDataPoint - 56, // 51: api.v1.ListClustersResponse.clusters:type_name -> api.v1.Cluster - 151, // 52: api.v1.ListClustersResponse.pagination:type_name -> api.v1.Pagination - 160, // 53: api.v1.GetNodeResponse.node:type_name -> api.v1.Node - 155, // 54: api.v1.GetNodeResponse.resource_metrics:type_name -> api.v1.ResourceMetrics - 156, // 55: api.v1.GetNodeResponse.cost_info:type_name -> api.v1.CostInfo - 158, // 56: api.v1.GetNodeResponse.cost_data_points:type_name -> api.v1.CostDataPoint - 159, // 57: api.v1.GetNodeResponse.resource_data_points:type_name -> api.v1.ResourceDataPoint - 152, // 58: api.v1.GetWorkloadsResponse.workload_items:type_name -> api.v1.WorkloadItem - 156, // 59: api.v1.GetWorkloadsResponse.cost_info:type_name -> api.v1.CostInfo - 155, // 60: api.v1.GetWorkloadsResponse.resource_metrics:type_name -> api.v1.ResourceMetrics - 161, // 61: api.v1.GetWorkloadsResponse.resource_summary:type_name -> api.v1.ResourceSummary - 152, // 62: api.v1.GetWorkloadResponse.workload_item:type_name -> api.v1.WorkloadItem - 156, // 63: api.v1.GetWorkloadResponse.cost_info:type_name -> api.v1.CostInfo - 155, // 64: api.v1.GetWorkloadResponse.resource_metrics:type_name -> api.v1.ResourceMetrics - 161, // 65: api.v1.GetWorkloadResponse.resource_summary:type_name -> api.v1.ResourceSummary - 158, // 66: api.v1.GetWorkloadResponse.cost_data_points:type_name -> api.v1.CostDataPoint - 159, // 67: api.v1.GetWorkloadResponse.resource_data_points:type_name -> api.v1.ResourceDataPoint - 148, // 68: api.v1.GetForecastWorkloadsRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 69: api.v1.GetForecastWorkloadsRequest.end_time:type_name -> google.protobuf.Timestamp - 152, // 70: api.v1.GetForecastWorkloadsResponse.workload_items:type_name -> api.v1.WorkloadItem - 156, // 71: api.v1.GetForecastWorkloadsResponse.cost_info:type_name -> api.v1.CostInfo - 162, // 72: api.v1.GetForecastWorkloadsResponse.resource_metrics:type_name -> api.v1.ForecastResourceMetrics - 161, // 73: api.v1.GetForecastWorkloadsResponse.resource_summary:type_name -> api.v1.ResourceSummary - 148, // 74: api.v1.GetForecastWorkloadRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 75: api.v1.GetForecastWorkloadRequest.end_time:type_name -> google.protobuf.Timestamp - 152, // 76: api.v1.GetForecastWorkloadResponse.workload_item:type_name -> api.v1.WorkloadItem - 156, // 77: api.v1.GetForecastWorkloadResponse.cost_info:type_name -> api.v1.CostInfo - 162, // 78: api.v1.GetForecastWorkloadResponse.resource_metrics:type_name -> api.v1.ForecastResourceMetrics - 161, // 79: api.v1.GetForecastWorkloadResponse.resource_summary:type_name -> api.v1.ResourceSummary - 158, // 80: api.v1.GetForecastWorkloadResponse.cost_data_points:type_name -> api.v1.CostDataPoint - 159, // 81: api.v1.GetForecastWorkloadResponse.resource_data_points:type_name -> api.v1.ResourceDataPoint - 56, // 82: api.v1.GetClusterMetadataResponse.clusters:type_name -> api.v1.Cluster - 45, // 83: api.v1.GetAllNamespacesResponse.cluster_id_with_namespaces:type_name -> api.v1.ClusterElement - 150, // 84: api.v1.GetAllWorkloadNamesRequest.kinds:type_name -> api.v1.K8sObjectKind - 45, // 85: api.v1.GetAllWorkloadNamesResponse.cluster_id_with_workload_name:type_name -> api.v1.ClusterElement - 150, // 86: api.v1.GetAllWorkloadLabelsRequest.kinds:type_name -> api.v1.K8sObjectKind - 45, // 87: api.v1.GetAllWorkloadLabelsResponse.cluster_id_with_labels:type_name -> api.v1.ClusterElement - 45, // 88: api.v1.GetAllNodeGroupNamesResponse.cluster_id_with_node_group_names:type_name -> api.v1.ClusterElement - 155, // 89: api.v1.Cluster.resource_metrics:type_name -> api.v1.ResourceMetrics - 156, // 90: api.v1.Cluster.cost_info:type_name -> api.v1.CostInfo - 157, // 91: api.v1.Cluster.node_info:type_name -> api.v1.NodeInfo - 158, // 92: api.v1.Cluster.cost_data_points:type_name -> api.v1.CostDataPoint - 159, // 93: api.v1.Cluster.resource_data_points:type_name -> api.v1.ResourceDataPoint - 160, // 94: api.v1.Cluster.most_expensive_node:type_name -> api.v1.Node - 160, // 95: api.v1.Cluster.least_expensive_node:type_name -> api.v1.Node - 160, // 96: api.v1.Cluster.most_underutilized_node:type_name -> api.v1.Node - 58, // 97: api.v1.Cluster.most_underutilized_container:type_name -> api.v1.Container - 57, // 98: api.v1.Cluster.zxp_info:type_name -> api.v1.OperatorInfo - 57, // 99: api.v1.Cluster.zxp_helm_info:type_name -> api.v1.OperatorInfo - 57, // 100: api.v1.Cluster.dakr_op_info:type_name -> api.v1.OperatorInfo - 57, // 101: api.v1.Cluster.node_op_info:type_name -> api.v1.OperatorInfo - 57, // 102: api.v1.Cluster.security_op_info:type_name -> api.v1.OperatorInfo - 57, // 103: api.v1.Cluster.network_op_info:type_name -> api.v1.OperatorInfo - 155, // 104: api.v1.Container.resource_metrics:type_name -> api.v1.ResourceMetrics - 57, // 105: api.v1.GetLatestOperatorVersionResponse.zxp_info:type_name -> api.v1.OperatorInfo - 57, // 106: api.v1.GetLatestOperatorVersionResponse.zxp_helm_info:type_name -> api.v1.OperatorInfo - 57, // 107: api.v1.GetLatestOperatorVersionResponse.zxp_netmon_info:type_name -> api.v1.OperatorInfo - 57, // 108: api.v1.GetLatestOperatorVersionResponse.zxp_netmon_helm_info:type_name -> api.v1.OperatorInfo - 57, // 109: api.v1.GetLatestOperatorVersionResponse.dakr_op_info:type_name -> api.v1.OperatorInfo - 57, // 110: api.v1.GetLatestOperatorVersionResponse.dakr_op_helm_info:type_name -> api.v1.OperatorInfo - 57, // 111: api.v1.GetLatestOperatorVersionResponse.node_op_info_aws:type_name -> api.v1.OperatorInfo - 57, // 112: api.v1.GetLatestOperatorVersionResponse.node_op_info_azure:type_name -> api.v1.OperatorInfo - 57, // 113: api.v1.GetLatestOperatorVersionResponse.node_op_info_gcp:type_name -> api.v1.OperatorInfo - 57, // 114: api.v1.GetLatestOperatorVersionResponse.node_op_info_oci:type_name -> api.v1.OperatorInfo - 57, // 115: api.v1.GetLatestOperatorVersionResponse.security_op_info:type_name -> api.v1.OperatorInfo - 57, // 116: api.v1.GetLatestOperatorVersionResponse.security_op_helm_info:type_name -> api.v1.OperatorInfo - 0, // 117: api.v1.GalaxyGetClusterPerspectiveRequest.group_by:type_name -> api.v1.GalaxyPOVClusterGroupBy - 70, // 118: api.v1.GalaxyGetClusterPerspectiveRequest.datapoint_opts:type_name -> api.v1.PerspectiveDatapointOpts - 63, // 119: api.v1.GalaxyGetClusterPerspectiveResponse.groupings:type_name -> api.v1.GalaxyClusterGroup - 156, // 120: api.v1.GalaxyClusterGroup.cost_info:type_name -> api.v1.CostInfo - 155, // 121: api.v1.GalaxyClusterGroup.resource_metrics:type_name -> api.v1.ResourceMetrics - 157, // 122: api.v1.GalaxyClusterGroup.node_info:type_name -> api.v1.NodeInfo - 1, // 123: api.v1.GalaxyGetNodePerspectiveRequest.group_by:type_name -> api.v1.GalaxyPOVNodeGroupBy - 70, // 124: api.v1.GalaxyGetNodePerspectiveRequest.datapoint_opts:type_name -> api.v1.PerspectiveDatapointOpts - 66, // 125: api.v1.GalaxyGetNodePerspectiveResponse.groupings:type_name -> api.v1.GalaxyNodeGroup - 156, // 126: api.v1.GalaxyNodeGroup.cost_info:type_name -> api.v1.CostInfo - 155, // 127: api.v1.GalaxyNodeGroup.resource_metrics:type_name -> api.v1.ResourceMetrics - 157, // 128: api.v1.GalaxyNodeGroup.node_info:type_name -> api.v1.NodeInfo - 2, // 129: api.v1.GalaxyGetWorkloadPerspectiveRequest.group_by:type_name -> api.v1.GalaxyPOVWorkloadGroupBy - 70, // 130: api.v1.GalaxyGetWorkloadPerspectiveRequest.datapoint_opts:type_name -> api.v1.PerspectiveDatapointOpts - 69, // 131: api.v1.GalaxyGetWorkloadPerspectiveResponse.groupings:type_name -> api.v1.GalaxyWorkloadGroup - 128, // 132: api.v1.GalaxyGetWorkloadPerspectiveResponse.clusters:type_name -> api.v1.GalaxyGetWorkloadPerspectiveResponse.ClustersEntry - 129, // 133: api.v1.GalaxyGetWorkloadPerspectiveResponse.workloads:type_name -> api.v1.GalaxyGetWorkloadPerspectiveResponse.WorkloadsEntry - 156, // 134: api.v1.GalaxyWorkloadGroup.cost_info:type_name -> api.v1.CostInfo - 155, // 135: api.v1.GalaxyWorkloadGroup.resource_metrics:type_name -> api.v1.ResourceMetrics - 161, // 136: api.v1.GalaxyWorkloadGroup.resource_summary:type_name -> api.v1.ResourceSummary - 150, // 137: api.v1.ListAuditLogsRequest.workload_type:type_name -> api.v1.K8sObjectKind - 148, // 138: api.v1.ListAuditLogsRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 139: api.v1.ListAuditLogsRequest.end_time:type_name -> google.protobuf.Timestamp - 151, // 140: api.v1.ListAuditLogsRequest.pagination:type_name -> api.v1.Pagination - 163, // 141: api.v1.ListAuditLogsResponse.logs:type_name -> api.v1.AuditLogEntry - 151, // 142: api.v1.ListAuditLogsResponse.pagination:type_name -> api.v1.Pagination - 150, // 143: api.v1.ListAuditLogOriginatorsRequest.workload_type:type_name -> api.v1.K8sObjectKind - 148, // 144: api.v1.ListAuditLogOriginatorsRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 145: api.v1.ListAuditLogOriginatorsRequest.end_time:type_name -> google.protobuf.Timestamp - 78, // 146: api.v1.SendWeeklySummaryEmailRequest.request:type_name -> api.v1.SendWeeklySummaryEmailRequestData - 148, // 147: api.v1.GetClustersNodeInfoRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 148: api.v1.GetClustersNodeInfoRequest.end_time:type_name -> google.protobuf.Timestamp - 157, // 149: api.v1.GetClustersNodeInfoResponse.node_info:type_name -> api.v1.NodeInfo - 160, // 150: api.v1.GetClustersNodeInfoResponse.most_expensive_node:type_name -> api.v1.Node - 160, // 151: api.v1.GetClustersNodeInfoResponse.least_expensive_node:type_name -> api.v1.Node - 160, // 152: api.v1.GetClustersNodeInfoResponse.most_underutilized_node:type_name -> api.v1.Node - 84, // 153: api.v1.SearchK8sResourcesResponse.results:type_name -> api.v1.K8sSearchResult - 87, // 154: api.v1.SearchK8sWorkloadsResponse.results:type_name -> api.v1.K8sWorkloadSearchResult - 130, // 155: api.v1.MetadataForWorkloadsRequest.workload_uid_to_kind:type_name -> api.v1.MetadataForWorkloadsRequest.WorkloadUidToKindEntry - 131, // 156: api.v1.MetadataForWorkloadsResponse.workload_uid_to_metadata:type_name -> api.v1.MetadataForWorkloadsResponse.WorkloadUidToMetadataEntry - 56, // 157: api.v1.AddClusterTagsResponse.cluster:type_name -> api.v1.Cluster - 56, // 158: api.v1.RemoveClusterTagsResponse.cluster:type_name -> api.v1.Cluster - 95, // 159: api.v1.ListTagsResponse.tags:type_name -> api.v1.TagSummary - 132, // 160: api.v1.WorkloadMetadata.pod_uid_to_node_metadata:type_name -> api.v1.WorkloadMetadata.PodUidToNodeMetadataEntry - 133, // 161: api.v1.WorkloadMetadata.pod_uid_to_pod_metadata:type_name -> api.v1.WorkloadMetadata.PodUidToPodMetadataEntry - 150, // 162: api.v1.WorkloadMetadata.kind:type_name -> api.v1.K8sObjectKind - 150, // 163: api.v1.GetRelatedResourcesRequest.kind:type_name -> api.v1.K8sObjectKind - 103, // 164: api.v1.GetWorkloadPodHistoryResponse.replica_sets:type_name -> api.v1.ReplicaSetHistory - 104, // 165: api.v1.GetWorkloadPodHistoryResponse.direct_pods:type_name -> api.v1.PodHistory - 102, // 166: api.v1.GetWorkloadPodHistoryResponse.jobs:type_name -> api.v1.JobHistory - 148, // 167: api.v1.JobHistory.created_at:type_name -> google.protobuf.Timestamp - 148, // 168: api.v1.JobHistory.deleted_at:type_name -> google.protobuf.Timestamp - 104, // 169: api.v1.JobHistory.pods:type_name -> api.v1.PodHistory - 148, // 170: api.v1.ReplicaSetHistory.created_at:type_name -> google.protobuf.Timestamp - 148, // 171: api.v1.ReplicaSetHistory.deleted_at:type_name -> google.protobuf.Timestamp - 104, // 172: api.v1.ReplicaSetHistory.pods:type_name -> api.v1.PodHistory - 148, // 173: api.v1.PodHistory.created_at:type_name -> google.protobuf.Timestamp - 148, // 174: api.v1.PodHistory.deleted_at:type_name -> google.protobuf.Timestamp - 106, // 175: api.v1.GetRelatedResourcesResponse.relations:type_name -> api.v1.K8sRelatedResource - 107, // 176: api.v1.GetRelatedResourcesResponse.nodes:type_name -> api.v1.K8sResourceNode - 108, // 177: api.v1.GetRelatedResourcesResponse.edges:type_name -> api.v1.K8sResourceEdge - 3, // 178: api.v1.GetClusterTypeResponse.cluster_type:type_name -> api.v1.ClusterType - 148, // 179: api.v1.GetWorkloadsStatsRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 180: api.v1.GetWorkloadsStatsRequest.end_time:type_name -> google.protobuf.Timestamp - 148, // 181: api.v1.DailyUtilizationRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 182: api.v1.DailyUtilizationRequest.end_time:type_name -> google.protobuf.Timestamp - 136, // 183: api.v1.DailyUtilizationResponse.cluster_id_to_daily_total_core_minutes:type_name -> api.v1.DailyUtilizationResponse.ClusterIdToDailyTotalCoreMinutesEntry - 137, // 184: api.v1.DailyUtilizationResponse.cluster_id_to_meta:type_name -> api.v1.DailyUtilizationResponse.ClusterIdToMetaEntry - 148, // 185: api.v1.DailyUtilizationInstanceTypeRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 186: api.v1.DailyUtilizationInstanceTypeRequest.end_time:type_name -> google.protobuf.Timestamp - 140, // 187: api.v1.DailyUtilizationInstanceTypeResponse.cluster_id_to_datapoints:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToDatapointsEntry - 141, // 188: api.v1.DailyUtilizationInstanceTypeResponse.cluster_id_to_meta:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToMetaEntry - 148, // 189: api.v1.DailyUtilizationNodeTypeRequest.start_time:type_name -> google.protobuf.Timestamp - 148, // 190: api.v1.DailyUtilizationNodeTypeRequest.end_time:type_name -> google.protobuf.Timestamp - 145, // 191: api.v1.DailyUtilizationNodeTypeResponse.cluster_id_to_datapoints:type_name -> api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToDatapointsEntry - 146, // 192: api.v1.DailyUtilizationNodeTypeResponse.cluster_id_to_meta:type_name -> api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToMetaEntry - 164, // 193: api.v1.LookupNodeInstanceResponse.dynamic_instance:type_name -> api.v1.Instance - 164, // 194: api.v1.LookupNodeInstanceResponse.cached_instance:type_name -> api.v1.Instance - 120, // 195: api.v1.LookupNodeInstanceResponse.lookup_params:type_name -> api.v1.InstanceLookupParams - 153, // 196: api.v1.GetAllNodeGroupsResponse.NodeGroupMapEntry.value:type_name -> api.v1.NodeGroup - 32, // 197: api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics.node_group_metrics:type_name -> api.v1.NodeGroupMetric - 123, // 198: api.v1.GetNodeGroupsUtilizationResponse.NodeGroupToUtilMetricsEntry.value:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics - 123, // 199: api.v1.GetNodeGroupsUtilizationResponse.InstanceTypeToUtilMetricsEntry.value:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics - 123, // 200: api.v1.GetNodeGroupsUtilizationResponse.ReservationTypeToUtilMetricsEntry.value:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics - 123, // 201: api.v1.GetNodeGroupsUtilizationResponse.LogicalAzToUtilMetricsEntry.value:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics - 56, // 202: api.v1.GalaxyGetWorkloadPerspectiveResponse.ClustersEntry.value:type_name -> api.v1.Cluster - 152, // 203: api.v1.GalaxyGetWorkloadPerspectiveResponse.WorkloadsEntry.value:type_name -> api.v1.WorkloadItem - 150, // 204: api.v1.MetadataForWorkloadsRequest.WorkloadUidToKindEntry.value:type_name -> api.v1.K8sObjectKind - 97, // 205: api.v1.MetadataForWorkloadsResponse.WorkloadUidToMetadataEntry.value:type_name -> api.v1.WorkloadMetadata - 99, // 206: api.v1.WorkloadMetadata.PodUidToNodeMetadataEntry.value:type_name -> api.v1.NodeMetadata - 98, // 207: api.v1.WorkloadMetadata.PodUidToPodMetadataEntry.value:type_name -> api.v1.PodMetadata - 135, // 208: api.v1.DailyUtilizationResponse.Datapoints.datapoints:type_name -> api.v1.DailyUtilizationResponse.Datapoint - 134, // 209: api.v1.DailyUtilizationResponse.ClusterIdToDailyTotalCoreMinutesEntry.value:type_name -> api.v1.DailyUtilizationResponse.Datapoints - 56, // 210: api.v1.DailyUtilizationResponse.ClusterIdToMetaEntry.value:type_name -> api.v1.Cluster - 139, // 211: api.v1.DailyUtilizationInstanceTypeResponse.Datapoints.datapoints:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.Datapoint - 142, // 212: api.v1.DailyUtilizationInstanceTypeResponse.Datapoint.instance_type_to_daily_total_core_minutes:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.Datapoint.InstanceTypeToDailyTotalCoreMinutesEntry - 138, // 213: api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToDatapointsEntry.value:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.Datapoints - 56, // 214: api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToMetaEntry.value:type_name -> api.v1.Cluster - 144, // 215: api.v1.DailyUtilizationNodeTypeResponse.Datapoints.datapoints:type_name -> api.v1.DailyUtilizationNodeTypeResponse.Datapoint - 147, // 216: api.v1.DailyUtilizationNodeTypeResponse.Datapoint.node_type_to_daily_total_core_minutes:type_name -> api.v1.DailyUtilizationNodeTypeResponse.Datapoint.NodeTypeToDailyTotalCoreMinutesEntry - 143, // 217: api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToDatapointsEntry.value:type_name -> api.v1.DailyUtilizationNodeTypeResponse.Datapoints - 56, // 218: api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToMetaEntry.value:type_name -> api.v1.Cluster - 111, // 219: api.v1.K8SService.GetWorkloadsStats:input_type -> api.v1.GetWorkloadsStatsRequest - 13, // 220: api.v1.K8SService.GetClusters:input_type -> api.v1.GetClustersRequest - 14, // 221: api.v1.K8SService.ListClusters:input_type -> api.v1.ListClustersRequest - 15, // 222: api.v1.K8SService.GetCluster:input_type -> api.v1.GetClusterRequest - 6, // 223: api.v1.K8SService.GetClusterMetadata:input_type -> api.v1.GetClusterMetadataRequest - 46, // 224: api.v1.K8SService.GetAllNamespaces:input_type -> api.v1.GetAllNamespacesRequest - 48, // 225: api.v1.K8SService.SearchNamespacesByCluster:input_type -> api.v1.SearchNamespacesByClusterRequest - 50, // 226: api.v1.K8SService.GetAllWorkloadNames:input_type -> api.v1.GetAllWorkloadNamesRequest - 52, // 227: api.v1.K8SService.GetAllWorkloadLabels:input_type -> api.v1.GetAllWorkloadLabelsRequest - 54, // 228: api.v1.K8SService.GetAllNodeGroupNames:input_type -> api.v1.GetAllNodeGroupNamesRequest - 88, // 229: api.v1.K8SService.MetadataForWorkloads:input_type -> api.v1.MetadataForWorkloadsRequest - 25, // 230: api.v1.K8SService.GetNodeGroups:input_type -> api.v1.GetNodeGroupsRequest - 26, // 231: api.v1.K8SService.GetAllNodeGroups:input_type -> api.v1.GetAllNodeGroupsRequest - 30, // 232: api.v1.K8SService.GetNodeGroupsUtilization:input_type -> api.v1.GetNodeGroupsUtilizationRequest - 7, // 233: api.v1.K8SService.GetNodeGroup:input_type -> api.v1.GetNodeGroupRequest - 4, // 234: api.v1.K8SService.GetNode:input_type -> api.v1.GetNodeRequest - 8, // 235: api.v1.K8SService.GetWorkloads:input_type -> api.v1.GetWorkloadsRequest - 12, // 236: api.v1.K8SService.GetWorkload:input_type -> api.v1.GetWorkloadRequest - 40, // 237: api.v1.K8SService.GetForecastWorkloads:input_type -> api.v1.GetForecastWorkloadsRequest - 42, // 238: api.v1.K8SService.GetForecastWorkload:input_type -> api.v1.GetForecastWorkloadRequest - 9, // 239: api.v1.K8SService.GetResources:input_type -> api.v1.GetResourcesRequest - 10, // 240: api.v1.K8SService.GetPods:input_type -> api.v1.GetPodsRequest - 59, // 241: api.v1.K8SService.GetLatestOperatorVersion:input_type -> api.v1.GetLatestOperatorVersionRequest - 61, // 242: api.v1.K8SService.GalaxyGetClusterPerspective:input_type -> api.v1.GalaxyGetClusterPerspectiveRequest - 64, // 243: api.v1.K8SService.GalaxyGetNodePerspective:input_type -> api.v1.GalaxyGetNodePerspectiveRequest - 67, // 244: api.v1.K8SService.GalaxyGetWorkloadPerspective:input_type -> api.v1.GalaxyGetWorkloadPerspectiveRequest - 71, // 245: api.v1.K8SService.ListAuditLogs:input_type -> api.v1.ListAuditLogsRequest - 73, // 246: api.v1.K8SService.ListAuditLogOriginators:input_type -> api.v1.ListAuditLogOriginatorsRequest - 75, // 247: api.v1.K8SService.SendWorkloadEmail:input_type -> api.v1.SendWorkloadEmailRequest - 77, // 248: api.v1.K8SService.SendWeeklySummaryEmail:input_type -> api.v1.SendWeeklySummaryEmailRequest - 80, // 249: api.v1.K8SService.GetClustersNodeInfo:input_type -> api.v1.GetClustersNodeInfoRequest - 82, // 250: api.v1.K8SService.SearchK8sResources:input_type -> api.v1.SearchK8sResourcesRequest - 85, // 251: api.v1.K8SService.SearchK8sWorkloads:input_type -> api.v1.SearchK8sWorkloadsRequest - 109, // 252: api.v1.K8SService.GetClusterType:input_type -> api.v1.GetClusterTypeRequest - 100, // 253: api.v1.K8SService.GetRelationsForKind:input_type -> api.v1.GetRelatedResourcesRequest - 119, // 254: api.v1.K8SService.LookupNodeInstance:input_type -> api.v1.LookupNodeInstanceRequest - 5, // 255: api.v1.K8SService.GetWorkloadPodHistory:input_type -> api.v1.GetWorkloadPodHistoryRequest - 90, // 256: api.v1.K8SService.AddClusterTags:input_type -> api.v1.AddClusterTagsRequest - 92, // 257: api.v1.K8SService.RemoveClusterTags:input_type -> api.v1.RemoveClusterTagsRequest - 94, // 258: api.v1.K8SService.ListTags:input_type -> api.v1.ListTagsRequest - 21, // 259: api.v1.ClusterMutationService.CreateCluster:input_type -> api.v1.CreateClusterRequest - 16, // 260: api.v1.ClusterMutationService.DeleteCluster:input_type -> api.v1.DeleteClusterRequest - 18, // 261: api.v1.ClusterMutationService.UpdateCluster:input_type -> api.v1.UpdateClusterRequest - 23, // 262: api.v1.ClusterMutationService.ResetClusterToken:input_type -> api.v1.ResetClusterTokenRequest - 113, // 263: api.v1.UtilizationService.DailyUtilization:input_type -> api.v1.DailyUtilizationRequest - 115, // 264: api.v1.UtilizationService.DailyUtilizationInstanceType:input_type -> api.v1.DailyUtilizationInstanceTypeRequest - 117, // 265: api.v1.UtilizationService.DailyUtilizationNodeType:input_type -> api.v1.DailyUtilizationNodeTypeRequest - 112, // 266: api.v1.K8SService.GetWorkloadsStats:output_type -> api.v1.GetWorkloadsStatsResponse - 35, // 267: api.v1.K8SService.GetClusters:output_type -> api.v1.GetClustersResponse - 36, // 268: api.v1.K8SService.ListClusters:output_type -> api.v1.ListClustersResponse - 34, // 269: api.v1.K8SService.GetCluster:output_type -> api.v1.GetClusterResponse - 44, // 270: api.v1.K8SService.GetClusterMetadata:output_type -> api.v1.GetClusterMetadataResponse - 47, // 271: api.v1.K8SService.GetAllNamespaces:output_type -> api.v1.GetAllNamespacesResponse - 49, // 272: api.v1.K8SService.SearchNamespacesByCluster:output_type -> api.v1.SearchNamespacesByClusterResponse - 51, // 273: api.v1.K8SService.GetAllWorkloadNames:output_type -> api.v1.GetAllWorkloadNamesResponse - 53, // 274: api.v1.K8SService.GetAllWorkloadLabels:output_type -> api.v1.GetAllWorkloadLabelsResponse - 55, // 275: api.v1.K8SService.GetAllNodeGroupNames:output_type -> api.v1.GetAllNodeGroupNamesResponse - 89, // 276: api.v1.K8SService.MetadataForWorkloads:output_type -> api.v1.MetadataForWorkloadsResponse - 27, // 277: api.v1.K8SService.GetNodeGroups:output_type -> api.v1.GetNodeGroupsResponse - 28, // 278: api.v1.K8SService.GetAllNodeGroups:output_type -> api.v1.GetAllNodeGroupsResponse - 31, // 279: api.v1.K8SService.GetNodeGroupsUtilization:output_type -> api.v1.GetNodeGroupsUtilizationResponse - 33, // 280: api.v1.K8SService.GetNodeGroup:output_type -> api.v1.GetNodeGroupResponse - 37, // 281: api.v1.K8SService.GetNode:output_type -> api.v1.GetNodeResponse - 38, // 282: api.v1.K8SService.GetWorkloads:output_type -> api.v1.GetWorkloadsResponse - 39, // 283: api.v1.K8SService.GetWorkload:output_type -> api.v1.GetWorkloadResponse - 41, // 284: api.v1.K8SService.GetForecastWorkloads:output_type -> api.v1.GetForecastWorkloadsResponse - 43, // 285: api.v1.K8SService.GetForecastWorkload:output_type -> api.v1.GetForecastWorkloadResponse - 20, // 286: api.v1.K8SService.GetResources:output_type -> api.v1.GetResourcesResponse - 11, // 287: api.v1.K8SService.GetPods:output_type -> api.v1.GetPodsResponse - 60, // 288: api.v1.K8SService.GetLatestOperatorVersion:output_type -> api.v1.GetLatestOperatorVersionResponse - 62, // 289: api.v1.K8SService.GalaxyGetClusterPerspective:output_type -> api.v1.GalaxyGetClusterPerspectiveResponse - 65, // 290: api.v1.K8SService.GalaxyGetNodePerspective:output_type -> api.v1.GalaxyGetNodePerspectiveResponse - 68, // 291: api.v1.K8SService.GalaxyGetWorkloadPerspective:output_type -> api.v1.GalaxyGetWorkloadPerspectiveResponse - 72, // 292: api.v1.K8SService.ListAuditLogs:output_type -> api.v1.ListAuditLogsResponse - 74, // 293: api.v1.K8SService.ListAuditLogOriginators:output_type -> api.v1.ListAuditLogOriginatorsResponse - 76, // 294: api.v1.K8SService.SendWorkloadEmail:output_type -> api.v1.SendWorkloadEmailResponse - 79, // 295: api.v1.K8SService.SendWeeklySummaryEmail:output_type -> api.v1.SendWeeklySummaryEmailResponse - 81, // 296: api.v1.K8SService.GetClustersNodeInfo:output_type -> api.v1.GetClustersNodeInfoResponse - 83, // 297: api.v1.K8SService.SearchK8sResources:output_type -> api.v1.SearchK8sResourcesResponse - 86, // 298: api.v1.K8SService.SearchK8sWorkloads:output_type -> api.v1.SearchK8sWorkloadsResponse - 110, // 299: api.v1.K8SService.GetClusterType:output_type -> api.v1.GetClusterTypeResponse - 105, // 300: api.v1.K8SService.GetRelationsForKind:output_type -> api.v1.GetRelatedResourcesResponse - 121, // 301: api.v1.K8SService.LookupNodeInstance:output_type -> api.v1.LookupNodeInstanceResponse - 101, // 302: api.v1.K8SService.GetWorkloadPodHistory:output_type -> api.v1.GetWorkloadPodHistoryResponse - 91, // 303: api.v1.K8SService.AddClusterTags:output_type -> api.v1.AddClusterTagsResponse - 93, // 304: api.v1.K8SService.RemoveClusterTags:output_type -> api.v1.RemoveClusterTagsResponse - 96, // 305: api.v1.K8SService.ListTags:output_type -> api.v1.ListTagsResponse - 22, // 306: api.v1.ClusterMutationService.CreateCluster:output_type -> api.v1.CreateClusterResponse - 17, // 307: api.v1.ClusterMutationService.DeleteCluster:output_type -> api.v1.DeleteClusterResponse - 19, // 308: api.v1.ClusterMutationService.UpdateCluster:output_type -> api.v1.UpdateClusterResponse - 24, // 309: api.v1.ClusterMutationService.ResetClusterToken:output_type -> api.v1.ResetClusterTokenResponse - 114, // 310: api.v1.UtilizationService.DailyUtilization:output_type -> api.v1.DailyUtilizationResponse - 116, // 311: api.v1.UtilizationService.DailyUtilizationInstanceType:output_type -> api.v1.DailyUtilizationInstanceTypeResponse - 118, // 312: api.v1.UtilizationService.DailyUtilizationNodeType:output_type -> api.v1.DailyUtilizationNodeTypeResponse - 266, // [266:313] is the sub-list for method output_type - 219, // [219:266] is the sub-list for method input_type - 219, // [219:219] is the sub-list for extension type_name - 219, // [219:219] is the sub-list for extension extendee - 0, // [0:219] is the sub-list for field type_name + 157, // 0: api.v1.GetNodeRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 1: api.v1.GetNodeRequest.end_time:type_name -> google.protobuf.Timestamp + 157, // 2: api.v1.GetWorkloadPodHistoryRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 3: api.v1.GetWorkloadPodHistoryRequest.end_time:type_name -> google.protobuf.Timestamp + 157, // 4: api.v1.GetNodeGroupRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 5: api.v1.GetNodeGroupRequest.end_time:type_name -> google.protobuf.Timestamp + 157, // 6: api.v1.GetWorkloadsRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 7: api.v1.GetWorkloadsRequest.end_time:type_name -> google.protobuf.Timestamp + 158, // 8: api.v1.GetWorkloadsRequest.filters:type_name -> api.v1.WorkloadFilters + 159, // 9: api.v1.GetResourcesRequest.kind:type_name -> api.v1.K8sObjectKind + 160, // 10: api.v1.GetResourcesRequest.pagination:type_name -> api.v1.Pagination + 160, // 11: api.v1.GetPodsRequest.pagination:type_name -> api.v1.Pagination + 157, // 12: api.v1.GetPodsRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 13: api.v1.GetPodsRequest.end_time:type_name -> google.protobuf.Timestamp + 161, // 14: api.v1.GetPodsResponse.workload_items:type_name -> api.v1.WorkloadItem + 160, // 15: api.v1.GetPodsResponse.pagination:type_name -> api.v1.Pagination + 157, // 16: api.v1.GetWorkloadRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 17: api.v1.GetWorkloadRequest.end_time:type_name -> google.protobuf.Timestamp + 157, // 18: api.v1.GetClustersRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 19: api.v1.GetClustersRequest.end_time:type_name -> google.protobuf.Timestamp + 160, // 20: api.v1.ListClustersRequest.pagination:type_name -> api.v1.Pagination + 157, // 21: api.v1.GetClusterRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 22: api.v1.GetClusterRequest.end_time:type_name -> google.protobuf.Timestamp + 65, // 23: api.v1.UpdateClusterResponse.cluster:type_name -> api.v1.Cluster + 161, // 24: api.v1.GetResourcesResponse.workload_items:type_name -> api.v1.WorkloadItem + 160, // 25: api.v1.GetResourcesResponse.pagination:type_name -> api.v1.Pagination + 65, // 26: api.v1.CreateClusterResponse.cluster:type_name -> api.v1.Cluster + 157, // 27: api.v1.GetNodeGroupsRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 28: api.v1.GetNodeGroupsRequest.end_time:type_name -> google.protobuf.Timestamp + 162, // 29: api.v1.GetNodeGroupsResponse.node_groups:type_name -> api.v1.NodeGroup + 131, // 30: api.v1.GetAllNodeGroupsResponse.node_group_map:type_name -> api.v1.GetAllNodeGroupsResponse.NodeGroupMapEntry + 162, // 31: api.v1.NodeGroupSet.node_groups:type_name -> api.v1.NodeGroup + 157, // 32: api.v1.GetNodeGroupsUtilizationRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 33: api.v1.GetNodeGroupsUtilizationRequest.end_time:type_name -> google.protobuf.Timestamp + 133, // 34: api.v1.GetNodeGroupsUtilizationResponse.node_group_to_util_metrics:type_name -> api.v1.GetNodeGroupsUtilizationResponse.NodeGroupToUtilMetricsEntry + 134, // 35: api.v1.GetNodeGroupsUtilizationResponse.instance_type_to_util_metrics:type_name -> api.v1.GetNodeGroupsUtilizationResponse.InstanceTypeToUtilMetricsEntry + 135, // 36: api.v1.GetNodeGroupsUtilizationResponse.reservation_type_to_util_metrics:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ReservationTypeToUtilMetricsEntry + 136, // 37: api.v1.GetNodeGroupsUtilizationResponse.logical_az_to_util_metrics:type_name -> api.v1.GetNodeGroupsUtilizationResponse.LogicalAzToUtilMetricsEntry + 163, // 38: api.v1.NodeGroupMetric.hourly_cost:type_name -> google.type.Money + 163, // 39: api.v1.NodeGroupMetric.hourly_cpu_cost:type_name -> google.type.Money + 163, // 40: api.v1.NodeGroupMetric.hourly_memory_cost:type_name -> google.type.Money + 163, // 41: api.v1.NodeGroupMetric.hourly_gpu_cost:type_name -> google.type.Money + 157, // 42: api.v1.NodeGroupMetric.bucket_time:type_name -> google.protobuf.Timestamp + 162, // 43: api.v1.GetNodeGroupResponse.node_group:type_name -> api.v1.NodeGroup + 65, // 44: api.v1.GetClusterResponse.cluster:type_name -> api.v1.Cluster + 65, // 45: api.v1.GetClustersResponse.clusters:type_name -> api.v1.Cluster + 164, // 46: api.v1.GetClustersResponse.resource_metrics:type_name -> api.v1.ResourceMetrics + 165, // 47: api.v1.GetClustersResponse.cost_info:type_name -> api.v1.CostInfo + 166, // 48: api.v1.GetClustersResponse.node_info:type_name -> api.v1.NodeInfo + 167, // 49: api.v1.GetClustersResponse.cost_data_points:type_name -> api.v1.CostDataPoint + 168, // 50: api.v1.GetClustersResponse.resource_data_points:type_name -> api.v1.ResourceDataPoint + 65, // 51: api.v1.ListClustersResponse.clusters:type_name -> api.v1.Cluster + 160, // 52: api.v1.ListClustersResponse.pagination:type_name -> api.v1.Pagination + 169, // 53: api.v1.GetNodeResponse.node:type_name -> api.v1.Node + 164, // 54: api.v1.GetNodeResponse.resource_metrics:type_name -> api.v1.ResourceMetrics + 165, // 55: api.v1.GetNodeResponse.cost_info:type_name -> api.v1.CostInfo + 167, // 56: api.v1.GetNodeResponse.cost_data_points:type_name -> api.v1.CostDataPoint + 168, // 57: api.v1.GetNodeResponse.resource_data_points:type_name -> api.v1.ResourceDataPoint + 161, // 58: api.v1.GetWorkloadsResponse.workload_items:type_name -> api.v1.WorkloadItem + 165, // 59: api.v1.GetWorkloadsResponse.cost_info:type_name -> api.v1.CostInfo + 164, // 60: api.v1.GetWorkloadsResponse.resource_metrics:type_name -> api.v1.ResourceMetrics + 170, // 61: api.v1.GetWorkloadsResponse.resource_summary:type_name -> api.v1.ResourceSummary + 161, // 62: api.v1.GetWorkloadResponse.workload_item:type_name -> api.v1.WorkloadItem + 165, // 63: api.v1.GetWorkloadResponse.cost_info:type_name -> api.v1.CostInfo + 164, // 64: api.v1.GetWorkloadResponse.resource_metrics:type_name -> api.v1.ResourceMetrics + 170, // 65: api.v1.GetWorkloadResponse.resource_summary:type_name -> api.v1.ResourceSummary + 167, // 66: api.v1.GetWorkloadResponse.cost_data_points:type_name -> api.v1.CostDataPoint + 168, // 67: api.v1.GetWorkloadResponse.resource_data_points:type_name -> api.v1.ResourceDataPoint + 157, // 68: api.v1.GetWorkloadContainerPercentilesRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 69: api.v1.GetWorkloadContainerPercentilesRequest.end_time:type_name -> google.protobuf.Timestamp + 171, // 70: api.v1.GetWorkloadContainerPercentilesResponse.containers:type_name -> api.v1.ContainerPercentileSummary + 157, // 71: api.v1.GetWorkloadContainerFsPercentilesRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 72: api.v1.GetWorkloadContainerFsPercentilesRequest.end_time:type_name -> google.protobuf.Timestamp + 172, // 73: api.v1.GetWorkloadContainerFsPercentilesResponse.containers:type_name -> api.v1.ContainerFsPercentileSummary + 173, // 74: api.v1.GetLatestContainerRequestLimitsResponse.containers:type_name -> api.v1.ContainerRequestLimits + 157, // 75: api.v1.GetForecastWorkloadsRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 76: api.v1.GetForecastWorkloadsRequest.end_time:type_name -> google.protobuf.Timestamp + 161, // 77: api.v1.GetForecastWorkloadsResponse.workload_items:type_name -> api.v1.WorkloadItem + 165, // 78: api.v1.GetForecastWorkloadsResponse.cost_info:type_name -> api.v1.CostInfo + 174, // 79: api.v1.GetForecastWorkloadsResponse.resource_metrics:type_name -> api.v1.ForecastResourceMetrics + 170, // 80: api.v1.GetForecastWorkloadsResponse.resource_summary:type_name -> api.v1.ResourceSummary + 157, // 81: api.v1.GetForecastWorkloadRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 82: api.v1.GetForecastWorkloadRequest.end_time:type_name -> google.protobuf.Timestamp + 161, // 83: api.v1.GetForecastWorkloadResponse.workload_item:type_name -> api.v1.WorkloadItem + 165, // 84: api.v1.GetForecastWorkloadResponse.cost_info:type_name -> api.v1.CostInfo + 174, // 85: api.v1.GetForecastWorkloadResponse.resource_metrics:type_name -> api.v1.ForecastResourceMetrics + 170, // 86: api.v1.GetForecastWorkloadResponse.resource_summary:type_name -> api.v1.ResourceSummary + 167, // 87: api.v1.GetForecastWorkloadResponse.cost_data_points:type_name -> api.v1.CostDataPoint + 168, // 88: api.v1.GetForecastWorkloadResponse.resource_data_points:type_name -> api.v1.ResourceDataPoint + 65, // 89: api.v1.GetClusterMetadataResponse.clusters:type_name -> api.v1.Cluster + 51, // 90: api.v1.GetAllNamespacesResponse.cluster_id_with_namespaces:type_name -> api.v1.ClusterElement + 58, // 91: api.v1.ListNamespacesByClusterResponse.namespaces:type_name -> api.v1.NamespaceItem + 159, // 92: api.v1.GetAllWorkloadNamesRequest.kinds:type_name -> api.v1.K8sObjectKind + 51, // 93: api.v1.GetAllWorkloadNamesResponse.cluster_id_with_workload_name:type_name -> api.v1.ClusterElement + 159, // 94: api.v1.GetAllWorkloadLabelsRequest.kinds:type_name -> api.v1.K8sObjectKind + 51, // 95: api.v1.GetAllWorkloadLabelsResponse.cluster_id_with_labels:type_name -> api.v1.ClusterElement + 51, // 96: api.v1.GetAllNodeGroupNamesResponse.cluster_id_with_node_group_names:type_name -> api.v1.ClusterElement + 164, // 97: api.v1.Cluster.resource_metrics:type_name -> api.v1.ResourceMetrics + 165, // 98: api.v1.Cluster.cost_info:type_name -> api.v1.CostInfo + 166, // 99: api.v1.Cluster.node_info:type_name -> api.v1.NodeInfo + 167, // 100: api.v1.Cluster.cost_data_points:type_name -> api.v1.CostDataPoint + 168, // 101: api.v1.Cluster.resource_data_points:type_name -> api.v1.ResourceDataPoint + 169, // 102: api.v1.Cluster.most_expensive_node:type_name -> api.v1.Node + 169, // 103: api.v1.Cluster.least_expensive_node:type_name -> api.v1.Node + 169, // 104: api.v1.Cluster.most_underutilized_node:type_name -> api.v1.Node + 67, // 105: api.v1.Cluster.most_underutilized_container:type_name -> api.v1.Container + 66, // 106: api.v1.Cluster.zxp_info:type_name -> api.v1.OperatorInfo + 66, // 107: api.v1.Cluster.zxp_helm_info:type_name -> api.v1.OperatorInfo + 66, // 108: api.v1.Cluster.dakr_op_info:type_name -> api.v1.OperatorInfo + 66, // 109: api.v1.Cluster.node_op_info:type_name -> api.v1.OperatorInfo + 66, // 110: api.v1.Cluster.security_op_info:type_name -> api.v1.OperatorInfo + 66, // 111: api.v1.Cluster.network_op_info:type_name -> api.v1.OperatorInfo + 164, // 112: api.v1.Container.resource_metrics:type_name -> api.v1.ResourceMetrics + 66, // 113: api.v1.GetLatestOperatorVersionResponse.zxp_info:type_name -> api.v1.OperatorInfo + 66, // 114: api.v1.GetLatestOperatorVersionResponse.zxp_helm_info:type_name -> api.v1.OperatorInfo + 66, // 115: api.v1.GetLatestOperatorVersionResponse.zxp_netmon_info:type_name -> api.v1.OperatorInfo + 66, // 116: api.v1.GetLatestOperatorVersionResponse.zxp_netmon_helm_info:type_name -> api.v1.OperatorInfo + 66, // 117: api.v1.GetLatestOperatorVersionResponse.dakr_op_info:type_name -> api.v1.OperatorInfo + 66, // 118: api.v1.GetLatestOperatorVersionResponse.dakr_op_helm_info:type_name -> api.v1.OperatorInfo + 66, // 119: api.v1.GetLatestOperatorVersionResponse.node_op_info_aws:type_name -> api.v1.OperatorInfo + 66, // 120: api.v1.GetLatestOperatorVersionResponse.node_op_info_azure:type_name -> api.v1.OperatorInfo + 66, // 121: api.v1.GetLatestOperatorVersionResponse.node_op_info_gcp:type_name -> api.v1.OperatorInfo + 66, // 122: api.v1.GetLatestOperatorVersionResponse.node_op_info_oci:type_name -> api.v1.OperatorInfo + 66, // 123: api.v1.GetLatestOperatorVersionResponse.security_op_info:type_name -> api.v1.OperatorInfo + 66, // 124: api.v1.GetLatestOperatorVersionResponse.security_op_helm_info:type_name -> api.v1.OperatorInfo + 0, // 125: api.v1.GalaxyGetClusterPerspectiveRequest.group_by:type_name -> api.v1.GalaxyPOVClusterGroupBy + 79, // 126: api.v1.GalaxyGetClusterPerspectiveRequest.datapoint_opts:type_name -> api.v1.PerspectiveDatapointOpts + 72, // 127: api.v1.GalaxyGetClusterPerspectiveResponse.groupings:type_name -> api.v1.GalaxyClusterGroup + 165, // 128: api.v1.GalaxyClusterGroup.cost_info:type_name -> api.v1.CostInfo + 164, // 129: api.v1.GalaxyClusterGroup.resource_metrics:type_name -> api.v1.ResourceMetrics + 166, // 130: api.v1.GalaxyClusterGroup.node_info:type_name -> api.v1.NodeInfo + 1, // 131: api.v1.GalaxyGetNodePerspectiveRequest.group_by:type_name -> api.v1.GalaxyPOVNodeGroupBy + 79, // 132: api.v1.GalaxyGetNodePerspectiveRequest.datapoint_opts:type_name -> api.v1.PerspectiveDatapointOpts + 75, // 133: api.v1.GalaxyGetNodePerspectiveResponse.groupings:type_name -> api.v1.GalaxyNodeGroup + 165, // 134: api.v1.GalaxyNodeGroup.cost_info:type_name -> api.v1.CostInfo + 164, // 135: api.v1.GalaxyNodeGroup.resource_metrics:type_name -> api.v1.ResourceMetrics + 166, // 136: api.v1.GalaxyNodeGroup.node_info:type_name -> api.v1.NodeInfo + 2, // 137: api.v1.GalaxyGetWorkloadPerspectiveRequest.group_by:type_name -> api.v1.GalaxyPOVWorkloadGroupBy + 79, // 138: api.v1.GalaxyGetWorkloadPerspectiveRequest.datapoint_opts:type_name -> api.v1.PerspectiveDatapointOpts + 78, // 139: api.v1.GalaxyGetWorkloadPerspectiveResponse.groupings:type_name -> api.v1.GalaxyWorkloadGroup + 137, // 140: api.v1.GalaxyGetWorkloadPerspectiveResponse.clusters:type_name -> api.v1.GalaxyGetWorkloadPerspectiveResponse.ClustersEntry + 138, // 141: api.v1.GalaxyGetWorkloadPerspectiveResponse.workloads:type_name -> api.v1.GalaxyGetWorkloadPerspectiveResponse.WorkloadsEntry + 165, // 142: api.v1.GalaxyWorkloadGroup.cost_info:type_name -> api.v1.CostInfo + 164, // 143: api.v1.GalaxyWorkloadGroup.resource_metrics:type_name -> api.v1.ResourceMetrics + 170, // 144: api.v1.GalaxyWorkloadGroup.resource_summary:type_name -> api.v1.ResourceSummary + 159, // 145: api.v1.ListAuditLogsRequest.workload_type:type_name -> api.v1.K8sObjectKind + 157, // 146: api.v1.ListAuditLogsRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 147: api.v1.ListAuditLogsRequest.end_time:type_name -> google.protobuf.Timestamp + 160, // 148: api.v1.ListAuditLogsRequest.pagination:type_name -> api.v1.Pagination + 175, // 149: api.v1.ListAuditLogsResponse.logs:type_name -> api.v1.AuditLogEntry + 160, // 150: api.v1.ListAuditLogsResponse.pagination:type_name -> api.v1.Pagination + 159, // 151: api.v1.ListAuditLogOriginatorsRequest.workload_type:type_name -> api.v1.K8sObjectKind + 157, // 152: api.v1.ListAuditLogOriginatorsRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 153: api.v1.ListAuditLogOriginatorsRequest.end_time:type_name -> google.protobuf.Timestamp + 87, // 154: api.v1.SendWeeklySummaryEmailRequest.request:type_name -> api.v1.SendWeeklySummaryEmailRequestData + 157, // 155: api.v1.GetClustersNodeInfoRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 156: api.v1.GetClustersNodeInfoRequest.end_time:type_name -> google.protobuf.Timestamp + 166, // 157: api.v1.GetClustersNodeInfoResponse.node_info:type_name -> api.v1.NodeInfo + 169, // 158: api.v1.GetClustersNodeInfoResponse.most_expensive_node:type_name -> api.v1.Node + 169, // 159: api.v1.GetClustersNodeInfoResponse.least_expensive_node:type_name -> api.v1.Node + 169, // 160: api.v1.GetClustersNodeInfoResponse.most_underutilized_node:type_name -> api.v1.Node + 93, // 161: api.v1.SearchK8sResourcesResponse.results:type_name -> api.v1.K8sSearchResult + 96, // 162: api.v1.SearchK8sWorkloadsResponse.results:type_name -> api.v1.K8sWorkloadSearchResult + 139, // 163: api.v1.MetadataForWorkloadsRequest.workload_uid_to_kind:type_name -> api.v1.MetadataForWorkloadsRequest.WorkloadUidToKindEntry + 140, // 164: api.v1.MetadataForWorkloadsResponse.workload_uid_to_metadata:type_name -> api.v1.MetadataForWorkloadsResponse.WorkloadUidToMetadataEntry + 65, // 165: api.v1.AddClusterTagsResponse.cluster:type_name -> api.v1.Cluster + 65, // 166: api.v1.RemoveClusterTagsResponse.cluster:type_name -> api.v1.Cluster + 104, // 167: api.v1.ListTagsResponse.tags:type_name -> api.v1.TagSummary + 141, // 168: api.v1.WorkloadMetadata.pod_uid_to_node_metadata:type_name -> api.v1.WorkloadMetadata.PodUidToNodeMetadataEntry + 142, // 169: api.v1.WorkloadMetadata.pod_uid_to_pod_metadata:type_name -> api.v1.WorkloadMetadata.PodUidToPodMetadataEntry + 159, // 170: api.v1.WorkloadMetadata.kind:type_name -> api.v1.K8sObjectKind + 159, // 171: api.v1.GetRelatedResourcesRequest.kind:type_name -> api.v1.K8sObjectKind + 112, // 172: api.v1.GetWorkloadPodHistoryResponse.replica_sets:type_name -> api.v1.ReplicaSetHistory + 113, // 173: api.v1.GetWorkloadPodHistoryResponse.direct_pods:type_name -> api.v1.PodHistory + 111, // 174: api.v1.GetWorkloadPodHistoryResponse.jobs:type_name -> api.v1.JobHistory + 157, // 175: api.v1.JobHistory.created_at:type_name -> google.protobuf.Timestamp + 157, // 176: api.v1.JobHistory.deleted_at:type_name -> google.protobuf.Timestamp + 113, // 177: api.v1.JobHistory.pods:type_name -> api.v1.PodHistory + 157, // 178: api.v1.ReplicaSetHistory.created_at:type_name -> google.protobuf.Timestamp + 157, // 179: api.v1.ReplicaSetHistory.deleted_at:type_name -> google.protobuf.Timestamp + 113, // 180: api.v1.ReplicaSetHistory.pods:type_name -> api.v1.PodHistory + 157, // 181: api.v1.PodHistory.created_at:type_name -> google.protobuf.Timestamp + 157, // 182: api.v1.PodHistory.deleted_at:type_name -> google.protobuf.Timestamp + 115, // 183: api.v1.GetRelatedResourcesResponse.relations:type_name -> api.v1.K8sRelatedResource + 116, // 184: api.v1.GetRelatedResourcesResponse.nodes:type_name -> api.v1.K8sResourceNode + 117, // 185: api.v1.GetRelatedResourcesResponse.edges:type_name -> api.v1.K8sResourceEdge + 3, // 186: api.v1.GetClusterTypeResponse.cluster_type:type_name -> api.v1.ClusterType + 157, // 187: api.v1.GetWorkloadsStatsRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 188: api.v1.GetWorkloadsStatsRequest.end_time:type_name -> google.protobuf.Timestamp + 157, // 189: api.v1.DailyUtilizationRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 190: api.v1.DailyUtilizationRequest.end_time:type_name -> google.protobuf.Timestamp + 145, // 191: api.v1.DailyUtilizationResponse.cluster_id_to_daily_total_core_minutes:type_name -> api.v1.DailyUtilizationResponse.ClusterIdToDailyTotalCoreMinutesEntry + 146, // 192: api.v1.DailyUtilizationResponse.cluster_id_to_meta:type_name -> api.v1.DailyUtilizationResponse.ClusterIdToMetaEntry + 157, // 193: api.v1.DailyUtilizationInstanceTypeRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 194: api.v1.DailyUtilizationInstanceTypeRequest.end_time:type_name -> google.protobuf.Timestamp + 149, // 195: api.v1.DailyUtilizationInstanceTypeResponse.cluster_id_to_datapoints:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToDatapointsEntry + 150, // 196: api.v1.DailyUtilizationInstanceTypeResponse.cluster_id_to_meta:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToMetaEntry + 157, // 197: api.v1.DailyUtilizationNodeTypeRequest.start_time:type_name -> google.protobuf.Timestamp + 157, // 198: api.v1.DailyUtilizationNodeTypeRequest.end_time:type_name -> google.protobuf.Timestamp + 154, // 199: api.v1.DailyUtilizationNodeTypeResponse.cluster_id_to_datapoints:type_name -> api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToDatapointsEntry + 155, // 200: api.v1.DailyUtilizationNodeTypeResponse.cluster_id_to_meta:type_name -> api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToMetaEntry + 176, // 201: api.v1.LookupNodeInstanceResponse.dynamic_instance:type_name -> api.v1.Instance + 176, // 202: api.v1.LookupNodeInstanceResponse.cached_instance:type_name -> api.v1.Instance + 129, // 203: api.v1.LookupNodeInstanceResponse.lookup_params:type_name -> api.v1.InstanceLookupParams + 162, // 204: api.v1.GetAllNodeGroupsResponse.NodeGroupMapEntry.value:type_name -> api.v1.NodeGroup + 32, // 205: api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics.node_group_metrics:type_name -> api.v1.NodeGroupMetric + 132, // 206: api.v1.GetNodeGroupsUtilizationResponse.NodeGroupToUtilMetricsEntry.value:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics + 132, // 207: api.v1.GetNodeGroupsUtilizationResponse.InstanceTypeToUtilMetricsEntry.value:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics + 132, // 208: api.v1.GetNodeGroupsUtilizationResponse.ReservationTypeToUtilMetricsEntry.value:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics + 132, // 209: api.v1.GetNodeGroupsUtilizationResponse.LogicalAzToUtilMetricsEntry.value:type_name -> api.v1.GetNodeGroupsUtilizationResponse.ListNodeGroupMetrics + 65, // 210: api.v1.GalaxyGetWorkloadPerspectiveResponse.ClustersEntry.value:type_name -> api.v1.Cluster + 161, // 211: api.v1.GalaxyGetWorkloadPerspectiveResponse.WorkloadsEntry.value:type_name -> api.v1.WorkloadItem + 159, // 212: api.v1.MetadataForWorkloadsRequest.WorkloadUidToKindEntry.value:type_name -> api.v1.K8sObjectKind + 106, // 213: api.v1.MetadataForWorkloadsResponse.WorkloadUidToMetadataEntry.value:type_name -> api.v1.WorkloadMetadata + 108, // 214: api.v1.WorkloadMetadata.PodUidToNodeMetadataEntry.value:type_name -> api.v1.NodeMetadata + 107, // 215: api.v1.WorkloadMetadata.PodUidToPodMetadataEntry.value:type_name -> api.v1.PodMetadata + 144, // 216: api.v1.DailyUtilizationResponse.Datapoints.datapoints:type_name -> api.v1.DailyUtilizationResponse.Datapoint + 143, // 217: api.v1.DailyUtilizationResponse.ClusterIdToDailyTotalCoreMinutesEntry.value:type_name -> api.v1.DailyUtilizationResponse.Datapoints + 65, // 218: api.v1.DailyUtilizationResponse.ClusterIdToMetaEntry.value:type_name -> api.v1.Cluster + 148, // 219: api.v1.DailyUtilizationInstanceTypeResponse.Datapoints.datapoints:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.Datapoint + 151, // 220: api.v1.DailyUtilizationInstanceTypeResponse.Datapoint.instance_type_to_daily_total_core_minutes:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.Datapoint.InstanceTypeToDailyTotalCoreMinutesEntry + 147, // 221: api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToDatapointsEntry.value:type_name -> api.v1.DailyUtilizationInstanceTypeResponse.Datapoints + 65, // 222: api.v1.DailyUtilizationInstanceTypeResponse.ClusterIdToMetaEntry.value:type_name -> api.v1.Cluster + 153, // 223: api.v1.DailyUtilizationNodeTypeResponse.Datapoints.datapoints:type_name -> api.v1.DailyUtilizationNodeTypeResponse.Datapoint + 156, // 224: api.v1.DailyUtilizationNodeTypeResponse.Datapoint.node_type_to_daily_total_core_minutes:type_name -> api.v1.DailyUtilizationNodeTypeResponse.Datapoint.NodeTypeToDailyTotalCoreMinutesEntry + 152, // 225: api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToDatapointsEntry.value:type_name -> api.v1.DailyUtilizationNodeTypeResponse.Datapoints + 65, // 226: api.v1.DailyUtilizationNodeTypeResponse.ClusterIdToMetaEntry.value:type_name -> api.v1.Cluster + 120, // 227: api.v1.K8SService.GetWorkloadsStats:input_type -> api.v1.GetWorkloadsStatsRequest + 13, // 228: api.v1.K8SService.GetClusters:input_type -> api.v1.GetClustersRequest + 14, // 229: api.v1.K8SService.ListClusters:input_type -> api.v1.ListClustersRequest + 15, // 230: api.v1.K8SService.GetCluster:input_type -> api.v1.GetClusterRequest + 6, // 231: api.v1.K8SService.GetClusterMetadata:input_type -> api.v1.GetClusterMetadataRequest + 52, // 232: api.v1.K8SService.GetAllNamespaces:input_type -> api.v1.GetAllNamespacesRequest + 54, // 233: api.v1.K8SService.SearchNamespacesByCluster:input_type -> api.v1.SearchNamespacesByClusterRequest + 56, // 234: api.v1.K8SService.ListNamespacesByCluster:input_type -> api.v1.ListNamespacesByClusterRequest + 59, // 235: api.v1.K8SService.GetAllWorkloadNames:input_type -> api.v1.GetAllWorkloadNamesRequest + 61, // 236: api.v1.K8SService.GetAllWorkloadLabels:input_type -> api.v1.GetAllWorkloadLabelsRequest + 63, // 237: api.v1.K8SService.GetAllNodeGroupNames:input_type -> api.v1.GetAllNodeGroupNamesRequest + 97, // 238: api.v1.K8SService.MetadataForWorkloads:input_type -> api.v1.MetadataForWorkloadsRequest + 25, // 239: api.v1.K8SService.GetNodeGroups:input_type -> api.v1.GetNodeGroupsRequest + 26, // 240: api.v1.K8SService.GetAllNodeGroups:input_type -> api.v1.GetAllNodeGroupsRequest + 30, // 241: api.v1.K8SService.GetNodeGroupsUtilization:input_type -> api.v1.GetNodeGroupsUtilizationRequest + 7, // 242: api.v1.K8SService.GetNodeGroup:input_type -> api.v1.GetNodeGroupRequest + 4, // 243: api.v1.K8SService.GetNode:input_type -> api.v1.GetNodeRequest + 8, // 244: api.v1.K8SService.GetWorkloads:input_type -> api.v1.GetWorkloadsRequest + 12, // 245: api.v1.K8SService.GetWorkload:input_type -> api.v1.GetWorkloadRequest + 40, // 246: api.v1.K8SService.GetWorkloadContainerPercentiles:input_type -> api.v1.GetWorkloadContainerPercentilesRequest + 42, // 247: api.v1.K8SService.GetWorkloadContainerFsPercentiles:input_type -> api.v1.GetWorkloadContainerFsPercentilesRequest + 44, // 248: api.v1.K8SService.GetLatestContainerRequestLimits:input_type -> api.v1.GetLatestContainerRequestLimitsRequest + 46, // 249: api.v1.K8SService.GetForecastWorkloads:input_type -> api.v1.GetForecastWorkloadsRequest + 48, // 250: api.v1.K8SService.GetForecastWorkload:input_type -> api.v1.GetForecastWorkloadRequest + 9, // 251: api.v1.K8SService.GetResources:input_type -> api.v1.GetResourcesRequest + 10, // 252: api.v1.K8SService.GetPods:input_type -> api.v1.GetPodsRequest + 68, // 253: api.v1.K8SService.GetLatestOperatorVersion:input_type -> api.v1.GetLatestOperatorVersionRequest + 70, // 254: api.v1.K8SService.GalaxyGetClusterPerspective:input_type -> api.v1.GalaxyGetClusterPerspectiveRequest + 73, // 255: api.v1.K8SService.GalaxyGetNodePerspective:input_type -> api.v1.GalaxyGetNodePerspectiveRequest + 76, // 256: api.v1.K8SService.GalaxyGetWorkloadPerspective:input_type -> api.v1.GalaxyGetWorkloadPerspectiveRequest + 80, // 257: api.v1.K8SService.ListAuditLogs:input_type -> api.v1.ListAuditLogsRequest + 82, // 258: api.v1.K8SService.ListAuditLogOriginators:input_type -> api.v1.ListAuditLogOriginatorsRequest + 84, // 259: api.v1.K8SService.SendWorkloadEmail:input_type -> api.v1.SendWorkloadEmailRequest + 86, // 260: api.v1.K8SService.SendWeeklySummaryEmail:input_type -> api.v1.SendWeeklySummaryEmailRequest + 89, // 261: api.v1.K8SService.GetClustersNodeInfo:input_type -> api.v1.GetClustersNodeInfoRequest + 91, // 262: api.v1.K8SService.SearchK8sResources:input_type -> api.v1.SearchK8sResourcesRequest + 94, // 263: api.v1.K8SService.SearchK8sWorkloads:input_type -> api.v1.SearchK8sWorkloadsRequest + 118, // 264: api.v1.K8SService.GetClusterType:input_type -> api.v1.GetClusterTypeRequest + 109, // 265: api.v1.K8SService.GetRelationsForKind:input_type -> api.v1.GetRelatedResourcesRequest + 128, // 266: api.v1.K8SService.LookupNodeInstance:input_type -> api.v1.LookupNodeInstanceRequest + 5, // 267: api.v1.K8SService.GetWorkloadPodHistory:input_type -> api.v1.GetWorkloadPodHistoryRequest + 99, // 268: api.v1.K8SService.AddClusterTags:input_type -> api.v1.AddClusterTagsRequest + 101, // 269: api.v1.K8SService.RemoveClusterTags:input_type -> api.v1.RemoveClusterTagsRequest + 103, // 270: api.v1.K8SService.ListTags:input_type -> api.v1.ListTagsRequest + 21, // 271: api.v1.ClusterMutationService.CreateCluster:input_type -> api.v1.CreateClusterRequest + 16, // 272: api.v1.ClusterMutationService.DeleteCluster:input_type -> api.v1.DeleteClusterRequest + 18, // 273: api.v1.ClusterMutationService.UpdateCluster:input_type -> api.v1.UpdateClusterRequest + 23, // 274: api.v1.ClusterMutationService.ResetClusterToken:input_type -> api.v1.ResetClusterTokenRequest + 122, // 275: api.v1.UtilizationService.DailyUtilization:input_type -> api.v1.DailyUtilizationRequest + 124, // 276: api.v1.UtilizationService.DailyUtilizationInstanceType:input_type -> api.v1.DailyUtilizationInstanceTypeRequest + 126, // 277: api.v1.UtilizationService.DailyUtilizationNodeType:input_type -> api.v1.DailyUtilizationNodeTypeRequest + 121, // 278: api.v1.K8SService.GetWorkloadsStats:output_type -> api.v1.GetWorkloadsStatsResponse + 35, // 279: api.v1.K8SService.GetClusters:output_type -> api.v1.GetClustersResponse + 36, // 280: api.v1.K8SService.ListClusters:output_type -> api.v1.ListClustersResponse + 34, // 281: api.v1.K8SService.GetCluster:output_type -> api.v1.GetClusterResponse + 50, // 282: api.v1.K8SService.GetClusterMetadata:output_type -> api.v1.GetClusterMetadataResponse + 53, // 283: api.v1.K8SService.GetAllNamespaces:output_type -> api.v1.GetAllNamespacesResponse + 55, // 284: api.v1.K8SService.SearchNamespacesByCluster:output_type -> api.v1.SearchNamespacesByClusterResponse + 57, // 285: api.v1.K8SService.ListNamespacesByCluster:output_type -> api.v1.ListNamespacesByClusterResponse + 60, // 286: api.v1.K8SService.GetAllWorkloadNames:output_type -> api.v1.GetAllWorkloadNamesResponse + 62, // 287: api.v1.K8SService.GetAllWorkloadLabels:output_type -> api.v1.GetAllWorkloadLabelsResponse + 64, // 288: api.v1.K8SService.GetAllNodeGroupNames:output_type -> api.v1.GetAllNodeGroupNamesResponse + 98, // 289: api.v1.K8SService.MetadataForWorkloads:output_type -> api.v1.MetadataForWorkloadsResponse + 27, // 290: api.v1.K8SService.GetNodeGroups:output_type -> api.v1.GetNodeGroupsResponse + 28, // 291: api.v1.K8SService.GetAllNodeGroups:output_type -> api.v1.GetAllNodeGroupsResponse + 31, // 292: api.v1.K8SService.GetNodeGroupsUtilization:output_type -> api.v1.GetNodeGroupsUtilizationResponse + 33, // 293: api.v1.K8SService.GetNodeGroup:output_type -> api.v1.GetNodeGroupResponse + 37, // 294: api.v1.K8SService.GetNode:output_type -> api.v1.GetNodeResponse + 38, // 295: api.v1.K8SService.GetWorkloads:output_type -> api.v1.GetWorkloadsResponse + 39, // 296: api.v1.K8SService.GetWorkload:output_type -> api.v1.GetWorkloadResponse + 41, // 297: api.v1.K8SService.GetWorkloadContainerPercentiles:output_type -> api.v1.GetWorkloadContainerPercentilesResponse + 43, // 298: api.v1.K8SService.GetWorkloadContainerFsPercentiles:output_type -> api.v1.GetWorkloadContainerFsPercentilesResponse + 45, // 299: api.v1.K8SService.GetLatestContainerRequestLimits:output_type -> api.v1.GetLatestContainerRequestLimitsResponse + 47, // 300: api.v1.K8SService.GetForecastWorkloads:output_type -> api.v1.GetForecastWorkloadsResponse + 49, // 301: api.v1.K8SService.GetForecastWorkload:output_type -> api.v1.GetForecastWorkloadResponse + 20, // 302: api.v1.K8SService.GetResources:output_type -> api.v1.GetResourcesResponse + 11, // 303: api.v1.K8SService.GetPods:output_type -> api.v1.GetPodsResponse + 69, // 304: api.v1.K8SService.GetLatestOperatorVersion:output_type -> api.v1.GetLatestOperatorVersionResponse + 71, // 305: api.v1.K8SService.GalaxyGetClusterPerspective:output_type -> api.v1.GalaxyGetClusterPerspectiveResponse + 74, // 306: api.v1.K8SService.GalaxyGetNodePerspective:output_type -> api.v1.GalaxyGetNodePerspectiveResponse + 77, // 307: api.v1.K8SService.GalaxyGetWorkloadPerspective:output_type -> api.v1.GalaxyGetWorkloadPerspectiveResponse + 81, // 308: api.v1.K8SService.ListAuditLogs:output_type -> api.v1.ListAuditLogsResponse + 83, // 309: api.v1.K8SService.ListAuditLogOriginators:output_type -> api.v1.ListAuditLogOriginatorsResponse + 85, // 310: api.v1.K8SService.SendWorkloadEmail:output_type -> api.v1.SendWorkloadEmailResponse + 88, // 311: api.v1.K8SService.SendWeeklySummaryEmail:output_type -> api.v1.SendWeeklySummaryEmailResponse + 90, // 312: api.v1.K8SService.GetClustersNodeInfo:output_type -> api.v1.GetClustersNodeInfoResponse + 92, // 313: api.v1.K8SService.SearchK8sResources:output_type -> api.v1.SearchK8sResourcesResponse + 95, // 314: api.v1.K8SService.SearchK8sWorkloads:output_type -> api.v1.SearchK8sWorkloadsResponse + 119, // 315: api.v1.K8SService.GetClusterType:output_type -> api.v1.GetClusterTypeResponse + 114, // 316: api.v1.K8SService.GetRelationsForKind:output_type -> api.v1.GetRelatedResourcesResponse + 130, // 317: api.v1.K8SService.LookupNodeInstance:output_type -> api.v1.LookupNodeInstanceResponse + 110, // 318: api.v1.K8SService.GetWorkloadPodHistory:output_type -> api.v1.GetWorkloadPodHistoryResponse + 100, // 319: api.v1.K8SService.AddClusterTags:output_type -> api.v1.AddClusterTagsResponse + 102, // 320: api.v1.K8SService.RemoveClusterTags:output_type -> api.v1.RemoveClusterTagsResponse + 105, // 321: api.v1.K8SService.ListTags:output_type -> api.v1.ListTagsResponse + 22, // 322: api.v1.ClusterMutationService.CreateCluster:output_type -> api.v1.CreateClusterResponse + 17, // 323: api.v1.ClusterMutationService.DeleteCluster:output_type -> api.v1.DeleteClusterResponse + 19, // 324: api.v1.ClusterMutationService.UpdateCluster:output_type -> api.v1.UpdateClusterResponse + 24, // 325: api.v1.ClusterMutationService.ResetClusterToken:output_type -> api.v1.ResetClusterTokenResponse + 123, // 326: api.v1.UtilizationService.DailyUtilization:output_type -> api.v1.DailyUtilizationResponse + 125, // 327: api.v1.UtilizationService.DailyUtilizationInstanceType:output_type -> api.v1.DailyUtilizationInstanceTypeResponse + 127, // 328: api.v1.UtilizationService.DailyUtilizationNodeType:output_type -> api.v1.DailyUtilizationNodeTypeResponse + 278, // [278:329] is the sub-list for method output_type + 227, // [227:278] is the sub-list for method input_type + 227, // [227:227] is the sub-list for extension type_name + 227, // [227:227] is the sub-list for extension extendee + 0, // [0:227] is the sub-list for field type_name } func init() { file_api_v1_k8s_proto_init() } @@ -12159,8 +12878,116 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateClusterResponse); i { + file_api_v1_k8s_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateClusterResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetResourcesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateClusterRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateClusterResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ResetClusterTokenRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ResetClusterTokenResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetNodeGroupsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAllNodeGroupsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetNodeGroupsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_api_v1_k8s_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAllNodeGroupsResponse); i { case 0: return &v.state case 1: @@ -12171,8 +12998,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetResourcesResponse); i { + file_api_v1_k8s_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NodeGroupSet); i { case 0: return &v.state case 1: @@ -12183,8 +13010,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateClusterRequest); i { + file_api_v1_k8s_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetNodeGroupsUtilizationRequest); i { case 0: return &v.state case 1: @@ -12195,8 +13022,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateClusterResponse); i { + file_api_v1_k8s_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetNodeGroupsUtilizationResponse); i { case 0: return &v.state case 1: @@ -12207,8 +13034,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResetClusterTokenRequest); i { + file_api_v1_k8s_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NodeGroupMetric); i { case 0: return &v.state case 1: @@ -12219,8 +13046,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResetClusterTokenResponse); i { + file_api_v1_k8s_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetNodeGroupResponse); i { case 0: return &v.state case 1: @@ -12231,8 +13058,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNodeGroupsRequest); i { + file_api_v1_k8s_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetClusterResponse); i { case 0: return &v.state case 1: @@ -12243,8 +13070,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetAllNodeGroupsRequest); i { + file_api_v1_k8s_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetClustersResponse); i { case 0: return &v.state case 1: @@ -12255,8 +13082,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNodeGroupsResponse); i { + file_api_v1_k8s_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListClustersResponse); i { case 0: return &v.state case 1: @@ -12267,8 +13094,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetAllNodeGroupsResponse); i { + file_api_v1_k8s_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetNodeResponse); i { case 0: return &v.state case 1: @@ -12279,8 +13106,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*NodeGroupSet); i { + file_api_v1_k8s_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetWorkloadsResponse); i { case 0: return &v.state case 1: @@ -12291,8 +13118,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNodeGroupsUtilizationRequest); i { + file_api_v1_k8s_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetWorkloadResponse); i { case 0: return &v.state case 1: @@ -12303,8 +13130,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNodeGroupsUtilizationResponse); i { + file_api_v1_k8s_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetWorkloadContainerPercentilesRequest); i { case 0: return &v.state case 1: @@ -12315,8 +13142,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*NodeGroupMetric); i { + file_api_v1_k8s_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetWorkloadContainerPercentilesResponse); i { case 0: return &v.state case 1: @@ -12327,8 +13154,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNodeGroupResponse); i { + file_api_v1_k8s_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetWorkloadContainerFsPercentilesRequest); i { case 0: return &v.state case 1: @@ -12339,8 +13166,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetClusterResponse); i { + file_api_v1_k8s_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetWorkloadContainerFsPercentilesResponse); i { case 0: return &v.state case 1: @@ -12351,8 +13178,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetClustersResponse); i { + file_api_v1_k8s_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetLatestContainerRequestLimitsRequest); i { case 0: return &v.state case 1: @@ -12363,8 +13190,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListClustersResponse); i { + file_api_v1_k8s_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetLatestContainerRequestLimitsResponse); i { case 0: return &v.state case 1: @@ -12375,8 +13202,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNodeResponse); i { + file_api_v1_k8s_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetForecastWorkloadsRequest); i { case 0: return &v.state case 1: @@ -12387,8 +13214,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetWorkloadsResponse); i { + file_api_v1_k8s_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetForecastWorkloadsResponse); i { case 0: return &v.state case 1: @@ -12399,8 +13226,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetWorkloadResponse); i { + file_api_v1_k8s_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetForecastWorkloadRequest); i { case 0: return &v.state case 1: @@ -12411,8 +13238,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetForecastWorkloadsRequest); i { + file_api_v1_k8s_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetForecastWorkloadResponse); i { case 0: return &v.state case 1: @@ -12423,8 +13250,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetForecastWorkloadsResponse); i { + file_api_v1_k8s_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetClusterMetadataResponse); i { case 0: return &v.state case 1: @@ -12435,8 +13262,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetForecastWorkloadRequest); i { + file_api_v1_k8s_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClusterElement); i { case 0: return &v.state case 1: @@ -12447,8 +13274,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetForecastWorkloadResponse); i { + file_api_v1_k8s_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAllNamespacesRequest); i { case 0: return &v.state case 1: @@ -12459,8 +13286,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetClusterMetadataResponse); i { + file_api_v1_k8s_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAllNamespacesResponse); i { case 0: return &v.state case 1: @@ -12471,8 +13298,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ClusterElement); i { + file_api_v1_k8s_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SearchNamespacesByClusterRequest); i { case 0: return &v.state case 1: @@ -12483,8 +13310,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetAllNamespacesRequest); i { + file_api_v1_k8s_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SearchNamespacesByClusterResponse); i { case 0: return &v.state case 1: @@ -12495,8 +13322,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetAllNamespacesResponse); i { + file_api_v1_k8s_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListNamespacesByClusterRequest); i { case 0: return &v.state case 1: @@ -12507,8 +13334,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchNamespacesByClusterRequest); i { + file_api_v1_k8s_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListNamespacesByClusterResponse); i { case 0: return &v.state case 1: @@ -12519,8 +13346,8 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchNamespacesByClusterResponse); i { + file_api_v1_k8s_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NamespaceItem); i { case 0: return &v.state case 1: @@ -12531,7 +13358,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetAllWorkloadNamesRequest); i { case 0: return &v.state @@ -12543,7 +13370,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetAllWorkloadNamesResponse); i { case 0: return &v.state @@ -12555,7 +13382,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetAllWorkloadLabelsRequest); i { case 0: return &v.state @@ -12567,7 +13394,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetAllWorkloadLabelsResponse); i { case 0: return &v.state @@ -12579,7 +13406,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetAllNodeGroupNamesRequest); i { case 0: return &v.state @@ -12591,7 +13418,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetAllNodeGroupNamesResponse); i { case 0: return &v.state @@ -12603,7 +13430,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Cluster); i { case 0: return &v.state @@ -12615,7 +13442,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*OperatorInfo); i { case 0: return &v.state @@ -12627,7 +13454,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Container); i { case 0: return &v.state @@ -12639,7 +13466,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetLatestOperatorVersionRequest); i { case 0: return &v.state @@ -12651,7 +13478,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetLatestOperatorVersionResponse); i { case 0: return &v.state @@ -12663,7 +13490,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyGetClusterPerspectiveRequest); i { case 0: return &v.state @@ -12675,7 +13502,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyGetClusterPerspectiveResponse); i { case 0: return &v.state @@ -12687,7 +13514,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyClusterGroup); i { case 0: return &v.state @@ -12699,7 +13526,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyGetNodePerspectiveRequest); i { case 0: return &v.state @@ -12711,7 +13538,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyGetNodePerspectiveResponse); i { case 0: return &v.state @@ -12723,7 +13550,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyNodeGroup); i { case 0: return &v.state @@ -12735,7 +13562,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyGetWorkloadPerspectiveRequest); i { case 0: return &v.state @@ -12747,7 +13574,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyGetWorkloadPerspectiveResponse); i { case 0: return &v.state @@ -12759,7 +13586,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GalaxyWorkloadGroup); i { case 0: return &v.state @@ -12771,7 +13598,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PerspectiveDatapointOpts); i { case 0: return &v.state @@ -12783,7 +13610,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListAuditLogsRequest); i { case 0: return &v.state @@ -12795,7 +13622,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListAuditLogsResponse); i { case 0: return &v.state @@ -12807,7 +13634,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListAuditLogOriginatorsRequest); i { case 0: return &v.state @@ -12819,7 +13646,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListAuditLogOriginatorsResponse); i { case 0: return &v.state @@ -12831,7 +13658,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendWorkloadEmailRequest); i { case 0: return &v.state @@ -12843,7 +13670,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendWorkloadEmailResponse); i { case 0: return &v.state @@ -12855,7 +13682,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendWeeklySummaryEmailRequest); i { case 0: return &v.state @@ -12867,7 +13694,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendWeeklySummaryEmailRequestData); i { case 0: return &v.state @@ -12879,7 +13706,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendWeeklySummaryEmailResponse); i { case 0: return &v.state @@ -12891,7 +13718,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetClustersNodeInfoRequest); i { case 0: return &v.state @@ -12903,7 +13730,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetClustersNodeInfoResponse); i { case 0: return &v.state @@ -12915,7 +13742,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SearchK8SResourcesRequest); i { case 0: return &v.state @@ -12927,7 +13754,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SearchK8SResourcesResponse); i { case 0: return &v.state @@ -12939,7 +13766,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*K8SSearchResult); i { case 0: return &v.state @@ -12951,7 +13778,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SearchK8SWorkloadsRequest); i { case 0: return &v.state @@ -12963,7 +13790,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SearchK8SWorkloadsResponse); i { case 0: return &v.state @@ -12975,7 +13802,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*K8SWorkloadSearchResult); i { case 0: return &v.state @@ -12987,7 +13814,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MetadataForWorkloadsRequest); i { case 0: return &v.state @@ -12999,7 +13826,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MetadataForWorkloadsResponse); i { case 0: return &v.state @@ -13011,7 +13838,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AddClusterTagsRequest); i { case 0: return &v.state @@ -13023,7 +13850,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AddClusterTagsResponse); i { case 0: return &v.state @@ -13035,7 +13862,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RemoveClusterTagsRequest); i { case 0: return &v.state @@ -13047,7 +13874,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RemoveClusterTagsResponse); i { case 0: return &v.state @@ -13059,7 +13886,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListTagsRequest); i { case 0: return &v.state @@ -13071,7 +13898,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TagSummary); i { case 0: return &v.state @@ -13083,7 +13910,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListTagsResponse); i { case 0: return &v.state @@ -13095,7 +13922,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkloadMetadata); i { case 0: return &v.state @@ -13107,7 +13934,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PodMetadata); i { case 0: return &v.state @@ -13119,7 +13946,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeMetadata); i { case 0: return &v.state @@ -13131,7 +13958,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetRelatedResourcesRequest); i { case 0: return &v.state @@ -13143,7 +13970,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetWorkloadPodHistoryResponse); i { case 0: return &v.state @@ -13155,7 +13982,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*JobHistory); i { case 0: return &v.state @@ -13167,7 +13994,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReplicaSetHistory); i { case 0: return &v.state @@ -13179,7 +14006,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PodHistory); i { case 0: return &v.state @@ -13191,7 +14018,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetRelatedResourcesResponse); i { case 0: return &v.state @@ -13203,7 +14030,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*K8SRelatedResource); i { case 0: return &v.state @@ -13215,7 +14042,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*K8SResourceNode); i { case 0: return &v.state @@ -13227,7 +14054,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*K8SResourceEdge); i { case 0: return &v.state @@ -13239,7 +14066,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetClusterTypeRequest); i { case 0: return &v.state @@ -13251,7 +14078,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetClusterTypeResponse); i { case 0: return &v.state @@ -13263,7 +14090,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetWorkloadsStatsRequest); i { case 0: return &v.state @@ -13275,7 +14102,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetWorkloadsStatsResponse); i { case 0: return &v.state @@ -13287,7 +14114,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationRequest); i { case 0: return &v.state @@ -13299,7 +14126,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationResponse); i { case 0: return &v.state @@ -13311,7 +14138,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationInstanceTypeRequest); i { case 0: return &v.state @@ -13323,7 +14150,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationInstanceTypeResponse); i { case 0: return &v.state @@ -13335,7 +14162,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationNodeTypeRequest); i { case 0: return &v.state @@ -13347,7 +14174,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationNodeTypeResponse); i { case 0: return &v.state @@ -13359,7 +14186,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LookupNodeInstanceRequest); i { case 0: return &v.state @@ -13371,7 +14198,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*InstanceLookupParams); i { case 0: return &v.state @@ -13383,7 +14210,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LookupNodeInstanceResponse); i { case 0: return &v.state @@ -13395,7 +14222,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetNodeGroupsUtilizationResponse_ListNodeGroupMetrics); i { case 0: return &v.state @@ -13407,7 +14234,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[130].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[139].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationResponse_Datapoints); i { case 0: return &v.state @@ -13419,7 +14246,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[131].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[140].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationResponse_Datapoint); i { case 0: return &v.state @@ -13431,7 +14258,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[134].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[143].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationInstanceTypeResponse_Datapoints); i { case 0: return &v.state @@ -13443,7 +14270,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[135].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[144].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationInstanceTypeResponse_Datapoint); i { case 0: return &v.state @@ -13455,7 +14282,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[139].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[148].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationNodeTypeResponse_Datapoints); i { case 0: return &v.state @@ -13467,7 +14294,7 @@ func file_api_v1_k8s_proto_init() { return nil } } - file_api_v1_k8s_proto_msgTypes[140].Exporter = func(v interface{}, i int) interface{} { + file_api_v1_k8s_proto_msgTypes[149].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DailyUtilizationNodeTypeResponse_Datapoint); i { case 0: return &v.state @@ -13494,19 +14321,21 @@ func file_api_v1_k8s_proto_init() { file_api_v1_k8s_proto_msgTypes[26].OneofWrappers = []interface{}{} file_api_v1_k8s_proto_msgTypes[36].OneofWrappers = []interface{}{} file_api_v1_k8s_proto_msgTypes[38].OneofWrappers = []interface{}{} - file_api_v1_k8s_proto_msgTypes[52].OneofWrappers = []interface{}{} - file_api_v1_k8s_proto_msgTypes[67].OneofWrappers = []interface{}{} - file_api_v1_k8s_proto_msgTypes[69].OneofWrappers = []interface{}{} + file_api_v1_k8s_proto_msgTypes[42].OneofWrappers = []interface{}{} + file_api_v1_k8s_proto_msgTypes[44].OneofWrappers = []interface{}{} + file_api_v1_k8s_proto_msgTypes[61].OneofWrappers = []interface{}{} file_api_v1_k8s_proto_msgTypes[76].OneofWrappers = []interface{}{} - file_api_v1_k8s_proto_msgTypes[96].OneofWrappers = []interface{}{} - file_api_v1_k8s_proto_msgTypes[107].OneofWrappers = []interface{}{} + file_api_v1_k8s_proto_msgTypes[78].OneofWrappers = []interface{}{} + file_api_v1_k8s_proto_msgTypes[85].OneofWrappers = []interface{}{} + file_api_v1_k8s_proto_msgTypes[105].OneofWrappers = []interface{}{} + file_api_v1_k8s_proto_msgTypes[116].OneofWrappers = []interface{}{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_api_v1_k8s_proto_rawDesc, NumEnums: 4, - NumMessages: 144, + NumMessages: 153, NumExtensions: 0, NumServices: 3, }, diff --git a/gen/api/v1/k8s_grpc.pb.go b/gen/api/v1/k8s_grpc.pb.go index 34b30db3..db53c779 100644 --- a/gen/api/v1/k8s_grpc.pb.go +++ b/gen/api/v1/k8s_grpc.pb.go @@ -19,46 +19,50 @@ import ( const _ = grpc.SupportPackageIsVersion7 const ( - K8SService_GetWorkloadsStats_FullMethodName = "/api.v1.K8SService/GetWorkloadsStats" - K8SService_GetClusters_FullMethodName = "/api.v1.K8SService/GetClusters" - K8SService_ListClusters_FullMethodName = "/api.v1.K8SService/ListClusters" - K8SService_GetCluster_FullMethodName = "/api.v1.K8SService/GetCluster" - K8SService_GetClusterMetadata_FullMethodName = "/api.v1.K8SService/GetClusterMetadata" - K8SService_GetAllNamespaces_FullMethodName = "/api.v1.K8SService/GetAllNamespaces" - K8SService_SearchNamespacesByCluster_FullMethodName = "/api.v1.K8SService/SearchNamespacesByCluster" - K8SService_GetAllWorkloadNames_FullMethodName = "/api.v1.K8SService/GetAllWorkloadNames" - K8SService_GetAllWorkloadLabels_FullMethodName = "/api.v1.K8SService/GetAllWorkloadLabels" - K8SService_GetAllNodeGroupNames_FullMethodName = "/api.v1.K8SService/GetAllNodeGroupNames" - K8SService_MetadataForWorkloads_FullMethodName = "/api.v1.K8SService/MetadataForWorkloads" - K8SService_GetNodeGroups_FullMethodName = "/api.v1.K8SService/GetNodeGroups" - K8SService_GetAllNodeGroups_FullMethodName = "/api.v1.K8SService/GetAllNodeGroups" - K8SService_GetNodeGroupsUtilization_FullMethodName = "/api.v1.K8SService/GetNodeGroupsUtilization" - K8SService_GetNodeGroup_FullMethodName = "/api.v1.K8SService/GetNodeGroup" - K8SService_GetNode_FullMethodName = "/api.v1.K8SService/GetNode" - K8SService_GetWorkloads_FullMethodName = "/api.v1.K8SService/GetWorkloads" - K8SService_GetWorkload_FullMethodName = "/api.v1.K8SService/GetWorkload" - K8SService_GetForecastWorkloads_FullMethodName = "/api.v1.K8SService/GetForecastWorkloads" - K8SService_GetForecastWorkload_FullMethodName = "/api.v1.K8SService/GetForecastWorkload" - K8SService_GetResources_FullMethodName = "/api.v1.K8SService/GetResources" - K8SService_GetPods_FullMethodName = "/api.v1.K8SService/GetPods" - K8SService_GetLatestOperatorVersion_FullMethodName = "/api.v1.K8SService/GetLatestOperatorVersion" - K8SService_GalaxyGetClusterPerspective_FullMethodName = "/api.v1.K8SService/GalaxyGetClusterPerspective" - K8SService_GalaxyGetNodePerspective_FullMethodName = "/api.v1.K8SService/GalaxyGetNodePerspective" - K8SService_GalaxyGetWorkloadPerspective_FullMethodName = "/api.v1.K8SService/GalaxyGetWorkloadPerspective" - K8SService_ListAuditLogs_FullMethodName = "/api.v1.K8SService/ListAuditLogs" - K8SService_ListAuditLogOriginators_FullMethodName = "/api.v1.K8SService/ListAuditLogOriginators" - K8SService_SendWorkloadEmail_FullMethodName = "/api.v1.K8SService/SendWorkloadEmail" - K8SService_SendWeeklySummaryEmail_FullMethodName = "/api.v1.K8SService/SendWeeklySummaryEmail" - K8SService_GetClustersNodeInfo_FullMethodName = "/api.v1.K8SService/GetClustersNodeInfo" - K8SService_SearchK8SResources_FullMethodName = "/api.v1.K8SService/SearchK8sResources" - K8SService_SearchK8SWorkloads_FullMethodName = "/api.v1.K8SService/SearchK8sWorkloads" - K8SService_GetClusterType_FullMethodName = "/api.v1.K8SService/GetClusterType" - K8SService_GetRelationsForKind_FullMethodName = "/api.v1.K8SService/GetRelationsForKind" - K8SService_LookupNodeInstance_FullMethodName = "/api.v1.K8SService/LookupNodeInstance" - K8SService_GetWorkloadPodHistory_FullMethodName = "/api.v1.K8SService/GetWorkloadPodHistory" - K8SService_AddClusterTags_FullMethodName = "/api.v1.K8SService/AddClusterTags" - K8SService_RemoveClusterTags_FullMethodName = "/api.v1.K8SService/RemoveClusterTags" - K8SService_ListTags_FullMethodName = "/api.v1.K8SService/ListTags" + K8SService_GetWorkloadsStats_FullMethodName = "/api.v1.K8SService/GetWorkloadsStats" + K8SService_GetClusters_FullMethodName = "/api.v1.K8SService/GetClusters" + K8SService_ListClusters_FullMethodName = "/api.v1.K8SService/ListClusters" + K8SService_GetCluster_FullMethodName = "/api.v1.K8SService/GetCluster" + K8SService_GetClusterMetadata_FullMethodName = "/api.v1.K8SService/GetClusterMetadata" + K8SService_GetAllNamespaces_FullMethodName = "/api.v1.K8SService/GetAllNamespaces" + K8SService_SearchNamespacesByCluster_FullMethodName = "/api.v1.K8SService/SearchNamespacesByCluster" + K8SService_ListNamespacesByCluster_FullMethodName = "/api.v1.K8SService/ListNamespacesByCluster" + K8SService_GetAllWorkloadNames_FullMethodName = "/api.v1.K8SService/GetAllWorkloadNames" + K8SService_GetAllWorkloadLabels_FullMethodName = "/api.v1.K8SService/GetAllWorkloadLabels" + K8SService_GetAllNodeGroupNames_FullMethodName = "/api.v1.K8SService/GetAllNodeGroupNames" + K8SService_MetadataForWorkloads_FullMethodName = "/api.v1.K8SService/MetadataForWorkloads" + K8SService_GetNodeGroups_FullMethodName = "/api.v1.K8SService/GetNodeGroups" + K8SService_GetAllNodeGroups_FullMethodName = "/api.v1.K8SService/GetAllNodeGroups" + K8SService_GetNodeGroupsUtilization_FullMethodName = "/api.v1.K8SService/GetNodeGroupsUtilization" + K8SService_GetNodeGroup_FullMethodName = "/api.v1.K8SService/GetNodeGroup" + K8SService_GetNode_FullMethodName = "/api.v1.K8SService/GetNode" + K8SService_GetWorkloads_FullMethodName = "/api.v1.K8SService/GetWorkloads" + K8SService_GetWorkload_FullMethodName = "/api.v1.K8SService/GetWorkload" + K8SService_GetWorkloadContainerPercentiles_FullMethodName = "/api.v1.K8SService/GetWorkloadContainerPercentiles" + K8SService_GetWorkloadContainerFsPercentiles_FullMethodName = "/api.v1.K8SService/GetWorkloadContainerFsPercentiles" + K8SService_GetLatestContainerRequestLimits_FullMethodName = "/api.v1.K8SService/GetLatestContainerRequestLimits" + K8SService_GetForecastWorkloads_FullMethodName = "/api.v1.K8SService/GetForecastWorkloads" + K8SService_GetForecastWorkload_FullMethodName = "/api.v1.K8SService/GetForecastWorkload" + K8SService_GetResources_FullMethodName = "/api.v1.K8SService/GetResources" + K8SService_GetPods_FullMethodName = "/api.v1.K8SService/GetPods" + K8SService_GetLatestOperatorVersion_FullMethodName = "/api.v1.K8SService/GetLatestOperatorVersion" + K8SService_GalaxyGetClusterPerspective_FullMethodName = "/api.v1.K8SService/GalaxyGetClusterPerspective" + K8SService_GalaxyGetNodePerspective_FullMethodName = "/api.v1.K8SService/GalaxyGetNodePerspective" + K8SService_GalaxyGetWorkloadPerspective_FullMethodName = "/api.v1.K8SService/GalaxyGetWorkloadPerspective" + K8SService_ListAuditLogs_FullMethodName = "/api.v1.K8SService/ListAuditLogs" + K8SService_ListAuditLogOriginators_FullMethodName = "/api.v1.K8SService/ListAuditLogOriginators" + K8SService_SendWorkloadEmail_FullMethodName = "/api.v1.K8SService/SendWorkloadEmail" + K8SService_SendWeeklySummaryEmail_FullMethodName = "/api.v1.K8SService/SendWeeklySummaryEmail" + K8SService_GetClustersNodeInfo_FullMethodName = "/api.v1.K8SService/GetClustersNodeInfo" + K8SService_SearchK8SResources_FullMethodName = "/api.v1.K8SService/SearchK8sResources" + K8SService_SearchK8SWorkloads_FullMethodName = "/api.v1.K8SService/SearchK8sWorkloads" + K8SService_GetClusterType_FullMethodName = "/api.v1.K8SService/GetClusterType" + K8SService_GetRelationsForKind_FullMethodName = "/api.v1.K8SService/GetRelationsForKind" + K8SService_LookupNodeInstance_FullMethodName = "/api.v1.K8SService/LookupNodeInstance" + K8SService_GetWorkloadPodHistory_FullMethodName = "/api.v1.K8SService/GetWorkloadPodHistory" + K8SService_AddClusterTags_FullMethodName = "/api.v1.K8SService/AddClusterTags" + K8SService_RemoveClusterTags_FullMethodName = "/api.v1.K8SService/RemoveClusterTags" + K8SService_ListTags_FullMethodName = "/api.v1.K8SService/ListTags" ) // K8SServiceClient is the client API for K8SService service. @@ -81,6 +85,8 @@ type K8SServiceClient interface { GetAllNamespaces(ctx context.Context, in *GetAllNamespacesRequest, opts ...grpc.CallOption) (*GetAllNamespacesResponse, error) // SearchNamespacesByCluster searches namespaces by name within a single cluster. SearchNamespacesByCluster(ctx context.Context, in *SearchNamespacesByClusterRequest, opts ...grpc.CallOption) (*SearchNamespacesByClusterResponse, error) + // ListNamespacesByCluster lists namespaces (id and name) within a single cluster. + ListNamespacesByCluster(ctx context.Context, in *ListNamespacesByClusterRequest, opts ...grpc.CallOption) (*ListNamespacesByClusterResponse, error) // GetAllWorkloadNames returns a list of all workload names for a team ID; if cluster list is empty, returns all. GetAllWorkloadNames(ctx context.Context, in *GetAllWorkloadNamesRequest, opts ...grpc.CallOption) (*GetAllWorkloadNamesResponse, error) // GetAllWorkloadLabels returns all workload labels for a team ID; if cluster list is empty, returns all. @@ -102,6 +108,16 @@ type K8SServiceClient interface { GetWorkloads(ctx context.Context, in *GetWorkloadsRequest, opts ...grpc.CallOption) (*GetWorkloadsResponse, error) // GetWorkload retrieves detailed information for a specific workload. GetWorkload(ctx context.Context, in *GetWorkloadRequest, opts ...grpc.CallOption) (*GetWorkloadResponse, error) + // GetWorkloadContainerPercentiles retrieves per-container percentile metrics for a workload. + // + // Note: fs_* and current_* fields in the response are no longer populated. + // Prefer GetWorkloadContainerFsPercentiles and GetLatestContainerRequestLimits + // for progressive loading. + GetWorkloadContainerPercentiles(ctx context.Context, in *GetWorkloadContainerPercentilesRequest, opts ...grpc.CallOption) (*GetWorkloadContainerPercentilesResponse, error) + // GetWorkloadContainerFsPercentiles retrieves per-container filesystem I/O percentiles for a workload. + GetWorkloadContainerFsPercentiles(ctx context.Context, in *GetWorkloadContainerFsPercentilesRequest, opts ...grpc.CallOption) (*GetWorkloadContainerFsPercentilesResponse, error) + // GetLatestContainerRequestLimits retrieves the most recent request/limit values per container for a workload. + GetLatestContainerRequestLimits(ctx context.Context, in *GetLatestContainerRequestLimitsRequest, opts ...grpc.CallOption) (*GetLatestContainerRequestLimitsResponse, error) // Deprecated: Do not use. // GetForecastWorkloads retrieves all workloads for a specific cluster. GetForecastWorkloads(ctx context.Context, in *GetForecastWorkloadsRequest, opts ...grpc.CallOption) (*GetForecastWorkloadsResponse, error) @@ -213,6 +229,15 @@ func (c *k8SServiceClient) SearchNamespacesByCluster(ctx context.Context, in *Se return out, nil } +func (c *k8SServiceClient) ListNamespacesByCluster(ctx context.Context, in *ListNamespacesByClusterRequest, opts ...grpc.CallOption) (*ListNamespacesByClusterResponse, error) { + out := new(ListNamespacesByClusterResponse) + err := c.cc.Invoke(ctx, K8SService_ListNamespacesByCluster_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *k8SServiceClient) GetAllWorkloadNames(ctx context.Context, in *GetAllWorkloadNamesRequest, opts ...grpc.CallOption) (*GetAllWorkloadNamesResponse, error) { out := new(GetAllWorkloadNamesResponse) err := c.cc.Invoke(ctx, K8SService_GetAllWorkloadNames_FullMethodName, in, out, opts...) @@ -312,6 +337,33 @@ func (c *k8SServiceClient) GetWorkload(ctx context.Context, in *GetWorkloadReque return out, nil } +func (c *k8SServiceClient) GetWorkloadContainerPercentiles(ctx context.Context, in *GetWorkloadContainerPercentilesRequest, opts ...grpc.CallOption) (*GetWorkloadContainerPercentilesResponse, error) { + out := new(GetWorkloadContainerPercentilesResponse) + err := c.cc.Invoke(ctx, K8SService_GetWorkloadContainerPercentiles_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *k8SServiceClient) GetWorkloadContainerFsPercentiles(ctx context.Context, in *GetWorkloadContainerFsPercentilesRequest, opts ...grpc.CallOption) (*GetWorkloadContainerFsPercentilesResponse, error) { + out := new(GetWorkloadContainerFsPercentilesResponse) + err := c.cc.Invoke(ctx, K8SService_GetWorkloadContainerFsPercentiles_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *k8SServiceClient) GetLatestContainerRequestLimits(ctx context.Context, in *GetLatestContainerRequestLimitsRequest, opts ...grpc.CallOption) (*GetLatestContainerRequestLimitsResponse, error) { + out := new(GetLatestContainerRequestLimitsResponse) + err := c.cc.Invoke(ctx, K8SService_GetLatestContainerRequestLimits_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // Deprecated: Do not use. func (c *k8SServiceClient) GetForecastWorkloads(ctx context.Context, in *GetForecastWorkloadsRequest, opts ...grpc.CallOption) (*GetForecastWorkloadsResponse, error) { out := new(GetForecastWorkloadsResponse) @@ -532,6 +584,8 @@ type K8SServiceServer interface { GetAllNamespaces(context.Context, *GetAllNamespacesRequest) (*GetAllNamespacesResponse, error) // SearchNamespacesByCluster searches namespaces by name within a single cluster. SearchNamespacesByCluster(context.Context, *SearchNamespacesByClusterRequest) (*SearchNamespacesByClusterResponse, error) + // ListNamespacesByCluster lists namespaces (id and name) within a single cluster. + ListNamespacesByCluster(context.Context, *ListNamespacesByClusterRequest) (*ListNamespacesByClusterResponse, error) // GetAllWorkloadNames returns a list of all workload names for a team ID; if cluster list is empty, returns all. GetAllWorkloadNames(context.Context, *GetAllWorkloadNamesRequest) (*GetAllWorkloadNamesResponse, error) // GetAllWorkloadLabels returns all workload labels for a team ID; if cluster list is empty, returns all. @@ -553,6 +607,16 @@ type K8SServiceServer interface { GetWorkloads(context.Context, *GetWorkloadsRequest) (*GetWorkloadsResponse, error) // GetWorkload retrieves detailed information for a specific workload. GetWorkload(context.Context, *GetWorkloadRequest) (*GetWorkloadResponse, error) + // GetWorkloadContainerPercentiles retrieves per-container percentile metrics for a workload. + // + // Note: fs_* and current_* fields in the response are no longer populated. + // Prefer GetWorkloadContainerFsPercentiles and GetLatestContainerRequestLimits + // for progressive loading. + GetWorkloadContainerPercentiles(context.Context, *GetWorkloadContainerPercentilesRequest) (*GetWorkloadContainerPercentilesResponse, error) + // GetWorkloadContainerFsPercentiles retrieves per-container filesystem I/O percentiles for a workload. + GetWorkloadContainerFsPercentiles(context.Context, *GetWorkloadContainerFsPercentilesRequest) (*GetWorkloadContainerFsPercentilesResponse, error) + // GetLatestContainerRequestLimits retrieves the most recent request/limit values per container for a workload. + GetLatestContainerRequestLimits(context.Context, *GetLatestContainerRequestLimitsRequest) (*GetLatestContainerRequestLimitsResponse, error) // Deprecated: Do not use. // GetForecastWorkloads retrieves all workloads for a specific cluster. GetForecastWorkloads(context.Context, *GetForecastWorkloadsRequest) (*GetForecastWorkloadsResponse, error) @@ -618,6 +682,9 @@ func (UnimplementedK8SServiceServer) GetAllNamespaces(context.Context, *GetAllNa func (UnimplementedK8SServiceServer) SearchNamespacesByCluster(context.Context, *SearchNamespacesByClusterRequest) (*SearchNamespacesByClusterResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SearchNamespacesByCluster not implemented") } +func (UnimplementedK8SServiceServer) ListNamespacesByCluster(context.Context, *ListNamespacesByClusterRequest) (*ListNamespacesByClusterResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListNamespacesByCluster not implemented") +} func (UnimplementedK8SServiceServer) GetAllWorkloadNames(context.Context, *GetAllWorkloadNamesRequest) (*GetAllWorkloadNamesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetAllWorkloadNames not implemented") } @@ -651,6 +718,15 @@ func (UnimplementedK8SServiceServer) GetWorkloads(context.Context, *GetWorkloads func (UnimplementedK8SServiceServer) GetWorkload(context.Context, *GetWorkloadRequest) (*GetWorkloadResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetWorkload not implemented") } +func (UnimplementedK8SServiceServer) GetWorkloadContainerPercentiles(context.Context, *GetWorkloadContainerPercentilesRequest) (*GetWorkloadContainerPercentilesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetWorkloadContainerPercentiles not implemented") +} +func (UnimplementedK8SServiceServer) GetWorkloadContainerFsPercentiles(context.Context, *GetWorkloadContainerFsPercentilesRequest) (*GetWorkloadContainerFsPercentilesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetWorkloadContainerFsPercentiles not implemented") +} +func (UnimplementedK8SServiceServer) GetLatestContainerRequestLimits(context.Context, *GetLatestContainerRequestLimitsRequest) (*GetLatestContainerRequestLimitsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLatestContainerRequestLimits not implemented") +} func (UnimplementedK8SServiceServer) GetForecastWorkloads(context.Context, *GetForecastWorkloadsRequest) (*GetForecastWorkloadsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetForecastWorkloads not implemented") } @@ -856,6 +932,24 @@ func _K8SService_SearchNamespacesByCluster_Handler(srv interface{}, ctx context. return interceptor(ctx, in, info, handler) } +func _K8SService_ListNamespacesByCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListNamespacesByClusterRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(K8SServiceServer).ListNamespacesByCluster(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: K8SService_ListNamespacesByCluster_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(K8SServiceServer).ListNamespacesByCluster(ctx, req.(*ListNamespacesByClusterRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _K8SService_GetAllWorkloadNames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetAllWorkloadNamesRequest) if err := dec(in); err != nil { @@ -1054,6 +1148,60 @@ func _K8SService_GetWorkload_Handler(srv interface{}, ctx context.Context, dec f return interceptor(ctx, in, info, handler) } +func _K8SService_GetWorkloadContainerPercentiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetWorkloadContainerPercentilesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(K8SServiceServer).GetWorkloadContainerPercentiles(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: K8SService_GetWorkloadContainerPercentiles_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(K8SServiceServer).GetWorkloadContainerPercentiles(ctx, req.(*GetWorkloadContainerPercentilesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _K8SService_GetWorkloadContainerFsPercentiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetWorkloadContainerFsPercentilesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(K8SServiceServer).GetWorkloadContainerFsPercentiles(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: K8SService_GetWorkloadContainerFsPercentiles_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(K8SServiceServer).GetWorkloadContainerFsPercentiles(ctx, req.(*GetWorkloadContainerFsPercentilesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _K8SService_GetLatestContainerRequestLimits_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetLatestContainerRequestLimitsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(K8SServiceServer).GetLatestContainerRequestLimits(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: K8SService_GetLatestContainerRequestLimits_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(K8SServiceServer).GetLatestContainerRequestLimits(ctx, req.(*GetLatestContainerRequestLimitsRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _K8SService_GetForecastWorkloads_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetForecastWorkloadsRequest) if err := dec(in); err != nil { @@ -1485,6 +1633,10 @@ var K8SService_ServiceDesc = grpc.ServiceDesc{ MethodName: "SearchNamespacesByCluster", Handler: _K8SService_SearchNamespacesByCluster_Handler, }, + { + MethodName: "ListNamespacesByCluster", + Handler: _K8SService_ListNamespacesByCluster_Handler, + }, { MethodName: "GetAllWorkloadNames", Handler: _K8SService_GetAllWorkloadNames_Handler, @@ -1529,6 +1681,18 @@ var K8SService_ServiceDesc = grpc.ServiceDesc{ MethodName: "GetWorkload", Handler: _K8SService_GetWorkload_Handler, }, + { + MethodName: "GetWorkloadContainerPercentiles", + Handler: _K8SService_GetWorkloadContainerPercentiles_Handler, + }, + { + MethodName: "GetWorkloadContainerFsPercentiles", + Handler: _K8SService_GetWorkloadContainerFsPercentiles_Handler, + }, + { + MethodName: "GetLatestContainerRequestLimits", + Handler: _K8SService_GetLatestContainerRequestLimits_Handler, + }, { MethodName: "GetForecastWorkloads", Handler: _K8SService_GetForecastWorkloads_Handler, diff --git a/gen/api/v1/metrics_collector.pb.go b/gen/api/v1/metrics_collector.pb.go index f3fa9cea..dcde71ad 100644 --- a/gen/api/v1/metrics_collector.pb.go +++ b/gen/api/v1/metrics_collector.pb.go @@ -195,6 +195,8 @@ const ( ResourceType_RESOURCE_TYPE_CONTAINER_CRASHLOOP_EVENT ResourceType = 61 ResourceType_RESOURCE_TYPE_CONTAINER_STARTUP_LIFECYCLE ResourceType = 62 ResourceType_RESOURCE_TYPE_CONTAINER_CPU_THROTTLE_EVENT ResourceType = 63 + // Image analysis results from dive (ImageAnalysisResult CRD) + ResourceType_RESOURCE_TYPE_IMAGE_ANALYSIS_RESULT ResourceType = 64 // Cluster snapshot type ResourceType_RESOURCE_TYPE_CLUSTER_SNAPSHOT ResourceType = 77 ) @@ -266,6 +268,7 @@ var ( 61: "RESOURCE_TYPE_CONTAINER_CRASHLOOP_EVENT", 62: "RESOURCE_TYPE_CONTAINER_STARTUP_LIFECYCLE", 63: "RESOURCE_TYPE_CONTAINER_CPU_THROTTLE_EVENT", + 64: "RESOURCE_TYPE_IMAGE_ANALYSIS_RESULT", 77: "RESOURCE_TYPE_CLUSTER_SNAPSHOT", } ResourceType_value = map[string]int32{ @@ -333,6 +336,7 @@ var ( "RESOURCE_TYPE_CONTAINER_CRASHLOOP_EVENT": 61, "RESOURCE_TYPE_CONTAINER_STARTUP_LIFECYCLE": 62, "RESOURCE_TYPE_CONTAINER_CPU_THROTTLE_EVENT": 63, + "RESOURCE_TYPE_IMAGE_ANALYSIS_RESULT": 64, "RESOURCE_TYPE_CLUSTER_SNAPSHOT": 77, } ) @@ -3575,7 +3579,7 @@ var file_api_v1_metrics_collector_proto_rawDesc = []byte{ 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x41, 0x52, 0x54, 0x45, 0x44, 0x10, 0x08, 0x12, 0x1f, 0x0a, 0x1b, 0x45, 0x56, 0x45, 0x4e, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x53, 0x4e, - 0x41, 0x50, 0x53, 0x48, 0x4f, 0x54, 0x10, 0x09, 0x2a, 0xb7, 0x11, 0x0a, 0x0c, 0x52, 0x65, 0x73, + 0x41, 0x50, 0x53, 0x48, 0x4f, 0x54, 0x10, 0x09, 0x2a, 0xe0, 0x11, 0x0a, 0x0c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x52, 0x45, 0x53, 0x4f, @@ -3712,70 +3716,73 @@ var file_api_v1_metrics_collector_proto_rawDesc = []byte{ 0x55, 0x50, 0x5f, 0x4c, 0x49, 0x46, 0x45, 0x43, 0x59, 0x43, 0x4c, 0x45, 0x10, 0x3e, 0x12, 0x2e, 0x0a, 0x2a, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x45, 0x52, 0x5f, 0x43, 0x50, 0x55, 0x5f, 0x54, 0x48, - 0x52, 0x4f, 0x54, 0x54, 0x4c, 0x45, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, 0x10, 0x3f, 0x12, 0x22, - 0x0a, 0x1e, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x53, 0x4e, 0x41, 0x50, 0x53, 0x48, 0x4f, 0x54, - 0x10, 0x4d, 0x2a, 0x8c, 0x01, 0x0a, 0x08, 0x4c, 0x6f, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, - 0x19, 0x0a, 0x15, 0x4c, 0x4f, 0x47, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x55, 0x4e, 0x53, - 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x4f, - 0x47, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x44, 0x45, 0x42, 0x55, 0x47, 0x10, 0x01, 0x12, - 0x12, 0x0a, 0x0e, 0x4c, 0x4f, 0x47, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x49, 0x4e, 0x46, - 0x4f, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x4f, 0x47, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, - 0x5f, 0x57, 0x41, 0x52, 0x4e, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x4f, 0x47, 0x5f, 0x4c, - 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, - 0x4c, 0x4f, 0x47, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x46, 0x41, 0x54, 0x41, 0x4c, 0x10, - 0x05, 0x32, 0xa0, 0x05, 0x0a, 0x17, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6c, - 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x49, 0x0a, - 0x0c, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x1b, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, - 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x20, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x21, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, - 0x74, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x23, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, - 0x79, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x65, 0x6c, - 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x66, 0x0a, 0x19, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x12, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x43, 0x68, 0x75, 0x6e, 0x6b, - 0x1a, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x74, 0x72, - 0x65, 0x61, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x28, 0x01, 0x12, 0x58, 0x0a, - 0x11, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x4c, 0x6f, - 0x67, 0x73, 0x12, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, - 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, - 0x6e, 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x4c, 0x6f, 0x67, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x70, 0x0a, 0x19, 0x53, 0x65, 0x6e, 0x64, 0x4e, - 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x4d, 0x65, 0x74, - 0x72, 0x69, 0x63, 0x73, 0x12, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, - 0x6e, 0x64, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, - 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x4e, 0x65, 0x74, 0x77, - 0x6f, 0x72, 0x6b, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x0c, 0x4e, 0x6f, 0x64, - 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x8e, 0x01, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x69, - 0x2e, 0x76, 0x31, 0x42, 0x15, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x30, 0x67, 0x69, - 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x65, 0x76, 0x7a, 0x65, 0x72, 0x6f, - 0x2d, 0x69, 0x6e, 0x63, 0x2f, 0x7a, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x67, 0x65, - 0x6e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x3b, 0x61, 0x70, 0x69, 0x76, 0x31, 0xa2, 0x02, - 0x03, 0x41, 0x58, 0x58, 0xaa, 0x02, 0x06, 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, - 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x12, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0x5c, - 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x41, 0x70, - 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x52, 0x4f, 0x54, 0x54, 0x4c, 0x45, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, 0x10, 0x3f, 0x12, 0x27, + 0x0a, 0x23, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x49, 0x4d, 0x41, 0x47, 0x45, 0x5f, 0x41, 0x4e, 0x41, 0x4c, 0x59, 0x53, 0x49, 0x53, 0x5f, 0x52, + 0x45, 0x53, 0x55, 0x4c, 0x54, 0x10, 0x40, 0x12, 0x22, 0x0a, 0x1e, 0x52, 0x45, 0x53, 0x4f, 0x55, + 0x52, 0x43, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, + 0x5f, 0x53, 0x4e, 0x41, 0x50, 0x53, 0x48, 0x4f, 0x54, 0x10, 0x4d, 0x2a, 0x8c, 0x01, 0x0a, 0x08, + 0x4c, 0x6f, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x19, 0x0a, 0x15, 0x4c, 0x4f, 0x47, 0x5f, + 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, + 0x44, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x4f, 0x47, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, + 0x5f, 0x44, 0x45, 0x42, 0x55, 0x47, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x4f, 0x47, 0x5f, + 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x49, 0x4e, 0x46, 0x4f, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, + 0x4c, 0x4f, 0x47, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x57, 0x41, 0x52, 0x4e, 0x10, 0x03, + 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x4f, 0x47, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x45, 0x52, + 0x52, 0x4f, 0x52, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x4f, 0x47, 0x5f, 0x4c, 0x45, 0x56, + 0x45, 0x4c, 0x5f, 0x46, 0x41, 0x54, 0x41, 0x4c, 0x10, 0x05, 0x32, 0xa0, 0x05, 0x0a, 0x17, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x49, 0x0a, 0x0c, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, + 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x58, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x20, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x42, 0x61, 0x74, 0x63, + 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x42, 0x61, + 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x53, + 0x65, 0x6e, 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x73, 0x12, 0x23, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, + 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x66, + 0x0a, 0x19, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6e, 0x61, + 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x1c, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6e, 0x61, 0x70, + 0x73, 0x68, 0x6f, 0x74, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x1a, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6e, + 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x28, 0x01, 0x12, 0x58, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x65, + 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x20, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, + 0x72, 0x79, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x65, 0x6c, 0x65, 0x6d, + 0x65, 0x74, 0x72, 0x79, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x70, 0x0a, 0x19, 0x53, 0x65, 0x6e, 0x64, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x54, + 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x28, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x4e, 0x65, 0x74, 0x77, 0x6f, + 0x72, 0x6b, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x54, 0x72, 0x61, 0x66, + 0x66, 0x69, 0x63, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x49, 0x0a, 0x0c, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x12, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x8e, 0x01, + 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x42, 0x15, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x30, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x64, 0x65, 0x76, 0x7a, 0x65, 0x72, 0x6f, 0x2d, 0x69, 0x6e, 0x63, 0x2f, 0x7a, 0x78, + 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x3b, 0x61, 0x70, 0x69, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x41, 0x58, 0x58, 0xaa, 0x02, 0x06, + 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0xe2, + 0x02, 0x12, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x41, 0x70, 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( diff --git a/gen/api/v1/operator_health.pb.go b/gen/api/v1/operator_health.pb.go index ecfa6cda..3bd9c1e6 100644 --- a/gen/api/v1/operator_health.pb.go +++ b/gen/api/v1/operator_health.pb.go @@ -73,76 +73,6 @@ func (HealthStatus) EnumDescriptor() ([]byte, []int) { return file_api_v1_operator_health_proto_rawDescGZIP(), []int{0} } -type ClusterLifecycleState int32 - -const ( - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_UNSPECIFIED ClusterLifecycleState = 0 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_REGISTERED ClusterLifecycleState = 1 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_ZXPORTER_CONNECTED ClusterLifecycleState = 2 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_ZXPORTER_HEALTHY ClusterLifecycleState = 3 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_COLLECTING_DATA ClusterLifecycleState = 4 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_DAKR_CONNECTED ClusterLifecycleState = 5 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_DAKR_HEALTHY ClusterLifecycleState = 6 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_CLUSTER_READY ClusterLifecycleState = 7 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_DEGRADED ClusterLifecycleState = 8 - ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_DISCONNECTED ClusterLifecycleState = 9 -) - -// Enum value maps for ClusterLifecycleState. -var ( - ClusterLifecycleState_name = map[int32]string{ - 0: "CLUSTER_LIFECYCLE_STATE_UNSPECIFIED", - 1: "CLUSTER_LIFECYCLE_STATE_REGISTERED", - 2: "CLUSTER_LIFECYCLE_STATE_ZXPORTER_CONNECTED", - 3: "CLUSTER_LIFECYCLE_STATE_ZXPORTER_HEALTHY", - 4: "CLUSTER_LIFECYCLE_STATE_COLLECTING_DATA", - 5: "CLUSTER_LIFECYCLE_STATE_DAKR_CONNECTED", - 6: "CLUSTER_LIFECYCLE_STATE_DAKR_HEALTHY", - 7: "CLUSTER_LIFECYCLE_STATE_CLUSTER_READY", - 8: "CLUSTER_LIFECYCLE_STATE_DEGRADED", - 9: "CLUSTER_LIFECYCLE_STATE_DISCONNECTED", - } - ClusterLifecycleState_value = map[string]int32{ - "CLUSTER_LIFECYCLE_STATE_UNSPECIFIED": 0, - "CLUSTER_LIFECYCLE_STATE_REGISTERED": 1, - "CLUSTER_LIFECYCLE_STATE_ZXPORTER_CONNECTED": 2, - "CLUSTER_LIFECYCLE_STATE_ZXPORTER_HEALTHY": 3, - "CLUSTER_LIFECYCLE_STATE_COLLECTING_DATA": 4, - "CLUSTER_LIFECYCLE_STATE_DAKR_CONNECTED": 5, - "CLUSTER_LIFECYCLE_STATE_DAKR_HEALTHY": 6, - "CLUSTER_LIFECYCLE_STATE_CLUSTER_READY": 7, - "CLUSTER_LIFECYCLE_STATE_DEGRADED": 8, - "CLUSTER_LIFECYCLE_STATE_DISCONNECTED": 9, - } -) - -func (x ClusterLifecycleState) Enum() *ClusterLifecycleState { - p := new(ClusterLifecycleState) - *p = x - return p -} - -func (x ClusterLifecycleState) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (ClusterLifecycleState) Descriptor() protoreflect.EnumDescriptor { - return file_api_v1_operator_health_proto_enumTypes[1].Descriptor() -} - -func (ClusterLifecycleState) Type() protoreflect.EnumType { - return &file_api_v1_operator_health_proto_enumTypes[1] -} - -func (x ClusterLifecycleState) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use ClusterLifecycleState.Descriptor instead. -func (ClusterLifecycleState) EnumDescriptor() ([]byte, []int) { - return file_api_v1_operator_health_proto_rawDescGZIP(), []int{1} -} - type ComponentHealth struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -347,376 +277,6 @@ func (*ReportHealthResponse) Descriptor() ([]byte, []int) { return file_api_v1_operator_health_proto_rawDescGZIP(), []int{2} } -type GetClusterOperatorHealthRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` -} - -func (x *GetClusterOperatorHealthRequest) Reset() { - *x = GetClusterOperatorHealthRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_api_v1_operator_health_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetClusterOperatorHealthRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetClusterOperatorHealthRequest) ProtoMessage() {} - -func (x *GetClusterOperatorHealthRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_operator_health_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) -} - -// Deprecated: Use GetClusterOperatorHealthRequest.ProtoReflect.Descriptor instead. -func (*GetClusterOperatorHealthRequest) Descriptor() ([]byte, []int) { - return file_api_v1_operator_health_proto_rawDescGZIP(), []int{3} -} - -func (x *GetClusterOperatorHealthRequest) GetClusterId() string { - if x != nil { - return x.ClusterId - } - return "" -} - -type GetClusterOperatorHealthResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Operators []*OperatorHealthStatus `protobuf:"bytes,1,rep,name=operators,proto3" json:"operators,omitempty"` -} - -func (x *GetClusterOperatorHealthResponse) Reset() { - *x = GetClusterOperatorHealthResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_api_v1_operator_health_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetClusterOperatorHealthResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetClusterOperatorHealthResponse) ProtoMessage() {} - -func (x *GetClusterOperatorHealthResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_operator_health_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) -} - -// Deprecated: Use GetClusterOperatorHealthResponse.ProtoReflect.Descriptor instead. -func (*GetClusterOperatorHealthResponse) Descriptor() ([]byte, []int) { - return file_api_v1_operator_health_proto_rawDescGZIP(), []int{4} -} - -func (x *GetClusterOperatorHealthResponse) GetOperators() []*OperatorHealthStatus { - if x != nil { - return x.Operators - } - return nil -} - -type OperatorHealthStatus struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - OperatorType OperatorType `protobuf:"varint,1,opt,name=operator_type,json=operatorType,proto3,enum=api.v1.OperatorType" json:"operator_type,omitempty"` - OverallStatus HealthStatus `protobuf:"varint,2,opt,name=overall_status,json=overallStatus,proto3,enum=api.v1.HealthStatus" json:"overall_status,omitempty"` - Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"` - LastHeartbeat *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=last_heartbeat,json=lastHeartbeat,proto3" json:"last_heartbeat,omitempty"` - UptimeSince *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=uptime_since,json=uptimeSince,proto3" json:"uptime_since,omitempty"` - Components []*ComponentHealth `protobuf:"bytes,6,rep,name=components,proto3" json:"components,omitempty"` - Commit string `protobuf:"bytes,7,opt,name=commit,proto3" json:"commit,omitempty"` -} - -func (x *OperatorHealthStatus) Reset() { - *x = OperatorHealthStatus{} - if protoimpl.UnsafeEnabled { - mi := &file_api_v1_operator_health_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *OperatorHealthStatus) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*OperatorHealthStatus) ProtoMessage() {} - -func (x *OperatorHealthStatus) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_operator_health_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 mi.MessageOf(x) -} - -// Deprecated: Use OperatorHealthStatus.ProtoReflect.Descriptor instead. -func (*OperatorHealthStatus) Descriptor() ([]byte, []int) { - return file_api_v1_operator_health_proto_rawDescGZIP(), []int{5} -} - -func (x *OperatorHealthStatus) GetOperatorType() OperatorType { - if x != nil { - return x.OperatorType - } - return OperatorType_OPERATOR_TYPE_UNSPECIFIED -} - -func (x *OperatorHealthStatus) GetOverallStatus() HealthStatus { - if x != nil { - return x.OverallStatus - } - return HealthStatus_HEALTH_STATUS_UNSPECIFIED -} - -func (x *OperatorHealthStatus) GetVersion() string { - if x != nil { - return x.Version - } - return "" -} - -func (x *OperatorHealthStatus) GetLastHeartbeat() *timestamppb.Timestamp { - if x != nil { - return x.LastHeartbeat - } - return nil -} - -func (x *OperatorHealthStatus) GetUptimeSince() *timestamppb.Timestamp { - if x != nil { - return x.UptimeSince - } - return nil -} - -func (x *OperatorHealthStatus) GetComponents() []*ComponentHealth { - if x != nil { - return x.Components - } - return nil -} - -func (x *OperatorHealthStatus) GetCommit() string { - if x != nil { - return x.Commit - } - return "" -} - -type WatchClusterLifecycleRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - TeamId string `protobuf:"bytes,1,opt,name=team_id,json=teamId,proto3" json:"team_id,omitempty"` -} - -func (x *WatchClusterLifecycleRequest) Reset() { - *x = WatchClusterLifecycleRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_api_v1_operator_health_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *WatchClusterLifecycleRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*WatchClusterLifecycleRequest) ProtoMessage() {} - -func (x *WatchClusterLifecycleRequest) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_operator_health_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) -} - -// Deprecated: Use WatchClusterLifecycleRequest.ProtoReflect.Descriptor instead. -func (*WatchClusterLifecycleRequest) Descriptor() ([]byte, []int) { - return file_api_v1_operator_health_proto_rawDescGZIP(), []int{6} -} - -func (x *WatchClusterLifecycleRequest) GetTeamId() string { - if x != nil { - return x.TeamId - } - return "" -} - -type ClusterLifecycleEvent struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` - ClusterName string `protobuf:"bytes,2,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"` - State ClusterLifecycleState `protobuf:"varint,3,opt,name=state,proto3,enum=api.v1.ClusterLifecycleState" json:"state,omitempty"` - Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"` - Timestamp *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"` -} - -func (x *ClusterLifecycleEvent) Reset() { - *x = ClusterLifecycleEvent{} - if protoimpl.UnsafeEnabled { - mi := &file_api_v1_operator_health_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *ClusterLifecycleEvent) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ClusterLifecycleEvent) ProtoMessage() {} - -func (x *ClusterLifecycleEvent) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_operator_health_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) -} - -// Deprecated: Use ClusterLifecycleEvent.ProtoReflect.Descriptor instead. -func (*ClusterLifecycleEvent) Descriptor() ([]byte, []int) { - return file_api_v1_operator_health_proto_rawDescGZIP(), []int{7} -} - -func (x *ClusterLifecycleEvent) GetClusterId() string { - if x != nil { - return x.ClusterId - } - return "" -} - -func (x *ClusterLifecycleEvent) GetClusterName() string { - if x != nil { - return x.ClusterName - } - return "" -} - -func (x *ClusterLifecycleEvent) GetState() ClusterLifecycleState { - if x != nil { - return x.State - } - return ClusterLifecycleState_CLUSTER_LIFECYCLE_STATE_UNSPECIFIED -} - -func (x *ClusterLifecycleEvent) GetMessage() string { - if x != nil { - return x.Message - } - return "" -} - -func (x *ClusterLifecycleEvent) GetTimestamp() *timestamppb.Timestamp { - if x != nil { - return x.Timestamp - } - return nil -} - -type WatchClusterLifecycleResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Events []*ClusterLifecycleEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` - CheckedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=checked_at,json=checkedAt,proto3" json:"checked_at,omitempty"` -} - -func (x *WatchClusterLifecycleResponse) Reset() { - *x = WatchClusterLifecycleResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_api_v1_operator_health_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *WatchClusterLifecycleResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*WatchClusterLifecycleResponse) ProtoMessage() {} - -func (x *WatchClusterLifecycleResponse) ProtoReflect() protoreflect.Message { - mi := &file_api_v1_operator_health_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) -} - -// Deprecated: Use WatchClusterLifecycleResponse.ProtoReflect.Descriptor instead. -func (*WatchClusterLifecycleResponse) Descriptor() ([]byte, []int) { - return file_api_v1_operator_health_proto_rawDescGZIP(), []int{8} -} - -func (x *WatchClusterLifecycleResponse) GetEvents() []*ClusterLifecycleEvent { - if x != nil { - return x.Events - } - return nil -} - -func (x *WatchClusterLifecycleResponse) GetCheckedAt() *timestamppb.Timestamp { - if x != nil { - return x.CheckedAt - } - return nil -} - var File_api_v1_operator_health_proto protoreflect.FileDescriptor var file_api_v1_operator_health_proto_rawDesc = []byte{ @@ -763,134 +323,31 @@ var file_api_v1_operator_health_proto_rawDesc = []byte{ 0x6d, 0x70, 0x52, 0x0b, 0x75, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x22, 0x16, 0x0a, 0x14, 0x52, 0x65, 0x70, 0x6f, 0x72, - 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x40, 0x0a, 0x1f, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4f, 0x70, 0x65, - 0x72, 0x61, 0x74, 0x6f, 0x72, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, - 0x64, 0x22, 0x5e, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4f, - 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, - 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, - 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, - 0x73, 0x22, 0xfb, 0x02, 0x0a, 0x14, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x48, 0x65, - 0x61, 0x6c, 0x74, 0x68, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x39, 0x0a, 0x0d, 0x6f, 0x70, - 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x14, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, - 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0c, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, - 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3b, 0x0a, 0x0e, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, - 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x52, 0x0d, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x0e, - 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 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, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x12, - 0x3d, 0x0a, 0x0c, 0x75, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x18, - 0x05, 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, 0x0b, 0x75, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x12, 0x37, - 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x70, - 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x0a, 0x63, 0x6f, 0x6d, - 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, - 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x22, - 0x37, 0x0a, 0x1c, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4c, - 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x17, 0x0a, 0x07, 0x74, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x74, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x22, 0xe2, 0x01, 0x0a, 0x15, 0x43, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, - 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, - 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, - 0x61, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, - 0x18, 0x05, 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, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x91, 0x01, - 0x0a, 0x1d, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69, - 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x35, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x4c, 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, - 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, - 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, 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, 0x09, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x64, 0x41, - 0x74, 0x2a, 0x81, 0x01, 0x0a, 0x0c, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x19, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x5f, 0x53, 0x54, 0x41, - 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, - 0x00, 0x12, 0x19, 0x0a, 0x15, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, - 0x55, 0x53, 0x5f, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x59, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, - 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x44, 0x45, - 0x47, 0x52, 0x41, 0x44, 0x45, 0x44, 0x10, 0x02, 0x12, 0x1b, 0x0a, 0x17, 0x48, 0x45, 0x41, 0x4c, - 0x54, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x48, 0x45, 0x41, 0x4c, - 0x54, 0x48, 0x59, 0x10, 0x03, 0x2a, 0xc4, 0x03, 0x0a, 0x15, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x4c, 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, - 0x27, 0x0a, 0x23, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, 0x45, 0x43, - 0x59, 0x43, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, - 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x26, 0x0a, 0x22, 0x43, 0x4c, 0x55, 0x53, - 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, 0x45, 0x43, 0x59, 0x43, 0x4c, 0x45, 0x5f, 0x53, 0x54, - 0x41, 0x54, 0x45, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x53, 0x54, 0x45, 0x52, 0x45, 0x44, 0x10, 0x01, - 0x12, 0x2e, 0x0a, 0x2a, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, 0x45, - 0x43, 0x59, 0x43, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x5a, 0x58, 0x50, 0x4f, - 0x52, 0x54, 0x45, 0x52, 0x5f, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x02, - 0x12, 0x2c, 0x0a, 0x28, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, 0x45, - 0x43, 0x59, 0x43, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x5a, 0x58, 0x50, 0x4f, - 0x52, 0x54, 0x45, 0x52, 0x5f, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x59, 0x10, 0x03, 0x12, 0x2b, - 0x0a, 0x27, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, 0x45, 0x43, 0x59, - 0x43, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4f, 0x4c, 0x4c, 0x45, 0x43, - 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x10, 0x04, 0x12, 0x2a, 0x0a, 0x26, 0x43, - 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, 0x45, 0x43, 0x59, 0x43, 0x4c, 0x45, - 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x44, 0x41, 0x4b, 0x52, 0x5f, 0x43, 0x4f, 0x4e, 0x4e, - 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x05, 0x12, 0x28, 0x0a, 0x24, 0x43, 0x4c, 0x55, 0x53, 0x54, - 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, 0x45, 0x43, 0x59, 0x43, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, - 0x54, 0x45, 0x5f, 0x44, 0x41, 0x4b, 0x52, 0x5f, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x59, 0x10, - 0x06, 0x12, 0x29, 0x0a, 0x25, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, - 0x45, 0x43, 0x59, 0x43, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4c, 0x55, - 0x53, 0x54, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x07, 0x12, 0x24, 0x0a, 0x20, - 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, 0x46, 0x45, 0x43, 0x59, 0x43, 0x4c, - 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x44, 0x45, 0x47, 0x52, 0x41, 0x44, 0x45, 0x44, - 0x10, 0x08, 0x12, 0x28, 0x0a, 0x24, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x49, - 0x46, 0x45, 0x43, 0x59, 0x43, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x44, 0x49, - 0x53, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x09, 0x32, 0xb9, 0x02, 0x0a, - 0x15, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, - 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x49, 0x0a, 0x0c, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, - 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, - 0x6f, 0x72, 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x6d, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4f, - 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x27, 0x2e, - 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, - 0x6f, 0x72, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x66, 0x0a, 0x15, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x4c, 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x12, 0x24, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4c, - 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x25, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x42, 0x8c, 0x01, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, - 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x42, 0x13, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, - 0x72, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x30, - 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x65, 0x76, 0x7a, 0x65, - 0x72, 0x6f, 0x2d, 0x69, 0x6e, 0x63, 0x2f, 0x7a, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, - 0x67, 0x65, 0x6e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x3b, 0x61, 0x70, 0x69, 0x76, 0x31, - 0xa2, 0x02, 0x03, 0x41, 0x58, 0x58, 0xaa, 0x02, 0x06, 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, 0xca, - 0x02, 0x06, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x12, 0x41, 0x70, 0x69, 0x5c, 0x56, - 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, - 0x41, 0x70, 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2a, + 0x81, 0x01, 0x0a, 0x0c, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x1d, 0x0a, 0x19, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, + 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x19, 0x0a, 0x15, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, + 0x5f, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, 0x59, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x48, 0x45, + 0x41, 0x4c, 0x54, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x44, 0x45, 0x47, 0x52, + 0x41, 0x44, 0x45, 0x44, 0x10, 0x02, 0x12, 0x1b, 0x0a, 0x17, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x48, 0x45, 0x41, 0x4c, 0x54, 0x48, + 0x59, 0x10, 0x03, 0x32, 0x62, 0x0a, 0x15, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x48, + 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x49, 0x0a, 0x0c, + 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x1b, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x65, 0x61, 0x6c, + 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x8c, 0x01, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x42, 0x13, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, + 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x30, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x65, 0x76, 0x7a, 0x65, 0x72, + 0x6f, 0x2d, 0x69, 0x6e, 0x63, 0x2f, 0x7a, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x3b, 0x61, 0x70, 0x69, 0x76, 0x31, 0xa2, + 0x02, 0x03, 0x41, 0x58, 0x58, 0xaa, 0x02, 0x06, 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, 0xca, 0x02, + 0x06, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x12, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x41, + 0x70, 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -905,52 +362,31 @@ func file_api_v1_operator_health_proto_rawDescGZIP() []byte { return file_api_v1_operator_health_proto_rawDescData } -var file_api_v1_operator_health_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_api_v1_operator_health_proto_msgTypes = make([]protoimpl.MessageInfo, 10) +var file_api_v1_operator_health_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_api_v1_operator_health_proto_msgTypes = make([]protoimpl.MessageInfo, 4) var file_api_v1_operator_health_proto_goTypes = []interface{}{ - (HealthStatus)(0), // 0: api.v1.HealthStatus - (ClusterLifecycleState)(0), // 1: api.v1.ClusterLifecycleState - (*ComponentHealth)(nil), // 2: api.v1.ComponentHealth - (*ReportHealthRequest)(nil), // 3: api.v1.ReportHealthRequest - (*ReportHealthResponse)(nil), // 4: api.v1.ReportHealthResponse - (*GetClusterOperatorHealthRequest)(nil), // 5: api.v1.GetClusterOperatorHealthRequest - (*GetClusterOperatorHealthResponse)(nil), // 6: api.v1.GetClusterOperatorHealthResponse - (*OperatorHealthStatus)(nil), // 7: api.v1.OperatorHealthStatus - (*WatchClusterLifecycleRequest)(nil), // 8: api.v1.WatchClusterLifecycleRequest - (*ClusterLifecycleEvent)(nil), // 9: api.v1.ClusterLifecycleEvent - (*WatchClusterLifecycleResponse)(nil), // 10: api.v1.WatchClusterLifecycleResponse - nil, // 11: api.v1.ComponentHealth.MetadataEntry - (OperatorType)(0), // 12: api.v1.OperatorType - (*timestamppb.Timestamp)(nil), // 13: google.protobuf.Timestamp + (HealthStatus)(0), // 0: api.v1.HealthStatus + (*ComponentHealth)(nil), // 1: api.v1.ComponentHealth + (*ReportHealthRequest)(nil), // 2: api.v1.ReportHealthRequest + (*ReportHealthResponse)(nil), // 3: api.v1.ReportHealthResponse + nil, // 4: api.v1.ComponentHealth.MetadataEntry + (OperatorType)(0), // 5: api.v1.OperatorType + (*timestamppb.Timestamp)(nil), // 6: google.protobuf.Timestamp } var file_api_v1_operator_health_proto_depIdxs = []int32{ - 0, // 0: api.v1.ComponentHealth.status:type_name -> api.v1.HealthStatus - 11, // 1: api.v1.ComponentHealth.metadata:type_name -> api.v1.ComponentHealth.MetadataEntry - 12, // 2: api.v1.ReportHealthRequest.operator_type:type_name -> api.v1.OperatorType - 0, // 3: api.v1.ReportHealthRequest.overall_status:type_name -> api.v1.HealthStatus - 2, // 4: api.v1.ReportHealthRequest.components:type_name -> api.v1.ComponentHealth - 13, // 5: api.v1.ReportHealthRequest.uptime_since:type_name -> google.protobuf.Timestamp - 7, // 6: api.v1.GetClusterOperatorHealthResponse.operators:type_name -> api.v1.OperatorHealthStatus - 12, // 7: api.v1.OperatorHealthStatus.operator_type:type_name -> api.v1.OperatorType - 0, // 8: api.v1.OperatorHealthStatus.overall_status:type_name -> api.v1.HealthStatus - 13, // 9: api.v1.OperatorHealthStatus.last_heartbeat:type_name -> google.protobuf.Timestamp - 13, // 10: api.v1.OperatorHealthStatus.uptime_since:type_name -> google.protobuf.Timestamp - 2, // 11: api.v1.OperatorHealthStatus.components:type_name -> api.v1.ComponentHealth - 1, // 12: api.v1.ClusterLifecycleEvent.state:type_name -> api.v1.ClusterLifecycleState - 13, // 13: api.v1.ClusterLifecycleEvent.timestamp:type_name -> google.protobuf.Timestamp - 9, // 14: api.v1.WatchClusterLifecycleResponse.events:type_name -> api.v1.ClusterLifecycleEvent - 13, // 15: api.v1.WatchClusterLifecycleResponse.checked_at:type_name -> google.protobuf.Timestamp - 3, // 16: api.v1.OperatorHealthService.ReportHealth:input_type -> api.v1.ReportHealthRequest - 5, // 17: api.v1.OperatorHealthService.GetClusterOperatorHealth:input_type -> api.v1.GetClusterOperatorHealthRequest - 8, // 18: api.v1.OperatorHealthService.WatchClusterLifecycle:input_type -> api.v1.WatchClusterLifecycleRequest - 4, // 19: api.v1.OperatorHealthService.ReportHealth:output_type -> api.v1.ReportHealthResponse - 6, // 20: api.v1.OperatorHealthService.GetClusterOperatorHealth:output_type -> api.v1.GetClusterOperatorHealthResponse - 10, // 21: api.v1.OperatorHealthService.WatchClusterLifecycle:output_type -> api.v1.WatchClusterLifecycleResponse - 19, // [19:22] is the sub-list for method output_type - 16, // [16:19] is the sub-list for method input_type - 16, // [16:16] is the sub-list for extension type_name - 16, // [16:16] is the sub-list for extension extendee - 0, // [0:16] is the sub-list for field type_name + 0, // 0: api.v1.ComponentHealth.status:type_name -> api.v1.HealthStatus + 4, // 1: api.v1.ComponentHealth.metadata:type_name -> api.v1.ComponentHealth.MetadataEntry + 5, // 2: api.v1.ReportHealthRequest.operator_type:type_name -> api.v1.OperatorType + 0, // 3: api.v1.ReportHealthRequest.overall_status:type_name -> api.v1.HealthStatus + 1, // 4: api.v1.ReportHealthRequest.components:type_name -> api.v1.ComponentHealth + 6, // 5: api.v1.ReportHealthRequest.uptime_since:type_name -> google.protobuf.Timestamp + 2, // 6: api.v1.OperatorHealthService.ReportHealth:input_type -> api.v1.ReportHealthRequest + 3, // 7: api.v1.OperatorHealthService.ReportHealth:output_type -> api.v1.ReportHealthResponse + 7, // [7:8] is the sub-list for method output_type + 6, // [6:7] is the sub-list for method input_type + 6, // [6:6] is the sub-list for extension type_name + 6, // [6:6] is the sub-list for extension extendee + 0, // [0:6] is the sub-list for field type_name } func init() { file_api_v1_operator_health_proto_init() } @@ -996,86 +432,14 @@ func file_api_v1_operator_health_proto_init() { return nil } } - file_api_v1_operator_health_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetClusterOperatorHealthRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_api_v1_operator_health_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetClusterOperatorHealthResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_api_v1_operator_health_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*OperatorHealthStatus); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_api_v1_operator_health_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*WatchClusterLifecycleRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_api_v1_operator_health_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ClusterLifecycleEvent); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_api_v1_operator_health_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*WatchClusterLifecycleResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_api_v1_operator_health_proto_rawDesc, - NumEnums: 2, - NumMessages: 10, + NumEnums: 1, + NumMessages: 4, NumExtensions: 0, NumServices: 1, }, diff --git a/gen/api/v1/operator_health_grpc.pb.go b/gen/api/v1/operator_health_grpc.pb.go index 7b057bb9..a43f3064 100644 --- a/gen/api/v1/operator_health_grpc.pb.go +++ b/gen/api/v1/operator_health_grpc.pb.go @@ -19,9 +19,7 @@ import ( const _ = grpc.SupportPackageIsVersion7 const ( - OperatorHealthService_ReportHealth_FullMethodName = "/api.v1.OperatorHealthService/ReportHealth" - OperatorHealthService_GetClusterOperatorHealth_FullMethodName = "/api.v1.OperatorHealthService/GetClusterOperatorHealth" - OperatorHealthService_WatchClusterLifecycle_FullMethodName = "/api.v1.OperatorHealthService/WatchClusterLifecycle" + OperatorHealthService_ReportHealth_FullMethodName = "/api.v1.OperatorHealthService/ReportHealth" ) // OperatorHealthServiceClient is the client API for OperatorHealthService service. @@ -29,8 +27,6 @@ const ( // 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 OperatorHealthServiceClient interface { ReportHealth(ctx context.Context, in *ReportHealthRequest, opts ...grpc.CallOption) (*ReportHealthResponse, error) - GetClusterOperatorHealth(ctx context.Context, in *GetClusterOperatorHealthRequest, opts ...grpc.CallOption) (*GetClusterOperatorHealthResponse, error) - WatchClusterLifecycle(ctx context.Context, in *WatchClusterLifecycleRequest, opts ...grpc.CallOption) (OperatorHealthService_WatchClusterLifecycleClient, error) } type operatorHealthServiceClient struct { @@ -50,54 +46,11 @@ func (c *operatorHealthServiceClient) ReportHealth(ctx context.Context, in *Repo return out, nil } -func (c *operatorHealthServiceClient) GetClusterOperatorHealth(ctx context.Context, in *GetClusterOperatorHealthRequest, opts ...grpc.CallOption) (*GetClusterOperatorHealthResponse, error) { - out := new(GetClusterOperatorHealthResponse) - err := c.cc.Invoke(ctx, OperatorHealthService_GetClusterOperatorHealth_FullMethodName, in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *operatorHealthServiceClient) WatchClusterLifecycle(ctx context.Context, in *WatchClusterLifecycleRequest, opts ...grpc.CallOption) (OperatorHealthService_WatchClusterLifecycleClient, error) { - stream, err := c.cc.NewStream(ctx, &OperatorHealthService_ServiceDesc.Streams[0], OperatorHealthService_WatchClusterLifecycle_FullMethodName, opts...) - if err != nil { - return nil, err - } - x := &operatorHealthServiceWatchClusterLifecycleClient{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 OperatorHealthService_WatchClusterLifecycleClient interface { - Recv() (*WatchClusterLifecycleResponse, error) - grpc.ClientStream -} - -type operatorHealthServiceWatchClusterLifecycleClient struct { - grpc.ClientStream -} - -func (x *operatorHealthServiceWatchClusterLifecycleClient) Recv() (*WatchClusterLifecycleResponse, error) { - m := new(WatchClusterLifecycleResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} - // OperatorHealthServiceServer is the server API for OperatorHealthService service. // All implementations must embed UnimplementedOperatorHealthServiceServer // for forward compatibility type OperatorHealthServiceServer interface { ReportHealth(context.Context, *ReportHealthRequest) (*ReportHealthResponse, error) - GetClusterOperatorHealth(context.Context, *GetClusterOperatorHealthRequest) (*GetClusterOperatorHealthResponse, error) - WatchClusterLifecycle(*WatchClusterLifecycleRequest, OperatorHealthService_WatchClusterLifecycleServer) error mustEmbedUnimplementedOperatorHealthServiceServer() } @@ -108,12 +61,6 @@ type UnimplementedOperatorHealthServiceServer struct { func (UnimplementedOperatorHealthServiceServer) ReportHealth(context.Context, *ReportHealthRequest) (*ReportHealthResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ReportHealth not implemented") } -func (UnimplementedOperatorHealthServiceServer) GetClusterOperatorHealth(context.Context, *GetClusterOperatorHealthRequest) (*GetClusterOperatorHealthResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetClusterOperatorHealth not implemented") -} -func (UnimplementedOperatorHealthServiceServer) WatchClusterLifecycle(*WatchClusterLifecycleRequest, OperatorHealthService_WatchClusterLifecycleServer) error { - return status.Errorf(codes.Unimplemented, "method WatchClusterLifecycle not implemented") -} func (UnimplementedOperatorHealthServiceServer) mustEmbedUnimplementedOperatorHealthServiceServer() {} // UnsafeOperatorHealthServiceServer may be embedded to opt out of forward compatibility for this service. @@ -145,45 +92,6 @@ func _OperatorHealthService_ReportHealth_Handler(srv interface{}, ctx context.Co return interceptor(ctx, in, info, handler) } -func _OperatorHealthService_GetClusterOperatorHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetClusterOperatorHealthRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(OperatorHealthServiceServer).GetClusterOperatorHealth(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: OperatorHealthService_GetClusterOperatorHealth_FullMethodName, - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(OperatorHealthServiceServer).GetClusterOperatorHealth(ctx, req.(*GetClusterOperatorHealthRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _OperatorHealthService_WatchClusterLifecycle_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(WatchClusterLifecycleRequest) - if err := stream.RecvMsg(m); err != nil { - return err - } - return srv.(OperatorHealthServiceServer).WatchClusterLifecycle(m, &operatorHealthServiceWatchClusterLifecycleServer{stream}) -} - -type OperatorHealthService_WatchClusterLifecycleServer interface { - Send(*WatchClusterLifecycleResponse) error - grpc.ServerStream -} - -type operatorHealthServiceWatchClusterLifecycleServer struct { - grpc.ServerStream -} - -func (x *operatorHealthServiceWatchClusterLifecycleServer) Send(m *WatchClusterLifecycleResponse) error { - return x.ServerStream.SendMsg(m) -} - // OperatorHealthService_ServiceDesc is the grpc.ServiceDesc for OperatorHealthService service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -195,17 +103,7 @@ var OperatorHealthService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ReportHealth", Handler: _OperatorHealthService_ReportHealth_Handler, }, - { - MethodName: "GetClusterOperatorHealth", - Handler: _OperatorHealthService_GetClusterOperatorHealth_Handler, - }, - }, - Streams: []grpc.StreamDesc{ - { - StreamName: "WatchClusterLifecycle", - Handler: _OperatorHealthService_WatchClusterLifecycle_Handler, - ServerStreams: true, - }, }, + Streams: []grpc.StreamDesc{}, Metadata: "api/v1/operator_health.proto", } diff --git a/internal/collector/image_analysis_result_collector.go b/internal/collector/image_analysis_result_collector.go new file mode 100644 index 00000000..2444cd08 --- /dev/null +++ b/internal/collector/image_analysis_result_collector.go @@ -0,0 +1,281 @@ +package collector + +import ( + "context" + "fmt" + "sync" + "time" + + telemetry_logger "github.com/devzero-inc/zxporter/internal/logger" + "github.com/go-logr/logr" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/dynamic/dynamicinformer" + "k8s.io/client-go/tools/cache" +) + +// ImageAnalysisResultCollector watches for ImageAnalysisResult CRD events +// and sends completed analysis results to the control plane via gRPC. +type ImageAnalysisResultCollector struct { + client dynamic.Interface + informerFactory dynamicinformer.DynamicSharedInformerFactory + iarInformer cache.SharedIndexInformer + batchChan chan CollectedResource + resourceChan chan []CollectedResource + batcher *ResourcesBatcher + stopCh chan struct{} + stopOnce sync.Once + mu sync.RWMutex + stopped bool + logger logr.Logger + telemetryLogger telemetry_logger.Logger +} + +// ImageAnalysisResult CRD resource identifier (cluster-scoped) +var imageAnalysisResultGVR = schema.GroupVersionResource{ + Group: "devzero.io", + Version: "v1", + Resource: "imageanalysisresults", +} + +// NewImageAnalysisResultCollector creates a new collector for ImageAnalysisResult CRDs. +func NewImageAnalysisResultCollector( + client dynamic.Interface, + maxBatchSize int, + maxBatchTime time.Duration, + logger logr.Logger, + telemetryLogger telemetry_logger.Logger, +) *ImageAnalysisResultCollector { + batchChan := make(chan CollectedResource, 100) + resourceChan := make(chan []CollectedResource, 100) + + batcher := NewResourcesBatcher( + maxBatchSize, + maxBatchTime, + batchChan, + resourceChan, + logger, + ) + + return &ImageAnalysisResultCollector{ + client: client, + batchChan: batchChan, + resourceChan: resourceChan, + batcher: batcher, + stopCh: make(chan struct{}), + logger: logger.WithName("image-analysis-result-collector"), + telemetryLogger: telemetryLogger, + } +} + +// Start begins the ImageAnalysisResult collection process. +func (c *ImageAnalysisResultCollector) Start(ctx context.Context) error { + c.logger.Info("Starting ImageAnalysisResult collector") + + // ImageAnalysisResult is cluster-scoped, no namespace filtering needed. + // Use 60s resync to catch any missed status transitions. + resyncPeriod := 60 * time.Second + c.informerFactory = dynamicinformer.NewDynamicSharedInformerFactory(c.client, resyncPeriod) + + c.iarInformer = c.informerFactory.ForResource(imageAnalysisResultGVR).Informer() + + _, err := c.iarInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{ + AddFunc: func(obj interface{}) { + iar := obj.(*unstructured.Unstructured) + c.handleEvent(iar, EventTypeAdd) + }, + UpdateFunc: func(oldObj, newObj interface{}) { + oldIAR := oldObj.(*unstructured.Unstructured) + newIAR := newObj.(*unstructured.Unstructured) + + // Resync: same ResourceVersion means informer resync, not a real change. + // Re-send completed results on resync to ensure the control plane is up-to-date. + if oldIAR.GetResourceVersion() == newIAR.GetResourceVersion() { + phase, _, _ := unstructured.NestedString(newIAR.Object, "status", "phase") + if phase == "Completed" { + c.handleEvent(newIAR, EventTypeUpdate) + } + return + } + + // Only re-send if analyzedAt changed (new scan result) + if c.analysisChanged(oldIAR, newIAR) { + c.handleEvent(newIAR, EventTypeUpdate) + } + }, + DeleteFunc: func(obj interface{}) { + iar := obj.(*unstructured.Unstructured) + c.handleEvent(iar, EventTypeDelete) + }, + }) + if err != nil { + return fmt.Errorf("failed to add event handler: %w", err) + } + + c.informerFactory.Start(c.stopCh) + + c.logger.Info("Waiting for informer caches to sync") + if !cache.WaitForCacheSync(ctx.Done(), c.iarInformer.HasSynced) { + return fmt.Errorf("failed to sync caches") + } + c.logger.Info("Informer caches synced successfully") + + c.logger.Info("Starting resources batcher for ImageAnalysisResults") + c.batcher.start() + + stopCh := c.stopCh + go func() { + select { + case <-ctx.Done(): + _ = c.Stop() + case <-stopCh: + } + }() + + return nil +} + +// handleEvent processes an ImageAnalysisResult event. +func (c *ImageAnalysisResultCollector) handleEvent(iar *unstructured.Unstructured, eventType EventType) { + c.mu.RLock() + defer c.mu.RUnlock() + if c.stopped { + return + } + + name := iar.GetName() + + // Only send completed analysis results (skip Pending, Analyzing, Failed). + // Delete events are always sent so the control plane can clean up. + if eventType != EventTypeDelete { + phase, _, _ := unstructured.NestedString(iar.Object, "status", "phase") + if phase != "Completed" { + c.logger.V(1).Info("Skipping ImageAnalysisResult with non-completed phase", + "name", name, "phase", phase) + return + } + } + + // Convert to trimmed wire format to minimize payload size + var obj interface{} + if eventType == EventTypeDelete { + // For deletes, send minimal identifying info + obj = map[string]interface{}{ + "imageDigest": getNestedString(iar.Object, "spec", "imageDigest"), + "imageRef": getNestedString(iar.Object, "spec", "imageRef"), + } + } else { + wireFormat, err := ToImageAnalysisWireFormat(iar) + if err != nil { + c.logger.Error(err, "Failed to convert ImageAnalysisResult to wire format", "name", name) + return + } + obj = wireFormat + } + + c.logger.Info("Sending ImageAnalysisResult to control plane", + "event_type", eventType.String(), + "name", name, + ) + + c.batchChan <- CollectedResource{ + ResourceType: ImageAnalysisResult, + Object: obj, + Timestamp: time.Now().UTC(), + EventType: eventType, + Key: name, + } +} + +// analysisChanged detects meaningful changes in an ImageAnalysisResult. +// Only triggers on new scan results (analyzedAt changed) or phase changes. +func (c *ImageAnalysisResultCollector) analysisChanged(oldIAR, newIAR *unstructured.Unstructured) bool { + if oldIAR.GetResourceVersion() == newIAR.GetResourceVersion() { + return false + } + + // Check if analyzedAt changed (indicates a new scan) + oldAnalyzedAt, _, _ := unstructured.NestedString(oldIAR.Object, "status", "analyzedAt") + newAnalyzedAt, _, _ := unstructured.NestedString(newIAR.Object, "status", "analyzedAt") + if oldAnalyzedAt != newAnalyzedAt { + return true + } + + // Check if phase changed + oldPhase, _, _ := unstructured.NestedString(oldIAR.Object, "status", "phase") + newPhase, _, _ := unstructured.NestedString(newIAR.Object, "status", "phase") + if oldPhase != newPhase { + return true + } + + return false +} + +// Stop gracefully shuts down the collector. +func (c *ImageAnalysisResultCollector) Stop() error { + c.logger.Info("Stopping ImageAnalysisResult collector") + + c.stopOnce.Do(func() { + close(c.stopCh) + c.logger.Info("Closed ImageAnalysisResult collector stop channel") + + c.mu.Lock() + c.stopped = true + close(c.batchChan) + c.batchChan = nil + c.mu.Unlock() + c.logger.Info("Closed ImageAnalysisResult collector batch input channel") + }) + + if c.batcher != nil { + c.batcher.stop() + c.logger.Info("ImageAnalysisResult collector batcher stopped") + } + + return nil +} + +// GetResourceChannel returns the channel for collected resource batches. +func (c *ImageAnalysisResultCollector) GetResourceChannel() <-chan []CollectedResource { + return c.resourceChan +} + +// GetType returns the type of resource this collector handles. +func (c *ImageAnalysisResultCollector) GetType() string { + return "image_analysis_result" +} + +// IsAvailable checks if the ImageAnalysisResult CRD is installed in the cluster. +func (c *ImageAnalysisResultCollector) IsAvailable(ctx context.Context) bool { + _, err := c.client.Resource(imageAnalysisResultGVR).List(ctx, metav1.ListOptions{Limit: 1}) + if err == nil { + return true + } + + if isResourceTypeUnavailableError(err) { + c.logger.Info("ImageAnalysisResult CRD not installed in cluster", "error", err.Error()) + return false + } + + c.logger.Error(err, "Error checking ImageAnalysisResult resource availability") + return false +} + +// AddResource manually adds an ImageAnalysisResult resource to be processed. +func (c *ImageAnalysisResultCollector) AddResource(resource interface{}) error { + iar, ok := resource.(*unstructured.Unstructured) + if !ok { + return fmt.Errorf("expected *unstructured.Unstructured, got %T", resource) + } + + c.handleEvent(iar, EventTypeAdd) + return nil +} + +// getNestedString is a helper to extract a nested string from unstructured data. +func getNestedString(obj map[string]interface{}, fields ...string) string { + val, _, _ := unstructured.NestedString(obj, fields...) + return val +} diff --git a/internal/collector/image_analysis_wire_format.go b/internal/collector/image_analysis_wire_format.go new file mode 100644 index 00000000..91bcd1f1 --- /dev/null +++ b/internal/collector/image_analysis_wire_format.go @@ -0,0 +1,233 @@ +package collector + +import ( + "encoding/json" + "fmt" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +const ( + maxWireLayers = 50 + maxWireWastedFiles = 20 + maxWireFilePath = 120 +) + +// ImageAnalysisWireFormat is the trimmed payload sent over the wire to dakr. +// It strips unnecessary detail (full workloadReferences, excess layers/files) +// to keep compressed size under ~50KB per CRD. +type ImageAnalysisWireFormat struct { + ImageRef string `json:"imageRef"` + ImageDigest string `json:"imageDigest"` + ImageSizeBytes int64 `json:"imageSizeBytes,omitempty"` + + // Core analysis metrics + Efficiency string `json:"efficiency"` + WastedBytes int64 `json:"wastedBytes"` + UserWastedPercent string `json:"userWastedPercent"` + Passed bool `json:"passed"` + LayerCount int `json:"layerCount"` + + // Trimmed detail arrays + Layers []LayerWire `json:"layers,omitempty"` + WastedFiles []WastedFileWire `json:"wastedFiles,omitempty"` + + // File analysis aggregate + FileAnalysis *FileAnalysisWire `json:"fileAnalysis,omitempty"` + + // Workload summary (aggregate only, no individual refs) + WorkloadSummary WorkloadSummaryWire `json:"workloadSummary"` + + // Metadata + ImageSourceType string `json:"imageSourceType,omitempty"` + AnalyzedAt string `json:"analyzedAt"` + AnalysisDurationSecs int `json:"analysisDurationSeconds,omitempty"` +} + +// LayerWire is the wire representation of a single image layer. +type LayerWire struct { + Index int `json:"index"` + Digest string `json:"digest,omitempty"` + SizeBytes int64 `json:"sizeBytes"` + Command string `json:"command,omitempty"` +} + +// WastedFileWire is the wire representation of a wasted file entry. +type WastedFileWire struct { + Path string `json:"path"` + SizeBytes int64 `json:"sizeBytes"` +} + +// FileAnalysisWire is the wire representation of aggregate file analysis. +type FileAnalysisWire struct { + TotalFiles int `json:"totalFiles,omitempty"` + ModifiedFiles int `json:"modifiedFiles,omitempty"` + AddedFiles int `json:"addedFiles,omitempty"` + RemovedFiles int `json:"removedFiles,omitempty"` +} + +// WorkloadSummaryWire is the wire representation of the workload summary. +type WorkloadSummaryWire struct { + TotalContainers int `json:"totalContainers,omitempty"` + TotalWorkloads int `json:"totalWorkloads,omitempty"` + NodesRunningImage int `json:"nodesRunningImage,omitempty"` + Namespaces []string `json:"namespaces,omitempty"` +} + +// ToImageAnalysisWireFormat extracts and trims an ImageAnalysisResult CRD +// into a compact wire format suitable for gRPC transport. +func ToImageAnalysisWireFormat(obj *unstructured.Unstructured) (*ImageAnalysisWireFormat, error) { + spec, found, err := unstructured.NestedMap(obj.Object, "spec") + if err != nil || !found { + return nil, fmt.Errorf("missing spec in ImageAnalysisResult: %w", err) + } + + status, _, _ := unstructured.NestedMap(obj.Object, "status") + + wf := &ImageAnalysisWireFormat{} + + // Top-level fields + wf.ImageRef, _, _ = unstructured.NestedString(spec, "imageRef") + wf.ImageDigest, _, _ = unstructured.NestedString(spec, "imageDigest") + wf.ImageSizeBytes, _, _ = unstructured.NestedInt64(spec, "imageSizeBytes") + + // Image source + wf.ImageSourceType, _, _ = unstructured.NestedString(spec, "imageSource", "type") + + // Analysis fields + analysis, _, _ := unstructured.NestedMap(spec, "analysis") + if analysis != nil { + wf.Efficiency, _, _ = unstructured.NestedString(analysis, "efficiency") + wf.WastedBytes, _, _ = unstructured.NestedInt64(analysis, "wastedBytes") + wf.UserWastedPercent, _, _ = unstructured.NestedString(analysis, "userWastedPercent") + wf.Passed, _, _ = unstructured.NestedBool(analysis, "passed") + wf.LayerCount = nestedInt(analysis, "layerCount") + + // Extract layers (capped) + wf.Layers = extractLayers(analysis) + + // Extract wasted files (capped) + wf.WastedFiles = extractWastedFiles(analysis) + + // Extract file analysis + wf.FileAnalysis = extractFileAnalysis(analysis) + } + + // Workload summary (aggregate only — drop individual workloadReferences) + wf.WorkloadSummary = extractWorkloadSummary(spec) + + // Status fields + if status != nil { + wf.AnalyzedAt, _, _ = unstructured.NestedString(status, "analyzedAt") + wf.AnalysisDurationSecs = nestedInt(status, "analysisDurationSeconds") + } + + return wf, nil +} + +func extractLayers(analysis map[string]interface{}) []LayerWire { + raw, found, _ := unstructured.NestedSlice(analysis, "layers") + if !found { + return nil + } + + limit := len(raw) + if limit > maxWireLayers { + limit = maxWireLayers + } + + layers := make([]LayerWire, 0, limit) + for i := 0; i < limit; i++ { + m, ok := raw[i].(map[string]interface{}) + if !ok { + continue + } + l := LayerWire{ + Index: nestedInt(m, "index"), + } + l.Digest, _, _ = unstructured.NestedString(m, "digest") + l.SizeBytes, _, _ = unstructured.NestedInt64(m, "sizeBytes") + l.Command, _, _ = unstructured.NestedString(m, "command") + layers = append(layers, l) + } + return layers +} + +func extractWastedFiles(analysis map[string]interface{}) []WastedFileWire { + raw, found, _ := unstructured.NestedSlice(analysis, "wastedFiles") + if !found { + return nil + } + + limit := len(raw) + if limit > maxWireWastedFiles { + limit = maxWireWastedFiles + } + + files := make([]WastedFileWire, 0, limit) + for i := 0; i < limit; i++ { + m, ok := raw[i].(map[string]interface{}) + if !ok { + continue + } + path, _, _ := unstructured.NestedString(m, "path") + if len(path) > maxWireFilePath { + path = path[:maxWireFilePath] + } + size, _, _ := unstructured.NestedInt64(m, "sizeBytes") + files = append(files, WastedFileWire{Path: path, SizeBytes: size}) + } + return files +} + +func extractFileAnalysis(analysis map[string]interface{}) *FileAnalysisWire { + fa, found, _ := unstructured.NestedMap(analysis, "fileAnalysis") + if !found || fa == nil { + return nil + } + return &FileAnalysisWire{ + TotalFiles: nestedInt(fa, "totalFiles"), + ModifiedFiles: nestedInt(fa, "modifiedFiles"), + AddedFiles: nestedInt(fa, "addedFiles"), + RemovedFiles: nestedInt(fa, "removedFiles"), + } +} + +func extractWorkloadSummary(spec map[string]interface{}) WorkloadSummaryWire { + ws, found, _ := unstructured.NestedMap(spec, "workloadSummary") + if !found || ws == nil { + return WorkloadSummaryWire{} + } + + summary := WorkloadSummaryWire{ + TotalContainers: nestedInt(ws, "totalContainers"), + TotalWorkloads: nestedInt(ws, "totalWorkloads"), + NodesRunningImage: nestedInt(ws, "nodesRunningImage"), + } + + nsSlice, found, _ := unstructured.NestedStringSlice(ws, "namespaces") + if found { + summary.Namespaces = nsSlice + } + + return summary +} + +// nestedInt extracts an int from a map, handling JSON number types (float64). +func nestedInt(m map[string]interface{}, key string) int { + val, ok := m[key] + if !ok { + return 0 + } + switch v := val.(type) { + case int64: + return int(v) + case float64: + return int(v) + case json.Number: + n, _ := v.Int64() + return int(n) + default: + return 0 + } +} diff --git a/internal/collector/interface.go b/internal/collector/interface.go index 320eb0e2..b5529703 100644 --- a/internal/collector/interface.go +++ b/internal/collector/interface.go @@ -150,6 +150,7 @@ const ( ContainerCrashLoopEvent ContainerStartupLifecycle ContainerCPUThrottleEvent + ImageAnalysisResult ) // String returns the string representation of the ResourceType @@ -214,6 +215,7 @@ func (r ResourceType) String() string { ContainerCrashLoopEvent: "container_crashloop_event", ContainerStartupLifecycle: "container_startup_lifecycle", ContainerCPUThrottleEvent: "container_cpu_throttle_event", + ImageAnalysisResult: "image_analysis_result", } if name, ok := names[r]; ok { @@ -343,6 +345,8 @@ func (r ResourceType) ProtoType() gen.ResourceType { return gen.ResourceType_RESOURCE_TYPE_CONTAINER_STARTUP_LIFECYCLE case ContainerCPUThrottleEvent: return gen.ResourceType_RESOURCE_TYPE_CONTAINER_CPU_THROTTLE_EVENT + case ImageAnalysisResult: + return gen.ResourceType_RESOURCE_TYPE_IMAGE_ANALYSIS_RESULT default: return gen.ResourceType_RESOURCE_TYPE_UNSPECIFIED } diff --git a/internal/controller/collectionpolicy_controller.go b/internal/controller/collectionpolicy_controller.go index 691c4947..1507dfe6 100644 --- a/internal/controller/collectionpolicy_controller.go +++ b/internal/controller/collectionpolicy_controller.go @@ -3000,6 +3000,17 @@ func (r *CollectionPolicyReconciler) registerResourceCollectors( ), name: collector.CNPGCluster, }, + // ImageAnalysisResult collector for syncing dive image analysis results to control plane + { + collector: collector.NewImageAnalysisResultCollector( + r.DynamicClient, + collector.DefaultMaxBatchSize, + collector.DefaultMaxBatchTime, + logger, + r.TelemetryLogger, + ), + name: collector.ImageAnalysisResult, + }, } // Register all collectors diff --git a/internal/transport/dakr_client.go b/internal/transport/dakr_client.go index 1d2bae42..7bed7450 100644 --- a/internal/transport/dakr_client.go +++ b/internal/transport/dakr_client.go @@ -15,6 +15,7 @@ import ( "github.com/devzero-inc/zxporter/internal/collector" "github.com/devzero-inc/zxporter/internal/version" "github.com/go-logr/logr" + "github.com/klauspost/compress/zstd" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/types/known/structpb" "google.golang.org/protobuf/types/known/timestamppb" @@ -384,11 +385,45 @@ func (c *RealDakrClient) splitBatchBySize(resourceItems []*gen.ResourceItem) [][ return batches } +// compressZstd compresses data using zstd at default speed level. +// This provides ~70-80% compression on JSON payloads while being faster to decompress than gzip. +func compressZstd(data []byte) ([]byte, error) { + enc, err := zstd.NewWriter(nil, zstd.WithEncoderLevel(zstd.SpeedDefault)) + if err != nil { + return nil, fmt.Errorf("failed to create zstd encoder: %w", err) + } + defer enc.Close() + return enc.EncodeAll(data, make([]byte, 0, len(data)/2)), nil +} + // SendResourceBatch sends a batch of resources to Dakr through gRPC func (c *RealDakrClient) SendResourceBatch(ctx context.Context, resources []collector.CollectedResource, resourceType collector.ResourceType) (string, error) { resourceItems := make([]*gen.ResourceItem, 0, len(resources)) for _, resource := range resources { + // ImageAnalysisResult: use data_bytes with zstd compression to minimize payload + if resource.ResourceType == collector.ImageAnalysisResult { + jsonBytes, err := json.Marshal(resource.Object) + if err != nil { + c.logger.Error(err, "Failed to marshal ImageAnalysisResult for batch item", "key", resource.Key) + continue + } + compressed, err := compressZstd(jsonBytes) + if err != nil { + c.logger.Error(err, "Failed to compress ImageAnalysisResult, falling back to raw JSON", "key", resource.Key) + compressed = jsonBytes + } + item := &gen.ResourceItem{ + Key: resource.Key, + Timestamp: timestamppb.New(resource.Timestamp), + EventType: resource.EventType.ProtoType(), + DataBytes: compressed, + ResourceType: resource.ResourceType.ProtoType(), + } + resourceItems = append(resourceItems, item) + continue + } + // Convert resource data to structpb for protobuf serialization data, err := c.toStructpb(resource.Object) if err != nil { diff --git a/proto/dakr_proto_descriptor.bin b/proto/dakr_proto_descriptor.bin index 372ed000dfd99eff401ee70fbf85e6561c58057c..cf5353a6acc099acb9d6f2906e662ed099c8cf8e 100644 GIT binary patch delta 108940 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⁢?aQ>n{2%KO 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 F{vVIptK0wp delta 98568 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�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

TN2rO)_D+tz?QZ!fT;N`*}IjOCGhuP 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 From 133a169e1e41b00fb85a78a61d382cadf30fac83 Mon Sep 17 00:00:00 2001 From: Parthiba-Hazra Date: Mon, 30 Mar 2026 22:56:10 +0530 Subject: [PATCH 4/7] ci and installer staffs --- .../workflows/push-image-analyzer-image.yml | 297 ++++++++++++++++++ Makefile | 9 + .../rbac/image_analyzer_service_account.yaml | 10 + config/rbac/kustomization.yaml | 2 + dist/backend-install.yaml | 40 +++ dist/install.yaml | 40 +++ dist/installer_updater.yaml | 9 + dist/zxporter.yaml | 40 +++ 8 files changed, 447 insertions(+) create mode 100644 .github/workflows/push-image-analyzer-image.yml create mode 100644 config/rbac/image_analyzer_service_account.yaml diff --git a/.github/workflows/push-image-analyzer-image.yml b/.github/workflows/push-image-analyzer-image.yml new file mode 100644 index 00000000..59ba0cc4 --- /dev/null +++ b/.github/workflows/push-image-analyzer-image.yml @@ -0,0 +1,297 @@ +name: "Push image-analyzer to Docker Hub and ECR" + +on: + workflow_dispatch: + inputs: + push_latest: + description: "Push latest tag" + required: false + type: boolean + default: false + push: + tags: + - "v*" + +permissions: + contents: write + packages: write + id-token: write + +jobs: + package-and-push: + name: Package & Push Docker image + runs-on: namespace-profile-dz-generic + outputs: + is_release: ${{ steps.version.outputs.is_release }} + + steps: + - name: Checkout Code Repository + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Extract Version Info + id: version + run: | + # Get the most recent tag that matches the release pattern (v*.*.*) + # Exclude chart-* tags + GITVERSION=$(git describe --tags --match="v[0-9]*.[0-9]*.[0-9]*" --exclude="chart-*" --always || echo "v0.0.0-$(git rev-parse --short HEAD)") + echo "GITVERSION=${GITVERSION}" >> $GITHUB_ENV + if [[ "$GITVERSION" =~ ^v([0-9]+)\.([0-9]+)\.(.+)$ ]]; then + MAJOR=${BASH_REMATCH[1]} + MINOR=${BASH_REMATCH[2]} + PATCH=${BASH_REMATCH[3]} + PATCH_SHORT=${PATCH%%[-]*} + FULLV=v${MAJOR}.${MINOR}.${PATCH_SHORT} + + echo "MAJOR=${MAJOR}" >> $GITHUB_ENV + echo "MINOR=${MINOR}" >> $GITHUB_ENV + echo "PATCH=${PATCH}" >> $GITHUB_ENV + echo "PATCH_SHORT=${PATCH_SHORT}" >> $GITHUB_ENV + echo "FULLV=${FULLV}" >> $GITHUB_ENV + echo "IS_RELEASE=true" >> $GITHUB_ENV + + echo "Debug: MAJOR=${BASH_REMATCH[1]}, MINOR=${BASH_REMATCH[2]}, PATCH=${PATCH}, PATCH_SHORT=${PATCH_SHORT}" + echo "Debug: FULLV=${FULLV}" + echo "is_release=${IS_RELEASE}" >> $GITHUB_OUTPUT + else + echo "MAJOR=0" >> $GITHUB_ENV + echo "MINOR=0" >> $GITHUB_ENV + echo "PATCH=0" >> $GITHUB_ENV + echo "FULLV=v0.0.0" >> $GITHUB_ENV + echo "IS_RELEASE=false" >> $GITHUB_ENV + echo "is_release=false" >> $GITHUB_OUTPUT + fi + + - name: Log in to Docker Hub + uses: docker/login-action@v3 + with: + username: ${{ secrets.DOCKERHUB_ZXPORTER_BALANCE_USERNAME }} + password: ${{ secrets.DOCKERHUB_ZXPORTER_BALANCE_TOKEN }} + + - name: Set up Docker Buildx + uses: namespacelabs/nscloud-setup-buildx-action@v0 + + - name: Check existing tags and validate + id: validate_tags + env: + GITVERSION: ${{ env.GITVERSION }} + FULLV: ${{ env.FULLV }} + IS_RELEASE: ${{ env.IS_RELEASE }} + PUSH_LATEST: ${{ inputs.push_latest || false }} + run: | + # Function to check if a Docker tag exists in registry + check_tag_exists() { + local tag=$1 + echo "Checking if tag '$tag' exists in registry..." + + # Use docker manifest inspect to check if tag exists + if docker manifest inspect docker.io/devzeroinc/image-analyzer:$tag >/dev/null 2>&1; then + echo "Tag '$tag' exists in registry" + return 0 + else + echo "Tag '$tag' does not exist in registry" + return 1 + fi + } + + # Build the list of tags that will be created + TAGS=("$GITVERSION") + + if [[ "$PUSH_LATEST" == "true" ]]; then + TAGS+=("latest") + fi + + if [[ "$IS_RELEASE" == "true" ]]; then + TAGS+=("$FULLV") + fi + + echo "Tags to be processed: ${TAGS[@]}" + + # Check existing tags + EXISTING_TAGS=() + for tag in "${TAGS[@]}"; do + if check_tag_exists "$tag"; then + EXISTING_TAGS+=("$tag") + fi + done + + # Handle existing tags + if [ ${#EXISTING_TAGS[@]} -gt 0 ]; then + echo "Found existing tags: ${EXISTING_TAGS[@]}" + + # Check if any non-latest tags exist + NON_LATEST_EXISTING=() + for tag in "${EXISTING_TAGS[@]}"; do + if [[ "$tag" != "latest" ]]; then + NON_LATEST_EXISTING+=("$tag") + fi + done + + # Def have to fail if any non-latest tags exist + if [ ${#NON_LATEST_EXISTING[@]} -gt 0 ]; then + echo "ERROR: The following tags already exist in the registry and cannot be overridden:" + printf ' - %s\n' "${NON_LATEST_EXISTING[@]}" + echo "" + echo "To avoid accidentally overriding existing images, this build is being stopped." + echo "If you need to rebuild these tags, please delete them from the registry first." + exit 1 + fi + + # check latest tag to push or not + for tag in "${EXISTING_TAGS[@]}"; do + if [[ "$tag" == "latest" ]]; then + if [[ "$PUSH_LATEST" != "true" ]]; then + echo "ERROR: The 'latest' tag already exists in the registry." + echo "To override the 'latest' tag, you must set 'push_latest' to true in the workflow dispatch." + echo "Current push_latest value: $PUSH_LATEST" + exit 1 + else + echo "WARNING: The 'latest' tag exists but will be overridden because push_latest=true" + fi + fi + done + fi + + echo "Tag validation passed. Proceeding with build..." + + # Export validated tags for the next step + TAGS_STRING="${TAGS[*]}" + echo "VALIDATED_TAGS=${TAGS_STRING}" >> $GITHUB_OUTPUT + echo "Validated tags to build: ${TAGS_STRING}" + + - name: Configure AWS credentials for ECR using OIDC + uses: aws-actions/configure-aws-credentials@v4 + with: + role-to-assume: ${{ secrets.AWS_ECR_PUSH_ROLE_ARN }} + role-session-name: GitHubActions-ImageAnalyzerBuild + aws-region: us-east-1 + + - name: Login to Amazon ECR + id: login-ecr + uses: aws-actions/amazon-ecr-login@v2 + with: + registry-type: public + + - name: Build and push multi-arch images + env: + GITVERSION: ${{ env.GITVERSION }} + VALIDATED_TAGS: ${{ steps.validate_tags.outputs.VALIDATED_TAGS }} + run: | + # Use the validated tags from the previous step + read -ra TAGS <<< "$VALIDATED_TAGS" + + echo "Building and pushing validated tags: ${TAGS[@]}" + + for tag in "${TAGS[@]}"; do + echo "Building and pushing tag: $tag to both Docker Hub and ECR" + + docker buildx build \ + --platform linux/amd64,linux/arm64 \ + --push \ + -t docker.io/devzeroinc/image-analyzer:$tag \ + -t public.ecr.aws/devzeroinc/image-analyzer:$tag \ + -f internal/analyzer/Dockerfile \ + internal/analyzer/ + done + + echo "Successfully built and pushed all validated tags: ${TAGS[@]}" + + update-helm-values-image-tag-pr: + name: Update Helm values analyzerImage.tag and create PR + runs-on: namespace-profile-dz-generic + needs: [package-and-push] + if: ${{ needs.package-and-push.outputs.is_release == 'true' }} + steps: + - name: Get token that will be used to push branch and create PR + id: get_workflow_token + uses: peter-murray/workflow-application-token-action@v4 + with: + application_id: ${{ secrets.WORKFLOW_ACTIONS_APP_ID }} + application_private_key: ${{ secrets.WORKFLOW_ACTIONS_PEM }} + organization: devzero-inc + permissions: "contents:write, pull_requests:write" + + - name: Checkout repo + uses: actions/checkout@v3 + with: + repository: devzero-inc/zxporter + path: zxporter-tmp + token: ${{ steps.get_workflow_token.outputs.token }} + + - name: Update analyzerImage.tag in values.yaml + run: | + NEW_TAG="${{ env.FULLV }}" + sed -i.bak '/analyzerImage:/,/tag:/{s/tag: .*/tag: "'"$NEW_TAG"'"/}' zxporter-tmp/helm-chart/zxporter/values.yaml + rm zxporter-tmp/helm-chart/zxporter/values.yaml.bak || true + + - name: Check if there are changes + id: changes + run: | + cd zxporter-tmp + if git diff --exit-code; then + echo "No changes" + echo "changes=false" >> $GITHUB_OUTPUT + else + echo "Changes" + echo "changes=true" >> $GITHUB_OUTPUT + fi + + - name: Create branch, commit, and push if changes exist + if: steps.changes.outputs.changes == 'true' + env: + GITHUB_TOKEN: ${{ steps.get_workflow_token.outputs.token }} + run: | + cd zxporter-tmp + git config --global user.name "github-actions-dzbot" + git config --global user.email "github-actions@github.com" + + branch="update-image-analyzer-helm-${{ env.FULLV }}" + git checkout -b "$branch" + + # Check if anything in target paths actually changed + if git diff --quiet helm-chart/*; then + echo "No changes to commit. Skipping push and PR." + echo "SHOULD_CREATE_PR=false" >> $GITHUB_ENV + else + git add helm-chart/* + git commit -m "update analyzerImage.tag in Helm values.yaml to ${{ env.FULLV }}" + git push origin "$branch" + echo "SHOULD_CREATE_PR=true" >> $GITHUB_ENV + fi + + - name: Open Pull Request + if: env.SHOULD_CREATE_PR == 'true' + env: + GITHUB_TOKEN: ${{ steps.get_workflow_token.outputs.token }} + run: | + pr_url=$(gh pr create \ + --title "update analyzerImage.tag in Helm values.yaml to ${{ env.FULLV }}" \ + --body "This PR updates the value for 'imageAnalysis.analyzerImage.tag' in the helm chart to '${{ env.FULLV }}'." \ + --head "update-image-analyzer-helm-${{ env.FULLV }}" \ + --base main) + echo "PR_URL=${pr_url}" >> $GITHUB_ENV + + - name: Checkout services repo for access to private Slack actions + uses: actions/checkout@v4 + with: + repository: devzero-inc/services + token: ${{ steps.get_workflow_token.outputs.token }} + path: services + ref: main + fetch-depth: 1 + + - name: Notify Slack on failure + uses: ./services/.github/actions/slack-notify-failure + if: always() + with: + slack_bot_token: ${{ secrets.SLACK_BOT_TOKEN }} + workflow_name: "Update image-analyzer helm chart" + + - name: Notify Slack on success + uses: ./services/.github/actions/slack-notify-success + if: env.SHOULD_CREATE_PR == 'true' + with: + slack_bot_token: ${{ secrets.SLACK_BOT_TOKEN }} + workflow_name: "Update image-analyzer helm chart" + pr_url: ${{ env.PR_URL }} diff --git a/Makefile b/Makefile index b988bd39..455b7c97 100644 --- a/Makefile +++ b/Makefile @@ -261,6 +261,15 @@ docker-build-analyzer: ## Build docker image for the image analyzer docker-push-analyzer: ## Push docker image for the image analyzer $(CONTAINER_TOOL) push ${IMG_ANALYZER} +.PHONY: docker-buildx-analyzer +docker-buildx-analyzer: ## Build and push multi-arch docker image for the image analyzer + $(CONTAINER_TOOL) buildx build \ + --platform linux/amd64,linux/arm64 \ + --push \ + -t ${IMG_ANALYZER} \ + -f internal/analyzer/Dockerfile \ + internal/analyzer/ + # zxporter-netmon images IMG_NETMON ?= ttl.sh/zxporter-netmon:latest diff --git a/config/rbac/image_analyzer_service_account.yaml b/config/rbac/image_analyzer_service_account.yaml new file mode 100644 index 00000000..d34604d3 --- /dev/null +++ b/config/rbac/image_analyzer_service_account.yaml @@ -0,0 +1,10 @@ +# ServiceAccount for image analysis batch jobs. +# Jobs don't access the K8s API — this SA is only for imagePullSecrets +# to pull the analyzer image itself from private registries if needed. +apiVersion: v1 +kind: ServiceAccount +metadata: + name: image-analyzer + labels: + app.kubernetes.io/name: devzero-zxporter + app.kubernetes.io/component: image-analysis diff --git a/config/rbac/kustomization.yaml b/config/rbac/kustomization.yaml index 8163a1b0..0c7e8a08 100644 --- a/config/rbac/kustomization.yaml +++ b/config/rbac/kustomization.yaml @@ -24,4 +24,6 @@ resources: # if you do not want those helpers be installed with your Project. - collectionpolicy_editor_role.yaml - collectionpolicy_viewer_role.yaml +# ServiceAccount for image analysis batch jobs (imagePullSecrets only, no API access) +- image_analyzer_service_account.yaml diff --git a/dist/backend-install.yaml b/dist/backend-install.yaml index 44bfb308..1299df0d 100644 --- a/dist/backend-install.yaml +++ b/dist/backend-install.yaml @@ -832,6 +832,15 @@ metadata: name: devzero-zxporter-controller-manager namespace: devzero-zxporter --- +apiVersion: v1 +kind: ServiceAccount +metadata: + labels: + app.kubernetes.io/component: image-analysis + app.kubernetes.io/name: devzero-zxporter + name: devzero-zxporter-image-analyzer + namespace: devzero-zxporter +--- apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: @@ -1399,6 +1408,37 @@ data: EXCLUDED_STATEFULSETS: "" EXCLUDED_STORAGECLASSES: "" EXCLUDED_VPAS: "" + IMAGE_ANALYSIS_ANALYZER_IMAGE: devzeroinc/image-analyzer:v1 + IMAGE_ANALYSIS_BATCH_SIZE: "10" + IMAGE_ANALYSIS_CONTAINERD_NAMESPACE: k8s.io + IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH: /run/containerd/containerd.sock + IMAGE_ANALYSIS_CRON_EXPRESSION: "" + IMAGE_ANALYSIS_ENABLED: "true" + IMAGE_ANALYSIS_EXCLUDED_IMAGES: registry.k8s.io/pause:* + IMAGE_ANALYSIS_EXCLUDED_NAMESPACES: kube-system,kube-public + IMAGE_ANALYSIS_FALLBACK_TO_REMOTE: "true" + IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT: "0.20" + IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES: 50MB + IMAGE_ANALYSIS_INCLUDED_IMAGES: "" + IMAGE_ANALYSIS_INTERVAL_DAYS: "7" + IMAGE_ANALYSIS_JOB_CPU_LIMIT: "1" + IMAGE_ANALYSIS_JOB_CPU_REQUEST: 500m + IMAGE_ANALYSIS_JOB_MEMORY_LIMIT: 4Gi + IMAGE_ANALYSIS_JOB_MEMORY_REQUEST: 1Gi + IMAGE_ANALYSIS_JOB_NAMESPACE: devzero-zxporter + IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES: "30" + IMAGE_ANALYSIS_JOB_TOLERATIONS: '[]' + IMAGE_ANALYSIS_LOWEST_EFFICIENCY: "0.90" + IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS: "10" + IMAGE_ANALYSIS_MAX_JOBS_PER_NODE: "1" + IMAGE_ANALYSIS_MAX_RETRIES: "2" + IMAGE_ANALYSIS_PREFER_LOCAL: "true" + IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET: "" + IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE: "30" + IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT: 5m + IMAGE_ANALYSIS_RESULT_RETENTION_DAYS: "30" + IMAGE_ANALYSIS_TARGET_NAMESPACES: "" + IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT: 10Gi K8S_PROVIDER: '{{ .k8s_provider }}' KUBE_CONTEXT_NAME: '{{ .kube_context_name }}' MASK_SECRET_DATA: "" diff --git a/dist/install.yaml b/dist/install.yaml index 04e61b48..846aaf1d 100644 --- a/dist/install.yaml +++ b/dist/install.yaml @@ -837,6 +837,15 @@ metadata: name: devzero-zxporter-controller-manager namespace: devzero-zxporter --- +apiVersion: v1 +kind: ServiceAccount +metadata: + labels: + app.kubernetes.io/component: image-analysis + app.kubernetes.io/name: devzero-zxporter + name: devzero-zxporter-image-analyzer + namespace: devzero-zxporter +--- apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: @@ -1404,6 +1413,37 @@ data: EXCLUDED_STATEFULSETS: "" EXCLUDED_STORAGECLASSES: "" EXCLUDED_VPAS: "" + IMAGE_ANALYSIS_ANALYZER_IMAGE: devzeroinc/image-analyzer:v1 + IMAGE_ANALYSIS_BATCH_SIZE: "10" + IMAGE_ANALYSIS_CONTAINERD_NAMESPACE: k8s.io + IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH: /run/containerd/containerd.sock + IMAGE_ANALYSIS_CRON_EXPRESSION: "" + IMAGE_ANALYSIS_ENABLED: "true" + IMAGE_ANALYSIS_EXCLUDED_IMAGES: registry.k8s.io/pause:* + IMAGE_ANALYSIS_EXCLUDED_NAMESPACES: kube-system,kube-public + IMAGE_ANALYSIS_FALLBACK_TO_REMOTE: "true" + IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT: "0.20" + IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES: 50MB + IMAGE_ANALYSIS_INCLUDED_IMAGES: "" + IMAGE_ANALYSIS_INTERVAL_DAYS: "7" + IMAGE_ANALYSIS_JOB_CPU_LIMIT: "1" + IMAGE_ANALYSIS_JOB_CPU_REQUEST: 500m + IMAGE_ANALYSIS_JOB_MEMORY_LIMIT: 4Gi + IMAGE_ANALYSIS_JOB_MEMORY_REQUEST: 1Gi + IMAGE_ANALYSIS_JOB_NAMESPACE: devzero-zxporter + IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES: "30" + IMAGE_ANALYSIS_JOB_TOLERATIONS: '[]' + IMAGE_ANALYSIS_LOWEST_EFFICIENCY: "0.90" + IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS: "10" + IMAGE_ANALYSIS_MAX_JOBS_PER_NODE: "1" + IMAGE_ANALYSIS_MAX_RETRIES: "2" + IMAGE_ANALYSIS_PREFER_LOCAL: "true" + IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET: "" + IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE: "30" + IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT: 5m + IMAGE_ANALYSIS_RESULT_RETENTION_DAYS: "30" + IMAGE_ANALYSIS_TARGET_NAMESPACES: "" + IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT: 10Gi K8S_PROVIDER: '{{ .k8s_provider }}' KUBE_CONTEXT_NAME: '{{ .kube_context_name }}' MASK_SECRET_DATA: "" diff --git a/dist/installer_updater.yaml b/dist/installer_updater.yaml index c14d7841..fc276b6b 100644 --- a/dist/installer_updater.yaml +++ b/dist/installer_updater.yaml @@ -832,6 +832,15 @@ metadata: name: devzero-zxporter-controller-manager namespace: devzero-zxporter --- +apiVersion: v1 +kind: ServiceAccount +metadata: + labels: + app.kubernetes.io/component: image-analysis + app.kubernetes.io/name: devzero-zxporter + name: devzero-zxporter-image-analyzer + namespace: devzero-zxporter +--- apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: diff --git a/dist/zxporter.yaml b/dist/zxporter.yaml index a720ddba..9934a633 100644 --- a/dist/zxporter.yaml +++ b/dist/zxporter.yaml @@ -16,6 +16,15 @@ metadata: name: devzero-zxporter-controller-manager namespace: devzero-zxporter --- +apiVersion: v1 +kind: ServiceAccount +metadata: + labels: + app.kubernetes.io/component: image-analysis + app.kubernetes.io/name: devzero-zxporter + name: devzero-zxporter-image-analyzer + namespace: devzero-zxporter +--- apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: @@ -583,6 +592,37 @@ data: EXCLUDED_STATEFULSETS: "" EXCLUDED_STORAGECLASSES: "" EXCLUDED_VPAS: "" + IMAGE_ANALYSIS_ANALYZER_IMAGE: devzeroinc/image-analyzer:v1 + IMAGE_ANALYSIS_BATCH_SIZE: "10" + IMAGE_ANALYSIS_CONTAINERD_NAMESPACE: k8s.io + IMAGE_ANALYSIS_CONTAINERD_SOCKET_PATH: /run/containerd/containerd.sock + IMAGE_ANALYSIS_CRON_EXPRESSION: "" + IMAGE_ANALYSIS_ENABLED: "true" + IMAGE_ANALYSIS_EXCLUDED_IMAGES: registry.k8s.io/pause:* + IMAGE_ANALYSIS_EXCLUDED_NAMESPACES: kube-system,kube-public + IMAGE_ANALYSIS_FALLBACK_TO_REMOTE: "true" + IMAGE_ANALYSIS_HIGHEST_USER_WASTED_PERCENT: "0.20" + IMAGE_ANALYSIS_HIGHEST_WASTED_BYTES: 50MB + IMAGE_ANALYSIS_INCLUDED_IMAGES: "" + IMAGE_ANALYSIS_INTERVAL_DAYS: "7" + IMAGE_ANALYSIS_JOB_CPU_LIMIT: "1" + IMAGE_ANALYSIS_JOB_CPU_REQUEST: 500m + IMAGE_ANALYSIS_JOB_MEMORY_LIMIT: 4Gi + IMAGE_ANALYSIS_JOB_MEMORY_REQUEST: 1Gi + IMAGE_ANALYSIS_JOB_NAMESPACE: devzero-zxporter + IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES: "30" + IMAGE_ANALYSIS_JOB_TOLERATIONS: '[]' + IMAGE_ANALYSIS_LOWEST_EFFICIENCY: "0.90" + IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS: "10" + IMAGE_ANALYSIS_MAX_JOBS_PER_NODE: "1" + IMAGE_ANALYSIS_MAX_RETRIES: "2" + IMAGE_ANALYSIS_PREFER_LOCAL: "true" + IMAGE_ANALYSIS_REGISTRY_AUTH_SECRET: "" + IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE: "30" + IMAGE_ANALYSIS_REMOTE_PULL_TIMEOUT: 5m + IMAGE_ANALYSIS_RESULT_RETENTION_DAYS: "30" + IMAGE_ANALYSIS_TARGET_NAMESPACES: "" + IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT: 10Gi K8S_PROVIDER: '{{ .k8s_provider }}' KUBE_CONTEXT_NAME: '{{ .kube_context_name }}' MASK_SECRET_DATA: "" From 9608cd0a8dbf89dc11406f47db20dfe6518482ea Mon Sep 17 00:00:00 2001 From: Parthiba-Hazra Date: Mon, 30 Mar 2026 22:56:27 +0530 Subject: [PATCH 5/7] not to use latest tag for dive --- internal/analyzer/Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/analyzer/Dockerfile b/internal/analyzer/Dockerfile index 2952f859..ef4d57b0 100644 --- a/internal/analyzer/Dockerfile +++ b/internal/analyzer/Dockerfile @@ -18,7 +18,7 @@ RUN apk add --no-cache bash jq coreutils COPY --from=gcr.io/go-containerregistry/crane:latest /ko-app/crane /usr/local/bin/crane # dive — the core image analysis tool -COPY --from=wagoodman/dive:latest /usr/local/bin/dive /usr/local/bin/dive +COPY --from=wagoodman/dive:v0.13 /usr/local/bin/dive /usr/local/bin/dive # ctr — containerd CLI for local image export COPY --from=docker.io/rancher/k3s:v1.31.4-k3s1 /bin/ctr /usr/local/bin/ctr From 6b97d38a032ffc9909e5290c03cbd90913684c60 Mon Sep 17 00:00:00 2001 From: Parthiba-Hazra Date: Mon, 30 Mar 2026 22:59:39 +0530 Subject: [PATCH 6/7] safe casting of int32 --- internal/controller/image_job_manager.go | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/internal/controller/image_job_manager.go b/internal/controller/image_job_manager.go index 8bffb959..48ba9b7c 100644 --- a/internal/controller/image_job_manager.go +++ b/internal/controller/image_job_manager.go @@ -319,7 +319,14 @@ func (m *JobManager) buildJobObject(spec BatchJobSpec) (*batchv1.Job, error) { activeDeadlineSeconds := int64(m.config.JobTimeoutMinutes * 60) // backoffLimit from config. - backoffLimit := int32(m.config.MaxRetries) + retries := m.config.MaxRetries + if retries <= 0 { + retries = 1 + } else if retries > 10 { + // Prevent overflow and unreasonable retry counts. + retries = 10 + } + backoffLimit := int32(retries) ttl := int32(ttlSecondsAfterFinished) From 80e57034ff727544f44c6c07682011633d92768e Mon Sep 17 00:00:00 2001 From: Parthiba-Hazra Date: Mon, 30 Mar 2026 23:06:04 +0530 Subject: [PATCH 7/7] lint fixes --- api/v1/imageanalysisresult_types.go | 6 ++-- .../image_analysis_result_collector.go | 6 +--- internal/controller/image_analysis_config.go | 35 ++++++++++--------- .../controller/image_analysis_config_test.go | 2 +- .../controller/image_analysis_controller.go | 22 ------------ internal/controller/image_discovery.go | 2 +- internal/controller/image_job_manager.go | 2 +- internal/controller/image_job_manager_test.go | 4 +-- internal/controller/image_result_collector.go | 33 +++++++++-------- internal/transport/dakr_client.go | 2 +- 10 files changed, 48 insertions(+), 66 deletions(-) diff --git a/api/v1/imageanalysisresult_types.go b/api/v1/imageanalysisresult_types.go index 6bdc5a81..a1261244 100644 --- a/api/v1/imageanalysisresult_types.go +++ b/api/v1/imageanalysisresult_types.go @@ -184,9 +184,9 @@ type ImageAnalysisResultStatus struct { Message string `json:"message,omitempty"` } -//+kubebuilder:object:root=true -//+kubebuilder:subresource:status -//+kubebuilder:resource:scope=Cluster +// +kubebuilder:object:root=true +// +kubebuilder:subresource:status +// +kubebuilder:resource:scope=Cluster //+kubebuilder:printcolumn:name="Image",type="string",JSONPath=".spec.imageRef",priority=0 //+kubebuilder:printcolumn:name="Efficiency",type="string",JSONPath=".spec.analysis.efficiency",priority=0 //+kubebuilder:printcolumn:name="Passed",type="boolean",JSONPath=".spec.analysis.passed",priority=0 diff --git a/internal/collector/image_analysis_result_collector.go b/internal/collector/image_analysis_result_collector.go index 2444cd08..208b2e7a 100644 --- a/internal/collector/image_analysis_result_collector.go +++ b/internal/collector/image_analysis_result_collector.go @@ -206,11 +206,7 @@ func (c *ImageAnalysisResultCollector) analysisChanged(oldIAR, newIAR *unstructu // Check if phase changed oldPhase, _, _ := unstructured.NestedString(oldIAR.Object, "status", "phase") newPhase, _, _ := unstructured.NestedString(newIAR.Object, "status", "phase") - if oldPhase != newPhase { - return true - } - - return false + return oldPhase != newPhase } // Stop gracefully shuts down the collector. diff --git a/internal/controller/image_analysis_config.go b/internal/controller/image_analysis_config.go index ae6b28ec..090012e6 100644 --- a/internal/controller/image_analysis_config.go +++ b/internal/controller/image_analysis_config.go @@ -38,18 +38,18 @@ const ( _ENV_IMAGE_ANALYSIS_CRON_EXPRESSION = "IMAGE_ANALYSIS_CRON_EXPRESSION" // Job execution tuning - _ENV_IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS = "IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS" - _ENV_IMAGE_ANALYSIS_MAX_JOBS_PER_NODE = "IMAGE_ANALYSIS_MAX_JOBS_PER_NODE" - _ENV_IMAGE_ANALYSIS_BATCH_SIZE = "IMAGE_ANALYSIS_BATCH_SIZE" - _ENV_IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES = "IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES" - _ENV_IMAGE_ANALYSIS_MAX_RETRIES = "IMAGE_ANALYSIS_MAX_RETRIES" - _ENV_IMAGE_ANALYSIS_JOB_NAMESPACE = "IMAGE_ANALYSIS_JOB_NAMESPACE" - _ENV_IMAGE_ANALYSIS_ANALYZER_IMAGE = "IMAGE_ANALYSIS_ANALYZER_IMAGE" - _ENV_IMAGE_ANALYSIS_JOB_CPU_REQUEST = "IMAGE_ANALYSIS_JOB_CPU_REQUEST" - _ENV_IMAGE_ANALYSIS_JOB_CPU_LIMIT = "IMAGE_ANALYSIS_JOB_CPU_LIMIT" - _ENV_IMAGE_ANALYSIS_JOB_MEMORY_REQUEST = "IMAGE_ANALYSIS_JOB_MEMORY_REQUEST" - _ENV_IMAGE_ANALYSIS_JOB_MEMORY_LIMIT = "IMAGE_ANALYSIS_JOB_MEMORY_LIMIT" - _ENV_IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT = "IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT" + _ENV_IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS = "IMAGE_ANALYSIS_MAX_CONCURRENT_JOBS" + _ENV_IMAGE_ANALYSIS_MAX_JOBS_PER_NODE = "IMAGE_ANALYSIS_MAX_JOBS_PER_NODE" + _ENV_IMAGE_ANALYSIS_BATCH_SIZE = "IMAGE_ANALYSIS_BATCH_SIZE" + _ENV_IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES = "IMAGE_ANALYSIS_JOB_TIMEOUT_MINUTES" + _ENV_IMAGE_ANALYSIS_MAX_RETRIES = "IMAGE_ANALYSIS_MAX_RETRIES" + _ENV_IMAGE_ANALYSIS_JOB_NAMESPACE = "IMAGE_ANALYSIS_JOB_NAMESPACE" + _ENV_IMAGE_ANALYSIS_ANALYZER_IMAGE = "IMAGE_ANALYSIS_ANALYZER_IMAGE" + _ENV_IMAGE_ANALYSIS_JOB_CPU_REQUEST = "IMAGE_ANALYSIS_JOB_CPU_REQUEST" + _ENV_IMAGE_ANALYSIS_JOB_CPU_LIMIT = "IMAGE_ANALYSIS_JOB_CPU_LIMIT" + _ENV_IMAGE_ANALYSIS_JOB_MEMORY_REQUEST = "IMAGE_ANALYSIS_JOB_MEMORY_REQUEST" + _ENV_IMAGE_ANALYSIS_JOB_MEMORY_LIMIT = "IMAGE_ANALYSIS_JOB_MEMORY_LIMIT" + _ENV_IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT = "IMAGE_ANALYSIS_WORKSPACE_SIZE_LIMIT" _ENV_IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE = "IMAGE_ANALYSIS_REGISTRY_PULL_RATE_PER_MINUTE" // Job tolerations @@ -308,7 +308,11 @@ func LoadImageAnalysisConfigFromEnv() (ImageAnalysisConfig, error) { return cfg, err } - // === Validate resource quantities to catch bad values at load time (not at Job creation) === + return cfg, validateResourceQuantities(cfg) +} + +// validateResourceQuantities checks that resource quantity strings are valid at config load time. +func validateResourceQuantities(cfg ImageAnalysisConfig) error { for _, check := range []struct { name, value string }{ @@ -319,9 +323,8 @@ func LoadImageAnalysisConfigFromEnv() (ImageAnalysisConfig, error) { {"WorkspaceSizeLimit", cfg.WorkspaceSizeLimit}, } { if _, err := resource.ParseQuantity(check.value); err != nil { - return cfg, fmt.Errorf("invalid resource quantity for %s (%q): %w", check.name, check.value, err) + return fmt.Errorf("invalid resource quantity for %s (%q): %w", check.name, check.value, err) } } - - return cfg, nil + return nil } diff --git a/internal/controller/image_analysis_config_test.go b/internal/controller/image_analysis_config_test.go index 301e9b4a..5fb61b91 100644 --- a/internal/controller/image_analysis_config_test.go +++ b/internal/controller/image_analysis_config_test.go @@ -60,7 +60,7 @@ func clearImageAnalysisEnvVars(t *testing.T) { _ENV_IMAGE_ANALYSIS_RESULT_RETENTION_DAYS, } for _, v := range envVars { - os.Unsetenv(v) + _ = os.Unsetenv(v) } } diff --git a/internal/controller/image_analysis_controller.go b/internal/controller/image_analysis_controller.go index 595bdff7..e4f9bd84 100644 --- a/internal/controller/image_analysis_controller.go +++ b/internal/controller/image_analysis_controller.go @@ -23,7 +23,6 @@ import ( "time" "github.com/go-logr/logr" - "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/kubernetes" "sigs.k8s.io/controller-runtime/pkg/client" @@ -586,24 +585,3 @@ func (c *ImageAnalysisController) pruneStaleResults(ctx context.Context, discove } } -// updateWorkloadRefs updates workload references for existing CRDs without re-analyzing. -// Used when an image is still running but workload refs may have changed. -func (c *ImageAnalysisController) updateWorkloadRefs( - ctx context.Context, - digest string, - workloadRefs WorkloadRefMap, -) { - crdName := generateCRDName(digest) - existing := &v1.ImageAnalysisResult{} - if err := c.crdClient.Get(ctx, types.NamespacedName{Name: crdName}, existing); err != nil { - return // not found, nothing to update - } - - newRefs, newSummary := buildWorkloadData(digest, workloadRefs) - existing.Spec.WorkloadReferences = newRefs - existing.Spec.WorkloadSummary = newSummary - - if err := c.crdClient.Update(ctx, existing); err != nil { - c.log.V(1).Info("failed to update workload refs", "name", crdName, "error", err) - } -} diff --git a/internal/controller/image_discovery.go b/internal/controller/image_discovery.go index 32f7990b..f11673c6 100644 --- a/internal/controller/image_discovery.go +++ b/internal/controller/image_discovery.go @@ -178,7 +178,7 @@ func (d *ImageDiscoverer) Discover(ctx context.Context) (*DiscoveryResult, error func (d *ImageDiscoverer) processContainerStatuses( pod *corev1.Pod, statuses []corev1.ContainerStatus, - isInit bool, + _ bool, result *DiscoveryResult, globalDedup map[string]bool, containerCountByDigest map[string]int, diff --git a/internal/controller/image_job_manager.go b/internal/controller/image_job_manager.go index 48ba9b7c..8db77b0b 100644 --- a/internal/controller/image_job_manager.go +++ b/internal/controller/image_job_manager.go @@ -177,7 +177,7 @@ func (m *JobManager) SubmitBatches(ctx context.Context, specs []BatchJobSpec) ([ maxPerNode = 1 } - var created []*batchv1.Job + created := make([]*batchv1.Job, 0, len(specs)) for _, spec := range specs { // Check cluster-level concurrency. diff --git a/internal/controller/image_job_manager_test.go b/internal/controller/image_job_manager_test.go index 361d9a60..c0505cab 100644 --- a/internal/controller/image_job_manager_test.go +++ b/internal/controller/image_job_manager_test.go @@ -235,8 +235,8 @@ func TestParseDurationToSeconds(t *testing.T) { assert.Equal(t, 60, parseDurationToSeconds("1m")) assert.Equal(t, 600, parseDurationToSeconds("10m")) assert.Equal(t, 30, parseDurationToSeconds("30s")) - assert.Equal(t, 300, parseDurationToSeconds("invalid")) // fallback - assert.Equal(t, 300, parseDurationToSeconds("")) // fallback + assert.Equal(t, 300, parseDurationToSeconds("invalid")) // fallback + assert.Equal(t, 300, parseDurationToSeconds("")) // fallback assert.Equal(t, 3600, parseDurationToSeconds("1h")) } diff --git a/internal/controller/image_result_collector.go b/internal/controller/image_result_collector.go index f0493a5d..1187301a 100644 --- a/internal/controller/image_result_collector.go +++ b/internal/controller/image_result_collector.go @@ -58,6 +58,11 @@ const ( // Annotation keys. AnnotationFullImageRef = "devzero.io/full-image-ref" + + // Image source types from the batch analyzer. + sourceLocalContainerd = "local-containerd" + sourceRemotePull = "remote-pull" + sourceFailed = "failed" ) // --- Dive JSON types (matches dive's export format) --- @@ -115,16 +120,16 @@ type DiveFile struct { // CollectionResult holds the outcome of collecting results from a single batch Job. type CollectionResult struct { - JobName string - NodeName string - ScanID string - Succeeded []BatchImageResult // images that were analyzed successfully - Failed []BatchImageResult // images that failed (source="failed" or error!="") - ParseErrors int // count of NDJSON lines that couldn't be parsed - TotalLines int // total NDJSON lines parsed - LocalContainerd int // count of images acquired via containerd - RemotePull int // count of images acquired via remote pull - AcquisitionFailed int // count of images where acquisition failed + JobName string + NodeName string + ScanID string + Succeeded []BatchImageResult // images that were analyzed successfully + Failed []BatchImageResult // images that failed (source="failed" or error!="") + ParseErrors int // count of NDJSON lines that couldn't be parsed + TotalLines int // total NDJSON lines parsed + LocalContainerd int // count of images acquired via containerd + RemotePull int // count of images acquired via remote pull + AcquisitionFailed int // count of images where acquisition failed } // --- ResultCollector --- @@ -182,7 +187,7 @@ func (rc *ResultCollector) CollectFromJob(ctx context.Context, job *batchv1.Job) if err != nil { return nil, fmt.Errorf("reading logs from pod %s: %w", pod.Name, err) } - defer logStream.Close() + defer func() { _ = logStream.Close() }() // Parse NDJSON lines. scanner := bufio.NewScanner(logStream) @@ -211,13 +216,13 @@ func (rc *ResultCollector) CollectFromJob(ctx context.Context, job *batchv1.Job) // Classify the result. switch { - case imgResult.Source == "failed" || imgResult.Error != "": + case imgResult.Source == sourceFailed || imgResult.Error != "": result.Failed = append(result.Failed, imgResult) result.AcquisitionFailed++ - case imgResult.Source == "local-containerd": + case imgResult.Source == sourceLocalContainerd: result.Succeeded = append(result.Succeeded, imgResult) result.LocalContainerd++ - case imgResult.Source == "remote-pull": + case imgResult.Source == sourceRemotePull: result.Succeeded = append(result.Succeeded, imgResult) result.RemotePull++ default: diff --git a/internal/transport/dakr_client.go b/internal/transport/dakr_client.go index 7bed7450..4d563e38 100644 --- a/internal/transport/dakr_client.go +++ b/internal/transport/dakr_client.go @@ -392,7 +392,7 @@ func compressZstd(data []byte) ([]byte, error) { if err != nil { return nil, fmt.Errorf("failed to create zstd encoder: %w", err) } - defer enc.Close() + defer func() { _ = enc.Close() }() return enc.EncodeAll(data, make([]byte, 0, len(data)/2)), nil }