Repository: argoproj-labs/old-argo-dataflow (language: python)

Issue:
Message meta-data
Currently messages are just byte-arrays. This the lowest common-denominator, but means that dataflow can't infer useful information about messages. 

Use case for meta-data include:

* Tracing messages through the system to diagnose problem
* Message de-duplication
* Grouping by time
* Verifying messages

What sources already provide:

* HTTP:
  * Etag
  * Content-length
* Kafka:
  * Timestamp
  * Topic
  * Partition
  * Offset
* S3:
  * Etag 
  * Last-modified time
  * Size
  * Owner
* STAN:
  * Sequence
  * Timestamp
  * Redelivery
  * Subject

Cloud-events provides a formal specification:

* ID (UUID)
* Source (URI)
* Type
* Data-content-type
* Dataschema
* Subject
* Time

```json
{
    "specversion" : "1.0",
    "type" : "com.github.pull_request.opened",
    "source" : "https://github.com/cloudevents/spec/pull",
    "subject" : "123",
    "id" : "A234-1234-1234",
    "time" : "2018-04-05T17:31:00Z",
    "comexampleextension1" : "value",
    "comexampleothervalue" : 5,
    "datacontenttype" : "text/xml",
    "data" : "<much wow=\"xml\"/>"
}
```




Discussion / hints:

Fix patch:
diff --git a/README.md b/README.md
index 2cf6e21a..f54297cf 100644
--- a/README.md
+++ b/README.md
@@ -69,6 +69,7 @@ Intermediate:
 * [Scaling](docs/SCALING.md)
 * [Command line](docs/CLI.md)
 * [Expression syntax](docs/EXPRESSIONS.md)
+* [Meta-data](docs/META.md)
 * [Workflow interop](docs/WORKFLOW_INTEROP.md)
 * [Events interop](docs/EVENTS_INTEROP.md)
 * [Kubectl](docs/KUBECTL.md)
diff --git a/api/v1alpha1/abstract_volume_source.go b/api/v1alpha1/abstract_volume_source.go
new file mode 100644
index 00000000..4b0d73ad
--- /dev/null
+++ b/api/v1alpha1/abstract_volume_source.go
@@ -0,0 +1,26 @@
+package v1alpha1
+
+import (
+	"fmt"
+	"strings"
+
+	corev1 "k8s.io/api/core/v1"
+)
+
+type AbstractVolumeSource corev1.VolumeSource
+
+func (in AbstractVolumeSource) getURNParts() (kind string, name string) {
+	if v := in.ConfigMap; v != nil {
+		return "configmap", v.Name
+	} else if v := in.PersistentVolumeClaim; v != nil {
+		return "persistentvolumeclaim", v.ClaimName
+	} else if v := in.Secret; v != nil {
+		return "secret", v.SecretName
+	}
+	panic(fmt.Errorf("un-suppported volume source %v", in))
+}
+
+func (in AbstractVolumeSource) GenURN(cluster, namespace string) string {
+	kind, name := in.getURNParts()
+	return fmt.Sprintf("urn:dataflow:volume:%s:%s.%s.%s.%s", strings.ToLower(kind), name, kind, namespace, cluster)
+}
diff --git a/api/v1alpha1/const.go b/api/v1alpha1/const.go
index cdf147e3..a13806a9 100644
--- a/api/v1alpha1/const.go
+++ b/api/v1alpha1/const.go
@@ -23,6 +23,7 @@ const (
 	EnvImagePrefix      = "ARGO_DATAFLOW_IMAGE_PREFIX" // default "quay.io/argoproj"
 	EnvNamespace        = "ARGO_DATAFLOW_NAMESPACE"
 	EnvPipelineName     = "ARGO_DATAFLOW_PIPELINE_NAME"
+	EnvPod              = "ARGO_DATAFLOW_POD"
 	EnvReplica          = "ARGO_DATAFLOW_REPLICA"
 	EnvStep             = "ARGO_DATAFLOW_STEP"
 	EnvPeekDelay        = "ARGO_DATAFLOW_PEEK_DELAY"         // how long between peeking (default 4m)
diff --git a/api/v1alpha1/cron.go b/api/v1alpha1/cron.go
index e15e9b5e..8e07029d 100644
--- a/api/v1alpha1/cron.go
+++ b/api/v1alpha1/cron.go
@@ -1,7 +1,15 @@
 package v1alpha1
 
+import (
+	"fmt"
+)
+
 type Cron struct {
 	Schedule string `json:"schedule" protobuf:"bytes,1,opt,name=schedule"`
 	// +kubebuilder:default="2006-01-02T15:04:05Z07:00"
 	Layout string `json:"layout,omitempty" protobuf:"bytes,2,opt,name=layout"`
 }
+
+func (in Cron) GenURN(cluster, namespace string) string {
+	return fmt.Sprintf("urn:dataflow:cron:%s", in.Schedule)
+}
diff --git a/api/v1alpha1/db.go b/api/v1alpha1/db.go
index 5c85c9a1..4223b08e 100644
--- a/api/v1alpha1/db.go
+++ b/api/v1alpha1/db.go
@@ -1,6 +1,10 @@
 package v1alpha1
 
-import corev1 "k8s.io/api/core/v1"
+import (
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+)
 
 type Database struct {
 	// +kubebuilder:default=default
@@ -8,6 +12,14 @@ type Database struct {
 	DataSource *DBDataSource `json:"dataSource,omitempty" protobuf:"bytes,2,opt,name=dataSource"`
 }
 
+func (in Database) GenURN(cluster, namespace string) string {
+	if in.DataSource.Value != "" {
+		return fmt.Sprintf("urn:dataflow:db:%s", in.DataSource.Value)
+	} else {
+		return fmt.Sprintf("urn:dataflow:db:%s.secret.%s.%s:%s", in.DataSource.ValueFrom.SecretKeyRef.Name, namespace, cluster, in.DataSource.ValueFrom.SecretKeyRef.Key)
+	}
+}
+
 type DBDataSource struct {
 	Value     string            `json:"value,omitempty" protobuf:"bytes,1,opt,name=value"`
 	ValueFrom *DBDataSourceFrom `json:"valueFrom,omitempty" protobuf:"bytes,2,opt,name=valueFrom"`
diff --git a/api/v1alpha1/generated.pb.go b/api/v1alpha1/generated.pb.go
index 780bdb8d..4c6b40b6 100644
--- a/api/v1alpha1/generated.pb.go
+++ b/api/v1alpha1/generated.pb.go
@@ -147,10 +147,43 @@ func (m *AbstractStep) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_AbstractStep proto.InternalMessageInfo
 
+func (m *AbstractVolumeSource) Reset()      { *m = AbstractVolumeSource{} }
+func (*AbstractVolumeSource) ProtoMessage() {}
+func (*AbstractVolumeSource) Descriptor() ([]byte, []int) {
+	return fileDescriptor_7a4218a80d7ff35f, []int{3}
+}
+
+func (m *AbstractVolumeSource) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+
+func (m *AbstractVolumeSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	b = b[:cap(b)]
+	n, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}
+
+func (m *AbstractVolumeSource) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AbstractVolumeSource.Merge(m, src)
+}
+
+func (m *AbstractVolumeSource) XXX_Size() int {
+	return m.Size()
+}
+
+func (m *AbstractVolumeSource) XXX_DiscardUnknown() {
+	xxx_messageInfo_AbstractVolumeSource.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AbstractVolumeSource proto.InternalMessageInfo
+
 func (m *Backoff) Reset()      { *m = Backoff{} }
 func (*Backoff) ProtoMessage() {}
 func (*Backoff) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{3}
+	return fileDescriptor_7a4218a80d7ff35f, []int{4}
 }
 
 func (m *Backoff) XXX_Unmarshal(b []byte) error {
@@ -183,7 +216,7 @@ var xxx_messageInfo_Backoff proto.InternalMessageInfo
 func (m *Cat) Reset()      { *m = Cat{} }
 func (*Cat) ProtoMessage() {}
 func (*Cat) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{4}
+	return fileDescriptor_7a4218a80d7ff35f, []int{5}
 }
 
 func (m *Cat) XXX_Unmarshal(b []byte) error {
@@ -216,7 +249,7 @@ var xxx_messageInfo_Cat proto.InternalMessageInfo
 func (m *Code) Reset()      { *m = Code{} }
 func (*Code) ProtoMessage() {}
 func (*Code) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{5}
+	return fileDescriptor_7a4218a80d7ff35f, []int{6}
 }
 
 func (m *Code) XXX_Unmarshal(b []byte) error {
@@ -249,7 +282,7 @@ var xxx_messageInfo_Code proto.InternalMessageInfo
 func (m *Container) Reset()      { *m = Container{} }
 func (*Container) ProtoMessage() {}
 func (*Container) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{6}
+	return fileDescriptor_7a4218a80d7ff35f, []int{7}
 }
 
 func (m *Container) XXX_Unmarshal(b []byte) error {
@@ -282,7 +315,7 @@ var xxx_messageInfo_Container proto.InternalMessageInfo
 func (m *Cron) Reset()      { *m = Cron{} }
 func (*Cron) ProtoMessage() {}
 func (*Cron) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{7}
+	return fileDescriptor_7a4218a80d7ff35f, []int{8}
 }
 
 func (m *Cron) XXX_Unmarshal(b []byte) error {
@@ -315,7 +348,7 @@ var xxx_messageInfo_Cron proto.InternalMessageInfo
 func (m *DBDataSource) Reset()      { *m = DBDataSource{} }
 func (*DBDataSource) ProtoMessage() {}
 func (*DBDataSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{8}
+	return fileDescriptor_7a4218a80d7ff35f, []int{9}
 }
 
 func (m *DBDataSource) XXX_Unmarshal(b []byte) error {
@@ -348,7 +381,7 @@ var xxx_messageInfo_DBDataSource proto.InternalMessageInfo
 func (m *DBDataSourceFrom) Reset()      { *m = DBDataSourceFrom{} }
 func (*DBDataSourceFrom) ProtoMessage() {}
 func (*DBDataSourceFrom) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{9}
+	return fileDescriptor_7a4218a80d7ff35f, []int{10}
 }
 
 func (m *DBDataSourceFrom) XXX_Unmarshal(b []byte) error {
@@ -381,7 +414,7 @@ var xxx_messageInfo_DBDataSourceFrom proto.InternalMessageInfo
 func (m *DBSink) Reset()      { *m = DBSink{} }
 func (*DBSink) ProtoMessage() {}
 func (*DBSink) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{10}
+	return fileDescriptor_7a4218a80d7ff35f, []int{11}
 }
 
 func (m *DBSink) XXX_Unmarshal(b []byte) error {
@@ -414,7 +447,7 @@ var xxx_messageInfo_DBSink proto.InternalMessageInfo
 func (m *DBSource) Reset()      { *m = DBSource{} }
 func (*DBSource) ProtoMessage() {}
 func (*DBSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{11}
+	return fileDescriptor_7a4218a80d7ff35f, []int{12}
 }
 
 func (m *DBSource) XXX_Unmarshal(b []byte) error {
@@ -447,7 +480,7 @@ var xxx_messageInfo_DBSource proto.InternalMessageInfo
 func (m *Database) Reset()      { *m = Database{} }
 func (*Database) ProtoMessage() {}
 func (*Database) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{12}
+	return fileDescriptor_7a4218a80d7ff35f, []int{13}
 }
 
 func (m *Database) XXX_Unmarshal(b []byte) error {
@@ -480,7 +513,7 @@ var xxx_messageInfo_Database proto.InternalMessageInfo
 func (m *Dedupe) Reset()      { *m = Dedupe{} }
 func (*Dedupe) ProtoMessage() {}
 func (*Dedupe) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{13}
+	return fileDescriptor_7a4218a80d7ff35f, []int{14}
 }
 
 func (m *Dedupe) XXX_Unmarshal(b []byte) error {
@@ -513,7 +546,7 @@ var xxx_messageInfo_Dedupe proto.InternalMessageInfo
 func (m *Expand) Reset()      { *m = Expand{} }
 func (*Expand) ProtoMessage() {}
 func (*Expand) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{14}
+	return fileDescriptor_7a4218a80d7ff35f, []int{15}
 }
 
 func (m *Expand) XXX_Unmarshal(b []byte) error {
@@ -546,7 +579,7 @@ var xxx_messageInfo_Expand proto.InternalMessageInfo
 func (m *Filter) Reset()      { *m = Filter{} }
 func (*Filter) ProtoMessage() {}
 func (*Filter) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{15}
+	return fileDescriptor_7a4218a80d7ff35f, []int{16}
 }
 
 func (m *Filter) XXX_Unmarshal(b []byte) error {
@@ -579,7 +612,7 @@ var xxx_messageInfo_Filter proto.InternalMessageInfo
 func (m *Flatten) Reset()      { *m = Flatten{} }
 func (*Flatten) ProtoMessage() {}
 func (*Flatten) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{16}
+	return fileDescriptor_7a4218a80d7ff35f, []int{17}
 }
 
 func (m *Flatten) XXX_Unmarshal(b []byte) error {
@@ -612,7 +645,7 @@ var xxx_messageInfo_Flatten proto.InternalMessageInfo
 func (m *GetPodSpecReq) Reset()      { *m = GetPodSpecReq{} }
 func (*GetPodSpecReq) ProtoMessage() {}
 func (*GetPodSpecReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{17}
+	return fileDescriptor_7a4218a80d7ff35f, []int{18}
 }
 
 func (m *GetPodSpecReq) XXX_Unmarshal(b []byte) error {
@@ -645,7 +678,7 @@ var xxx_messageInfo_GetPodSpecReq proto.InternalMessageInfo
 func (m *Git) Reset()      { *m = Git{} }
 func (*Git) ProtoMessage() {}
 func (*Git) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{18}
+	return fileDescriptor_7a4218a80d7ff35f, []int{19}
 }
 
 func (m *Git) XXX_Unmarshal(b []byte) error {
@@ -678,7 +711,7 @@ var xxx_messageInfo_Git proto.InternalMessageInfo
 func (m *Group) Reset()      { *m = Group{} }
 func (*Group) ProtoMessage() {}
 func (*Group) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{19}
+	return fileDescriptor_7a4218a80d7ff35f, []int{20}
 }
 
 func (m *Group) XXX_Unmarshal(b []byte) error {
@@ -711,7 +744,7 @@ var xxx_messageInfo_Group proto.InternalMessageInfo
 func (m *HTTP) Reset()      { *m = HTTP{} }
 func (*HTTP) ProtoMessage() {}
 func (*HTTP) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{20}
+	return fileDescriptor_7a4218a80d7ff35f, []int{21}
 }
 
 func (m *HTTP) XXX_Unmarshal(b []byte) error {
@@ -744,7 +777,7 @@ var xxx_messageInfo_HTTP proto.InternalMessageInfo
 func (m *HTTPHeader) Reset()      { *m = HTTPHeader{} }
 func (*HTTPHeader) ProtoMessage() {}
 func (*HTTPHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{21}
+	return fileDescriptor_7a4218a80d7ff35f, []int{22}
 }
 
 func (m *HTTPHeader) XXX_Unmarshal(b []byte) error {
@@ -777,7 +810,7 @@ var xxx_messageInfo_HTTPHeader proto.InternalMessageInfo
 func (m *HTTPHeaderSource) Reset()      { *m = HTTPHeaderSource{} }
 func (*HTTPHeaderSource) ProtoMessage() {}
 func (*HTTPHeaderSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{22}
+	return fileDescriptor_7a4218a80d7ff35f, []int{23}
 }
 
 func (m *HTTPHeaderSource) XXX_Unmarshal(b []byte) error {
@@ -810,7 +843,7 @@ var xxx_messageInfo_HTTPHeaderSource proto.InternalMessageInfo
 func (m *HTTPSink) Reset()      { *m = HTTPSink{} }
 func (*HTTPSink) ProtoMessage() {}
 func (*HTTPSink) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{23}
+	return fileDescriptor_7a4218a80d7ff35f, []int{24}
 }
 
 func (m *HTTPSink) XXX_Unmarshal(b []byte) error {
@@ -843,7 +876,7 @@ var xxx_messageInfo_HTTPSink proto.InternalMessageInfo
 func (m *HTTPSource) Reset()      { *m = HTTPSource{} }
 func (*HTTPSource) ProtoMessage() {}
 func (*HTTPSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{24}
+	return fileDescriptor_7a4218a80d7ff35f, []int{25}
 }
 
 func (m *HTTPSource) XXX_Unmarshal(b []byte) error {
@@ -876,7 +909,7 @@ var xxx_messageInfo_HTTPSource proto.InternalMessageInfo
 func (m *Interface) Reset()      { *m = Interface{} }
 func (*Interface) ProtoMessage() {}
 func (*Interface) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{25}
+	return fileDescriptor_7a4218a80d7ff35f, []int{26}
 }
 
 func (m *Interface) XXX_Unmarshal(b []byte) error {
@@ -909,7 +942,7 @@ var xxx_messageInfo_Interface proto.InternalMessageInfo
 func (m *Kafka) Reset()      { *m = Kafka{} }
 func (*Kafka) ProtoMessage() {}
 func (*Kafka) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{26}
+	return fileDescriptor_7a4218a80d7ff35f, []int{27}
 }
 
 func (m *Kafka) XXX_Unmarshal(b []byte) error {
@@ -942,7 +975,7 @@ var xxx_messageInfo_Kafka proto.InternalMessageInfo
 func (m *KafkaAutoCommit) Reset()      { *m = KafkaAutoCommit{} }
 func (*KafkaAutoCommit) ProtoMessage() {}
 func (*KafkaAutoCommit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{27}
+	return fileDescriptor_7a4218a80d7ff35f, []int{28}
 }
 
 func (m *KafkaAutoCommit) XXX_Unmarshal(b []byte) error {
@@ -975,7 +1008,7 @@ var xxx_messageInfo_KafkaAutoCommit proto.InternalMessageInfo
 func (m *KafkaConfig) Reset()      { *m = KafkaConfig{} }
 func (*KafkaConfig) ProtoMessage() {}
 func (*KafkaConfig) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{28}
+	return fileDescriptor_7a4218a80d7ff35f, []int{29}
 }
 
 func (m *KafkaConfig) XXX_Unmarshal(b []byte) error {
@@ -1008,7 +1041,7 @@ var xxx_messageInfo_KafkaConfig proto.InternalMessageInfo
 func (m *KafkaNET) Reset()      { *m = KafkaNET{} }
 func (*KafkaNET) ProtoMessage() {}
 func (*KafkaNET) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{29}
+	return fileDescriptor_7a4218a80d7ff35f, []int{30}
 }
 
 func (m *KafkaNET) XXX_Unmarshal(b []byte) error {
@@ -1041,7 +1074,7 @@ var xxx_messageInfo_KafkaNET proto.InternalMessageInfo
 func (m *KafkaSink) Reset()      { *m = KafkaSink{} }
 func (*KafkaSink) ProtoMessage() {}
 func (*KafkaSink) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{30}
+	return fileDescriptor_7a4218a80d7ff35f, []int{31}
 }
 
 func (m *KafkaSink) XXX_Unmarshal(b []byte) error {
@@ -1074,7 +1107,7 @@ var xxx_messageInfo_KafkaSink proto.InternalMessageInfo
 func (m *KafkaSource) Reset()      { *m = KafkaSource{} }
 func (*KafkaSource) ProtoMessage() {}
 func (*KafkaSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{31}
+	return fileDescriptor_7a4218a80d7ff35f, []int{32}
 }
 
 func (m *KafkaSource) XXX_Unmarshal(b []byte) error {
@@ -1107,7 +1140,7 @@ var xxx_messageInfo_KafkaSource proto.InternalMessageInfo
 func (m *Log) Reset()      { *m = Log{} }
 func (*Log) ProtoMessage() {}
 func (*Log) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{32}
+	return fileDescriptor_7a4218a80d7ff35f, []int{33}
 }
 
 func (m *Log) XXX_Unmarshal(b []byte) error {
@@ -1140,7 +1173,7 @@ var xxx_messageInfo_Log proto.InternalMessageInfo
 func (m *Map) Reset()      { *m = Map{} }
 func (*Map) ProtoMessage() {}
 func (*Map) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{33}
+	return fileDescriptor_7a4218a80d7ff35f, []int{34}
 }
 
 func (m *Map) XXX_Unmarshal(b []byte) error {
@@ -1173,7 +1206,7 @@ var xxx_messageInfo_Map proto.InternalMessageInfo
 func (m *Metadata) Reset()      { *m = Metadata{} }
 func (*Metadata) ProtoMessage() {}
 func (*Metadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{34}
+	return fileDescriptor_7a4218a80d7ff35f, []int{35}
 }
 
 func (m *Metadata) XXX_Unmarshal(b []byte) error {
@@ -1206,7 +1239,7 @@ var xxx_messageInfo_Metadata proto.InternalMessageInfo
 func (m *Metrics) Reset()      { *m = Metrics{} }
 func (*Metrics) ProtoMessage() {}
 func (*Metrics) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{35}
+	return fileDescriptor_7a4218a80d7ff35f, []int{36}
 }
 
 func (m *Metrics) XXX_Unmarshal(b []byte) error {
@@ -1239,7 +1272,7 @@ var xxx_messageInfo_Metrics proto.InternalMessageInfo
 func (m *Pipeline) Reset()      { *m = Pipeline{} }
 func (*Pipeline) ProtoMessage() {}
 func (*Pipeline) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{36}
+	return fileDescriptor_7a4218a80d7ff35f, []int{37}
 }
 
 func (m *Pipeline) XXX_Unmarshal(b []byte) error {
@@ -1272,7 +1305,7 @@ var xxx_messageInfo_Pipeline proto.InternalMessageInfo
 func (m *PipelineList) Reset()      { *m = PipelineList{} }
 func (*PipelineList) ProtoMessage() {}
 func (*PipelineList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{37}
+	return fileDescriptor_7a4218a80d7ff35f, []int{38}
 }
 
 func (m *PipelineList) XXX_Unmarshal(b []byte) error {
@@ -1305,7 +1338,7 @@ var xxx_messageInfo_PipelineList proto.InternalMessageInfo
 func (m *PipelineSpec) Reset()      { *m = PipelineSpec{} }
 func (*PipelineSpec) ProtoMessage() {}
 func (*PipelineSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{38}
+	return fileDescriptor_7a4218a80d7ff35f, []int{39}
 }
 
 func (m *PipelineSpec) XXX_Unmarshal(b []byte) error {
@@ -1338,7 +1371,7 @@ var xxx_messageInfo_PipelineSpec proto.InternalMessageInfo
 func (m *PipelineStatus) Reset()      { *m = PipelineStatus{} }
 func (*PipelineStatus) ProtoMessage() {}
 func (*PipelineStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{39}
+	return fileDescriptor_7a4218a80d7ff35f, []int{40}
 }
 
 func (m *PipelineStatus) XXX_Unmarshal(b []byte) error {
@@ -1371,7 +1404,7 @@ var xxx_messageInfo_PipelineStatus proto.InternalMessageInfo
 func (m *S3) Reset()      { *m = S3{} }
 func (*S3) ProtoMessage() {}
 func (*S3) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{40}
+	return fileDescriptor_7a4218a80d7ff35f, []int{41}
 }
 
 func (m *S3) XXX_Unmarshal(b []byte) error {
@@ -1404,7 +1437,7 @@ var xxx_messageInfo_S3 proto.InternalMessageInfo
 func (m *S3Sink) Reset()      { *m = S3Sink{} }
 func (*S3Sink) ProtoMessage() {}
 func (*S3Sink) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{41}
+	return fileDescriptor_7a4218a80d7ff35f, []int{42}
 }
 
 func (m *S3Sink) XXX_Unmarshal(b []byte) error {
@@ -1437,7 +1470,7 @@ var xxx_messageInfo_S3Sink proto.InternalMessageInfo
 func (m *S3Source) Reset()      { *m = S3Source{} }
 func (*S3Source) ProtoMessage() {}
 func (*S3Source) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{42}
+	return fileDescriptor_7a4218a80d7ff35f, []int{43}
 }
 
 func (m *S3Source) XXX_Unmarshal(b []byte) error {
@@ -1470,7 +1503,7 @@ var xxx_messageInfo_S3Source proto.InternalMessageInfo
 func (m *SASL) Reset()      { *m = SASL{} }
 func (*SASL) ProtoMessage() {}
 func (*SASL) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{43}
+	return fileDescriptor_7a4218a80d7ff35f, []int{44}
 }
 
 func (m *SASL) XXX_Unmarshal(b []byte) error {
@@ -1503,7 +1536,7 @@ var xxx_messageInfo_SASL proto.InternalMessageInfo
 func (m *SQLAction) Reset()      { *m = SQLAction{} }
 func (*SQLAction) ProtoMessage() {}
 func (*SQLAction) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{44}
+	return fileDescriptor_7a4218a80d7ff35f, []int{45}
 }
 
 func (m *SQLAction) XXX_Unmarshal(b []byte) error {
@@ -1536,7 +1569,7 @@ var xxx_messageInfo_SQLAction proto.InternalMessageInfo
 func (m *SQLStatement) Reset()      { *m = SQLStatement{} }
 func (*SQLStatement) ProtoMessage() {}
 func (*SQLStatement) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{45}
+	return fileDescriptor_7a4218a80d7ff35f, []int{46}
 }
 
 func (m *SQLStatement) XXX_Unmarshal(b []byte) error {
@@ -1569,7 +1602,7 @@ var xxx_messageInfo_SQLStatement proto.InternalMessageInfo
 func (m *STAN) Reset()      { *m = STAN{} }
 func (*STAN) ProtoMessage() {}
 func (*STAN) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{46}
+	return fileDescriptor_7a4218a80d7ff35f, []int{47}
 }
 
 func (m *STAN) XXX_Unmarshal(b []byte) error {
@@ -1602,7 +1635,7 @@ var xxx_messageInfo_STAN proto.InternalMessageInfo
 func (m *STANAuth) Reset()      { *m = STANAuth{} }
 func (*STANAuth) ProtoMessage() {}
 func (*STANAuth) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{47}
+	return fileDescriptor_7a4218a80d7ff35f, []int{48}
 }
 
 func (m *STANAuth) XXX_Unmarshal(b []byte) error {
@@ -1635,7 +1668,7 @@ var xxx_messageInfo_STANAuth proto.InternalMessageInfo
 func (m *Scale) Reset()      { *m = Scale{} }
 func (*Scale) ProtoMessage() {}
 func (*Scale) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{48}
+	return fileDescriptor_7a4218a80d7ff35f, []int{49}
 }
 
 func (m *Scale) XXX_Unmarshal(b []byte) error {
@@ -1668,7 +1701,7 @@ var xxx_messageInfo_Scale proto.InternalMessageInfo
 func (m *Sidecar) Reset()      { *m = Sidecar{} }
 func (*Sidecar) ProtoMessage() {}
 func (*Sidecar) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{49}
+	return fileDescriptor_7a4218a80d7ff35f, []int{50}
 }
 
 func (m *Sidecar) XXX_Unmarshal(b []byte) error {
@@ -1701,7 +1734,7 @@ var xxx_messageInfo_Sidecar proto.InternalMessageInfo
 func (m *Sink) Reset()      { *m = Sink{} }
 func (*Sink) ProtoMessage() {}
 func (*Sink) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{50}
+	return fileDescriptor_7a4218a80d7ff35f, []int{51}
 }
 
 func (m *Sink) XXX_Unmarshal(b []byte) error {
@@ -1734,7 +1767,7 @@ var xxx_messageInfo_Sink proto.InternalMessageInfo
 func (m *Source) Reset()      { *m = Source{} }
 func (*Source) ProtoMessage() {}
 func (*Source) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{51}
+	return fileDescriptor_7a4218a80d7ff35f, []int{52}
 }
 
 func (m *Source) XXX_Unmarshal(b []byte) error {
@@ -1767,7 +1800,7 @@ var xxx_messageInfo_Source proto.InternalMessageInfo
 func (m *SourceStatus) Reset()      { *m = SourceStatus{} }
 func (*SourceStatus) ProtoMessage() {}
 func (*SourceStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{52}
+	return fileDescriptor_7a4218a80d7ff35f, []int{53}
 }
 
 func (m *SourceStatus) XXX_Unmarshal(b []byte) error {
@@ -1800,7 +1833,7 @@ var xxx_messageInfo_SourceStatus proto.InternalMessageInfo
 func (m *Step) Reset()      { *m = Step{} }
 func (*Step) ProtoMessage() {}
 func (*Step) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{53}
+	return fileDescriptor_7a4218a80d7ff35f, []int{54}
 }
 
 func (m *Step) XXX_Unmarshal(b []byte) error {
@@ -1833,7 +1866,7 @@ var xxx_messageInfo_Step proto.InternalMessageInfo
 func (m *StepList) Reset()      { *m = StepList{} }
 func (*StepList) ProtoMessage() {}
 func (*StepList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{54}
+	return fileDescriptor_7a4218a80d7ff35f, []int{55}
 }
 
 func (m *StepList) XXX_Unmarshal(b []byte) error {
@@ -1866,7 +1899,7 @@ var xxx_messageInfo_StepList proto.InternalMessageInfo
 func (m *StepSpec) Reset()      { *m = StepSpec{} }
 func (*StepSpec) ProtoMessage() {}
 func (*StepSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{55}
+	return fileDescriptor_7a4218a80d7ff35f, []int{56}
 }
 
 func (m *StepSpec) XXX_Unmarshal(b []byte) error {
@@ -1899,7 +1932,7 @@ var xxx_messageInfo_StepSpec proto.InternalMessageInfo
 func (m *StepStatus) Reset()      { *m = StepStatus{} }
 func (*StepStatus) ProtoMessage() {}
 func (*StepStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{56}
+	return fileDescriptor_7a4218a80d7ff35f, []int{57}
 }
 
 func (m *StepStatus) XXX_Unmarshal(b []byte) error {
@@ -1932,7 +1965,7 @@ var xxx_messageInfo_StepStatus proto.InternalMessageInfo
 func (m *Storage) Reset()      { *m = Storage{} }
 func (*Storage) ProtoMessage() {}
 func (*Storage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{57}
+	return fileDescriptor_7a4218a80d7ff35f, []int{58}
 }
 
 func (m *Storage) XXX_Unmarshal(b []byte) error {
@@ -1965,7 +1998,7 @@ var xxx_messageInfo_Storage proto.InternalMessageInfo
 func (m *TLS) Reset()      { *m = TLS{} }
 func (*TLS) ProtoMessage() {}
 func (*TLS) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{58}
+	return fileDescriptor_7a4218a80d7ff35f, []int{59}
 }
 
 func (m *TLS) XXX_Unmarshal(b []byte) error {
@@ -1998,7 +2031,7 @@ var xxx_messageInfo_TLS proto.InternalMessageInfo
 func (m *VolumeSink) Reset()      { *m = VolumeSink{} }
 func (*VolumeSink) ProtoMessage() {}
 func (*VolumeSink) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{59}
+	return fileDescriptor_7a4218a80d7ff35f, []int{60}
 }
 
 func (m *VolumeSink) XXX_Unmarshal(b []byte) error {
@@ -2031,7 +2064,7 @@ var xxx_messageInfo_VolumeSink proto.InternalMessageInfo
 func (m *VolumeSource) Reset()      { *m = VolumeSource{} }
 func (*VolumeSource) ProtoMessage() {}
 func (*VolumeSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7a4218a80d7ff35f, []int{60}
+	return fileDescriptor_7a4218a80d7ff35f, []int{61}
 }
 
 func (m *VolumeSource) XXX_Unmarshal(b []byte) error {
@@ -2065,6 +2098,7 @@ func init() {
 	proto.RegisterType((*AWSCredentials)(nil), "github.com.argoproj_labs.argo_dataflow.api.v1alpha1.AWSCredentials")
 	proto.RegisterType((*AWSEndpoint)(nil), "github.com.argoproj_labs.argo_dataflow.api.v1alpha1.AWSEndpoint")
 	proto.RegisterType((*AbstractStep)(nil), "github.com.argoproj_labs.argo_dataflow.api.v1alpha1.AbstractStep")
+	proto.RegisterType((*AbstractVolumeSource)(nil), "github.com.argoproj_labs.argo_dataflow.api.v1alpha1.AbstractVolumeSource")
 	proto.RegisterType((*Backoff)(nil), "github.com.argoproj_labs.argo_dataflow.api.v1alpha1.Backoff")
 	proto.RegisterType((*Cat)(nil), "github.com.argoproj_labs.argo_dataflow.api.v1alpha1.Cat")
 	proto.RegisterType((*Code)(nil), "github.com.argoproj_labs.argo_dataflow.api.v1alpha1.Code")
@@ -2136,295 +2170,342 @@ func init() {
 }
 
 var fileDescriptor_7a4218a80d7ff35f = []byte{
-	// 4598 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x7b, 0x4d, 0x6c, 0x24, 0xc7,
-	0x75, 0xbf, 0xe6, 0x83, 0x9c, 0x99, 0x47, 0x72, 0x97, 0x5b, 0x12, 0xfe, 0x1e, 0xf3, 0x2f, 0x91,
-	0x8b, 0x36, 0xa4, 0xac, 0x03, 0x69, 0x28, 0x69, 0x25, 0x44, 0x6b, 0x45, 0x96, 0x66, 0x48, 0xee,
-	0x8a, 0x12, 0xc9, 0xe5, 0xbe, 0x26, 0x57, 0x96, 0x25, 0x7b, 0x53, 0xec, 0xae, 0x99, 0x69, 0x71,
-	0xa6, 0x7b, 0xb6, 0xbb, 0x86, 0x5a, 0x26, 0x17, 0xc3, 0x8e, 0x12, 0xe4, 0x10, 0x20, 0xb9, 0xe4,
-	0x94, 0x5b, 0xe0, 0xe4, 0x94, 0x04, 0x08, 0x90, 0x20, 0xbe, 0xf8, 0x1a, 0x01, 0xb9, 0xe8, 0x68,
-	0x38, 0x08, 0x61, 0x31, 0x39, 0xe5, 0x98, 0x83, 0x0f, 0x8b, 0x00, 0x09, 0xea, 0xab, 0xbb, 0x7a,
-	0x38, 0x6b, 0x93, 0x33, 0x2b, 0x29, 0xb9, 0x4d, 0xbf, 0xf7, 0xea, 0xf7, 0xea, 0xe3, 0xd5, 0xab,
-	0xf7, 0x5e, 0xd5, 0xc0, 0x5a, 0x27, 0xe0, 0xdd, 0xe1, 0x41, 0xc3, 0x8b, 0xfa, 0xab, 0x34, 0xee,
-	0x44, 0x83, 0x38, 0xfa, 0xe8, 0x85, 0x1e, 0x3d, 0x48, 0xe4, 0xd7, 0x0b, 0x3e, 0xe5, 0xb4, 0xdd,
-	0x8b, 0x3e, 0x5e, 0xa5, 0x83, 0x60, 0xf5, 0xe8, 0x25, 0xda, 0x1b, 0x74, 0xe9, 0x4b, 0xab, 0x1d,
-	0x16, 0xb2, 0x98, 0x72, 0xe6, 0x37, 0x06, 0x71, 0xc4, 0x23, 0x72, 0x3d, 0x03, 0x69, 0x18, 0x90,
-	0x7b, 0x02, 0x44, 0x7e, 0xdd, 0x33, 0x20, 0x0d, 0x3a, 0x08, 0x1a, 0x06, 0x64, 0xe9, 0x05, 0x4b,
-	0x73, 0x27, 0xea, 0x44, 0xab, 0x12, 0xeb, 0x60, 0xd8, 0x96, 0x5f, 0xf2, 0x43, 0xfe, 0x52, 0x3a,
-	0x96, 0x9c, 0xc3, 0xd7, 0x92, 0x46, 0x10, 0xc9, 0x8e, 0x78, 0x51, 0xcc, 0x56, 0x8f, 0xce, 0xf4,
-	0x63, 0xe9, 0x95, 0x4c, 0xa6, 0x4f, 0xbd, 0x6e, 0x10, 0xb2, 0xf8, 0x78, 0x75, 0x70, 0xd8, 0x91,
-	0x8d, 0x62, 0x96, 0x44, 0xc3, 0xd8, 0x63, 0x17, 0x6a, 0x95, 0xac, 0xf6, 0x19, 0xa7, 0x63, 0x74,
-	0x39, 0x3f, 0x29, 0xc2, 0xa5, 0xe6, 0x7b, 0xee, 0x5a, 0xcc, 0x7c, 0x16, 0xf2, 0x80, 0xf6, 0x12,
-	0xf2, 0x21, 0xcc, 0x51, 0xcf, 0x63, 0x49, 0xf2, 0x2e, 0x3b, 0xde, 0xf4, 0xeb, 0x85, 0xab, 0x85,
-	0x6b, 0x73, 0x2f, 0x3f, 0xdb, 0x50, 0xf0, 0x72, 0xf0, 0xa2, 0xe3, 0x8d, 0xa3, 0x97, 0x1a, 0x2e,
-	0xf3, 0x62, 0xc6, 0xdf, 0x65, 0xc7, 0x2e, 0xeb, 0x31, 0x8f, 0x47, 0x71, 0xeb, 0xc9, 0x4f, 0x4f,
-	0x56, 0x9e, 0x38, 0x3d, 0x59, 0x99, 0x6b, 0xa6, 0x08, 0xeb, 0x68, 0xc3, 0x91, 0x2e, 0x5c, 0x4e,
-	0x64, 0xb3, 0x54, 0xa2, 0x5e, 0xbc, 0x88, 0x86, 0xaf, 0x69, 0x0d, 0x97, 0xdd, 0x3c, 0x0a, 0x8e,
-	0xc2, 0x92, 0x7b, 0x30, 0x9f, 0xb0, 0x24, 0x09, 0xa2, 0x70, 0x2f, 0x3a, 0x64, 0x61, 0xbd, 0x74,
-	0x11, 0x35, 0x4f, 0x69, 0x35, 0xf3, 0xae, 0x05, 0x81, 0x39, 0x40, 0xe7, 0x79, 0x98, 0x6b, 0xbe,
-	0xe7, 0x6e, 0x84, 0xfe, 0x20, 0x0a, 0x42, 0x4e, 0x9e, 0x81, 0xd2, 0x30, 0xee, 0xc9, 0xf9, 0xaa,
-	0xb5, 0xe6, 0x74, 0xfb, 0xd2, 0x3e, 0x6e, 0xa1, 0xa0, 0x3b, 0x01, 0xcc, 0x37, 0x0f, 0x12, 0x1e,
-	0x53, 0x8f, 0xbb, 0x9c, 0x0d, 0xc8, 0xfb, 0x50, 0x33, 0x6b, 0x99, 0xe8, 0x49, 0xbe, 0x36, 0xae,
-	0x6f, 0xa8, 0x85, 0x90, 0xdd, 0x1f, 0x06, 0x31, 0xeb, 0xb3, 0x90, 0x27, 0xad, 0x2b, 0x1a, 0xbe,
-	0x66, 0xb8, 0x09, 0x66, 0x68, 0xce, 0x3f, 0x17, 0xa1, 0xd2, 0xa2, 0xde, 0x61, 0xd4, 0x6e, 0x93,
-	0xef, 0x40, 0xd5, 0x1f, 0xc6, 0x94, 0x07, 0x51, 0x58, 0x2f, 0x4b, 0x2d, 0x0d, 0x4b, 0x4b, 0x6a,
-	0x29, 0x8d, 0xc1, 0x61, 0x47, 0x10, 0x92, 0x86, 0xb0, 0x14, 0xa1, 0x77, 0x5d, 0xb7, 0x6a, 0xcd,
-	0x9f, 0x9e, 0xac, 0x54, 0xcd, 0x17, 0xa6, 0x68, 0xe4, 0x45, 0x58, 0xbc, 0x49, 0xc5, 0x64, 0xed,
-	0xb2, 0xd8, 0x63, 0x21, 0xa7, 0x1d, 0x56, 0x9f, 0xb9, 0x5a, 0xb8, 0xb6, 0xd0, 0x2a, 0x8b, 0xde,
-	0xe1, 0x19, 0x2e, 0xf9, 0x06, 0xcc, 0x24, 0x9c, 0x0d, 0xd4, 0x70, 0xcb, 0xad, 0x05, 0x3d, 0x88,
-	0x19, 0x31, 0x1f, 0x09, 0x2a, 0x1e, 0xd9, 0x84, 0x92, 0x47, 0x07, 0xda, 0x28, 0x2e, 0xda, 0xd7,
-	0x8a, 0x98, 0xf2, 0x35, 0x3a, 0x40, 0x81, 0x41, 0xd6, 0x61, 0xf1, 0xa3, 0x80, 0x73, 0x66, 0xf7,
-	0xb0, 0x24, 0x7b, 0x58, 0xd7, 0xaa, 0x17, 0xdf, 0x19, 0xe1, 0xe3, 0x99, 0x16, 0xce, 0x0f, 0x0b,
-	0x50, 0x5a, 0xa3, 0x9c, 0xfc, 0x1e, 0xcc, 0x53, 0x6b, 0x01, 0xf5, 0x9a, 0x35, 0x1b, 0x13, 0x78,
-	0x8d, 0x86, 0x6d, 0x09, 0x99, 0xad, 0xd9, 0x54, 0xcc, 0x29, 0x73, 0x7c, 0x28, 0xaf, 0x45, 0x3e,
-	0x23, 0xaf, 0x40, 0x25, 0x1e, 0x86, 0x3c, 0xe8, 0x33, 0xb9, 0x9a, 0xb5, 0xd6, 0x92, 0x6e, 0x5c,
-	0x41, 0x45, 0x7e, 0x98, 0xfd, 0x44, 0x23, 0x4a, 0x9e, 0x83, 0x59, 0x65, 0x1b, 0x72, 0xf8, 0xb5,
-	0xd6, 0x25, 0xdd, 0x68, 0xd6, 0x55, 0xa6, 0xa5, 0xb9, 0xce, 0x4f, 0x4b, 0x50, 0x5b, 0x8b, 0x42,
-	0x4e, 0xc5, 0x3c, 0x8b, 0xe5, 0x0a, 0xfa, 0x62, 0xce, 0x94, 0x49, 0xa7, 0xcb, 0xb5, 0x29, 0x88,
-	0xa8, 0x78, 0xe4, 0x7d, 0x98, 0x3f, 0x8a, 0x7a, 0xc3, 0x3e, 0xdb, 0x8e, 0x86, 0x21, 0x4f, 0xea,
-	0x33, 0x57, 0x4b, 0xd7, 0xe6, 0x5e, 0x5e, 0x19, 0x67, 0xc9, 0x77, 0x33, 0xb9, 0x6c, 0xcc, 0x16,
-	0x31, 0xc1, 0x1c, 0x14, 0xb9, 0x0b, 0xc5, 0xc0, 0x6c, 0xdb, 0x6f, 0x4f, 0x34, 0xcd, 0x9b, 0x21,
-	0x67, 0x71, 0x9b, 0x7a, 0xac, 0x35, 0x7b, 0x7a, 0xb2, 0x52, 0xdc, 0x0c, 0xb1, 0x18, 0x84, 0xe4,
-	0x59, 0xa8, 0x78, 0x51, 0xbf, 0x4f, 0x43, 0xbf, 0x3e, 0x7b, 0xb5, 0x24, 0x36, 0xab, 0x98, 0xbf,
-	0x35, 0x45, 0x42, 0xc3, 0x23, 0x4f, 0x43, 0x99, 0xc6, 0x9d, 0xa4, 0x5e, 0x91, 0x32, 0xd5, 0xd3,
-	0x93, 0x95, 0x72, 0x33, 0xee, 0x24, 0x28, 0xa9, 0xe4, 0x06, 0x94, 0x58, 0x78, 0x54, 0xaf, 0xca,
-	0xe1, 0x2e, 0x8d, 0x1b, 0xee, 0x46, 0x78, 0x74, 0x97, 0xc6, 0x99, 0x27, 0xd8, 0x08, 0x8f, 0x50,
-	0xb4, 0xc9, 0xef, 0xfc, 0xda, 0x63, 0xdd, 0xf9, 0x1f, 0x42, 0x79, 0x2d, 0x8e, 0x42, 0xf2, 0x3c,
-	0x54, 0x13, 0xaf, 0xcb, 0xfc, 0x61, 0xcf, 0xac, 0xde, 0xa2, 0x6e, 0x57, 0x75, 0x35, 0x1d, 0x53,
-	0x09, 0x61, 0x1e, 0x3d, 0x7a, 0x1c, 0x0d, 0xb9, 0xdc, 0x75, 0x96, 0x79, 0x6c, 0x49, 0x2a, 0x6a,
-	0xae, 0xf3, 0x57, 0x05, 0x98, 0x5f, 0x6f, 0xad, 0x53, 0x4e, 0x95, 0xdd, 0x08, 0x0b, 0x39, 0xa2,
-	0xbd, 0xe1, 0x19, 0x0b, 0xb9, 0x2b, 0x88, 0xa8, 0x78, 0x24, 0x86, 0x9a, 0xfc, 0x71, 0x33, 0x8e,
-	0xfa, 0x7a, 0x5b, 0x6f, 0x4c, 0xb4, 0x9a, 0xb6, 0x6a, 0x01, 0xd6, 0x5a, 0x10, 0xf3, 0x70, 0xd7,
-	0x60, 0x63, 0xa6, 0xc6, 0x89, 0x60, 0x71, 0x54, 0x9a, 0x7c, 0x20, 0xce, 0x03, 0xed, 0xe7, 0x91,
-	0xb5, 0x2f, 0x76, 0xb0, 0x2d, 0xaa, 0xb3, 0x20, 0x6b, 0x8e, 0x39, 0x30, 0xe7, 0x17, 0x05, 0x98,
-	0x5d, 0x6f, 0xb9, 0x41, 0x78, 0x48, 0x0e, 0xa1, 0x2a, 0xfa, 0x7f, 0x40, 0x13, 0xa6, 0x75, 0xbc,
-	0x31, 0xd9, 0x70, 0x35, 0x48, 0xb6, 0x74, 0x86, 0x82, 0xa9, 0x02, 0x12, 0x40, 0x85, 0x7a, 0xc2,
-	0xf5, 0x25, 0xf5, 0xa2, 0x34, 0xc5, 0xc9, 0x36, 0x8a, 0x7b, 0x67, 0xab, 0x29, 0x61, 0x5a, 0x97,
-	0x8d, 0x3f, 0x51, 0xdf, 0x09, 0x1a, 0x7c, 0xe7, 0xdf, 0x4b, 0x50, 0x5d, 0x6f, 0xe9, 0x95, 0xff,
-	0x52, 0x07, 0xf9, 0x0d, 0x98, 0xb9, 0x3f, 0x64, 0xf1, 0xb1, 0x36, 0xcf, 0xd4, 0xcc, 0xee, 0x08,
-	0x22, 0x2a, 0x1e, 0x79, 0x0d, 0xe6, 0xa3, 0x76, 0x3b, 0x61, 0x7c, 0x4d, 0xf8, 0x90, 0x50, 0x7b,
-	0xba, 0xd4, 0xcf, 0xdc, 0xb6, 0x78, 0x98, 0x93, 0x24, 0x5d, 0x98, 0x1f, 0x44, 0xbd, 0x9e, 0x74,
-	0x16, 0x47, 0xb4, 0x37, 0xe1, 0x31, 0x99, 0x6a, 0xda, 0xb5, 0xb0, 0x30, 0x87, 0x4c, 0x42, 0xb8,
-	0x24, 0xbc, 0x4b, 0xc0, 0x53, 0x5d, 0x33, 0x13, 0xe9, 0xfa, 0x7f, 0x5a, 0xd7, 0xa5, 0xb5, 0x1c,
-	0x1a, 0x8e, 0xa0, 0x93, 0x97, 0x01, 0x82, 0x30, 0xe0, 0x62, 0xcb, 0xf7, 0x69, 0x7d, 0xf6, 0x6a,
-	0xe1, 0x5a, 0xb5, 0x45, 0x74, 0x5b, 0xd8, 0x4c, 0x39, 0x68, 0x49, 0x39, 0x3f, 0x2e, 0x40, 0xba,
-	0x06, 0xc2, 0x33, 0xf8, 0x71, 0x70, 0xc4, 0x62, 0xbd, 0xc3, 0x53, 0xcf, 0xb0, 0x2e, 0xa9, 0xa8,
-	0xb9, 0xe4, 0x3e, 0x80, 0x9f, 0xee, 0x36, 0xbd, 0xc9, 0x9b, 0x53, 0x6f, 0xf2, 0xd6, 0x25, 0xd1,
-	0xcf, 0xec, 0x1b, 0x2d, 0x25, 0xce, 0x7f, 0x8b, 0x1d, 0xc7, 0xfc, 0xe1, 0x80, 0x7d, 0xa5, 0x27,
-	0xb3, 0x0c, 0xfb, 0x02, 0x5f, 0x9b, 0x66, 0x16, 0xf6, 0x6d, 0xae, 0xa3, 0xa0, 0x93, 0xf7, 0xa1,
-	0xd2, 0xa7, 0x0f, 0xdc, 0xe0, 0x77, 0x99, 0x3e, 0xc9, 0x7e, 0xe5, 0x5a, 0x37, 0x8c, 0x2b, 0x6f,
-	0xdc, 0x19, 0xd2, 0x90, 0x07, 0xfc, 0x38, 0xdb, 0x90, 0xdb, 0x0a, 0x06, 0x0d, 0x9e, 0xf3, 0x49,
-	0x01, 0x66, 0x37, 0x1e, 0x0c, 0xc4, 0x59, 0xf5, 0x95, 0xc6, 0x26, 0x3f, 0x29, 0xc0, 0xec, 0xcd,
-	0xa0, 0xc7, 0x59, 0xfc, 0xd5, 0xae, 0xc4, 0xcb, 0x00, 0xec, 0xc1, 0x20, 0x56, 0x21, 0xba, 0x5e,
-	0x90, 0xd4, 0xda, 0x37, 0x52, 0x0e, 0x5a, 0x52, 0xce, 0x1f, 0x14, 0xa0, 0x72, 0xb3, 0x47, 0x39,
-	0x67, 0xe1, 0x57, 0x3b, 0x89, 0x9f, 0x54, 0x60, 0xe1, 0x16, 0xe3, 0xbb, 0x91, 0xef, 0x0e, 0x98,
-	0x87, 0xec, 0x3e, 0xf9, 0x26, 0x54, 0xbc, 0xde, 0x30, 0xe1, 0xe9, 0xe6, 0x4b, 0x2d, 0x61, 0x4d,
-	0x91, 0xd1, 0xf0, 0x85, 0x83, 0xf4, 0xd9, 0xc1, 0xb0, 0x23, 0x07, 0x5d, 0xcd, 0x1c, 0xe4, 0xba,
-	0x20, 0xa2, 0xe2, 0x09, 0x07, 0x39, 0x08, 0x06, 0xac, 0x17, 0x84, 0x6c, 0x87, 0xf6, 0xd9, 0xa8,
-	0x83, 0xdc, 0xb5, 0x78, 0x98, 0x93, 0x14, 0x3d, 0x89, 0xd9, 0xa0, 0x17, 0x78, 0x54, 0xfa, 0xc6,
-	0x99, 0xac, 0x27, 0xa8, 0xc8, 0x68, 0xf8, 0xe4, 0x55, 0x98, 0x93, 0x71, 0xe1, 0xcd, 0x28, 0xee,
-	0x53, 0x2e, 0xdd, 0x5b, 0x2d, 0xcb, 0x0a, 0x37, 0x33, 0x16, 0xda, 0x72, 0xa2, 0x59, 0x3c, 0x0c,
-	0x43, 0x16, 0x4b, 0x09, 0xe9, 0xa9, 0xac, 0x66, 0x98, 0xb1, 0xd0, 0x96, 0x23, 0x2e, 0xc0, 0x60,
-	0xd8, 0xeb, 0xed, 0x46, 0xbd, 0xc0, 0x3b, 0xae, 0x57, 0x64, 0xab, 0xeb, 0x66, 0xc5, 0x77, 0x53,
-	0xce, 0xc3, 0x93, 0x95, 0x67, 0xce, 0xe6, 0xdd, 0x8d, 0x4c, 0x00, 0x2d, 0x18, 0x72, 0x1b, 0x2e,
-	0x0d, 0x07, 0x3e, 0xe5, 0x2c, 0x75, 0xd2, 0xd5, 0xab, 0x85, 0x6b, 0xa5, 0xd6, 0x6f, 0x18, 0xa7,
-	0xbb, 0x9f, 0xe3, 0x3e, 0x3c, 0x59, 0x59, 0x10, 0x41, 0x76, 0xea, 0x9d, 0x71, 0xa4, 0x39, 0x49,
-	0x00, 0x44, 0x6a, 0xe3, 0x72, 0xca, 0x87, 0x26, 0xe0, 0x7b, 0x73, 0xb2, 0x63, 0x3a, 0x85, 0xc9,
-	0x0c, 0x3b, 0xa3, 0xa1, 0xa5, 0x86, 0x74, 0xa0, 0x92, 0x04, 0x3e, 0xf3, 0x68, 0x5c, 0x07, 0xa9,
-	0xf1, 0xb7, 0x27, 0xd3, 0xa8, 0x30, 0xb2, 0x15, 0xd7, 0x04, 0x34, 0xe8, 0x24, 0x84, 0x45, 0xb9,
-	0x92, 0x62, 0x36, 0x55, 0x80, 0x94, 0xd4, 0xe7, 0x64, 0x28, 0x32, 0x36, 0xa8, 0xdd, 0x8a, 0x3c,
-	0xda, 0xbb, 0x7d, 0xf0, 0x11, 0xf3, 0x38, 0xb2, 0x36, 0x8b, 0x59, 0xe8, 0xb1, 0x2c, 0x1d, 0xdb,
-	0x1c, 0x41, 0xc2, 0x33, 0xd8, 0x22, 0xb4, 0xed, 0x46, 0x09, 0x0f, 0x85, 0x09, 0xcf, 0xe7, 0x43,
-	0xdb, 0xb7, 0x35, 0x1d, 0x53, 0x09, 0xb2, 0x0a, 0xb5, 0x64, 0x78, 0xe0, 0x47, 0x7d, 0x1a, 0x84,
-	0xf5, 0x05, 0x29, 0x9e, 0x46, 0xd0, 0xae, 0x61, 0x60, 0x26, 0xe3, 0xfc, 0x75, 0x19, 0x4a, 0xb7,
-	0x02, 0x7e, 0xbe, 0xe4, 0xe7, 0x9c, 0x99, 0x84, 0xae, 0x0c, 0x14, 0xc7, 0x57, 0x06, 0x08, 0x85,
-	0x4b, 0xc3, 0x84, 0xc5, 0xa2, 0xbf, 0x6a, 0x90, 0xd2, 0x92, 0xcf, 0x1d, 0x9a, 0x12, 0x69, 0x93,
-	0x39, 0x00, 0x1c, 0x01, 0x14, 0x2a, 0x06, 0x34, 0x49, 0x3e, 0x8e, 0x62, 0x5f, 0xab, 0xa8, 0x5e,
-	0x58, 0xc5, 0x6e, 0x0e, 0x00, 0x47, 0x00, 0xc9, 0x00, 0x9e, 0x4c, 0x92, 0xee, 0x6e, 0x1c, 0x1c,
-	0x51, 0xce, 0x64, 0x63, 0xa9, 0xa7, 0x76, 0xa1, 0xe2, 0xce, 0xe9, 0xc9, 0xca, 0x93, 0xae, 0xfb,
-	0xf6, 0x28, 0x0a, 0x8e, 0x83, 0x26, 0x57, 0xa1, 0x3c, 0xa0, 0xbc, 0xab, 0x1d, 0xd9, 0xbc, 0x9e,
-	0xd7, 0xf2, 0x2e, 0xe5, 0x5d, 0x94, 0x1c, 0x11, 0xbe, 0x1c, 0xc4, 0x34, 0xf4, 0xba, 0x3a, 0x59,
-	0x4e, 0xc3, 0x97, 0x96, 0xa4, 0xa2, 0xe6, 0x9a, 0x64, 0x6e, 0xe6, 0xe2, 0xc9, 0x9c, 0xf3, 0xcb,
-	0x02, 0xcc, 0xdc, 0x8a, 0xa3, 0xa1, 0x0c, 0x04, 0x0e, 0xd9, 0xf1, 0x68, 0xfd, 0x47, 0xe4, 0x07,
-	0x82, 0x2e, 0x4f, 0xa7, 0xd0, 0xbf, 0xdd, 0x96, 0xc2, 0x67, 0x4e, 0xa7, 0x94, 0x83, 0x96, 0x14,
-	0x79, 0x15, 0x66, 0xdb, 0xca, 0x91, 0xaa, 0x31, 0x3e, 0x63, 0xfa, 0xaf, 0xdc, 0xe6, 0xc3, 0x93,
-	0x95, 0x39, 0x29, 0xa8, 0x5d, 0xaa, 0x16, 0x26, 0x1e, 0x54, 0x12, 0x1e, 0xc5, 0xc2, 0x7a, 0xcb,
-	0xd3, 0xec, 0x7d, 0x85, 0xa1, 0x8c, 0x5a, 0x7f, 0xa0, 0x41, 0x76, 0x66, 0xa1, 0xfc, 0xf6, 0xde,
-	0xde, 0xae, 0xf3, 0x4f, 0x05, 0x00, 0xf1, 0xe3, 0x6d, 0x46, 0x7d, 0x16, 0x8b, 0x45, 0x91, 0x5b,
-	0xb3, 0x90, 0x5f, 0x14, 0x79, 0xaa, 0x48, 0x4e, 0x96, 0x34, 0x16, 0xcf, 0x9b, 0x34, 0x96, 0xa6,
-	0x48, 0x1a, 0xb3, 0xae, 0xe9, 0x98, 0xf2, 0xd1, 0x49, 0x63, 0x02, 0x8b, 0xa3, 0xd2, 0xaa, 0x88,
-	0x38, 0x69, 0xd2, 0x68, 0x15, 0x11, 0x1f, 0x99, 0x38, 0x7e, 0x5e, 0x80, 0xaa, 0xd0, 0x2a, 0x53,
-	0xc7, 0x5f, 0x5d, 0x42, 0x24, 0x1f, 0x41, 0xa5, 0x2b, 0x3b, 0x67, 0x92, 0xbd, 0x37, 0xa7, 0x9c,
-	0x92, 0xcc, 0xad, 0xab, 0xef, 0x04, 0x8d, 0x02, 0xf2, 0x0e, 0x90, 0x20, 0x4c, 0x98, 0x37, 0x8c,
-	0x99, 0x7b, 0x18, 0x0c, 0xee, 0xb2, 0x38, 0x68, 0x1f, 0xcb, 0x95, 0xa8, 0xa6, 0x35, 0x27, 0xb2,
-	0x79, 0x46, 0x02, 0xc7, 0xb4, 0x72, 0xd6, 0x94, 0x85, 0xe8, 0x29, 0x7d, 0x15, 0xe6, 0x12, 0x16,
-	0x1f, 0x05, 0x9e, 0x0a, 0x43, 0x0a, 0xf9, 0xb3, 0xde, 0xcd, 0x58, 0x68, 0xcb, 0x89, 0x48, 0xad,
-	0x96, 0xd6, 0x73, 0x84, 0x99, 0xb5, 0x83, 0x76, 0x24, 0x5b, 0x57, 0x33, 0x33, 0xbb, 0xb9, 0x79,
-	0xf3, 0x36, 0x4a, 0x0e, 0x79, 0x0f, 0xca, 0x5d, 0xce, 0x4d, 0x21, 0xf1, 0xc6, 0xc4, 0x33, 0xa5,
-	0x2a, 0x3f, 0xe2, 0x17, 0x4a, 0x40, 0x61, 0xf0, 0x33, 0xef, 0xd2, 0xf6, 0x21, 0x3d, 0x87, 0xad,
-	0x7f, 0x0c, 0x73, 0x87, 0x42, 0x74, 0x2d, 0x0a, 0xdb, 0x41, 0x47, 0xef, 0xc6, 0xb7, 0x26, 0xea,
-	0xcb, 0xbb, 0x19, 0x4e, 0x36, 0x5b, 0x16, 0x11, 0x6d, 0x4d, 0x62, 0x93, 0xf1, 0x68, 0x10, 0x78,
-	0xda, 0x71, 0xa4, 0x9b, 0x6c, 0x4f, 0x10, 0x51, 0xf1, 0x9c, 0x1b, 0x70, 0x59, 0x02, 0x34, 0x87,
-	0x3c, 0x52, 0x99, 0xa4, 0xf0, 0x98, 0x2c, 0xa4, 0x07, 0xba, 0x6c, 0x54, 0xcd, 0x3c, 0xe6, 0x86,
-	0xa4, 0xa2, 0xe6, 0x3a, 0xff, 0x55, 0x00, 0x5b, 0xb9, 0x38, 0x09, 0x0f, 0xe2, 0xe8, 0x50, 0x98,
-	0x66, 0x21, 0x3b, 0x09, 0x5b, 0x8a, 0x84, 0x86, 0x27, 0x22, 0xc9, 0x23, 0x16, 0x5b, 0xf1, 0x79,
-	0x6a, 0x80, 0x77, 0x15, 0x19, 0x0d, 0x9f, 0x7c, 0x07, 0x4a, 0x21, 0xe3, 0x7a, 0xef, 0xbf, 0x31,
-	0xf9, 0x94, 0xed, 0x6c, 0xec, 0xa9, 0xb2, 0xf0, 0xce, 0xc6, 0x1e, 0x0a, 0x48, 0xd2, 0x84, 0xcb,
-	0x7d, 0xfa, 0x60, 0x9b, 0x25, 0x89, 0xf0, 0x6e, 0xc7, 0x9c, 0x25, 0x3a, 0xac, 0x4d, 0xef, 0x16,
-	0xb6, 0xf3, 0x6c, 0x1c, 0x95, 0x77, 0xfe, 0xb1, 0x00, 0x55, 0x83, 0x4e, 0x5c, 0x28, 0xf1, 0x9e,
-	0xa9, 0xe1, 0xbf, 0x36, 0x51, 0x4f, 0xf7, 0xb6, 0x5c, 0xd5, 0xc9, 0xbd, 0x2d, 0x17, 0x05, 0x9a,
-	0x30, 0xdf, 0x84, 0x26, 0xbd, 0xa9, 0xcc, 0xd7, 0x6d, 0xba, 0x5b, 0xca, 0x7c, 0xc5, 0x2f, 0x94,
-	0x80, 0xce, 0x9f, 0x16, 0xa0, 0x26, 0xbb, 0x2e, 0x3d, 0xce, 0x3d, 0x98, 0x91, 0x66, 0xa3, 0x7b,
-	0xff, 0xad, 0xc9, 0xe7, 0x39, 0xb3, 0x31, 0xf9, 0x89, 0x0a, 0x57, 0x18, 0x22, 0x4d, 0x8e, 0x43,
-	0x6f, 0x34, 0x35, 0x69, 0x0a, 0x22, 0x2a, 0x9e, 0xf3, 0x37, 0x45, 0x6d, 0x4d, 0xa9, 0xd7, 0xfd,
-	0x82, 0x7b, 0xb5, 0x0e, 0x73, 0x09, 0xa7, 0x31, 0x57, 0x55, 0x21, 0x6d, 0x8b, 0x4e, 0xea, 0x83,
-	0x32, 0xd6, 0x43, 0xb3, 0xc9, 0xd4, 0x27, 0xda, 0xcd, 0xc8, 0x03, 0x00, 0x9a, 0x6e, 0x1d, 0x6d,
-	0xa9, 0xeb, 0x93, 0xf7, 0x35, 0xdb, 0x86, 0x59, 0x60, 0x90, 0xd1, 0xd0, 0xd2, 0xe5, 0xac, 0x42,
-	0x69, 0x2b, 0xea, 0x90, 0x6b, 0x50, 0xe5, 0xf1, 0x30, 0xf4, 0x28, 0x67, 0xfa, 0x4e, 0x45, 0x5e,
-	0xd6, 0xec, 0x69, 0x1a, 0xa6, 0x5c, 0xe7, 0x1f, 0x0a, 0x50, 0xda, 0xa6, 0x83, 0xff, 0x7b, 0x09,
-	0xfa, 0x0f, 0x4a, 0x50, 0xdd, 0x66, 0x9c, 0x8a, 0x2e, 0x90, 0x4f, 0x0a, 0x30, 0x47, 0xc3, 0x30,
-	0xe2, 0x54, 0x95, 0x3c, 0x0b, 0xf2, 0x14, 0xdc, 0x99, 0xa8, 0xf7, 0x06, 0xb4, 0xd1, 0xcc, 0x00,
-	0x37, 0x42, 0x1e, 0x1f, 0x5b, 0x97, 0x98, 0x19, 0x07, 0x6d, 0xbd, 0xe4, 0x3e, 0xcc, 0xf6, 0xe8,
-	0x01, 0xeb, 0x99, 0x73, 0x78, 0x73, 0xba, 0x1e, 0x6c, 0x49, 0x2c, 0xa5, 0xdc, 0xaa, 0xbd, 0x0b,
-	0x22, 0x6a, 0x45, 0x4b, 0xdf, 0x86, 0xc5, 0xd1, 0x8e, 0x92, 0x45, 0x2b, 0xe2, 0x54, 0x41, 0xe6,
-	0x53, 0xb9, 0xd8, 0x4a, 0x07, 0x53, 0xdf, 0x2a, 0xbe, 0x56, 0x58, 0xba, 0x01, 0x73, 0x96, 0x9a,
-	0x8b, 0x34, 0x75, 0xfe, 0xb0, 0x08, 0x95, 0x6d, 0xc6, 0xe3, 0xc0, 0x4b, 0xd4, 0xb9, 0xc2, 0x69,
-	0x6f, 0xf4, 0x0a, 0x6f, 0x4f, 0x10, 0x51, 0xf1, 0xe4, 0x21, 0x12, 0xc7, 0x91, 0x0c, 0x53, 0x84,
-	0x54, 0x76, 0x88, 0x48, 0x2a, 0x6a, 0x2e, 0xd9, 0x85, 0x72, 0x2c, 0x4c, 0x77, 0xb2, 0xc2, 0x58,
-	0x7a, 0xde, 0xa2, 0x30, 0x75, 0x89, 0xa4, 0x2a, 0x15, 0x3c, 0x0e, 0xb4, 0x4b, 0x2f, 0xdb, 0x95,
-	0x0a, 0x49, 0x46, 0xc3, 0x17, 0xc6, 0x28, 0x7b, 0xab, 0x0e, 0x80, 0x19, 0x29, 0x9d, 0x1a, 0xe3,
-	0x5e, 0xca, 0x41, 0x4b, 0xca, 0xf9, 0x69, 0x11, 0xaa, 0xa6, 0x4e, 0x42, 0x7e, 0x07, 0xaa, 0x7d,
-	0xbd, 0x82, 0x7a, 0x1b, 0xbd, 0x78, 0xbe, 0x32, 0xae, 0xca, 0x7e, 0xc5, 0xea, 0x67, 0x0a, 0x33,
-	0x1a, 0xa6, 0xa8, 0xc4, 0x83, 0x72, 0x32, 0x60, 0xde, 0x54, 0xf5, 0x54, 0xd3, 0x5d, 0x77, 0xc0,
-	0xbc, 0x6c, 0xca, 0x64, 0x8d, 0x49, 0x82, 0x93, 0x43, 0x98, 0x4d, 0x54, 0x65, 0x42, 0x2d, 0xc3,
-	0xda, 0x74, 0x6a, 0x54, 0x75, 0x22, 0xbb, 0x60, 0x54, 0x95, 0x09, 0xad, 0xc2, 0xf9, 0xac, 0x00,
-	0x69, 0xa1, 0x69, 0x2b, 0x48, 0x38, 0xf9, 0xf0, 0xcc, 0x24, 0x9e, 0xb3, 0x16, 0x2e, 0x5a, 0xcb,
-	0x29, 0x4c, 0xb3, 0x7f, 0x43, 0xb1, 0x26, 0xf0, 0x00, 0x66, 0x02, 0xce, 0xfa, 0x66, 0x9b, 0xbe,
-	0x31, 0xd5, 0xd0, 0xac, 0x1a, 0x80, 0xc0, 0x44, 0x05, 0xed, 0xfc, 0x8b, 0x35, 0x24, 0x31, 0xad,
-	0x42, 0xa9, 0xb9, 0xe5, 0x9e, 0x5c, 0xa9, 0xac, 0xea, 0x88, 0x25, 0x1b, 0x7f, 0x49, 0xde, 0x81,
-	0x05, 0x9f, 0xf5, 0x98, 0xf0, 0x05, 0xeb, 0xac, 0x47, 0x8f, 0x27, 0xbc, 0x2e, 0xbf, 0x72, 0x7a,
-	0xb2, 0xb2, 0xb0, 0x6e, 0x03, 0x61, 0x1e, 0x57, 0xbe, 0x0f, 0xc9, 0xaf, 0x2d, 0x79, 0x05, 0x66,
-	0x06, 0x5d, 0x73, 0xef, 0x53, 0x6b, 0x2d, 0x9b, 0x0e, 0xee, 0x0a, 0xe2, 0xc3, 0x93, 0x95, 0x05,
-	0x23, 0x2f, 0x09, 0xa8, 0x84, 0xc5, 0xce, 0xec, 0xab, 0x08, 0x6a, 0x34, 0xf2, 0xd3, 0x81, 0x15,
-	0x1a, 0x3e, 0xf1, 0x00, 0xbc, 0x28, 0xf4, 0x03, 0xe5, 0xe3, 0x4b, 0x72, 0x16, 0x57, 0xcf, 0x37,
-	0xb2, 0x35, 0xd3, 0x2e, 0xdb, 0x59, 0x29, 0x29, 0x41, 0x0b, 0x96, 0x50, 0x98, 0xeb, 0xd1, 0x84,
-	0xab, 0x5a, 0x9e, 0xaf, 0x23, 0xf3, 0xdf, 0x3c, 0x9f, 0x96, 0xbd, 0xa0, 0xcf, 0xb2, 0x53, 0x62,
-	0x2b, 0x83, 0x41, 0x1b, 0xd3, 0xf9, 0x79, 0x11, 0x8a, 0xee, 0xf5, 0x73, 0x64, 0x09, 0xcf, 0xc1,
-	0xec, 0xc1, 0xd0, 0x3b, 0x64, 0x67, 0xee, 0x5f, 0x5b, 0x92, 0x8a, 0x9a, 0x2b, 0xe4, 0x62, 0xd6,
-	0x11, 0x67, 0xe7, 0xc8, 0x35, 0x3e, 0x4a, 0x2a, 0x6a, 0x2e, 0x39, 0x82, 0x39, 0x2f, 0x7b, 0xd0,
-	0xa3, 0xc7, 0x36, 0xd9, 0xbe, 0xce, 0xbf, 0x0d, 0x6a, 0x5d, 0x16, 0x03, 0xb6, 0x08, 0x68, 0x2b,
-	0x22, 0x1f, 0x41, 0x95, 0xe9, 0xd7, 0x30, 0xfa, 0x62, 0xeb, 0xad, 0x49, 0x95, 0x9a, 0x57, 0x35,
-	0x2a, 0xa0, 0x31, 0x5f, 0x98, 0xe2, 0x3b, 0xdf, 0x83, 0x59, 0xf7, 0xba, 0x0c, 0x61, 0x5d, 0x28,
-	0x26, 0xd7, 0xf5, 0x20, 0x7f, 0x6b, 0xb2, 0xcd, 0x76, 0xbd, 0x05, 0x7a, 0x2a, 0x8b, 0xee, 0x75,
-	0x2c, 0x26, 0xd7, 0x9d, 0x5f, 0x16, 0xa0, 0xea, 0x5e, 0xd7, 0xe1, 0xa8, 0xd2, 0x50, 0x79, 0xac,
-	0x1a, 0xc8, 0xf7, 0x01, 0x06, 0x51, 0xaf, 0xb7, 0xcb, 0xe2, 0x20, 0xf2, 0x65, 0xc5, 0xfb, 0xe2,
-	0xfb, 0x57, 0xde, 0x8f, 0xed, 0xa6, 0x28, 0x68, 0x21, 0x8a, 0x34, 0xdb, 0x8b, 0x42, 0x6f, 0x18,
-	0xc7, 0x2c, 0xf4, 0x8e, 0x65, 0xbd, 0x6f, 0x21, 0x33, 0xda, 0xb5, 0x8c, 0x85, 0xb6, 0x9c, 0xf3,
-	0x1f, 0x05, 0x90, 0xd9, 0x02, 0x79, 0x0b, 0x6a, 0x7d, 0xe6, 0x75, 0x69, 0x18, 0x24, 0x7d, 0x6d,
-	0xbb, 0x26, 0x40, 0xae, 0x6d, 0x1b, 0x86, 0xd8, 0xee, 0x42, 0x3a, 0x25, 0x60, 0xd6, 0x88, 0x6c,
-	0x42, 0x79, 0x98, 0xb0, 0xf8, 0x62, 0xef, 0xbb, 0xe4, 0x90, 0xf6, 0x13, 0x16, 0xeb, 0xca, 0x9f,
-	0x84, 0x20, 0xfb, 0x50, 0x35, 0xe5, 0xc6, 0x8b, 0xbd, 0xe3, 0x1a, 0x57, 0xb9, 0x4c, 0xa1, 0x9c,
-	0xff, 0x2c, 0x42, 0x2d, 0xbd, 0xfa, 0x26, 0x43, 0xa8, 0x89, 0x63, 0x4a, 0x3e, 0xb4, 0x98, 0x2a,
-	0x30, 0x76, 0xef, 0x6c, 0xb9, 0x06, 0xc8, 0x2a, 0x02, 0x59, 0x54, 0xcc, 0x34, 0x91, 0x1f, 0x15,
-	0x60, 0x31, 0x0a, 0x91, 0x79, 0x51, 0xec, 0xef, 0x44, 0xfc, 0x66, 0x34, 0x0c, 0xfd, 0xa9, 0x8e,
-	0xfc, 0xbc, 0xfa, 0xd3, 0x93, 0x95, 0xc5, 0xdb, 0x23, 0xf0, 0x78, 0x46, 0x21, 0xe9, 0x42, 0x25,
-	0x0a, 0x65, 0x7c, 0xa6, 0x27, 0xf8, 0x31, 0xe8, 0x96, 0x35, 0x80, 0xdb, 0x0a, 0x15, 0x0d, 0xbc,
-	0xf3, 0x2e, 0xe4, 0xa6, 0x82, 0x3c, 0x03, 0xa5, 0xe4, 0xfe, 0x99, 0xa2, 0x97, 0x7b, 0x67, 0x0b,
-	0x05, 0x3d, 0x7d, 0x86, 0x53, 0x1c, 0xf7, 0x0c, 0xc7, 0xf9, 0x79, 0x09, 0xca, 0xee, 0x5e, 0x73,
-	0xe7, 0x1c, 0x5e, 0xf6, 0x9b, 0x50, 0x09, 0x29, 0x4f, 0xf6, 0xe3, 0x9e, 0xae, 0x06, 0xa7, 0x27,
-	0xd0, 0x4e, 0x73, 0xcf, 0xdd, 0xc7, 0x2d, 0x34, 0x7c, 0x72, 0x0b, 0xae, 0x88, 0x9f, 0xdb, 0x51,
-	0x18, 0xf0, 0x28, 0x0e, 0xc2, 0x8e, 0x68, 0x54, 0x95, 0x8d, 0xbe, 0xae, 0x1b, 0x5d, 0x11, 0x8d,
-	0x2c, 0x01, 0xdc, 0xc2, 0xb3, 0x6d, 0xc8, 0x2a, 0xd4, 0xf4, 0x1d, 0xdd, 0xa6, 0xaf, 0x2f, 0xc3,
-	0xd2, 0xeb, 0x07, 0x7d, 0x8b, 0xb7, 0xb9, 0x8e, 0x99, 0x8c, 0xe8, 0x64, 0x32, 0x94, 0xb1, 0xa0,
-	0xf6, 0xf1, 0xd9, 0xc5, 0x8b, 0x22, 0xa3, 0xe1, 0x93, 0x2d, 0x58, 0xd0, 0x3f, 0x77, 0x63, 0xd6,
-	0x0e, 0x1e, 0xe8, 0x5b, 0xb3, 0xe7, 0x74, 0x83, 0x05, 0xd7, 0x66, 0x3e, 0x1c, 0x25, 0x60, 0xbe,
-	0x31, 0xf9, 0x00, 0xca, 0x74, 0xc8, 0xbb, 0xda, 0xcb, 0x4d, 0x18, 0xb4, 0xec, 0x35, 0x77, 0x9a,
-	0x43, 0xde, 0xd5, 0xab, 0x34, 0xe4, 0x5d, 0x94, 0xa0, 0xc2, 0x17, 0xf5, 0xe9, 0x83, 0xcd, 0xb0,
-	0xdd, 0x0b, 0x3a, 0x5d, 0x75, 0x27, 0x60, 0xf9, 0xa2, 0xed, 0x8c, 0x85, 0xb6, 0x9c, 0x83, 0x50,
-	0x35, 0x90, 0xe4, 0xa6, 0x48, 0x3c, 0x0e, 0x59, 0x78, 0xb1, 0x0a, 0x6c, 0x4d, 0xe5, 0x26, 0x87,
-	0x2c, 0x44, 0xd5, 0xdc, 0xf9, 0xfb, 0x02, 0xcc, 0xb8, 0x1e, 0xed, 0x31, 0xd2, 0x84, 0xcb, 0x3e,
-	0x4b, 0x82, 0x98, 0xf9, 0xfa, 0x16, 0x33, 0xd1, 0xc6, 0x93, 0x96, 0x81, 0xd6, 0xf3, 0x6c, 0x1c,
-	0x95, 0x17, 0xcb, 0x3b, 0x60, 0xec, 0x30, 0x0b, 0xc1, 0xac, 0xe5, 0xdd, 0x35, 0x0c, 0xcc, 0x64,
-	0xc8, 0x6b, 0x30, 0x9f, 0x78, 0xb4, 0x17, 0x84, 0x1d, 0xd5, 0x66, 0xe4, 0x0e, 0xd6, 0xb5, 0x78,
-	0x98, 0x93, 0x74, 0x7c, 0x30, 0x57, 0x6f, 0x5f, 0xe4, 0xcb, 0xd1, 0xbf, 0x98, 0x81, 0xb2, 0x3c,
-	0x54, 0x7f, 0xfd, 0x76, 0x7a, 0x0f, 0xca, 0x09, 0xa7, 0xe1, 0x74, 0x05, 0xaa, 0xbd, 0xe6, 0x8e,
-	0x2e, 0x50, 0xed, 0x35, 0x77, 0x50, 0x02, 0x66, 0xc5, 0x9f, 0x69, 0x5e, 0xfe, 0xa5, 0x15, 0x2e,
-	0x65, 0x02, 0xb9, 0xe2, 0x8f, 0x0b, 0xa5, 0x5e, 0x64, 0x8a, 0xb1, 0x93, 0xd5, 0xeb, 0xb6, 0xa2,
-	0x8e, 0xaa, 0xd7, 0x6d, 0x45, 0x1d, 0x14, 0x68, 0x62, 0xff, 0xc8, 0x72, 0xf3, 0xcc, 0x14, 0xfb,
-	0xc7, 0xdc, 0x03, 0x8c, 0x96, 0x9c, 0x75, 0x00, 0xa2, 0x62, 0x84, 0xd7, 0x27, 0x0c, 0x40, 0x24,
-	0xf0, 0xac, 0x15, 0x80, 0xb8, 0x50, 0xf4, 0x0f, 0xf4, 0x7e, 0x7f, 0x7d, 0xc2, 0xb7, 0x3a, 0x19,
-	0xe8, 0x7a, 0x0b, 0x8b, 0xfe, 0x01, 0xf1, 0x60, 0x56, 0xbd, 0xe1, 0xd4, 0x17, 0x8c, 0x93, 0xdd,
-	0x50, 0xa8, 0x47, 0xa1, 0x12, 0x1c, 0x44, 0x7c, 0xab, 0xbe, 0x51, 0x43, 0x3b, 0x7f, 0x36, 0x0b,
-	0xfa, 0xe5, 0xea, 0xf9, 0xec, 0xd4, 0x8b, 0xa3, 0xe9, 0xec, 0x74, 0x2d, 0x8e, 0x42, 0xb5, 0x28,
-	0xe2, 0x17, 0x4a, 0xc0, 0x74, 0x03, 0x94, 0x1e, 0xf7, 0x06, 0xa0, 0x66, 0x03, 0x4c, 0x7d, 0x5d,
-	0xa0, 0xaf, 0xbc, 0xce, 0x6e, 0x81, 0xef, 0xe5, 0xac, 0x75, 0xf2, 0x6b, 0x24, 0xad, 0x60, 0xd4,
-	0x5e, 0xf7, 0xa5, 0xbd, 0x56, 0xa7, 0x39, 0x4a, 0x74, 0xec, 0x9d, 0xb3, 0xd8, 0x7d, 0x69, 0xb1,
-	0xb3, 0xd3, 0x3c, 0x37, 0x6c, 0xd9, 0xb0, 0xda, 0x66, 0x59, 0x6a, 0xb3, 0xb5, 0x29, 0x22, 0x1f,
-	0x6d, 0xb3, 0x0a, 0x7e, 0x8c, 0xd5, 0x8a, 0x65, 0x8d, 0x19, 0x8f, 0x8f, 0xf5, 0x96, 0x9b, 0xec,
-	0x4e, 0x56, 0x3f, 0xeb, 0xcf, 0xca, 0x02, 0x28, 0x20, 0x51, 0x21, 0x3b, 0xff, 0x5a, 0x84, 0x79,
-	0xd5, 0x03, 0x9d, 0xab, 0x3f, 0x0b, 0x95, 0x01, 0x0b, 0xfd, 0x20, 0xec, 0x48, 0x33, 0x2d, 0xab,
-	0x90, 0x6c, 0x57, 0x91, 0xd0, 0xf0, 0xc8, 0x4b, 0x2a, 0x19, 0xd6, 0x74, 0x5d, 0x0c, 0xbb, 0x6c,
-	0x92, 0x5b, 0x23, 0x6e, 0xcb, 0x90, 0x63, 0x91, 0xcf, 0xcb, 0x9a, 0x60, 0xbd, 0x3c, 0x45, 0x15,
-	0xd6, 0xee, 0x6d, 0x43, 0x17, 0x19, 0x55, 0x21, 0xd4, 0xaa, 0x0f, 0x48, 0x2a, 0x1a, 0x7d, 0x4b,
-	0x0f, 0x60, 0xde, 0x96, 0x1c, 0x53, 0xcb, 0x44, 0xbb, 0x96, 0x39, 0xe9, 0x54, 0x1b, 0xbd, 0x56,
-	0x25, 0xf4, 0xef, 0x8a, 0x50, 0x96, 0x95, 0xec, 0x2f, 0xbe, 0xf6, 0x77, 0x2f, 0x57, 0xfb, 0x9b,
-	0xb2, 0x88, 0x34, 0xae, 0xee, 0xd7, 0x19, 0xa9, 0xfb, 0x4d, 0xfd, 0x22, 0xe9, 0x51, 0x35, 0xbf,
-	0x4f, 0x45, 0x2a, 0xcd, 0xd9, 0xe0, 0x4b, 0xa8, 0xf7, 0x7d, 0x3f, 0x5f, 0xef, 0xbb, 0x31, 0xf1,
-	0x90, 0x1e, 0x51, 0xeb, 0xfb, 0x11, 0x51, 0x43, 0x91, 0x75, 0x3e, 0x73, 0xf4, 0xcc, 0x3e, 0xf2,
-	0xe8, 0x71, 0xa1, 0xe4, 0x51, 0x5e, 0xbf, 0x3c, 0x45, 0xa0, 0xb1, 0x46, 0xb9, 0xf9, 0x53, 0x0b,
-	0x47, 0x81, 0x46, 0x0e, 0xa1, 0xe6, 0x99, 0xbf, 0x68, 0xe8, 0x29, 0x9c, 0x2c, 0x44, 0x4a, 0xff,
-	0xe8, 0xa1, 0x9e, 0x44, 0xa4, 0x9f, 0x98, 0xe1, 0x93, 0x7b, 0x30, 0xeb, 0xcb, 0x37, 0xb6, 0xf5,
-	0xff, 0x3f, 0x4d, 0x9c, 0x20, 0x21, 0x94, 0x53, 0x54, 0xbf, 0x51, 0xc3, 0x0a, 0x05, 0x4c, 0x3e,
-	0x61, 0xad, 0x2f, 0x4d, 0xa1, 0x40, 0xbd, 0x82, 0x55, 0x0a, 0xd4, 0x6f, 0xd4, 0xb0, 0x42, 0x41,
-	0x5b, 0xbe, 0x4d, 0xd5, 0xc7, 0xd1, 0x64, 0x0a, 0xd4, 0xf3, 0x56, 0xa5, 0x40, 0xfd, 0x46, 0x0d,
-	0x4b, 0x3c, 0xa8, 0xb4, 0xd5, 0x03, 0xd2, 0xfa, 0xd7, 0xa7, 0xf0, 0x36, 0xfa, 0x11, 0xaa, 0x72,
-	0xd0, 0xfa, 0x03, 0x0d, 0xb2, 0xb0, 0xa4, 0x4e, 0xc0, 0xe5, 0x7b, 0xb7, 0x49, 0x2d, 0xe9, 0x56,
-	0xa0, 0x2d, 0xe9, 0x56, 0xc0, 0x51, 0xa0, 0x91, 0x0f, 0x60, 0xa6, 0x23, 0x1f, 0x23, 0xcd, 0x4d,
-	0x71, 0xcb, 0x2a, 0xdf, 0x1f, 0xa9, 0x08, 0x43, 0xbd, 0x5f, 0x52, 0x98, 0x32, 0xec, 0x8a, 0x7c,
-	0xa6, 0x0f, 0xbb, 0x09, 0xc3, 0xae, 0xc8, 0xd7, 0xb1, 0x85, 0xf8, 0x85, 0x12, 0x50, 0x4c, 0x45,
-	0x9f, 0x0e, 0xf4, 0x51, 0x3d, 0xd9, 0x54, 0x6c, 0xd3, 0x81, 0x9a, 0x8a, 0x6d, 0x3a, 0x40, 0x81,
-	0x46, 0x9e, 0x87, 0x6a, 0x6c, 0x92, 0xc0, 0xaf, 0xc9, 0xec, 0x34, 0x75, 0x33, 0x69, 0xf6, 0x97,
-	0x4a, 0x88, 0x0c, 0x45, 0xe4, 0x66, 0xac, 0x5e, 0x9f, 0x62, 0xe2, 0x64, 0x12, 0x6a, 0x95, 0xf7,
-	0xc5, 0x27, 0x2a, 0x5c, 0xd2, 0x86, 0x8a, 0xc9, 0xef, 0x54, 0xf9, 0xfb, 0xf5, 0x29, 0x0e, 0x57,
-	0xab, 0x84, 0xa0, 0x13, 0x3e, 0x03, 0x2e, 0xfc, 0x65, 0x12, 0x84, 0x87, 0xe6, 0x08, 0x9f, 0xd0,
-	0x5f, 0x8a, 0x30, 0x3d, 0x1b, 0x87, 0xc0, 0x43, 0x05, 0x4b, 0xee, 0xc1, 0x42, 0xcc, 0xe4, 0x8d,
-	0xb9, 0x7e, 0xa2, 0xab, 0x4a, 0x20, 0x37, 0x4c, 0x89, 0x02, 0x6d, 0xe6, 0xc3, 0x93, 0x95, 0xab,
-	0x63, 0x5e, 0xe9, 0xe6, 0x64, 0x30, 0x8f, 0x27, 0x2f, 0xf1, 0x58, 0xdc, 0x0f, 0x42, 0xca, 0x23,
-	0xf5, 0xd0, 0xd5, 0xfa, 0x83, 0xc3, 0x5e, 0xca, 0x41, 0x4b, 0x8a, 0x6c, 0x40, 0x45, 0x45, 0x64,
-	0x49, 0x7d, 0xe1, 0xd1, 0x0f, 0xfe, 0x54, 0xf0, 0x66, 0xbd, 0x4f, 0x51, 0x4d, 0xd0, 0xb4, 0x25,
-	0xef, 0x00, 0xd1, 0xcf, 0x93, 0x9a, 0x9e, 0x17, 0x0d, 0x43, 0x2e, 0x5f, 0x33, 0x5d, 0xca, 0xfd,
-	0x29, 0x8f, 0xb8, 0x67, 0x24, 0x70, 0x4c, 0x2b, 0xd2, 0xb1, 0x4e, 0xc5, 0xc5, 0x29, 0x0e, 0x7c,
-	0x73, 0xa3, 0xac, 0xaa, 0xe6, 0xe6, 0xcb, 0x3a, 0x20, 0xff, 0xa8, 0x00, 0xf3, 0x61, 0xe4, 0x33,
-	0x53, 0x20, 0xa9, 0x5f, 0x91, 0x33, 0x70, 0x7b, 0xaa, 0xf0, 0xa2, 0xb1, 0x63, 0x21, 0xaa, 0xe0,
-	0x2d, 0xad, 0x68, 0xd8, 0x2c, 0xcc, 0xa9, 0x26, 0x37, 0xa1, 0x4a, 0xdb, 0xed, 0x20, 0x0c, 0xf8,
-	0x71, 0x9d, 0xc8, 0x41, 0x3f, 0x3d, 0x6e, 0x21, 0x9a, 0x5a, 0x46, 0x8d, 0xc9, 0x7c, 0x61, 0xda,
-	0x96, 0xec, 0xc3, 0x1c, 0x8f, 0x7a, 0x2c, 0xd6, 0x6f, 0x02, 0x9e, 0x94, 0x23, 0x5a, 0x1e, 0x07,
-	0xb5, 0x97, 0x8a, 0x65, 0xc5, 0xa7, 0x8c, 0x96, 0xa0, 0x8d, 0x63, 0x3f, 0xa0, 0x7e, 0xfa, 0x4b,
-	0x7f, 0x40, 0xfd, 0xd4, 0x17, 0xf7, 0x80, 0x7a, 0xe9, 0x4d, 0xb8, 0x72, 0x66, 0xc1, 0x2e, 0xf4,
-	0x1e, 0xe0, 0x2f, 0x2b, 0x60, 0xbd, 0x3a, 0x27, 0x2f, 0xe6, 0xef, 0x03, 0x97, 0x46, 0xef, 0x03,
-	0x6b, 0x42, 0x36, 0x77, 0x17, 0x28, 0xef, 0xb1, 0x68, 0x12, 0x85, 0xba, 0xa6, 0x6a, 0xdd, 0x63,
-	0x09, 0x2a, 0x6a, 0xee, 0x45, 0xee, 0x0c, 0x6d, 0x07, 0x3e, 0xf3, 0x6b, 0x1d, 0xf8, 0xf3, 0x50,
-	0x4d, 0xcc, 0x0e, 0xa8, 0x8c, 0xfc, 0x3d, 0xd2, 0x18, 0x6b, 0x2a, 0x41, 0x7c, 0x98, 0x17, 0x99,
-	0x8f, 0xf4, 0xd0, 0x7e, 0x93, 0xeb, 0x04, 0xf4, 0x22, 0x77, 0x85, 0xe9, 0x76, 0xd8, 0xb2, 0x70,
-	0x30, 0x87, 0x4a, 0x7e, 0x5c, 0x80, 0x4b, 0x89, 0x95, 0x0d, 0xa5, 0xbe, 0xdf, 0x9d, 0x32, 0x30,
-	0xcf, 0xe5, 0x58, 0x4c, 0x67, 0x57, 0xd7, 0xcc, 0x9f, 0x19, 0xf2, 0xcc, 0x87, 0x67, 0x28, 0x38,
-	0xd2, 0x29, 0xf2, 0xe7, 0x05, 0x98, 0x17, 0xde, 0x3d, 0xed, 0xa5, 0x3a, 0x3b, 0xee, 0x4c, 0xdd,
-	0x4b, 0x0b, 0x53, 0xf5, 0xf1, 0xd9, 0xf4, 0x3d, 0x96, 0x61, 0x8d, 0xed, 0x60, 0xae, 0x37, 0x4b,
-	0xbf, 0x5f, 0x80, 0x27, 0xc7, 0x0c, 0x78, 0x8c, 0x81, 0xbf, 0x97, 0x4f, 0x12, 0x9b, 0x53, 0xe7,
-	0xaf, 0xf6, 0x73, 0x9b, 0x1f, 0x16, 0xe0, 0xca, 0x99, 0x11, 0x7d, 0xc9, 0x9d, 0x70, 0xee, 0x82,
-	0x79, 0xb6, 0x7d, 0xbe, 0xeb, 0x91, 0x64, 0x78, 0xb0, 0x4b, 0x79, 0x77, 0x74, 0xb3, 0xb9, 0x8a,
-	0x8c, 0x86, 0xef, 0xfc, 0x71, 0x11, 0x4a, 0x7b, 0x5b, 0x2e, 0xf9, 0x00, 0xe6, 0x3d, 0xba, 0xc6,
-	0x62, 0xae, 0xdf, 0xfa, 0x5f, 0xfc, 0x1f, 0xb5, 0x6b, 0xcd, 0xac, 0x39, 0xe6, 0xc0, 0xc8, 0x3e,
-	0x80, 0x97, 0x41, 0x5f, 0xfc, 0x0e, 0xd1, 0x02, 0xb6, 0x80, 0x08, 0x42, 0xed, 0x30, 0xfd, 0x73,
-	0xc2, 0x85, 0xae, 0x12, 0x65, 0x96, 0x94, 0xfd, 0x25, 0x21, 0x83, 0x71, 0xba, 0x00, 0x59, 0xc5,
-	0x92, 0x7c, 0xd7, 0xfc, 0x23, 0x5e, 0xff, 0x1b, 0x52, 0xcd, 0xca, 0xd5, 0x47, 0x07, 0x19, 0x3a,
-	0x4c, 0x1b, 0xf9, 0x4b, 0xbc, 0xfe, 0xcb, 0x63, 0x0e, 0xcb, 0xf9, 0xdb, 0x22, 0xe4, 0xd8, 0x67,
-	0x94, 0xd5, 0x1e, 0x9f, 0xb2, 0xff, 0xa5, 0x37, 0xd4, 0xca, 0xd5, 0x53, 0xff, 0x76, 0xd8, 0x3b,
-	0xd6, 0x11, 0x9f, 0xe5, 0xea, 0x15, 0x1d, 0x53, 0x89, 0x56, 0xe3, 0xd3, 0xcf, 0x97, 0x9f, 0xf8,
-	0xec, 0xf3, 0xe5, 0x27, 0x7e, 0xf6, 0xf9, 0xf2, 0x13, 0x3f, 0x38, 0x5d, 0x2e, 0x7c, 0x7a, 0xba,
-	0x5c, 0xf8, 0xec, 0x74, 0xb9, 0xf0, 0xb3, 0xd3, 0xe5, 0xc2, 0x2f, 0x4e, 0x97, 0x0b, 0x7f, 0xf2,
-	0x6f, 0xcb, 0x4f, 0x7c, 0xb7, 0x6a, 0xf6, 0xd2, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x6f, 0xa2,
-	0x65, 0xc0, 0x4a, 0x46, 0x00, 0x00,
+	// 5349 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5c, 0x4d, 0x70, 0x23, 0xc7,
+	0x75, 0x16, 0x00, 0x92, 0x00, 0x1e, 0x7f, 0x96, 0xdb, 0xbb, 0xb2, 0x61, 0x46, 0x5a, 0x6e, 0x8d,
+	0x22, 0x79, 0x9d, 0xc8, 0xa4, 0xa5, 0x95, 0x2a, 0x5a, 0x3b, 0xb6, 0x04, 0x80, 0xe4, 0x8a, 0x12,
+	0xc9, 0xe5, 0xbe, 0xe1, 0xae, 0xac, 0x48, 0xd6, 0xa6, 0x39, 0xd3, 0x00, 0x46, 0x04, 0x66, 0x66,
+	0x67, 0x1a, 0xdc, 0xa5, 0x73, 0x71, 0xc9, 0x91, 0x53, 0x39, 0xa4, 0x2a, 0xb9, 0xe4, 0x92, 0x9c,
+	0x92, 0x72, 0x52, 0x95, 0xaa, 0xe4, 0x90, 0xaa, 0xa4, 0xe2, 0x8b, 0xaf, 0x51, 0x55, 0x2e, 0x3a,
+	0xba, 0x9c, 0x0a, 0xcb, 0x62, 0x72, 0xca, 0x2d, 0x39, 0xf8, 0xb0, 0x95, 0xaa, 0xa4, 0xfa, 0x6f,
+	0x7e, 0x00, 0x50, 0x22, 0x01, 0xfd, 0x38, 0x37, 0xcc, 0x7b, 0xaf, 0xbf, 0xd7, 0xd3, 0xfd, 0xfa,
+	0xf5, 0x7b, 0xaf, 0x7b, 0x00, 0xcd, 0xb6, 0xc7, 0x3b, 0xfd, 0xfd, 0x15, 0x27, 0xe8, 0xad, 0xd2,
+	0xa8, 0x1d, 0x84, 0x51, 0xf0, 0xee, 0xd7, 0xbb, 0x74, 0x3f, 0x96, 0x4f, 0x5f, 0x77, 0x29, 0xa7,
+	0xad, 0x6e, 0xf0, 0x60, 0x95, 0x86, 0xde, 0xea, 0xe1, 0x73, 0xb4, 0x1b, 0x76, 0xe8, 0x73, 0xab,
+	0x6d, 0xe6, 0xb3, 0x88, 0x72, 0xe6, 0xae, 0x84, 0x51, 0xc0, 0x03, 0x72, 0x3d, 0x05, 0x59, 0x31,
+	0x20, 0xf7, 0x04, 0x88, 0x7c, 0xba, 0x67, 0x40, 0x56, 0x68, 0xe8, 0xad, 0x18, 0x90, 0xa5, 0xaf,
+	0x67, 0x34, 0xb7, 0x83, 0x76, 0xb0, 0x2a, 0xb1, 0xf6, 0xfb, 0x2d, 0xf9, 0x24, 0x1f, 0xe4, 0x2f,
+	0xa5, 0x63, 0xc9, 0x3a, 0x78, 0x29, 0x5e, 0xf1, 0x02, 0xd9, 0x11, 0x27, 0x88, 0xd8, 0xea, 0xe1,
+	0x50, 0x3f, 0x96, 0x5e, 0x48, 0x65, 0x7a, 0xd4, 0xe9, 0x78, 0x3e, 0x8b, 0x8e, 0x56, 0xc3, 0x83,
+	0xb6, 0x6c, 0x14, 0xb1, 0x38, 0xe8, 0x47, 0x0e, 0x3b, 0x57, 0xab, 0x78, 0xb5, 0xc7, 0x38, 0x1d,
+	0xa1, 0xcb, 0xfa, 0x49, 0x11, 0x16, 0xea, 0x6f, 0xd8, 0xcd, 0x88, 0xb9, 0xcc, 0xe7, 0x1e, 0xed,
+	0xc6, 0xe4, 0x6d, 0x98, 0xa5, 0x8e, 0xc3, 0xe2, 0xf8, 0x75, 0x76, 0xb4, 0xe9, 0xd6, 0x0a, 0x57,
+	0x0b, 0xd7, 0x66, 0x9f, 0x7f, 0x7a, 0x45, 0xc1, 0xcb, 0x97, 0x17, 0x1d, 0x5f, 0x39, 0x7c, 0x6e,
+	0xc5, 0x66, 0x4e, 0xc4, 0xf8, 0xeb, 0xec, 0xc8, 0x66, 0x5d, 0xe6, 0xf0, 0x20, 0x6a, 0x5c, 0xfa,
+	0xe0, 0x78, 0xf9, 0xb1, 0x93, 0xe3, 0xe5, 0xd9, 0x7a, 0x82, 0xb0, 0x86, 0x59, 0x38, 0xd2, 0x81,
+	0x0b, 0xb1, 0x6c, 0x96, 0x48, 0xd4, 0x8a, 0xe7, 0xd1, 0xf0, 0x65, 0xad, 0xe1, 0x82, 0x9d, 0x47,
+	0xc1, 0x41, 0x58, 0x72, 0x0f, 0xe6, 0x62, 0x16, 0xc7, 0x5e, 0xe0, 0xef, 0x05, 0x07, 0xcc, 0xaf,
+	0x95, 0xce, 0xa3, 0xe6, 0xb2, 0x56, 0x33, 0x67, 0x67, 0x20, 0x30, 0x07, 0x68, 0x3d, 0x0b, 0xb3,
+	0xf5, 0x37, 0xec, 0x75, 0xdf, 0x0d, 0x03, 0xcf, 0xe7, 0xe4, 0x49, 0x28, 0xf5, 0xa3, 0xae, 0x1c,
+	0xaf, 0x6a, 0x63, 0x56, 0xb7, 0x2f, 0xdd, 0xc1, 0x2d, 0x14, 0x74, 0xcb, 0x83, 0xb9, 0xfa, 0x7e,
+	0xcc, 0x23, 0xea, 0x70, 0x9b, 0xb3, 0x90, 0xbc, 0x09, 0x55, 0x33, 0x97, 0xb1, 0x1e, 0xe4, 0x6b,
+	0xa3, 0xfa, 0x86, 0x5a, 0x08, 0xd9, 0xfd, 0xbe, 0x17, 0xb1, 0x1e, 0xf3, 0x79, 0xdc, 0xb8, 0xa8,
+	0xe1, 0xab, 0x86, 0x1b, 0x63, 0x8a, 0x66, 0xfd, 0xc5, 0x65, 0xb8, 0x6c, 0x74, 0xdd, 0x0d, 0xba,
+	0xfd, 0x1e, 0xb3, 0x25, 0x87, 0x20, 0x54, 0x3a, 0x41, 0xcc, 0x77, 0x29, 0xef, 0x7c, 0x9c, 0xca,
+	0x57, 0xb5, 0x4c, 0xb6, 0x6d, 0x63, 0xee, 0xe4, 0x78, 0xb9, 0x62, 0x38, 0x98, 0xe0, 0x08, 0x4c,
+	0xd6, 0x0b, 0xf9, 0xd1, 0x9a, 0x17, 0xe9, 0x99, 0x1c, 0x89, 0xb9, 0xae, 0x65, 0x86, 0x31, 0x0d,
+	0x07, 0x13, 0x1c, 0x72, 0x08, 0x17, 0xdb, 0x0e, 0xdb, 0x65, 0x51, 0xec, 0xc5, 0x9c, 0xf9, 0x7c,
+	0xcd, 0x8b, 0x0f, 0xf4, 0xfc, 0x3d, 0x37, 0x0a, 0xfc, 0x66, 0x73, 0x3d, 0x2f, 0x9c, 0xd3, 0xf2,
+	0xf8, 0xc9, 0xf1, 0xf2, 0xc5, 0x21, 0x11, 0x1c, 0x56, 0x41, 0xde, 0x2b, 0xc0, 0x65, 0xfa, 0x20,
+	0x5e, 0xef, 0xd2, 0x98, 0x7b, 0x4e, 0xa3, 0x1b, 0x38, 0x07, 0x36, 0x0f, 0x22, 0x56, 0x9b, 0x92,
+	0xba, 0x5f, 0x18, 0xa5, 0x5b, 0x98, 0xc0, 0xa0, 0x7c, 0x4e, 0x7d, 0xed, 0xe4, 0x78, 0xf9, 0xf2,
+	0x28, 0x29, 0x1c, 0xa9, 0x8b, 0xec, 0x40, 0xb9, 0xed, 0x71, 0x64, 0x61, 0x50, 0x9b, 0x96, 0x6a,
+	0xbf, 0x3a, 0xf2, 0x95, 0x95, 0x48, 0x4e, 0xd3, 0xec, 0xc9, 0xf1, 0x72, 0x59, 0x33, 0xd0, 0x80,
+	0x90, 0xd7, 0x60, 0x46, 0x2d, 0x8d, 0xda, 0x8c, 0x84, 0x7b, 0xe6, 0xf4, 0x15, 0x90, 0x43, 0x83,
+	0x93, 0xe3, 0xe5, 0x19, 0x45, 0x47, 0x8d, 0x40, 0xbe, 0x03, 0x25, 0xbf, 0x15, 0xd7, 0xca, 0x12,
+	0xe8, 0xa9, 0x51, 0x40, 0x3b, 0x1b, 0x76, 0x0e, 0xa5, 0x2c, 0x16, 0xc1, 0xce, 0x86, 0x8d, 0xa2,
+	0x21, 0xd9, 0x80, 0x69, 0x2f, 0x76, 0x62, 0xaf, 0x56, 0x39, 0x7d, 0x31, 0x6e, 0xda, 0x4d, 0x7b,
+	0x33, 0x87, 0x51, 0x3d, 0x39, 0x5e, 0x9e, 0x96, 0x64, 0x54, 0xcd, 0xc9, 0x5d, 0xa8, 0xb6, 0xbb,
+	0xfd, 0x98, 0xb3, 0xa8, 0x15, 0xd7, 0xaa, 0x12, 0xeb, 0x6b, 0x23, 0x47, 0xc9, 0x08, 0xe5, 0xf0,
+	0xe6, 0xc5, 0xca, 0x49, 0x58, 0x98, 0x42, 0x91, 0x1f, 0x15, 0xe0, 0xf1, 0x30, 0xb1, 0x09, 0xd5,
+	0xa8, 0xd9, 0xa5, 0x5e, 0xaf, 0x06, 0x52, 0xc9, 0x8b, 0xa3, 0x94, 0xec, 0x8e, 0x6a, 0x90, 0x53,
+	0xf8, 0x95, 0x93, 0xe3, 0xe5, 0xc7, 0x47, 0x8a, 0xe1, 0x68, 0x75, 0x62, 0xa0, 0xa3, 0x7d, 0xb7,
+	0x36, 0x7b, 0xfa, 0x40, 0x63, 0x63, 0x6d, 0x78, 0xa0, 0xb1, 0xb1, 0x86, 0xa2, 0x21, 0xd9, 0x03,
+	0x68, 0x75, 0xd9, 0x43, 0x25, 0x51, 0x9b, 0x93, 0x30, 0xbf, 0x3e, 0x0a, 0x66, 0x23, 0x91, 0xd2,
+	0x38, 0x0b, 0x27, 0xc7, 0xcb, 0x90, 0x52, 0x31, 0x83, 0x23, 0x4c, 0xc9, 0xf1, 0x7c, 0x97, 0x45,
+	0xb5, 0xf9, 0xd3, 0x4d, 0xa9, 0x29, 0x25, 0x86, 0x4d, 0x49, 0xd1, 0x51, 0x23, 0x48, 0x2c, 0x16,
+	0x76, 0x5a, 0x71, 0x6d, 0xe1, 0x63, 0xb0, 0x58, 0xd8, 0x19, 0x30, 0x28, 0x85, 0x25, 0xe9, 0xa8,
+	0x11, 0xc4, 0x92, 0x69, 0x89, 0x05, 0xc4, 0xa2, 0xda, 0x85, 0xd3, 0x97, 0xcc, 0x86, 0x12, 0x19,
+	0x5e, 0x32, 0x9a, 0x81, 0x06, 0x84, 0xbc, 0x03, 0xb3, 0x6e, 0xf0, 0xc0, 0x7f, 0x40, 0x23, 0xb7,
+	0xbe, 0xbb, 0x59, 0x5b, 0x94, 0x98, 0xbf, 0x39, 0x0a, 0x73, 0x2d, 0x15, 0xcb, 0xe1, 0x5e, 0x10,
+	0x9b, 0x60, 0x86, 0x89, 0x59, 0x40, 0xf2, 0x4d, 0x28, 0xb6, 0x9c, 0xda, 0x45, 0x09, 0x6b, 0x8d,
+	0xec, 0x6a, 0x33, 0x87, 0x36, 0x73, 0x72, 0xbc, 0x5c, 0xdc, 0x68, 0x62, 0xb1, 0xe5, 0x08, 0xd3,
+	0xa7, 0xdf, 0xef, 0x47, 0x6c, 0xc3, 0xeb, 0xb2, 0x1a, 0x39, 0xdd, 0xf4, 0xeb, 0x46, 0x68, 0xd8,
+	0xf4, 0x13, 0x16, 0xa6, 0x50, 0x02, 0xd7, 0x09, 0xfc, 0x96, 0xd7, 0xde, 0xa6, 0x61, 0xed, 0xd2,
+	0xe9, 0xb8, 0x4d, 0x23, 0x34, 0x8c, 0x9b, 0xb0, 0x30, 0x85, 0x22, 0x07, 0x30, 0x7f, 0x18, 0x87,
+	0x1d, 0x66, 0xbc, 0x62, 0xed, 0xb2, 0xc4, 0x7e, 0x7e, 0x14, 0xf6, 0x5d, 0x2d, 0xe8, 0x45, 0xbc,
+	0x4f, 0xbb, 0x43, 0x8e, 0xfc, 0xe2, 0xc9, 0xf1, 0xf2, 0xfc, 0xdd, 0x2c, 0x18, 0xe6, 0xb1, 0x85,
+	0x21, 0xdc, 0xef, 0x07, 0xfb, 0x47, 0x9c, 0xd5, 0x1e, 0x3f, 0xdd, 0x10, 0x6e, 0x2b, 0x91, 0x61,
+	0x43, 0xd0, 0x0c, 0x34, 0x20, 0xc9, 0x60, 0xcb, 0x0d, 0xe8, 0x4b, 0x9f, 0x30, 0xd8, 0x43, 0xfd,
+	0x4d, 0x07, 0x5b, 0x6e, 0x38, 0x29, 0x94, 0xdc, 0x68, 0xc2, 0x4e, 0xc0, 0x03, 0x7f, 0x60, 0x93,
+	0xfb, 0xf2, 0xe9, 0x1b, 0xcd, 0xee, 0x08, 0xf9, 0xe1, 0x8d, 0x66, 0x94, 0x14, 0x8e, 0xd4, 0x25,
+	0x5e, 0x4e, 0x84, 0xb8, 0xcc, 0xe1, 0xcc, 0xad, 0x2d, 0x9d, 0xfe, 0x72, 0xbb, 0x46, 0x68, 0xf8,
+	0xe5, 0x12, 0x16, 0xa6, 0x50, 0xc4, 0x85, 0x85, 0x30, 0x88, 0xf8, 0x83, 0x20, 0x32, 0xfe, 0xa7,
+	0x76, 0x7a, 0x5c, 0xb0, 0x9b, 0x93, 0xd4, 0xd8, 0xe4, 0xe4, 0x78, 0x79, 0x21, 0xcf, 0xc1, 0x01,
+	0x4c, 0x31, 0xd5, 0xb1, 0x43, 0xbb, 0x6c, 0xf3, 0x56, 0xed, 0x2b, 0xa7, 0x4f, 0xb5, 0xad, 0x44,
+	0x86, 0xa7, 0x5a, 0x33, 0xd0, 0x80, 0x88, 0xd1, 0x88, 0x79, 0x10, 0xd1, 0x36, 0x0b, 0xe2, 0xda,
+	0xaf, 0x9d, 0x3e, 0x1a, 0xb6, 0x12, 0xba, 0x65, 0x0f, 0x8f, 0x46, 0xc2, 0xc2, 0x14, 0x4a, 0x78,
+	0x72, 0xb1, 0xe1, 0x3d, 0x71, 0xba, 0x27, 0x1f, 0xdc, 0xee, 0xa4, 0x27, 0x17, 0x9b, 0x5d, 0x49,
+	0x6f, 0x75, 0x2c, 0xec, 0xb0, 0x1e, 0x8b, 0x68, 0xb7, 0xf6, 0xe4, 0xe9, 0xfd, 0x5a, 0x37, 0x42,
+	0xc3, 0xfd, 0x4a, 0x58, 0x98, 0x42, 0x59, 0xff, 0x52, 0x84, 0x72, 0x83, 0x3a, 0x07, 0x41, 0xab,
+	0x45, 0xbe, 0x0b, 0x15, 0xb7, 0x1f, 0x51, 0xee, 0x05, 0xbe, 0x0e, 0x75, 0x56, 0x32, 0x2a, 0x92,
+	0x74, 0x62, 0x25, 0x3c, 0x68, 0x0b, 0x42, 0xbc, 0x22, 0xd2, 0x09, 0xe9, 0xfe, 0x74, 0x2b, 0x15,
+	0xc9, 0x99, 0x27, 0x4c, 0xd0, 0xc8, 0x37, 0x60, 0x71, 0x83, 0x8a, 0x88, 0x7a, 0x97, 0x45, 0x0e,
+	0xf3, 0x39, 0x6d, 0x33, 0x19, 0xd5, 0xcc, 0x37, 0xa6, 0x44, 0x08, 0x8b, 0x43, 0x5c, 0xf2, 0x14,
+	0x4c, 0xc7, 0x9c, 0x85, 0x2a, 0x26, 0x9e, 0x6a, 0xcc, 0xeb, 0x48, 0x77, 0x5a, 0x04, 0xcd, 0x31,
+	0x2a, 0x1e, 0xd9, 0x84, 0x92, 0x43, 0x43, 0x1d, 0x6f, 0x9e, 0xb7, 0xaf, 0x6a, 0x7c, 0x69, 0x88,
+	0x02, 0x83, 0xac, 0xc1, 0xe2, 0xbb, 0x1e, 0xe7, 0x2c, 0xdb, 0xc3, 0x92, 0xec, 0x61, 0x4d, 0xab,
+	0x5e, 0x7c, 0x6d, 0x80, 0x8f, 0x43, 0x2d, 0xac, 0xf7, 0x0a, 0x50, 0x6a, 0x52, 0x4e, 0x7e, 0x0f,
+	0xe6, 0x68, 0x26, 0xca, 0xd7, 0x51, 0x76, 0x7d, 0x65, 0x8c, 0xd4, 0x72, 0x25, 0x9b, 0x2e, 0xa4,
+	0x09, 0x49, 0x96, 0x8a, 0x39, 0x65, 0x96, 0x0b, 0x53, 0xcd, 0xc0, 0x65, 0xe4, 0x05, 0x28, 0x47,
+	0x7d, 0x9f, 0x7b, 0x3d, 0x15, 0xb8, 0x56, 0x1b, 0x4b, 0xba, 0x71, 0x19, 0x15, 0xf9, 0x51, 0xfa,
+	0x13, 0x8d, 0x28, 0x79, 0x06, 0x66, 0x54, 0x02, 0x21, 0x5f, 0xbf, 0xda, 0x58, 0xd0, 0x8d, 0x66,
+	0x94, 0x29, 0xa1, 0xe6, 0x5a, 0x3f, 0x2d, 0x81, 0xf0, 0xf4, 0x9c, 0x8a, 0x71, 0x16, 0xd3, 0xe5,
+	0xf5, 0xc4, 0x98, 0xa9, 0xbc, 0x27, 0x99, 0xae, 0x4d, 0x41, 0x44, 0xc5, 0x23, 0x6f, 0xc2, 0xdc,
+	0xa1, 0xb4, 0xca, 0xed, 0xa0, 0xef, 0xf3, 0xb8, 0x36, 0x7d, 0xb5, 0x74, 0x6d, 0xf6, 0xf9, 0xe5,
+	0x91, 0x5b, 0x40, 0x2a, 0x97, 0xbe, 0x73, 0x86, 0x18, 0x63, 0x0e, 0x8a, 0xdc, 0x85, 0xa2, 0x67,
+	0x72, 0xbb, 0xef, 0x8c, 0x35, 0xcc, 0x9b, 0xbe, 0x88, 0xfd, 0xa8, 0xd9, 0x66, 0x37, 0x7d, 0x2c,
+	0x7a, 0x3e, 0x79, 0x1a, 0xca, 0x4e, 0xd0, 0xeb, 0x51, 0xdf, 0xad, 0xcd, 0x5c, 0x2d, 0x89, 0x8c,
+	0x4e, 0x8c, 0x5f, 0x53, 0x91, 0xd0, 0xf0, 0xc8, 0x13, 0x30, 0x45, 0xa3, 0xb6, 0x88, 0x88, 0x85,
+	0x4c, 0xe5, 0xe4, 0x78, 0x79, 0xaa, 0x1e, 0xb5, 0x63, 0x94, 0x54, 0x72, 0x03, 0x4a, 0xcc, 0x3f,
+	0xac, 0x55, 0xe4, 0xeb, 0x2e, 0x8d, 0x5c, 0xb5, 0xfe, 0xe1, 0x5d, 0x1a, 0xa5, 0xe9, 0xe2, 0xba,
+	0x7f, 0x88, 0xa2, 0x4d, 0x3e, 0x3d, 0xac, 0x7e, 0xaa, 0xe9, 0xe1, 0xdb, 0x30, 0xd5, 0x8c, 0x02,
+	0x9f, 0x3c, 0x0b, 0x95, 0xd8, 0xe9, 0x30, 0xb7, 0xdf, 0x35, 0xb3, 0xb7, 0xa8, 0xdb, 0x55, 0x6c,
+	0x4d, 0xc7, 0x44, 0x42, 0x98, 0x47, 0x97, 0x1e, 0x05, 0x7d, 0x2e, 0x57, 0x5d, 0xc6, 0x3c, 0xb6,
+	0x24, 0x15, 0x35, 0xd7, 0xfa, 0xeb, 0x02, 0xcc, 0xad, 0x35, 0xd6, 0x28, 0xa7, 0x3a, 0xe9, 0x7c,
+	0x0a, 0xa6, 0x0f, 0x69, 0xb7, 0x3f, 0x64, 0x21, 0x77, 0x05, 0x11, 0x15, 0x8f, 0x44, 0x50, 0x95,
+	0x3f, 0x36, 0xa2, 0xa0, 0xa7, 0x97, 0xf5, 0xfa, 0x58, 0xb3, 0x99, 0x55, 0x2d, 0xc0, 0x94, 0x07,
+	0xbc, 0x6b, 0xb0, 0x31, 0x55, 0x63, 0x05, 0xb0, 0x38, 0x28, 0x4d, 0xde, 0x82, 0xb9, 0xd8, 0x14,
+	0x03, 0x90, 0xb5, 0xce, 0x57, 0xfd, 0x58, 0x54, 0x05, 0x83, 0xb4, 0x39, 0xe6, 0xc0, 0xac, 0x5f,
+	0x14, 0x60, 0x66, 0xad, 0x61, 0x7b, 0xfe, 0x01, 0x39, 0x80, 0x8a, 0xe8, 0xff, 0x3e, 0x8d, 0x99,
+	0xd6, 0xf1, 0xed, 0xf1, 0x5e, 0x57, 0x83, 0xa4, 0x53, 0x67, 0x28, 0x98, 0x28, 0x20, 0x1e, 0x94,
+	0xa9, 0x23, 0x5c, 0x5f, 0x5c, 0x2b, 0x4a, 0x53, 0x1c, 0x6f, 0xa1, 0xd8, 0xb7, 0xb7, 0xea, 0x12,
+	0xa6, 0x71, 0xc1, 0xf8, 0x13, 0xf5, 0x1c, 0xa3, 0xc1, 0xb7, 0xfe, 0xa3, 0x04, 0x95, 0xb5, 0x86,
+	0x9e, 0xf9, 0xcf, 0xf5, 0x25, 0x9f, 0x82, 0xe9, 0xfb, 0x7d, 0x16, 0x1d, 0x69, 0xf3, 0x4c, 0xcc,
+	0xec, 0xb6, 0x20, 0xa2, 0xe2, 0x91, 0x97, 0x60, 0x2e, 0x68, 0xb5, 0x62, 0xc6, 0x9b, 0xc2, 0x87,
+	0xf8, 0xda, 0xd3, 0x25, 0x7e, 0xe6, 0x56, 0x86, 0x87, 0x39, 0x49, 0xd2, 0x81, 0xb9, 0x30, 0xe8,
+	0x76, 0xa5, 0xb3, 0x38, 0xa4, 0xdd, 0x31, 0xb7, 0xc9, 0x44, 0xd3, 0x6e, 0x06, 0x0b, 0x73, 0xc8,
+	0xc4, 0x87, 0x05, 0xe1, 0x5d, 0x3c, 0x9e, 0xe8, 0x9a, 0x1e, 0x4b, 0xd7, 0x97, 0xb4, 0xae, 0x85,
+	0x66, 0x0e, 0x0d, 0x07, 0xd0, 0xc9, 0xf3, 0x00, 0x9e, 0xef, 0x71, 0xb1, 0xe4, 0x7b, 0x54, 0xd6,
+	0x08, 0x2a, 0x0d, 0xa2, 0xdb, 0xc2, 0x66, 0xc2, 0xc1, 0x8c, 0x94, 0xf5, 0xe3, 0x02, 0x24, 0x73,
+	0x20, 0x3c, 0x83, 0x1b, 0x79, 0x87, 0x2c, 0xd2, 0x2b, 0x3c, 0xf1, 0x0c, 0x6b, 0x92, 0x8a, 0x9a,
+	0x4b, 0xee, 0x03, 0xb8, 0xc9, 0x6a, 0xd3, 0x8b, 0xbc, 0x3e, 0xf1, 0x22, 0x57, 0x09, 0x6b, 0xfa,
+	0x8c, 0x19, 0x25, 0xd6, 0xff, 0x8a, 0x15, 0xc7, 0xdc, 0x7e, 0xc8, 0xbe, 0xd0, 0x9d, 0x59, 0xd6,
+	0x06, 0x3d, 0x57, 0x9b, 0x66, 0x5a, 0x1b, 0xdc, 0x5c, 0x43, 0x41, 0x27, 0x6f, 0x42, 0xb9, 0x47,
+	0x1f, 0xda, 0xde, 0xf7, 0x99, 0xde, 0xc9, 0x3e, 0x76, 0xae, 0x57, 0x8c, 0x2b, 0x5f, 0xb9, 0xdd,
+	0xa7, 0x3e, 0xf7, 0xf8, 0x51, 0xba, 0x20, 0xb7, 0x15, 0x0c, 0x1a, 0x3c, 0xeb, 0xfd, 0x02, 0xcc,
+	0xac, 0x3f, 0x0c, 0xc5, 0x5e, 0xf5, 0x85, 0xc6, 0x26, 0x3f, 0x29, 0xc0, 0xcc, 0x86, 0xd7, 0xe5,
+	0x2c, 0xfa, 0x62, 0x67, 0xe2, 0x79, 0x00, 0xf6, 0x30, 0x8c, 0x54, 0x1d, 0x57, 0x4f, 0x48, 0x62,
+	0xed, 0xeb, 0x09, 0x07, 0x33, 0x52, 0xd6, 0x8f, 0x0a, 0x50, 0xde, 0xe8, 0x52, 0xce, 0x99, 0xff,
+	0xc5, 0x0e, 0xe2, 0xfb, 0x65, 0x98, 0xbf, 0xc9, 0xf8, 0x6e, 0xe0, 0xda, 0x21, 0x73, 0x90, 0xdd,
+	0x27, 0x5f, 0x83, 0xb2, 0xa3, 0xaa, 0x57, 0x7a, 0xf1, 0x25, 0x96, 0xd0, 0x54, 0x64, 0x34, 0x7c,
+	0xe1, 0x20, 0x5d, 0xb6, 0xdf, 0x6f, 0xcb, 0x97, 0xae, 0xa4, 0x0e, 0x72, 0x4d, 0x10, 0x51, 0xf1,
+	0x84, 0x83, 0x0c, 0xbd, 0x90, 0x75, 0x3d, 0x9f, 0xed, 0xd0, 0x1e, 0x1b, 0x74, 0x90, 0xbb, 0x19,
+	0x1e, 0xe6, 0x24, 0x45, 0x4f, 0x22, 0x16, 0x76, 0x3d, 0x87, 0x4a, 0xdf, 0x38, 0x9d, 0xf6, 0x04,
+	0x15, 0x19, 0x0d, 0x9f, 0xbc, 0x08, 0xb3, 0x32, 0x2e, 0xdc, 0x08, 0xa2, 0x1e, 0xe5, 0xd2, 0xbd,
+	0x55, 0xd3, 0xa3, 0x83, 0xcd, 0x94, 0x85, 0x59, 0x39, 0xd1, 0x2c, 0xea, 0xfb, 0x3e, 0x8b, 0xa4,
+	0x84, 0xf4, 0x54, 0x99, 0x66, 0x98, 0xb2, 0x30, 0x2b, 0x47, 0x6c, 0x80, 0xb0, 0xdf, 0xed, 0xee,
+	0x06, 0x5d, 0xcf, 0x39, 0x92, 0xa5, 0xcb, 0x6a, 0xe3, 0xba, 0x99, 0xf1, 0xdd, 0x84, 0xf3, 0xe8,
+	0x78, 0xf9, 0xc9, 0xe1, 0xc3, 0x99, 0x95, 0x54, 0x00, 0x33, 0x30, 0xe4, 0x16, 0x2c, 0xf4, 0x43,
+	0x97, 0x72, 0x96, 0x38, 0xe9, 0xca, 0xd5, 0xc2, 0xb5, 0x52, 0xe3, 0xab, 0xc6, 0xe9, 0xde, 0xc9,
+	0x71, 0x1f, 0x1d, 0x2f, 0xcf, 0x8b, 0x20, 0x3b, 0xf1, 0xce, 0x38, 0xd0, 0x9c, 0xc4, 0x00, 0x22,
+	0xb5, 0xb1, 0x39, 0xe5, 0x7d, 0x13, 0xf0, 0xbd, 0x3c, 0xde, 0x36, 0x9d, 0xc0, 0xa4, 0x86, 0x9d,
+	0xd2, 0x30, 0xa3, 0x86, 0xb4, 0xa1, 0x1c, 0x7b, 0x2e, 0x73, 0x68, 0xa4, 0xeb, 0x9b, 0xbf, 0x3d,
+	0x9e, 0x46, 0x85, 0x91, 0xce, 0xb8, 0x26, 0xa0, 0x41, 0x27, 0x3e, 0x2c, 0xca, 0x99, 0x14, 0xa3,
+	0xa9, 0x02, 0xa4, 0xb8, 0x36, 0x2b, 0x43, 0x91, 0x91, 0x41, 0xed, 0x56, 0xe0, 0xd0, 0xee, 0xad,
+	0xfd, 0x77, 0x99, 0xc3, 0x91, 0xb5, 0x58, 0xc4, 0x7c, 0x87, 0xa5, 0xe9, 0xd8, 0xe6, 0x00, 0x12,
+	0x0e, 0x61, 0x8b, 0xd0, 0xb6, 0x13, 0xc4, 0xdc, 0xa7, 0xba, 0xf8, 0x99, 0x09, 0x6d, 0x5f, 0xd5,
+	0x74, 0x4c, 0x24, 0xc8, 0x2a, 0x54, 0xe3, 0xfe, 0xbe, 0x1b, 0xf4, 0xa8, 0xe7, 0xcb, 0xca, 0x66,
+	0x35, 0x8d, 0xa0, 0x6d, 0xc3, 0xc0, 0x54, 0xc6, 0xfa, 0xdb, 0x29, 0x28, 0xdd, 0xf4, 0xf8, 0xd9,
+	0x92, 0x9f, 0x33, 0x66, 0x12, 0xfa, 0xf8, 0xa8, 0x38, 0xfa, 0xf8, 0x88, 0x50, 0x58, 0xe8, 0xc7,
+	0x2c, 0x12, 0xfd, 0x55, 0x2f, 0xa9, 0x8b, 0xf0, 0x67, 0x0c, 0x4d, 0x65, 0x45, 0xe5, 0x4e, 0x0e,
+	0x00, 0x07, 0x00, 0x85, 0x8a, 0x90, 0xc6, 0xf1, 0x83, 0x20, 0x72, 0xb5, 0x8a, 0xca, 0xb9, 0x55,
+	0xec, 0xe6, 0x00, 0x70, 0x00, 0x90, 0x84, 0x70, 0x29, 0x8e, 0x3b, 0xbb, 0x91, 0x77, 0x48, 0x39,
+	0x93, 0x8d, 0xa5, 0x9e, 0xea, 0xb9, 0x4e, 0x00, 0x4f, 0x8e, 0x97, 0x2f, 0xd9, 0xf6, 0xab, 0x83,
+	0x28, 0x38, 0x0a, 0x9a, 0x5c, 0x85, 0xa9, 0x90, 0xf2, 0x8e, 0x76, 0x64, 0x73, 0x7a, 0x5c, 0xa7,
+	0xe4, 0x21, 0x96, 0xe4, 0x88, 0xf0, 0x65, 0x3f, 0xa2, 0xbe, 0xd3, 0xd1, 0xc9, 0x72, 0x12, 0xbe,
+	0x34, 0x24, 0x15, 0x35, 0xd7, 0x24, 0x73, 0xd3, 0xe7, 0x4f, 0xe6, 0xac, 0x5f, 0x16, 0x60, 0xfa,
+	0x66, 0x14, 0xf4, 0x65, 0x20, 0x70, 0xc0, 0x8e, 0x06, 0x0f, 0x09, 0x45, 0x7e, 0x20, 0xe8, 0x72,
+	0x77, 0xf2, 0xdd, 0x5b, 0x2d, 0x29, 0x3c, 0xb4, 0x3b, 0x25, 0x1c, 0xcc, 0x48, 0x91, 0x17, 0x61,
+	0xa6, 0xa5, 0x1c, 0xa9, 0x7a, 0xc7, 0x27, 0x4d, 0xff, 0x95, 0xdb, 0x7c, 0x74, 0xbc, 0x3c, 0x2b,
+	0x05, 0xb5, 0x4b, 0xd5, 0xc2, 0xc4, 0x81, 0xb2, 0x2e, 0x52, 0xe9, 0x58, 0x76, 0xcc, 0xb5, 0xaf,
+	0x30, 0x74, 0x51, 0x4d, 0x3d, 0xa0, 0x41, 0xb6, 0x66, 0x60, 0xea, 0xd5, 0xbd, 0xbd, 0x5d, 0xeb,
+	0x9f, 0x0b, 0x00, 0xe2, 0xc7, 0xab, 0x8c, 0xba, 0x2c, 0x12, 0x93, 0x22, 0x97, 0x66, 0x21, 0x3f,
+	0x29, 0x72, 0x57, 0x91, 0x9c, 0x34, 0x69, 0x2c, 0x9e, 0x35, 0x69, 0x2c, 0x4d, 0x90, 0x34, 0xa6,
+	0x5d, 0xcb, 0x96, 0xcd, 0x46, 0x26, 0x8d, 0x31, 0x2c, 0x0e, 0x4a, 0xab, 0x93, 0xe6, 0x71, 0x93,
+	0xc6, 0xcc, 0x49, 0xf3, 0xa9, 0x89, 0xe3, 0x47, 0x05, 0xa8, 0x08, 0xad, 0x32, 0x75, 0xfc, 0xf8,
+	0x73, 0x66, 0xf2, 0x2e, 0x94, 0x3b, 0xb2, 0x73, 0x26, 0xd9, 0x7b, 0x79, 0xc2, 0x21, 0x49, 0xdd,
+	0xba, 0x7a, 0x8e, 0xd1, 0x28, 0x20, 0xaf, 0x01, 0xf1, 0xfc, 0x98, 0x39, 0xfd, 0x88, 0xd9, 0x07,
+	0x5e, 0x78, 0x97, 0x45, 0x5e, 0xeb, 0x48, 0xce, 0x44, 0x25, 0xa9, 0x39, 0x91, 0xcd, 0x21, 0x09,
+	0x1c, 0xd1, 0xca, 0x6a, 0x2a, 0x0b, 0xd1, 0x43, 0xfa, 0x22, 0xcc, 0xc6, 0x2c, 0x3a, 0xf4, 0x1c,
+	0x15, 0x86, 0x14, 0xf2, 0x7b, 0xbd, 0x9d, 0xb2, 0x30, 0x2b, 0x27, 0x22, 0xb5, 0x6a, 0x52, 0xcf,
+	0x11, 0x66, 0xd6, 0xf2, 0x5a, 0x81, 0x6c, 0x5d, 0x49, 0xcd, 0x6c, 0x63, 0x73, 0xe3, 0x16, 0x4a,
+	0x0e, 0x79, 0x03, 0xa6, 0x3a, 0x9c, 0x9b, 0x42, 0xe2, 0x8d, 0xb1, 0x47, 0x4a, 0x55, 0x7e, 0xc4,
+	0x2f, 0x94, 0x80, 0xc2, 0xe0, 0xa7, 0x5f, 0xa7, 0xad, 0x03, 0x7a, 0x06, 0x5b, 0x7f, 0x00, 0xb3,
+	0x07, 0x42, 0x54, 0x1d, 0x9f, 0xe8, 0xd5, 0xf8, 0xca, 0x58, 0x7d, 0x79, 0x3d, 0xc5, 0x49, 0x47,
+	0x2b, 0x43, 0xc4, 0xac, 0x26, 0xb1, 0xc8, 0x78, 0x10, 0x7a, 0x8e, 0x76, 0x1c, 0xc9, 0x22, 0xdb,
+	0x13, 0x44, 0x54, 0x3c, 0xeb, 0x06, 0x5c, 0x90, 0x00, 0xf5, 0x3e, 0x0f, 0x54, 0x26, 0x29, 0x3c,
+	0x26, 0xf3, 0xe9, 0xbe, 0x2e, 0x1b, 0x55, 0x52, 0x8f, 0xb9, 0x2e, 0xa9, 0xa8, 0xb9, 0xd6, 0xff,
+	0x14, 0x20, 0xab, 0x5c, 0xec, 0x84, 0xfb, 0x51, 0x70, 0x20, 0x4c, 0xb3, 0x90, 0xee, 0x84, 0x0d,
+	0x45, 0x42, 0xc3, 0x13, 0x91, 0xe4, 0x21, 0x8b, 0x32, 0xf1, 0x79, 0x62, 0x80, 0x77, 0x15, 0x19,
+	0x0d, 0x9f, 0x7c, 0x17, 0x4a, 0x3e, 0xe3, 0x7a, 0xed, 0x7f, 0x7b, 0xfc, 0x21, 0xdb, 0x59, 0xdf,
+	0xd3, 0x27, 0xd5, 0xeb, 0x7b, 0x28, 0x20, 0x49, 0x1d, 0x2e, 0xf4, 0xe8, 0xc3, 0x6d, 0x16, 0xc7,
+	0xc2, 0xbb, 0x1d, 0x71, 0x16, 0xeb, 0xb0, 0x36, 0xb9, 0x80, 0xb2, 0x9d, 0x67, 0xe3, 0xa0, 0xbc,
+	0xf5, 0x4f, 0x05, 0xa8, 0x18, 0x74, 0x62, 0x43, 0x89, 0x77, 0xcd, 0x45, 0x8f, 0x97, 0xc6, 0xea,
+	0xe9, 0xde, 0x96, 0xad, 0x3a, 0xb9, 0xb7, 0x65, 0xa3, 0x40, 0x13, 0xe6, 0x1b, 0xd3, 0xb8, 0x3b,
+	0x91, 0xf9, 0xda, 0x75, 0x7b, 0x4b, 0x99, 0xaf, 0xf8, 0x85, 0x12, 0xd0, 0xfa, 0x93, 0x02, 0x54,
+	0x65, 0xd7, 0xa5, 0xc7, 0xb9, 0x07, 0xd3, 0xd2, 0x6c, 0x74, 0xef, 0xbf, 0x39, 0xfe, 0x38, 0xa7,
+	0x36, 0x26, 0x1f, 0x51, 0xe1, 0x0a, 0x43, 0xa4, 0xf1, 0x91, 0xef, 0x0c, 0xa6, 0x26, 0x75, 0x41,
+	0x44, 0xc5, 0xb3, 0xfe, 0xae, 0xa8, 0xad, 0x29, 0xf1, 0xba, 0x9f, 0x71, 0xaf, 0xd6, 0x60, 0x36,
+	0xe6, 0x34, 0xe2, 0xaa, 0x2a, 0xa4, 0x6d, 0xd1, 0x4a, 0x7c, 0x50, 0xca, 0x7a, 0x64, 0x16, 0x99,
+	0x7a, 0xc4, 0x6c, 0x33, 0xf2, 0x10, 0x80, 0x26, 0x4b, 0x47, 0x5b, 0xea, 0xda, 0xf8, 0x7d, 0x4d,
+	0x97, 0x61, 0x1a, 0x18, 0xa4, 0x34, 0xcc, 0xe8, 0xb2, 0x56, 0xa1, 0xb4, 0x15, 0xb4, 0xc9, 0x35,
+	0xa8, 0xf0, 0xa8, 0xef, 0x3b, 0x94, 0x33, 0x7d, 0xa6, 0x22, 0x0f, 0x6b, 0xf6, 0x34, 0x0d, 0x13,
+	0xae, 0xf5, 0x8f, 0x05, 0x28, 0x6d, 0xd3, 0xf0, 0xff, 0x5f, 0x82, 0xfe, 0x83, 0x12, 0x54, 0xb6,
+	0x19, 0xa7, 0xa2, 0x0b, 0xe4, 0xfd, 0x02, 0xcc, 0x52, 0xdf, 0x0f, 0x38, 0x55, 0x25, 0xcf, 0x82,
+	0xdc, 0x05, 0x77, 0xc6, 0xea, 0xbd, 0x01, 0x5d, 0xa9, 0xa7, 0x80, 0xeb, 0x3e, 0x8f, 0x8e, 0x32,
+	0x37, 0xdd, 0x52, 0x0e, 0x66, 0xf5, 0x92, 0xfb, 0x30, 0xd3, 0xa5, 0xfb, 0xac, 0x6b, 0xf6, 0xe1,
+	0xcd, 0xc9, 0x7a, 0xb0, 0x25, 0xb1, 0x94, 0xf2, 0x4c, 0xed, 0x5d, 0x10, 0x51, 0x2b, 0x5a, 0xfa,
+	0x0e, 0x2c, 0x0e, 0x76, 0x94, 0x2c, 0x66, 0x22, 0x4e, 0x15, 0x64, 0x5e, 0xce, 0xc5, 0x56, 0x3a,
+	0x98, 0xfa, 0x66, 0xf1, 0xa5, 0xc2, 0xd2, 0x0d, 0x98, 0xcd, 0xa8, 0x39, 0x4f, 0x53, 0xeb, 0x0f,
+	0x8a, 0x50, 0xde, 0x66, 0x3c, 0xf2, 0x9c, 0x58, 0xed, 0x2b, 0x9c, 0x76, 0x07, 0x8f, 0xf0, 0xf6,
+	0x04, 0x11, 0x15, 0x4f, 0x6e, 0x22, 0x51, 0x14, 0xc8, 0x30, 0x45, 0x48, 0xa5, 0x9b, 0x88, 0xa4,
+	0xa2, 0xe6, 0x92, 0x5d, 0x98, 0x8a, 0x84, 0xe9, 0x8e, 0x57, 0x18, 0x4b, 0xf6, 0x5b, 0x14, 0xa6,
+	0x2e, 0x91, 0x54, 0xa5, 0x82, 0x47, 0x9e, 0x76, 0xe9, 0x53, 0xd9, 0x4a, 0x85, 0x24, 0xa3, 0xe1,
+	0x0b, 0x63, 0x94, 0xbd, 0x55, 0x1b, 0xc0, 0xb4, 0x94, 0x4e, 0x8c, 0x71, 0x2f, 0xe1, 0x60, 0x46,
+	0xca, 0xfa, 0x69, 0x11, 0x2a, 0xa6, 0x4e, 0x42, 0x7e, 0x17, 0x2a, 0x3d, 0x3d, 0x83, 0x7a, 0x19,
+	0x7d, 0xe3, 0x6c, 0x65, 0x5c, 0x95, 0xfd, 0x8a, 0xd9, 0x4f, 0x15, 0xa6, 0x34, 0x4c, 0x50, 0x89,
+	0x03, 0x53, 0x71, 0xc8, 0x9c, 0x89, 0xea, 0xa9, 0xa6, 0xbb, 0x76, 0xc8, 0x9c, 0x74, 0xc8, 0x64,
+	0x8d, 0x49, 0x82, 0x93, 0x03, 0x98, 0x89, 0x55, 0x65, 0x42, 0x4d, 0x43, 0x73, 0x32, 0x35, 0xaa,
+	0x3a, 0x91, 0x1e, 0x30, 0xaa, 0xca, 0x84, 0x56, 0x61, 0x7d, 0x58, 0x80, 0xa4, 0xd0, 0xb4, 0xe5,
+	0xc5, 0x9c, 0xbc, 0x3d, 0x34, 0x88, 0x67, 0xac, 0x85, 0x8b, 0xd6, 0x72, 0x08, 0x93, 0xec, 0xdf,
+	0x50, 0x32, 0x03, 0xb8, 0x0f, 0xd3, 0x1e, 0x67, 0x3d, 0xb3, 0x4c, 0xbf, 0x3d, 0xd1, 0xab, 0x65,
+	0x6a, 0x00, 0x02, 0x13, 0x15, 0xb4, 0xf5, 0xaf, 0x99, 0x57, 0x12, 0xc3, 0x2a, 0x94, 0x9a, 0x53,
+	0xee, 0xf1, 0x95, 0xca, 0xaa, 0x8e, 0x98, 0xb2, 0xd1, 0x87, 0xe4, 0x6d, 0x98, 0x77, 0x59, 0x97,
+	0x09, 0x5f, 0xb0, 0xc6, 0xba, 0xf4, 0x68, 0xcc, 0xe3, 0x72, 0x79, 0xeb, 0x66, 0x2d, 0x0b, 0x84,
+	0x79, 0x5c, 0x79, 0x89, 0x38, 0x3f, 0xb7, 0xe4, 0x05, 0x98, 0x0e, 0x3b, 0xe6, 0xdc, 0xa7, 0xda,
+	0xb8, 0x62, 0x3a, 0xb8, 0x2b, 0x88, 0x8f, 0x8e, 0x97, 0xe7, 0x8d, 0xbc, 0x24, 0xa0, 0x12, 0x16,
+	0x2b, 0xb3, 0xa7, 0x22, 0xa8, 0xc1, 0xc8, 0x4f, 0x07, 0x56, 0x68, 0xf8, 0xc4, 0x01, 0x70, 0x02,
+	0xdf, 0xf5, 0x94, 0x8f, 0x2f, 0xc9, 0x51, 0x5c, 0x3d, 0xdb, 0x9b, 0x35, 0x4d, 0xbb, 0x74, 0x65,
+	0x25, 0xa4, 0x18, 0x33, 0xb0, 0x84, 0xc2, 0x6c, 0x97, 0xc6, 0x5c, 0xd5, 0xf2, 0x5c, 0x1d, 0x99,
+	0xff, 0xc6, 0xd9, 0xb4, 0xec, 0x79, 0x3d, 0x96, 0xee, 0x12, 0x5b, 0x29, 0x0c, 0x66, 0x31, 0xad,
+	0x9f, 0x17, 0xa1, 0x68, 0x5f, 0x3f, 0x43, 0x96, 0xf0, 0x0c, 0xcc, 0xec, 0xf7, 0x9d, 0x03, 0x36,
+	0x74, 0xfe, 0xda, 0x90, 0x54, 0xd4, 0x5c, 0x21, 0x17, 0xb1, 0xb6, 0xd8, 0x3b, 0x07, 0x8e, 0xf1,
+	0x51, 0x52, 0x51, 0x73, 0xc9, 0x21, 0xcc, 0x3a, 0xe9, 0xad, 0x6f, 0xfd, 0x6e, 0xe3, 0xad, 0xeb,
+	0xfc, 0x05, 0x72, 0x75, 0xf7, 0x2d, 0x43, 0xc0, 0xac, 0x22, 0xf2, 0x2e, 0x54, 0x98, 0xbe, 0x32,
+	0xad, 0x0f, 0xb6, 0x5e, 0x19, 0x57, 0xa9, 0xb9, 0x7a, 0xad, 0xef, 0x11, 0xeb, 0x27, 0x4c, 0xf0,
+	0xad, 0xef, 0xc1, 0x8c, 0x7d, 0x5d, 0x86, 0xb0, 0x36, 0x14, 0xe3, 0xeb, 0xfa, 0x25, 0x7f, 0x6b,
+	0xbc, 0xc5, 0x76, 0xbd, 0x01, 0x7a, 0x28, 0x8b, 0xf6, 0x75, 0x2c, 0xc6, 0xd7, 0xad, 0x5f, 0x16,
+	0xa0, 0x62, 0x5f, 0xd7, 0xe1, 0xa8, 0xd2, 0x50, 0xfe, 0x54, 0x35, 0x90, 0x77, 0x00, 0xc2, 0xa0,
+	0xdb, 0xdd, 0x65, 0x91, 0x17, 0xb8, 0xfa, 0xfe, 0xee, 0x79, 0xd7, 0xaf, 0x3c, 0x1f, 0xdb, 0x4d,
+	0x50, 0x30, 0x83, 0x28, 0xd2, 0x6c, 0x27, 0xf0, 0x9d, 0x7e, 0x14, 0x31, 0xdf, 0x39, 0x92, 0xf5,
+	0xbe, 0xf9, 0xd4, 0x68, 0x9b, 0x29, 0x0b, 0xb3, 0x72, 0xd6, 0x7f, 0x16, 0x40, 0x66, 0x0b, 0xe4,
+	0x15, 0xa8, 0xf6, 0x98, 0xd3, 0xa1, 0xbe, 0x17, 0xf7, 0xb4, 0xed, 0x9a, 0x00, 0xb9, 0xba, 0x6d,
+	0x18, 0x62, 0xb9, 0x0b, 0xe9, 0x84, 0x80, 0x69, 0x23, 0xb2, 0x09, 0x53, 0xfd, 0x98, 0x45, 0xe7,
+	0xfb, 0x08, 0x40, 0xbe, 0xd2, 0x9d, 0x98, 0x45, 0xba, 0xf2, 0x27, 0x21, 0xc8, 0x1d, 0xa8, 0x98,
+	0x72, 0xe3, 0xf9, 0x2e, 0xfb, 0x8f, 0xaa, 0x5c, 0x26, 0x50, 0xd6, 0x7f, 0x17, 0xa1, 0x9a, 0x1c,
+	0x7d, 0x93, 0x3e, 0x54, 0xc5, 0x36, 0x25, 0x2f, 0x5a, 0x4c, 0x14, 0x18, 0xdb, 0xb7, 0xb7, 0x6c,
+	0x03, 0x94, 0x29, 0x02, 0x65, 0xa8, 0x98, 0x6a, 0x22, 0x3f, 0x2c, 0xc0, 0x62, 0xe0, 0x23, 0x73,
+	0x82, 0xc8, 0xdd, 0x09, 0xf8, 0x46, 0xd0, 0xf7, 0xdd, 0x89, 0xb6, 0xfc, 0xbc, 0xfa, 0x93, 0xe3,
+	0xe5, 0xc5, 0x5b, 0x03, 0xf0, 0x38, 0xa4, 0x90, 0x74, 0xa0, 0x1c, 0xf8, 0x32, 0x3e, 0xd3, 0x03,
+	0xfc, 0x29, 0xe8, 0x96, 0x35, 0x80, 0x5b, 0x0a, 0x15, 0x0d, 0xbc, 0xf5, 0x3a, 0xe4, 0x86, 0x82,
+	0x3c, 0x09, 0xa5, 0xf8, 0xfe, 0x50, 0xd1, 0xcb, 0xbe, 0xbd, 0x85, 0x82, 0x9e, 0x5c, 0xc3, 0x29,
+	0x8e, 0xba, 0x86, 0x63, 0xfd, 0xbc, 0x04, 0x53, 0xf6, 0x5e, 0x7d, 0xe7, 0x0c, 0x5e, 0xf6, 0x6b,
+	0x50, 0xf6, 0x29, 0x8f, 0xef, 0x44, 0x5d, 0x5d, 0x0d, 0x4e, 0x76, 0xa0, 0x9d, 0xfa, 0x9e, 0x7d,
+	0x07, 0xb7, 0xd0, 0xf0, 0xc9, 0x4d, 0xb8, 0x28, 0x7e, 0x6e, 0x07, 0xbe, 0xc7, 0x83, 0xc8, 0xf3,
+	0xdb, 0xa2, 0x51, 0x45, 0x36, 0xfa, 0x8a, 0x6e, 0x74, 0x51, 0x34, 0xca, 0x08, 0xe0, 0x16, 0x0e,
+	0xb7, 0x21, 0xab, 0x50, 0xd5, 0x67, 0x74, 0x9b, 0xae, 0x3e, 0x0c, 0x4b, 0x8e, 0x1f, 0xf4, 0x29,
+	0xde, 0xe6, 0x1a, 0xa6, 0x32, 0xa2, 0x93, 0x71, 0x5f, 0xc6, 0x82, 0xda, 0xc7, 0xa7, 0x07, 0x2f,
+	0x8a, 0x8c, 0x86, 0x4f, 0xb6, 0x60, 0x5e, 0xff, 0xdc, 0x8d, 0x58, 0xcb, 0x7b, 0xa8, 0x4f, 0xcd,
+	0x9e, 0xd1, 0x0d, 0xe6, 0xed, 0x2c, 0xf3, 0xd1, 0x20, 0x01, 0xf3, 0x8d, 0xc9, 0x5b, 0x30, 0x45,
+	0xfb, 0xbc, 0xa3, 0xbd, 0xdc, 0x98, 0x41, 0xcb, 0x5e, 0x7d, 0xa7, 0xde, 0xe7, 0x1d, 0x3d, 0x4b,
+	0x7d, 0xde, 0x41, 0x09, 0x2a, 0x7c, 0x51, 0x8f, 0x3e, 0xdc, 0xf4, 0x5b, 0x5d, 0xaf, 0xdd, 0x51,
+	0x67, 0x02, 0x19, 0x5f, 0xb4, 0x9d, 0xb2, 0x30, 0x2b, 0x67, 0x21, 0x54, 0x0c, 0x24, 0xd9, 0x10,
+	0x89, 0xc7, 0x01, 0xf3, 0xcf, 0x57, 0x81, 0xad, 0xaa, 0xdc, 0xe4, 0x80, 0xf9, 0xa8, 0x9a, 0x5b,
+	0xff, 0x50, 0x80, 0x69, 0x79, 0x41, 0x94, 0xd4, 0xe1, 0x82, 0xcb, 0x62, 0x2f, 0x62, 0xae, 0x3e,
+	0xc5, 0x8c, 0xb5, 0xf1, 0x24, 0x65, 0xa0, 0xb5, 0x3c, 0x1b, 0x07, 0xe5, 0xc5, 0xf4, 0x86, 0x8c,
+	0x1d, 0xa4, 0x21, 0x58, 0x66, 0x7a, 0x77, 0x0d, 0x03, 0x53, 0x19, 0xf2, 0x12, 0xcc, 0xc5, 0x0e,
+	0xed, 0x7a, 0x7e, 0x5b, 0xb5, 0x19, 0x38, 0x83, 0xb5, 0x33, 0x3c, 0xcc, 0x49, 0x5a, 0x2e, 0x98,
+	0xa3, 0xb7, 0xcf, 0xf2, 0xf3, 0xa2, 0xbf, 0x9c, 0x86, 0x29, 0xb9, 0xa9, 0x7e, 0xf2, 0x72, 0x7a,
+	0x03, 0xa6, 0x62, 0x4e, 0xfd, 0xc9, 0x0a, 0x54, 0x7b, 0xf5, 0x1d, 0x5d, 0xa0, 0xda, 0xab, 0xef,
+	0xa0, 0x04, 0x4c, 0x8b, 0x3f, 0x93, 0xdc, 0xfc, 0x4b, 0x2a, 0x5c, 0xca, 0x04, 0x72, 0xc5, 0x1f,
+	0x1b, 0x4a, 0xdd, 0xc0, 0x14, 0x63, 0xc7, 0xab, 0xd7, 0x6d, 0x05, 0x6d, 0x55, 0xaf, 0xdb, 0x0a,
+	0xda, 0x28, 0xd0, 0xc4, 0xfa, 0x91, 0xe5, 0xe6, 0xe9, 0x09, 0xd6, 0x8f, 0x39, 0x07, 0x18, 0x2c,
+	0x39, 0xeb, 0x00, 0x44, 0xc5, 0x08, 0xdf, 0x1a, 0x33, 0x00, 0x91, 0xc0, 0x33, 0x99, 0x00, 0xc4,
+	0x86, 0xa2, 0xbb, 0xaf, 0xd7, 0xfb, 0xb7, 0xc6, 0xbc, 0xab, 0x93, 0x82, 0xae, 0x35, 0xb0, 0xe8,
+	0xee, 0x13, 0x07, 0x66, 0xd4, 0x1d, 0x4e, 0x7d, 0xc0, 0x38, 0xde, 0x09, 0x85, 0xbe, 0xe7, 0x2c,
+	0xc0, 0xe5, 0x37, 0x21, 0xfa, 0x9e, 0xb8, 0x86, 0xb6, 0xfe, 0x74, 0x06, 0xf4, 0xcd, 0xd5, 0xb3,
+	0xd9, 0xa9, 0x13, 0x05, 0x93, 0xd9, 0x69, 0x33, 0x0a, 0x7c, 0x35, 0x29, 0xe2, 0x17, 0x4a, 0xc0,
+	0x64, 0x01, 0x94, 0x3e, 0xed, 0x05, 0x40, 0xcd, 0x02, 0x98, 0xf8, 0xb8, 0x20, 0xfb, 0x91, 0x55,
+	0x6e, 0x09, 0x7c, 0x2f, 0x67, 0xad, 0xe3, 0x1f, 0x23, 0x69, 0x05, 0x83, 0xf6, 0x7a, 0x47, 0xda,
+	0x6b, 0x65, 0x92, 0xad, 0xe4, 0x7a, 0xf6, 0xfb, 0x18, 0x6d, 0xb1, 0x77, 0xa4, 0xc5, 0xce, 0x4c,
+	0x72, 0xdd, 0xb0, 0x91, 0x85, 0xd5, 0x36, 0xcb, 0x12, 0x9b, 0xad, 0x4e, 0x10, 0xf9, 0x0c, 0x7f,
+	0xc9, 0x94, 0xb7, 0x5a, 0x31, 0xad, 0x11, 0xe3, 0xd1, 0x91, 0x5e, 0x72, 0xe3, 0x9d, 0xc9, 0xea,
+	0x6b, 0xfd, 0x69, 0x59, 0x00, 0x05, 0x24, 0x2a, 0x64, 0xeb, 0xdf, 0x8a, 0x30, 0xa7, 0x7a, 0xa0,
+	0x73, 0xf5, 0xa7, 0xa1, 0x1c, 0x32, 0xdf, 0xf5, 0xfc, 0xb6, 0x34, 0xd3, 0x29, 0x15, 0x92, 0xed,
+	0x2a, 0x12, 0x1a, 0x1e, 0x79, 0x4e, 0x25, 0xc3, 0x9a, 0xae, 0x8b, 0x61, 0x17, 0x4c, 0x72, 0x6b,
+	0xc4, 0xb3, 0x32, 0xe4, 0x48, 0xe4, 0xf3, 0xb2, 0x26, 0x58, 0x9b, 0x9a, 0xa0, 0x0a, 0x9b, 0xed,
+	0xed, 0x8a, 0x2e, 0x32, 0xaa, 0x42, 0x68, 0xa6, 0x3e, 0x20, 0xa9, 0x68, 0xf4, 0x2d, 0x3d, 0x84,
+	0xb9, 0xac, 0xe4, 0x88, 0x5a, 0x26, 0x66, 0x6b, 0x99, 0xe3, 0x0e, 0xb5, 0xd1, 0x9b, 0xa9, 0x84,
+	0xfe, 0x7d, 0x11, 0xa6, 0x64, 0x25, 0xfb, 0xb3, 0xaf, 0xfd, 0xdd, 0xcb, 0xd5, 0xfe, 0x26, 0x2c,
+	0x22, 0x8d, 0xaa, 0xfb, 0xb5, 0x07, 0xea, 0x7e, 0x13, 0xdf, 0x48, 0x3a, 0xad, 0xe6, 0xf7, 0x81,
+	0x48, 0xa5, 0x39, 0x0b, 0x3f, 0x87, 0x7a, 0xdf, 0x3b, 0xf9, 0x7a, 0xdf, 0x8d, 0xb1, 0x5f, 0xe9,
+	0x94, 0x5a, 0xdf, 0x0f, 0x89, 0x7a, 0x15, 0x59, 0xe7, 0x33, 0x5b, 0xcf, 0xcc, 0xa9, 0x5b, 0x8f,
+	0x0d, 0x25, 0x87, 0x72, 0xfd, 0xdd, 0xe2, 0x78, 0x81, 0x46, 0x93, 0x72, 0xf3, 0x51, 0x0b, 0x47,
+	0x81, 0x46, 0x0e, 0xe4, 0xc7, 0x7c, 0xea, 0x13, 0x0d, 0x3d, 0x84, 0xe3, 0x85, 0x48, 0xc9, 0x87,
+	0x1e, 0xc9, 0x17, 0x7e, 0xea, 0x11, 0x53, 0x7c, 0x72, 0x0f, 0x66, 0x5c, 0x79, 0xc7, 0x56, 0x7f,
+	0x36, 0x35, 0x66, 0x9c, 0x20, 0x21, 0x94, 0x53, 0x54, 0xbf, 0x51, 0xc3, 0x0a, 0x05, 0x4c, 0x5e,
+	0x61, 0xd5, 0x5f, 0xa9, 0x8d, 0xa7, 0x40, 0xdd, 0x82, 0x55, 0x0a, 0xd4, 0x6f, 0xd4, 0xb0, 0x42,
+	0x41, 0x4b, 0xde, 0x4d, 0xd5, 0xdb, 0xd1, 0x78, 0x0a, 0xd4, 0xf5, 0x56, 0xa5, 0x40, 0xfd, 0x46,
+	0x0d, 0x4b, 0x1c, 0x28, 0xb7, 0xd4, 0x05, 0x52, 0xfd, 0xb1, 0xda, 0x78, 0xde, 0x46, 0x5f, 0x42,
+	0x35, 0x5f, 0xad, 0xca, 0x07, 0x34, 0xc8, 0xc2, 0x92, 0xda, 0x1e, 0xd7, 0x1f, 0xfb, 0x8e, 0x67,
+	0x49, 0x37, 0x3d, 0x6d, 0x49, 0x37, 0x3d, 0x8e, 0x02, 0x8d, 0xbc, 0x05, 0xd3, 0x6d, 0x79, 0x19,
+	0x69, 0x76, 0x82, 0x53, 0x56, 0x79, 0xff, 0x48, 0x45, 0x18, 0xea, 0xfe, 0x92, 0xc2, 0x94, 0x61,
+	0x57, 0xe0, 0x32, 0xbd, 0xd9, 0x8d, 0x19, 0x76, 0x05, 0xae, 0x8e, 0x2d, 0xc4, 0x2f, 0x94, 0x80,
+	0x62, 0x28, 0x7a, 0x34, 0xd4, 0x5b, 0xf5, 0x78, 0x43, 0xb1, 0x4d, 0x43, 0x35, 0x14, 0xdb, 0x34,
+	0x44, 0x81, 0x46, 0x9e, 0x85, 0x4a, 0x64, 0x92, 0xc0, 0x2f, 0xcb, 0xec, 0x34, 0x71, 0x33, 0x49,
+	0xf6, 0x97, 0x48, 0x88, 0x0c, 0x45, 0x7e, 0x5a, 0xa8, 0x3f, 0x7e, 0x1c, 0x6f, 0xe0, 0x64, 0x12,
+	0x9a, 0x29, 0xef, 0x8b, 0x47, 0x54, 0xb8, 0xa4, 0x05, 0x65, 0x93, 0xdf, 0xa9, 0xf2, 0xf7, 0xb7,
+	0x26, 0xd8, 0x5c, 0x33, 0x25, 0x04, 0x9d, 0xf0, 0x19, 0x70, 0xe1, 0x2f, 0x63, 0xcf, 0x3f, 0x30,
+	0x5b, 0xf8, 0x98, 0xfe, 0x52, 0x84, 0xe9, 0xe9, 0x7b, 0x08, 0x3c, 0x54, 0xb0, 0xe4, 0x1e, 0xcc,
+	0x47, 0x4c, 0x9e, 0x98, 0xeb, 0x2b, 0xba, 0xaa, 0x04, 0x72, 0xc3, 0x94, 0x28, 0x30, 0xcb, 0x7c,
+	0x74, 0xbc, 0x7c, 0x75, 0xc4, 0x2d, 0xdd, 0x9c, 0x0c, 0xe6, 0xf1, 0xe4, 0x21, 0x1e, 0x8b, 0x7a,
+	0x9e, 0x4f, 0x79, 0xa0, 0x2e, 0xba, 0x66, 0x3e, 0x70, 0xd8, 0x4b, 0x38, 0x98, 0x91, 0x22, 0xeb,
+	0x50, 0x56, 0x11, 0x59, 0x5c, 0x9b, 0x3f, 0xfd, 0xc2, 0x9f, 0x0a, 0xde, 0x32, 0xf7, 0x53, 0x54,
+	0x13, 0x34, 0x6d, 0xc9, 0x6b, 0x40, 0xf4, 0xf5, 0xa4, 0xba, 0xe3, 0x04, 0x7d, 0x9f, 0xcb, 0xdb,
+	0x4c, 0x0b, 0xb9, 0x8f, 0xf2, 0x88, 0x3d, 0x24, 0x81, 0x23, 0x5a, 0x91, 0x76, 0x66, 0x57, 0x5c,
+	0x9c, 0x60, 0xc3, 0x37, 0x27, 0xca, 0xaa, 0x6a, 0x6e, 0x9e, 0x32, 0x1b, 0xe4, 0x1f, 0x16, 0x60,
+	0xce, 0x0f, 0x5c, 0x66, 0x0a, 0x24, 0xb5, 0x8b, 0x72, 0x04, 0x6e, 0x4d, 0x14, 0x5e, 0xac, 0xec,
+	0x64, 0x10, 0x55, 0xf0, 0x96, 0x54, 0x34, 0xb2, 0x2c, 0xcc, 0xa9, 0x26, 0x1b, 0x50, 0xa1, 0xad,
+	0x96, 0xe7, 0x7b, 0xfc, 0x48, 0x7f, 0xec, 0xfe, 0xc4, 0xc8, 0xef, 0xaf, 0xb5, 0x8c, 0x7a, 0x27,
+	0xf3, 0x84, 0x49, 0x5b, 0x72, 0x07, 0x66, 0x79, 0xd0, 0x65, 0x91, 0xbe, 0x13, 0x70, 0x49, 0xbe,
+	0xd1, 0x95, 0x51, 0x50, 0x7b, 0x89, 0x58, 0x5a, 0x7c, 0x4a, 0x69, 0x31, 0x66, 0x71, 0xb2, 0x17,
+	0xa8, 0x9f, 0xf8, 0xdc, 0x2f, 0x50, 0x5f, 0xfe, 0xec, 0x2e, 0x50, 0x2f, 0xbd, 0x0c, 0x17, 0x87,
+	0x26, 0xec, 0x5c, 0xf7, 0x01, 0xfe, 0xaa, 0x0c, 0x99, 0x5b, 0xe7, 0xe4, 0x1b, 0xf9, 0xf3, 0xc0,
+	0xa5, 0xc1, 0xf3, 0xc0, 0xaa, 0x90, 0xcd, 0x9d, 0x05, 0xca, 0x73, 0x2c, 0x1a, 0x07, 0xbe, 0xae,
+	0xa9, 0x66, 0xce, 0xb1, 0x04, 0x15, 0x35, 0xf7, 0x3c, 0x67, 0x86, 0x59, 0x07, 0x3e, 0xfd, 0x89,
+	0x0e, 0xfc, 0x59, 0xa8, 0xc4, 0x66, 0x05, 0x94, 0x07, 0x3e, 0x8f, 0x34, 0xc6, 0x9a, 0x48, 0x10,
+	0x17, 0xe6, 0x44, 0xe6, 0x23, 0x3d, 0xb4, 0x5b, 0x37, 0xff, 0xb5, 0x72, 0x9e, 0xb3, 0xc2, 0x64,
+	0x39, 0x6c, 0x65, 0x70, 0x30, 0x87, 0x4a, 0x7e, 0x5c, 0x80, 0x85, 0x38, 0x93, 0x0d, 0x25, 0xbe,
+	0xdf, 0x9e, 0x30, 0x30, 0xcf, 0xe5, 0x58, 0x4c, 0x67, 0x57, 0xd7, 0xcc, 0xc7, 0x0c, 0x79, 0xe6,
+	0xa3, 0x21, 0x0a, 0x0e, 0x74, 0x8a, 0xfc, 0x79, 0x01, 0xe6, 0x84, 0x77, 0x4f, 0x7a, 0xa9, 0xf6,
+	0x8e, 0xdb, 0x13, 0xf7, 0x32, 0x83, 0xa9, 0xfa, 0xf8, 0x74, 0x72, 0x1f, 0xcb, 0xb0, 0x46, 0x76,
+	0x30, 0xd7, 0x9b, 0xa5, 0xdf, 0x2f, 0xc0, 0xa5, 0x11, 0x2f, 0x3c, 0xc2, 0xc0, 0xdf, 0xc8, 0x27,
+	0x89, 0xf5, 0x89, 0xf3, 0xd7, 0xec, 0x75, 0x9b, 0xf7, 0x0a, 0x70, 0x71, 0xe8, 0x8d, 0x3e, 0xe7,
+	0x4e, 0x58, 0x77, 0xc1, 0x5c, 0xdb, 0x3e, 0xdb, 0xf1, 0x48, 0xdc, 0xdf, 0x97, 0xff, 0x1f, 0x55,
+	0x1c, 0x3a, 0x79, 0x90, 0x77, 0xea, 0x0d, 0xdf, 0xfa, 0xa3, 0x22, 0x94, 0xf6, 0xb6, 0x6c, 0xf2,
+	0x16, 0xcc, 0x39, 0xb4, 0xc9, 0x22, 0xae, 0xef, 0xfa, 0x9f, 0xff, 0x8b, 0xda, 0x66, 0x3d, 0x6d,
+	0x8e, 0x39, 0x30, 0x72, 0x07, 0xc0, 0x49, 0xa1, 0xcf, 0x7f, 0x86, 0x98, 0x01, 0xce, 0x00, 0x11,
+	0x84, 0xea, 0x41, 0xf2, 0x71, 0xc2, 0xb9, 0x8e, 0x12, 0x65, 0x96, 0x94, 0x7e, 0x92, 0x90, 0xc2,
+	0x58, 0x7f, 0x53, 0x00, 0x48, 0x4b, 0x96, 0xe4, 0xcf, 0x0a, 0x70, 0x99, 0x8e, 0xf8, 0x8f, 0x2e,
+	0x3d, 0x3e, 0x9b, 0x13, 0x5d, 0xb6, 0xcb, 0x95, 0x99, 0x9e, 0xd0, 0x53, 0x34, 0xf2, 0x2f, 0xc1,
+	0x70, 0x64, 0x27, 0xac, 0xff, 0x2a, 0xc2, 0x5c, 0xee, 0x9f, 0xc3, 0x4e, 0xed, 0x6e, 0xf5, 0x57,
+	0xa0, 0xbb, 0xbf, 0xa2, 0xc7, 0xe4, 0x6a, 0xbf, 0xa1, 0xee, 0x2d, 0xbf, 0x7b, 0xa4, 0xc3, 0xce,
+	0xcc, 0x7e, 0xa3, 0xe8, 0x98, 0x48, 0x34, 0x56, 0x3e, 0xf8, 0xe8, 0xca, 0x63, 0x1f, 0x7e, 0x74,
+	0xe5, 0xb1, 0x9f, 0x7d, 0x74, 0xe5, 0xb1, 0x1f, 0x9c, 0x5c, 0x29, 0x7c, 0x70, 0x72, 0xa5, 0xf0,
+	0xe1, 0xc9, 0x95, 0xc2, 0xcf, 0x4e, 0xae, 0x14, 0x7e, 0x71, 0x72, 0xa5, 0xf0, 0xc7, 0xff, 0x7e,
+	0xe5, 0xb1, 0xdf, 0xa9, 0x98, 0xd1, 0xfb, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2b, 0x03, 0xd5,
+	0x94, 0xf4, 0x50, 0x00, 0x00,
 }
 
 func (m *AWSCredentials) Marshal() (dAtA []byte, err error) {
@@ -2541,7 +2622,7 @@ func (m *AbstractStep) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *Backoff) Marshal() (dAtA []byte, err error) {
+func (m *AbstractVolumeSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -2551,22 +2632,19 @@ func (m *Backoff) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Backoff) MarshalTo(dAtA []byte) (int, error) {
+func (m *AbstractVolumeSource) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Backoff) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *AbstractVolumeSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i = encodeVarintGenerated(dAtA, i, uint64(m.FactorPercentage))
-	i--
-	dAtA[i] = 0x28
-	if m.Duration != nil {
+	if m.Ephemeral != nil {
 		{
-			size, err := m.Duration.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Ephemeral.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -2574,14 +2652,13 @@ func (m *Backoff) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x22
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xea
 	}
-	i = encodeVarintGenerated(dAtA, i, uint64(m.JitterPercentage))
-	i--
-	dAtA[i] = 0x18
-	if m.Cap != nil {
+	if m.CSI != nil {
 		{
-			size, err := m.Cap.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.CSI.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -2589,159 +2666,125 @@ func (m *Backoff) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xe2
 	}
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Steps))
-	i--
-	dAtA[i] = 0x8
-	return len(dAtA) - i, nil
-}
-
-func (m *Cat) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.StorageOS != nil {
+		{
+			size, err := m.StorageOS.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xda
 	}
-	return dAtA[:n], nil
-}
-
-func (m *Cat) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Cat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.Projected != nil {
+		{
+			size, err := m.Projected.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xd2
 	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *Code) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.ScaleIO != nil {
+		{
+			size, err := m.ScaleIO.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xca
 	}
-	return dAtA[:n], nil
-}
-
-func (m *Code) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Code) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	i -= len(m.Runtime)
-	copy(dAtA[i:], m.Runtime)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Runtime)))
-	i--
-	dAtA[i] = 0x22
-	i -= len(m.Source)
-	copy(dAtA[i:], m.Source)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Source)))
-	i--
-	dAtA[i] = 0x1a
-	return len(dAtA) - i, nil
-}
-
-func (m *Container) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Container) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Container) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.PortworxVolume != nil {
+		{
+			size, err := m.PortworxVolume.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xc2
 	}
-	i--
-	dAtA[i] = 0x4a
-	if len(m.Env) > 0 {
-		for iNdEx := len(m.Env) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Env[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.PhotonPersistentDisk != nil {
+		{
+			size, err := m.PhotonPersistentDisk.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
 			}
-			i--
-			dAtA[i] = 0x42
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xba
 	}
-	if len(m.Args) > 0 {
-		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Args[iNdEx])
-			copy(dAtA[i:], m.Args[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Args[iNdEx])))
-			i--
-			dAtA[i] = 0x3a
+	if m.AzureDisk != nil {
+		{
+			size, err := m.AzureDisk.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xb2
 	}
-	if len(m.Command) > 0 {
-		for iNdEx := len(m.Command) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Command[iNdEx])
-			copy(dAtA[i:], m.Command[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Command[iNdEx])))
-			i--
-			dAtA[i] = 0x32
+	if m.Quobyte != nil {
+		{
+			size, err := m.Quobyte.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xaa
 	}
-	if len(m.VolumeMounts) > 0 {
-		for iNdEx := len(m.VolumeMounts) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.VolumeMounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.VsphereVolume != nil {
+		{
+			size, err := m.VsphereVolume.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
 			}
-			i--
-			dAtA[i] = 0x2a
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xa2
 	}
-	if m.In != nil {
+	if m.ConfigMap != nil {
 		{
-			size, err := m.In.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.ConfigMap.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -2749,72 +2792,41 @@ func (m *Container) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x1a
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x9a
 	}
-	i -= len(m.Image)
-	copy(dAtA[i:], m.Image)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Image)))
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *Cron) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.AzureFile != nil {
+		{
+			size, err := m.AzureFile.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x92
 	}
-	return dAtA[:n], nil
-}
-
-func (m *Cron) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Cron) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	i -= len(m.Layout)
-	copy(dAtA[i:], m.Layout)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Layout)))
-	i--
-	dAtA[i] = 0x12
-	i -= len(m.Schedule)
-	copy(dAtA[i:], m.Schedule)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Schedule)))
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *DBDataSource) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.FC != nil {
+		{
+			size, err := m.FC.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x8a
 	}
-	return dAtA[:n], nil
-}
-
-func (m *DBDataSource) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DBDataSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.ValueFrom != nil {
+	if m.DownwardAPI != nil {
 		{
-			size, err := m.ValueFrom.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.DownwardAPI.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -2822,39 +2834,25 @@ func (m *DBDataSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x82
 	}
-	i -= len(m.Value)
-	copy(dAtA[i:], m.Value)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value)))
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *DBDataSourceFrom) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.Flocker != nil {
+		{
+			size, err := m.Flocker.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x7a
 	}
-	return dAtA[:n], nil
-}
-
-func (m *DBDataSourceFrom) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DBDataSourceFrom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.SecretKeyRef != nil {
+	if m.CephFS != nil {
 		{
-			size, err := m.SecretKeyRef.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.CephFS.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -2862,130 +2860,168 @@ func (m *DBDataSourceFrom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x72
 	}
-	return len(dAtA) - i, nil
-}
-
-func (m *DBSink) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.Cinder != nil {
+		{
+			size, err := m.Cinder.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x6a
 	}
-	return dAtA[:n], nil
-}
-
-func (m *DBSink) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DBSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Actions) > 0 {
-		for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Actions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.FlexVolume != nil {
+		{
+			size, err := m.FlexVolume.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
 			}
-			i--
-			dAtA[i] = 0x12
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x62
 	}
-	{
-		size, err := m.Database.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.RBD != nil {
+		{
+			size, err := m.RBD.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x5a
 	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *DBSource) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.PersistentVolumeClaim != nil {
+		{
+			size, err := m.PersistentVolumeClaim.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x52
 	}
-	return dAtA[:n], nil
-}
-
-func (m *DBSource) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DBSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	i--
-	if m.InitSchema {
-		dAtA[i] = 1
-	} else {
-		dAtA[i] = 0
+	if m.Glusterfs != nil {
+		{
+			size, err := m.Glusterfs.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x4a
 	}
-	i--
-	dAtA[i] = 0x30
-	{
-		size, err := m.CommitInterval.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.ISCSI != nil {
+		{
+			size, err := m.ISCSI.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x42
 	}
-	i--
-	dAtA[i] = 0x2a
-	{
-		size, err := m.PollInterval.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.NFS != nil {
+		{
+			size, err := m.NFS.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x3a
 	}
-	i--
-	dAtA[i] = 0x22
-	i -= len(m.OffsetColumn)
-	copy(dAtA[i:], m.OffsetColumn)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.OffsetColumn)))
-	i--
-	dAtA[i] = 0x1a
-	i -= len(m.Query)
-	copy(dAtA[i:], m.Query)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
-	i--
-	dAtA[i] = 0x12
-	{
-		size, err := m.Database.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.Secret != nil {
+		{
+			size, err := m.Secret.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x32
+	}
+	if m.GitRepo != nil {
+		{
+			size, err := m.GitRepo.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x2a
+	}
+	if m.AWSElasticBlockStore != nil {
+		{
+			size, err := m.AWSElasticBlockStore.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	if m.GCEPersistentDisk != nil {
+		{
+			size, err := m.GCEPersistentDisk.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.EmptyDir != nil {
+		{
+			size, err := m.EmptyDir.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.HostPath != nil {
+		{
+			size, err := m.HostPath.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	i--
-	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Database) Marshal() (dAtA []byte, err error) {
+func (m *Backoff) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -2995,19 +3031,37 @@ func (m *Database) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Database) MarshalTo(dAtA []byte) (int, error) {
+func (m *Backoff) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Database) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Backoff) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.DataSource != nil {
+	i = encodeVarintGenerated(dAtA, i, uint64(m.FactorPercentage))
+	i--
+	dAtA[i] = 0x28
+	if m.Duration != nil {
 		{
-			size, err := m.DataSource.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Duration.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	i = encodeVarintGenerated(dAtA, i, uint64(m.JitterPercentage))
+	i--
+	dAtA[i] = 0x18
+	if m.Cap != nil {
+		{
+			size, err := m.Cap.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3017,15 +3071,13 @@ func (m *Database) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x12
 	}
-	i -= len(m.Driver)
-	copy(dAtA[i:], m.Driver)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver)))
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Steps))
 	i--
-	dAtA[i] = 0xa
+	dAtA[i] = 0x8
 	return len(dAtA) - i, nil
 }
 
-func (m *Dedupe) Marshal() (dAtA []byte, err error) {
+func (m *Cat) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3035,31 +3087,16 @@ func (m *Dedupe) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Dedupe) MarshalTo(dAtA []byte) (int, error) {
+func (m *Cat) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Dedupe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Cat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.MaxSize.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1a
-	i -= len(m.UID)
-	copy(dAtA[i:], m.UID)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
-	i--
-	dAtA[i] = 0x12
 	{
 		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
@@ -3073,7 +3110,7 @@ func (m *Dedupe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *Expand) Marshal() (dAtA []byte, err error) {
+func (m *Code) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3083,30 +3120,30 @@ func (m *Expand) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Expand) MarshalTo(dAtA []byte) (int, error) {
+func (m *Code) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Expand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Code) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
+	i -= len(m.Runtime)
+	copy(dAtA[i:], m.Runtime)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Runtime)))
 	i--
-	dAtA[i] = 0xa
+	dAtA[i] = 0x22
+	i -= len(m.Source)
+	copy(dAtA[i:], m.Source)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Source)))
+	i--
+	dAtA[i] = 0x1a
 	return len(dAtA) - i, nil
 }
 
-func (m *Filter) Marshal() (dAtA []byte, err error) {
+func (m *Container) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3116,23 +3153,18 @@ func (m *Filter) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Filter) MarshalTo(dAtA []byte) (int, error) {
+func (m *Container) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Filter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Container) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i -= len(m.Expression)
-	copy(dAtA[i:], m.Expression)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Expression)))
-	i--
-	dAtA[i] = 0x12
 	{
-		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -3140,11 +3172,74 @@ func (m *Filter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
+	dAtA[i] = 0x4a
+	if len(m.Env) > 0 {
+		for iNdEx := len(m.Env) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Env[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x42
+		}
+	}
+	if len(m.Args) > 0 {
+		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Args[iNdEx])
+			copy(dAtA[i:], m.Args[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Args[iNdEx])))
+			i--
+			dAtA[i] = 0x3a
+		}
+	}
+	if len(m.Command) > 0 {
+		for iNdEx := len(m.Command) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Command[iNdEx])
+			copy(dAtA[i:], m.Command[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Command[iNdEx])))
+			i--
+			dAtA[i] = 0x32
+		}
+	}
+	if len(m.VolumeMounts) > 0 {
+		for iNdEx := len(m.VolumeMounts) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.VolumeMounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x2a
+		}
+	}
+	if m.In != nil {
+		{
+			size, err := m.In.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	i -= len(m.Image)
+	copy(dAtA[i:], m.Image)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Image)))
+	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Flatten) Marshal() (dAtA []byte, err error) {
+func (m *Cron) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3154,30 +3249,30 @@ func (m *Flatten) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Flatten) MarshalTo(dAtA []byte) (int, error) {
+func (m *Cron) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Flatten) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Cron) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
+	i -= len(m.Layout)
+	copy(dAtA[i:], m.Layout)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Layout)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Schedule)
+	copy(dAtA[i:], m.Schedule)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Schedule)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *GetPodSpecReq) Marshal() (dAtA []byte, err error) {
+func (m *DBDataSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3187,103 +3282,37 @@ func (m *GetPodSpecReq) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *GetPodSpecReq) MarshalTo(dAtA []byte) (int, error) {
+func (m *DBDataSource) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *GetPodSpecReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *DBDataSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i -= len(m.Subdomain)
-	copy(dAtA[i:], m.Subdomain)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Subdomain)))
-	i--
-	dAtA[i] = 0x6a
-	i -= len(m.Hostname)
-	copy(dAtA[i:], m.Hostname)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Hostname)))
-	i--
-	dAtA[i] = 0x62
-	if len(m.ImagePullSecrets) > 0 {
-		for iNdEx := len(m.ImagePullSecrets) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ImagePullSecrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.ValueFrom != nil {
+		{
+			size, err := m.ValueFrom.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
 			}
-			i--
-			dAtA[i] = 0x5a
-		}
-	}
-	{
-		size, err := m.Sidecar.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x52
-	{
-		size, err := m.StepStatus.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x4a
-	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateInterval))
-	i--
-	dAtA[i] = 0x40
-	i -= len(m.PullPolicy)
-	copy(dAtA[i:], m.PullPolicy)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PullPolicy)))
-	i--
-	dAtA[i] = 0x3a
-	i -= len(m.RunnerImage)
-	copy(dAtA[i:], m.RunnerImage)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RunnerImage)))
-	i--
-	dAtA[i] = 0x32
-	i -= len(m.ImageFormat)
-	copy(dAtA[i:], m.ImageFormat)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ImageFormat)))
-	i--
-	dAtA[i] = 0x2a
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Replica))
-	i--
-	dAtA[i] = 0x20
-	i -= len(m.PipelineName)
-	copy(dAtA[i:], m.PipelineName)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PipelineName)))
-	i--
-	dAtA[i] = 0x1a
-	i--
-	if m.Debug {
-		dAtA[i] = 1
-	} else {
-		dAtA[i] = 0
+		i--
+		dAtA[i] = 0x12
 	}
-	i--
-	dAtA[i] = 0x10
-	i -= len(m.Cluster)
-	copy(dAtA[i:], m.Cluster)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Cluster)))
+	i -= len(m.Value)
+	copy(dAtA[i:], m.Value)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Git) Marshal() (dAtA []byte, err error) {
+func (m *DBDataSourceFrom) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3293,19 +3322,19 @@ func (m *Git) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Git) MarshalTo(dAtA []byte) (int, error) {
+func (m *DBDataSourceFrom) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Git) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *DBDataSourceFrom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.SSHPrivateKeySecret != nil {
+	if m.SecretKeyRef != nil {
 		{
-			size, err := m.SSHPrivateKeySecret.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.SecretKeyRef.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3313,45 +3342,35 @@ func (m *Git) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x4a
+		dAtA[i] = 0xa
 	}
-	if m.PasswordSecret != nil {
-		{
-			size, err := m.PasswordSecret.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x42
+	return len(dAtA) - i, nil
+}
+
+func (m *DBSink) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	if m.UsernameSecret != nil {
-		{
-			size, err := m.UsernameSecret.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x3a
-	}
-	if len(m.Command) > 0 {
-		for iNdEx := len(m.Command) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Command[iNdEx])
-			copy(dAtA[i:], m.Command[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Command[iNdEx])))
-			i--
-			dAtA[i] = 0x32
-		}
-	}
-	if len(m.Env) > 0 {
-		for iNdEx := len(m.Env) - 1; iNdEx >= 0; iNdEx-- {
+	return dAtA[:n], nil
+}
+
+func (m *DBSink) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DBSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Actions) > 0 {
+		for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size, err := m.Env[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				size, err := m.Actions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 				if err != nil {
 					return 0, err
 				}
@@ -3359,33 +3378,23 @@ func (m *Git) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 				i = encodeVarintGenerated(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0x2a
+			dAtA[i] = 0x12
 		}
 	}
-	i -= len(m.Branch)
-	copy(dAtA[i:], m.Branch)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Branch)))
-	i--
-	dAtA[i] = 0x22
-	i -= len(m.Path)
-	copy(dAtA[i:], m.Path)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
-	i--
-	dAtA[i] = 0x1a
-	i -= len(m.URL)
-	copy(dAtA[i:], m.URL)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL)))
-	i--
-	dAtA[i] = 0x12
-	i -= len(m.Image)
-	copy(dAtA[i:], m.Image)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Image)))
+	{
+		size, err := m.Database.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Group) Marshal() (dAtA []byte, err error) {
+func (m *DBSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3395,47 +3404,68 @@ func (m *Group) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Group) MarshalTo(dAtA []byte) (int, error) {
+func (m *DBSource) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Group) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *DBSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Storage != nil {
-		{
-			size, err := m.Storage.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+	i--
+	if m.InitSchema {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i--
+	dAtA[i] = 0x30
+	{
+		size, err := m.CommitInterval.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x22
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	i -= len(m.Format)
-	copy(dAtA[i:], m.Format)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Format)))
+	i--
+	dAtA[i] = 0x2a
+	{
+		size, err := m.PollInterval.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x22
+	i -= len(m.OffsetColumn)
+	copy(dAtA[i:], m.OffsetColumn)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.OffsetColumn)))
 	i--
 	dAtA[i] = 0x1a
-	i -= len(m.EndOfGroup)
-	copy(dAtA[i:], m.EndOfGroup)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.EndOfGroup)))
+	i -= len(m.Query)
+	copy(dAtA[i:], m.Query)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query)))
 	i--
 	dAtA[i] = 0x12
-	i -= len(m.Key)
-	copy(dAtA[i:], m.Key)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
+	{
+		size, err := m.Database.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *HTTP) Marshal() (dAtA []byte, err error) {
+func (m *Database) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3445,20 +3475,37 @@ func (m *HTTP) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *HTTP) MarshalTo(dAtA []byte) (int, error) {
+func (m *Database) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *HTTP) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Database) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.DataSource != nil {
+		{
+			size, err := m.DataSource.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	i -= len(m.Driver)
+	copy(dAtA[i:], m.Driver)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver)))
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *HTTPHeader) Marshal() (dAtA []byte, err error) {
+func (m *Dedupe) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3468,42 +3515,45 @@ func (m *HTTPHeader) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *HTTPHeader) MarshalTo(dAtA []byte) (int, error) {
+func (m *Dedupe) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *HTTPHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Dedupe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.ValueFrom != nil {
-		{
-			size, err := m.ValueFrom.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+	{
+		size, err := m.MaxSize.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x1a
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	i -= len(m.Value)
-	copy(dAtA[i:], m.Value)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value)))
+	i--
+	dAtA[i] = 0x1a
+	i -= len(m.UID)
+	copy(dAtA[i:], m.UID)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
 	i--
 	dAtA[i] = 0x12
-	i -= len(m.Name)
-	copy(dAtA[i:], m.Name)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	{
+		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *HTTPHeaderSource) Marshal() (dAtA []byte, err error) {
+func (m *Expand) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3513,18 +3563,18 @@ func (m *HTTPHeaderSource) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *HTTPHeaderSource) MarshalTo(dAtA []byte) (int, error) {
+func (m *Expand) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *HTTPHeaderSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Expand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
 	{
-		size, err := m.SecretKeyRef.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -3536,7 +3586,7 @@ func (m *HTTPHeaderSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *HTTPSink) Marshal() (dAtA []byte, err error) {
+func (m *Filter) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3546,47 +3596,35 @@ func (m *HTTPSink) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *HTTPSink) MarshalTo(dAtA []byte) (int, error) {
+func (m *Filter) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *HTTPSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Filter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	i -= len(m.Expression)
+	copy(dAtA[i:], m.Expression)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Expression)))
 	i--
-	if m.InsecureSkipVerify {
-		dAtA[i] = 1
-	} else {
-		dAtA[i] = 0
-	}
-	i--
-	dAtA[i] = 0x18
-	if len(m.Headers) > 0 {
-		for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x12
+	dAtA[i] = 0x12
+	{
+		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	i -= len(m.URL)
-	copy(dAtA[i:], m.URL)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *HTTPSource) Marshal() (dAtA []byte, err error) {
+func (m *Flatten) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3596,25 +3634,30 @@ func (m *HTTPSource) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *HTTPSource) MarshalTo(dAtA []byte) (int, error) {
+func (m *Flatten) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *HTTPSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Flatten) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i -= len(m.ServiceName)
-	copy(dAtA[i:], m.ServiceName)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
+	{
+		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Interface) Marshal() (dAtA []byte, err error) {
+func (m *GetPodSpecReq) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3624,40 +3667,103 @@ func (m *Interface) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Interface) MarshalTo(dAtA []byte) (int, error) {
+func (m *GetPodSpecReq) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Interface) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *GetPodSpecReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.HTTP != nil {
-		{
-			size, err := m.HTTP.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
+	i -= len(m.Subdomain)
+	copy(dAtA[i:], m.Subdomain)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Subdomain)))
+	i--
+	dAtA[i] = 0x6a
+	i -= len(m.Hostname)
+	copy(dAtA[i:], m.Hostname)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Hostname)))
+	i--
+	dAtA[i] = 0x62
+	if len(m.ImagePullSecrets) > 0 {
+		for iNdEx := len(m.ImagePullSecrets) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.ImagePullSecrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
 			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0x5a
 		}
-		i--
-		dAtA[i] = 0x12
+	}
+	{
+		size, err := m.Sidecar.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
-	if m.FIFO {
+	dAtA[i] = 0x52
+	{
+		size, err := m.StepStatus.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x4a
+	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateInterval))
+	i--
+	dAtA[i] = 0x40
+	i -= len(m.PullPolicy)
+	copy(dAtA[i:], m.PullPolicy)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PullPolicy)))
+	i--
+	dAtA[i] = 0x3a
+	i -= len(m.RunnerImage)
+	copy(dAtA[i:], m.RunnerImage)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RunnerImage)))
+	i--
+	dAtA[i] = 0x32
+	i -= len(m.ImageFormat)
+	copy(dAtA[i:], m.ImageFormat)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ImageFormat)))
+	i--
+	dAtA[i] = 0x2a
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Replica))
+	i--
+	dAtA[i] = 0x20
+	i -= len(m.PipelineName)
+	copy(dAtA[i:], m.PipelineName)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PipelineName)))
+	i--
+	dAtA[i] = 0x1a
+	i--
+	if m.Debug {
 		dAtA[i] = 1
 	} else {
 		dAtA[i] = 0
 	}
 	i--
-	dAtA[i] = 0x8
+	dAtA[i] = 0x10
+	i -= len(m.Cluster)
+	copy(dAtA[i:], m.Cluster)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Cluster)))
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Kafka) Marshal() (dAtA []byte, err error) {
+func (m *Git) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3667,40 +3773,99 @@ func (m *Kafka) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Kafka) MarshalTo(dAtA []byte) (int, error) {
+func (m *Git) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Kafka) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Git) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.KafkaConfig.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.SSHPrivateKeySecret != nil {
+		{
+			size, err := m.SSHPrivateKeySecret.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x4a
+	}
+	if m.PasswordSecret != nil {
+		{
+			size, err := m.PasswordSecret.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x42
+	}
+	if m.UsernameSecret != nil {
+		{
+			size, err := m.UsernameSecret.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x3a
+	}
+	if len(m.Command) > 0 {
+		for iNdEx := len(m.Command) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Command[iNdEx])
+			copy(dAtA[i:], m.Command[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Command[iNdEx])))
+			i--
+			dAtA[i] = 0x32
+		}
+	}
+	if len(m.Env) > 0 {
+		for iNdEx := len(m.Env) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Env[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x2a
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
+	i -= len(m.Branch)
+	copy(dAtA[i:], m.Branch)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Branch)))
 	i--
 	dAtA[i] = 0x22
-	i -= len(m.Topic)
-	copy(dAtA[i:], m.Topic)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Topic)))
+	i -= len(m.Path)
+	copy(dAtA[i:], m.Path)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
 	i--
 	dAtA[i] = 0x1a
-	i -= len(m.Name)
-	copy(dAtA[i:], m.Name)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	i -= len(m.URL)
+	copy(dAtA[i:], m.URL)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Image)
+	copy(dAtA[i:], m.Image)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Image)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *KafkaAutoCommit) Marshal() (dAtA []byte, err error) {
+func (m *Group) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3710,28 +3875,47 @@ func (m *KafkaAutoCommit) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *KafkaAutoCommit) MarshalTo(dAtA []byte) (int, error) {
+func (m *Group) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *KafkaAutoCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Group) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i--
-	if m.Enable {
-		dAtA[i] = 1
-	} else {
-		dAtA[i] = 0
+	if m.Storage != nil {
+		{
+			size, err := m.Storage.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
 	}
+	i -= len(m.Format)
+	copy(dAtA[i:], m.Format)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Format)))
 	i--
-	dAtA[i] = 0x8
+	dAtA[i] = 0x1a
+	i -= len(m.EndOfGroup)
+	copy(dAtA[i:], m.EndOfGroup)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.EndOfGroup)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Key)
+	copy(dAtA[i:], m.Key)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *KafkaConfig) Marshal() (dAtA []byte, err error) {
+func (m *HTTP) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3741,49 +3925,20 @@ func (m *KafkaConfig) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *KafkaConfig) MarshalTo(dAtA []byte) (int, error) {
+func (m *HTTP) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *KafkaConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *HTTP) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i = encodeVarintGenerated(dAtA, i, uint64(m.MaxMessageBytes))
-	i--
-	dAtA[i] = 0x20
-	if m.NET != nil {
-		{
-			size, err := m.NET.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
-	}
-	i -= len(m.Version)
-	copy(dAtA[i:], m.Version)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
-	i--
-	dAtA[i] = 0x12
-	if len(m.Brokers) > 0 {
-		for iNdEx := len(m.Brokers) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Brokers[iNdEx])
-			copy(dAtA[i:], m.Brokers[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Brokers[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-		}
-	}
 	return len(dAtA) - i, nil
 }
 
-func (m *KafkaNET) Marshal() (dAtA []byte, err error) {
+func (m *HTTPHeader) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3793,31 +3948,19 @@ func (m *KafkaNET) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *KafkaNET) MarshalTo(dAtA []byte) (int, error) {
+func (m *HTTPHeader) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *KafkaNET) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *HTTPHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.SASL != nil {
+	if m.ValueFrom != nil {
 		{
-			size, err := m.SASL.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.TLS != nil {
-		{
-			size, err := m.TLS.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.ValueFrom.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3825,12 +3968,22 @@ func (m *KafkaNET) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x1a
 	}
+	i -= len(m.Value)
+	copy(dAtA[i:], m.Value)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Value)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Name)
+	copy(dAtA[i:], m.Name)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *KafkaSink) Marshal() (dAtA []byte, err error) {
+func (m *HTTPHeaderSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3840,26 +3993,18 @@ func (m *KafkaSink) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *KafkaSink) MarshalTo(dAtA []byte) (int, error) {
+func (m *HTTPHeaderSource) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *KafkaSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *HTTPHeaderSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i--
-	if m.Async {
-		dAtA[i] = 1
-	} else {
-		dAtA[i] = 0
-	}
-	i--
-	dAtA[i] = 0x10
 	{
-		size, err := m.Kafka.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.SecretKeyRef.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -3871,7 +4016,7 @@ func (m *KafkaSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *KafkaSource) Marshal() (dAtA []byte, err error) {
+func (m *HTTPSink) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3881,45 +4026,47 @@ func (m *KafkaSource) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *KafkaSource) MarshalTo(dAtA []byte) (int, error) {
+func (m *HTTPSink) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *KafkaSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *HTTPSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.AutoCommit.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
 	i--
-	dAtA[i] = 0x1a
-	i -= len(m.StartOffset)
-	copy(dAtA[i:], m.StartOffset)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StartOffset)))
+	if m.InsecureSkipVerify {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
 	i--
-	dAtA[i] = 0x12
-	{
-		size, err := m.Kafka.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	dAtA[i] = 0x18
+	if len(m.Headers) > 0 {
+		for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
+	i -= len(m.URL)
+	copy(dAtA[i:], m.URL)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Log) Marshal() (dAtA []byte, err error) {
+func (m *HTTPSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3929,25 +4076,25 @@ func (m *Log) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Log) MarshalTo(dAtA []byte) (int, error) {
+func (m *HTTPSource) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Log) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *HTTPSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Truncate != nil {
-		i = encodeVarintGenerated(dAtA, i, uint64(*m.Truncate))
-		i--
-		dAtA[i] = 0x8
-	}
+	i -= len(m.ServiceName)
+	copy(dAtA[i:], m.ServiceName)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Map) Marshal() (dAtA []byte, err error) {
+func (m *Interface) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3957,35 +4104,40 @@ func (m *Map) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Map) MarshalTo(dAtA []byte) (int, error) {
+func (m *Interface) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Map) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Interface) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i -= len(m.Expression)
-	copy(dAtA[i:], m.Expression)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Expression)))
-	i--
-	dAtA[i] = 0x12
-	{
-		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.HTTP != nil {
+		{
+			size, err := m.HTTP.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x12
 	}
 	i--
-	dAtA[i] = 0xa
+	if m.FIFO {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i--
+	dAtA[i] = 0x8
 	return len(dAtA) - i, nil
 }
 
-func (m *Metadata) Marshal() (dAtA []byte, err error) {
+func (m *Kafka) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3995,68 +4147,40 @@ func (m *Metadata) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Metadata) MarshalTo(dAtA []byte) (int, error) {
+func (m *Kafka) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Metadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Kafka) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Labels) > 0 {
-		keysForLabels := make([]string, 0, len(m.Labels))
-		for k := range m.Labels {
-			keysForLabels = append(keysForLabels, string(k))
-		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
-		for iNdEx := len(keysForLabels) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.Labels[string(keysForLabels[iNdEx])]
-			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
-			i--
-			dAtA[i] = 0x12
-			i -= len(keysForLabels[iNdEx])
-			copy(dAtA[i:], keysForLabels[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForLabels[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0x12
-		}
-	}
-	if len(m.Annotations) > 0 {
-		keysForAnnotations := make([]string, 0, len(m.Annotations))
-		for k := range m.Annotations {
-			keysForAnnotations = append(keysForAnnotations, string(k))
-		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
-		for iNdEx := len(keysForAnnotations) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.Annotations[string(keysForAnnotations[iNdEx])]
-			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
-			i--
-			dAtA[i] = 0x12
-			i -= len(keysForAnnotations[iNdEx])
-			copy(dAtA[i:], keysForAnnotations[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAnnotations[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0xa
+	{
+		size, err := m.KafkaConfig.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
+	i--
+	dAtA[i] = 0x22
+	i -= len(m.Topic)
+	copy(dAtA[i:], m.Topic)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Topic)))
+	i--
+	dAtA[i] = 0x1a
+	i -= len(m.Name)
+	copy(dAtA[i:], m.Name)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Metrics) Marshal() (dAtA []byte, err error) {
+func (m *KafkaAutoCommit) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4066,42 +4190,28 @@ func (m *Metrics) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Metrics) MarshalTo(dAtA []byte) (int, error) {
+func (m *KafkaAutoCommit) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Metrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *KafkaAutoCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i = encodeVarintGenerated(dAtA, i, uint64(m.TotalBytes))
 	i--
-	dAtA[i] = 0x28
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Retries))
-	i--
-	dAtA[i] = 0x20
-	{
-		size, err := m.Rate.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.Enable {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
 	}
 	i--
-	dAtA[i] = 0x1a
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Errors))
-	i--
-	dAtA[i] = 0x10
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Total))
-	i--
 	dAtA[i] = 0x8
 	return len(dAtA) - i, nil
 }
 
-func (m *Pipeline) Marshal() (dAtA []byte, err error) {
+func (m *KafkaConfig) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4111,97 +4221,49 @@ func (m *Pipeline) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Pipeline) MarshalTo(dAtA []byte) (int, error) {
+func (m *KafkaConfig) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Pipeline) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *KafkaConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
+	i = encodeVarintGenerated(dAtA, i, uint64(m.MaxMessageBytes))
 	i--
-	dAtA[i] = 0x1a
-	{
-		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	dAtA[i] = 0x20
+	if m.NET != nil {
+		{
+			size, err := m.NET.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x1a
 	}
+	i -= len(m.Version)
+	copy(dAtA[i:], m.Version)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
 	i--
 	dAtA[i] = 0x12
-	{
-		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *PipelineList) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *PipelineList) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PipelineList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Items) > 0 {
-		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
+	if len(m.Brokers) > 0 {
+		for iNdEx := len(m.Brokers) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Brokers[iNdEx])
+			copy(dAtA[i:], m.Brokers[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Brokers[iNdEx])))
 			i--
-			dAtA[i] = 0x12
-		}
-	}
-	{
-		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+			dAtA[i] = 0xa
 		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	i--
-	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *PipelineSpec) Marshal() (dAtA []byte, err error) {
+func (m *KafkaNET) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4211,19 +4273,19 @@ func (m *PipelineSpec) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *PipelineSpec) MarshalTo(dAtA []byte) (int, error) {
+func (m *KafkaNET) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *PipelineSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *KafkaNET) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.DeletionDelay != nil {
+	if m.SASL != nil {
 		{
-			size, err := m.DeletionDelay.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.SASL.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -4233,24 +4295,22 @@ func (m *PipelineSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x12
 	}
-	if len(m.Steps) > 0 {
-		for iNdEx := len(m.Steps) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Steps[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.TLS != nil {
+		{
+			size, err := m.TLS.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
 			}
-			i--
-			dAtA[i] = 0xa
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *PipelineStatus) Marshal() (dAtA []byte, err error) {
+func (m *KafkaSink) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4260,18 +4320,26 @@ func (m *PipelineStatus) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *PipelineStatus) MarshalTo(dAtA []byte) (int, error) {
+func (m *KafkaSink) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *PipelineStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *KafkaSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	i--
+	if m.Async {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i--
+	dAtA[i] = 0x10
 	{
-		size, err := m.LastUpdated.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.Kafka.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4279,35 +4347,11 @@ func (m *PipelineStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x22
-	if len(m.Conditions) > 0 {
-		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1a
-		}
-	}
-	i -= len(m.Message)
-	copy(dAtA[i:], m.Message)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
-	i--
-	dAtA[i] = 0x12
-	i -= len(m.Phase)
-	copy(dAtA[i:], m.Phase)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
-	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *S3) Marshal() (dAtA []byte, err error) {
+func (m *KafkaSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4317,59 +4361,45 @@ func (m *S3) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *S3) MarshalTo(dAtA []byte) (int, error) {
+func (m *KafkaSource) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *S3) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *KafkaSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Endpoint != nil {
-		{
-			size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x2a
-	}
-	if m.Credentials != nil {
-		{
-			size, err := m.Credentials.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+	{
+		size, err := m.AutoCommit.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x22
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	i -= len(m.Region)
-	copy(dAtA[i:], m.Region)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Region)))
 	i--
 	dAtA[i] = 0x1a
-	i -= len(m.Bucket)
-	copy(dAtA[i:], m.Bucket)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Bucket)))
+	i -= len(m.StartOffset)
+	copy(dAtA[i:], m.StartOffset)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StartOffset)))
 	i--
 	dAtA[i] = 0x12
-	i -= len(m.Name)
-	copy(dAtA[i:], m.Name)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	{
+		size, err := m.Kafka.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *S3Sink) Marshal() (dAtA []byte, err error) {
+func (m *Log) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4379,30 +4409,25 @@ func (m *S3Sink) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *S3Sink) MarshalTo(dAtA []byte) (int, error) {
+func (m *Log) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *S3Sink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Log) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.S3.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.Truncate != nil {
+		i = encodeVarintGenerated(dAtA, i, uint64(*m.Truncate))
+		i--
+		dAtA[i] = 0x8
 	}
-	i--
-	dAtA[i] = 0x22
 	return len(dAtA) - i, nil
 }
 
-func (m *S3Source) Marshal() (dAtA []byte, err error) {
+func (m *Map) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4412,21 +4437,23 @@ func (m *S3Source) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *S3Source) MarshalTo(dAtA []byte) (int, error) {
+func (m *Map) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *S3Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Map) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Concurrency))
+	i -= len(m.Expression)
+	copy(dAtA[i:], m.Expression)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Expression)))
 	i--
-	dAtA[i] = 0x40
+	dAtA[i] = 0x12
 	{
-		size, err := m.S3.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.AbstractStep.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4434,23 +4461,11 @@ func (m *S3Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x3a
-	if m.PollPeriod != nil {
-		{
-			size, err := m.PollPeriod.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x32
-	}
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *SASL) Marshal() (dAtA []byte, err error) {
+func (m *Metadata) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4460,49 +4475,68 @@ func (m *SASL) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *SASL) MarshalTo(dAtA []byte) (int, error) {
+func (m *Metadata) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *SASL) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Metadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.PasswordSecret != nil {
-		{
-			size, err := m.PasswordSecret.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if len(m.Labels) > 0 {
+		keysForLabels := make([]string, 0, len(m.Labels))
+		for k := range m.Labels {
+			keysForLabels = append(keysForLabels, string(k))
+		}
+		github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
+		for iNdEx := len(keysForLabels) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.Labels[string(keysForLabels[iNdEx])]
+			baseI := i
+			i -= len(v)
+			copy(dAtA[i:], v)
+			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
+			i--
+			dAtA[i] = 0x12
+			i -= len(keysForLabels[iNdEx])
+			copy(dAtA[i:], keysForLabels[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForLabels[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0x12
 		}
-		i--
-		dAtA[i] = 0x1a
 	}
-	if m.UserSecret != nil {
-		{
-			size, err := m.UserSecret.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if len(m.Annotations) > 0 {
+		keysForAnnotations := make([]string, 0, len(m.Annotations))
+		for k := range m.Annotations {
+			keysForAnnotations = append(keysForAnnotations, string(k))
+		}
+		github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
+		for iNdEx := len(keysForAnnotations) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.Annotations[string(keysForAnnotations[iNdEx])]
+			baseI := i
+			i -= len(v)
+			copy(dAtA[i:], v)
+			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
+			i--
+			dAtA[i] = 0x12
+			i -= len(keysForAnnotations[iNdEx])
+			copy(dAtA[i:], keysForAnnotations[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAnnotations[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0xa
 		}
-		i--
-		dAtA[i] = 0x12
 	}
-	i -= len(m.Mechanism)
-	copy(dAtA[i:], m.Mechanism)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Mechanism)))
-	i--
-	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *SQLAction) Marshal() (dAtA []byte, err error) {
+func (m *Metrics) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4512,42 +4546,24 @@ func (m *SQLAction) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *SQLAction) MarshalTo(dAtA []byte) (int, error) {
+func (m *Metrics) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *SQLAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Metrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.OnError != nil {
-		{
-			size, err := m.OnError.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
-	}
-	if m.OnRecordNotFound != nil {
-		{
-			size, err := m.OnRecordNotFound.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
-	}
+	i = encodeVarintGenerated(dAtA, i, uint64(m.TotalBytes))
+	i--
+	dAtA[i] = 0x28
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Retries))
+	i--
+	dAtA[i] = 0x20
 	{
-		size, err := m.SQLStatement.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.Rate.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4555,11 +4571,17 @@ func (m *SQLAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0xa
+	dAtA[i] = 0x1a
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Errors))
+	i--
+	dAtA[i] = 0x10
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Total))
+	i--
+	dAtA[i] = 0x8
 	return len(dAtA) - i, nil
 }
 
-func (m *SQLStatement) Marshal() (dAtA []byte, err error) {
+func (m *Pipeline) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4569,34 +4591,50 @@ func (m *SQLStatement) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *SQLStatement) MarshalTo(dAtA []byte) (int, error) {
+func (m *Pipeline) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *SQLStatement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Pipeline) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Args) > 0 {
-		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Args[iNdEx])
-			copy(dAtA[i:], m.Args[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Args[iNdEx])))
-			i--
-			dAtA[i] = 0x12
+	{
+		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	{
+		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	i -= len(m.SQL)
-	copy(dAtA[i:], m.SQL)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SQL)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *STAN) Marshal() (dAtA []byte, err error) {
+func (m *PipelineList) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4606,65 +4644,44 @@ func (m *STAN) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *STAN) MarshalTo(dAtA []byte) (int, error) {
+func (m *PipelineList) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *STAN) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *PipelineList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i = encodeVarintGenerated(dAtA, i, uint64(m.MaxInflight))
-	i--
-	dAtA[i] = 0x48
-	i -= len(m.NATSMonitoringURL)
-	copy(dAtA[i:], m.NATSMonitoringURL)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.NATSMonitoringURL)))
-	i--
-	dAtA[i] = 0x42
-	if m.Auth != nil {
-		{
-			size, err := m.Auth.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
+	if len(m.Items) > 0 {
+		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
 			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0x12
 		}
-		i--
-		dAtA[i] = 0x3a
 	}
-	i -= len(m.SubjectPrefix)
-	copy(dAtA[i:], m.SubjectPrefix)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SubjectPrefix)))
-	i--
-	dAtA[i] = 0x32
-	i -= len(m.ClusterID)
-	copy(dAtA[i:], m.ClusterID)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClusterID)))
-	i--
-	dAtA[i] = 0x2a
-	i -= len(m.NATSURL)
-	copy(dAtA[i:], m.NATSURL)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.NATSURL)))
-	i--
-	dAtA[i] = 0x22
-	i -= len(m.Subject)
-	copy(dAtA[i:], m.Subject)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Subject)))
-	i--
-	dAtA[i] = 0x1a
-	i -= len(m.Name)
-	copy(dAtA[i:], m.Name)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	{
+		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *STANAuth) Marshal() (dAtA []byte, err error) {
+func (m *PipelineSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4674,19 +4691,19 @@ func (m *STANAuth) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *STANAuth) MarshalTo(dAtA []byte) (int, error) {
+func (m *PipelineSpec) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *STANAuth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *PipelineSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Token != nil {
+	if m.DeletionDelay != nil {
 		{
-			size, err := m.Token.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.DeletionDelay.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -4694,12 +4711,26 @@ func (m *STANAuth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x12
+	}
+	if len(m.Steps) > 0 {
+		for iNdEx := len(m.Steps) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Steps[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Scale) Marshal() (dAtA []byte, err error) {
+func (m *PipelineStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4709,35 +4740,116 @@ func (m *Scale) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
+func (m *PipelineStatus) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Scale) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *PipelineStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i -= len(m.ScalingDelay)
-	copy(dAtA[i:], m.ScalingDelay)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ScalingDelay)))
-	i--
+	{
+		size, err := m.LastUpdated.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x22
+	if len(m.Conditions) > 0 {
+		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	i -= len(m.Message)
+	copy(dAtA[i:], m.Message)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Phase)
+	copy(dAtA[i:], m.Phase)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *S3) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *S3) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *S3) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Endpoint != nil {
+		{
+			size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x2a
+	}
+	if m.Credentials != nil {
+		{
+			size, err := m.Credentials.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	i -= len(m.Region)
+	copy(dAtA[i:], m.Region)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Region)))
+	i--
 	dAtA[i] = 0x1a
-	i -= len(m.PeekDelay)
-	copy(dAtA[i:], m.PeekDelay)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PeekDelay)))
+	i -= len(m.Bucket)
+	copy(dAtA[i:], m.Bucket)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Bucket)))
 	i--
 	dAtA[i] = 0x12
-	i -= len(m.DesiredReplicas)
-	copy(dAtA[i:], m.DesiredReplicas)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.DesiredReplicas)))
+	i -= len(m.Name)
+	copy(dAtA[i:], m.Name)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Sidecar) Marshal() (dAtA []byte, err error) {
+func (m *S3Sink) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4747,18 +4859,18 @@ func (m *Sidecar) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Sidecar) MarshalTo(dAtA []byte) (int, error) {
+func (m *S3Sink) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Sidecar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *S3Sink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
 	{
-		size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.S3.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4766,11 +4878,11 @@ func (m *Sidecar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0xa
+	dAtA[i] = 0x22
 	return len(dAtA) - i, nil
 }
 
-func (m *Sink) Marshal() (dAtA []byte, err error) {
+func (m *S3Source) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4780,43 +4892,32 @@ func (m *Sink) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Sink) MarshalTo(dAtA []byte) (int, error) {
+func (m *S3Source) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Sink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *S3Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Volume != nil {
-		{
-			size, err := m.Volume.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x42
-	}
-	if m.DB != nil {
-		{
-			size, err := m.DB.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Concurrency))
+	i--
+	dAtA[i] = 0x40
+	{
+		size, err := m.S3.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x3a
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	if m.S3 != nil {
+	i--
+	dAtA[i] = 0x3a
+	if m.PollPeriod != nil {
 		{
-			size, err := m.S3.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.PollPeriod.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -4826,33 +4927,32 @@ func (m *Sink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x32
 	}
-	if m.HTTP != nil {
-		{
-			size, err := m.HTTP.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x2a
-	}
-	if m.Log != nil {
-		{
-			size, err := m.Log.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x22
+	return len(dAtA) - i, nil
+}
+
+func (m *SASL) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	if m.Kafka != nil {
+	return dAtA[:n], nil
+}
+
+func (m *SASL) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SASL) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.PasswordSecret != nil {
 		{
-			size, err := m.Kafka.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.PasswordSecret.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -4862,9 +4962,9 @@ func (m *Sink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x1a
 	}
-	if m.STAN != nil {
+	if m.UserSecret != nil {
 		{
-			size, err := m.STAN.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.UserSecret.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -4874,15 +4974,15 @@ func (m *Sink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x12
 	}
-	i -= len(m.Name)
-	copy(dAtA[i:], m.Name)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	i -= len(m.Mechanism)
+	copy(dAtA[i:], m.Mechanism)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Mechanism)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Source) Marshal() (dAtA []byte, err error) {
+func (m *SQLAction) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4892,19 +4992,19 @@ func (m *Source) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Source) MarshalTo(dAtA []byte) (int, error) {
+func (m *SQLAction) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *SQLAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Volume != nil {
+	if m.OnError != nil {
 		{
-			size, err := m.Volume.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.OnError.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -4912,11 +5012,11 @@ func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x4a
+		dAtA[i] = 0x1a
 	}
-	if m.S3 != nil {
+	if m.OnRecordNotFound != nil {
 		{
-			size, err := m.S3.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.OnRecordNotFound.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -4924,10 +5024,10 @@ func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x42
+		dAtA[i] = 0x12
 	}
 	{
-		size, err := m.Retry.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.SQLStatement.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4935,58 +5035,78 @@ func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x3a
-	if m.DB != nil {
-		{
-			size, err := m.DB.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x32
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *SQLStatement) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	if m.HTTP != nil {
-		{
-			size, err := m.HTTP.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x2a
-	}
-	if m.Kafka != nil {
-		{
-			size, err := m.Kafka.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+	return dAtA[:n], nil
+}
+
+func (m *SQLStatement) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SQLStatement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Args) > 0 {
+		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Args[iNdEx])
+			copy(dAtA[i:], m.Args[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Args[iNdEx])))
+			i--
+			dAtA[i] = 0x12
 		}
-		i--
-		dAtA[i] = 0x22
 	}
-	if m.STAN != nil {
-		{
-			size, err := m.STAN.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
+	i -= len(m.SQL)
+	copy(dAtA[i:], m.SQL)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SQL)))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *STAN) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	if m.Cron != nil {
+	return dAtA[:n], nil
+}
+
+func (m *STAN) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *STAN) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	i = encodeVarintGenerated(dAtA, i, uint64(m.MaxInflight))
+	i--
+	dAtA[i] = 0x48
+	i -= len(m.NATSMonitoringURL)
+	copy(dAtA[i:], m.NATSMonitoringURL)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.NATSMonitoringURL)))
+	i--
+	dAtA[i] = 0x42
+	if m.Auth != nil {
 		{
-			size, err := m.Cron.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Auth.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -4994,8 +5114,28 @@ func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x3a
 	}
+	i -= len(m.SubjectPrefix)
+	copy(dAtA[i:], m.SubjectPrefix)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SubjectPrefix)))
+	i--
+	dAtA[i] = 0x32
+	i -= len(m.ClusterID)
+	copy(dAtA[i:], m.ClusterID)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClusterID)))
+	i--
+	dAtA[i] = 0x2a
+	i -= len(m.NATSURL)
+	copy(dAtA[i:], m.NATSURL)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.NATSURL)))
+	i--
+	dAtA[i] = 0x22
+	i -= len(m.Subject)
+	copy(dAtA[i:], m.Subject)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Subject)))
+	i--
+	dAtA[i] = 0x1a
 	i -= len(m.Name)
 	copy(dAtA[i:], m.Name)
 	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
@@ -5004,7 +5144,7 @@ func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *SourceStatus) Marshal() (dAtA []byte, err error) {
+func (m *STANAuth) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5014,59 +5154,32 @@ func (m *SourceStatus) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *SourceStatus) MarshalTo(dAtA []byte) (int, error) {
+func (m *STANAuth) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *SourceStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *STANAuth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.LastPending != nil {
-		i = encodeVarintGenerated(dAtA, i, uint64(*m.LastPending))
-		i--
-		dAtA[i] = 0x28
-	}
-	if len(m.Metrics) > 0 {
-		keysForMetrics := make([]string, 0, len(m.Metrics))
-		for k := range m.Metrics {
-			keysForMetrics = append(keysForMetrics, string(k))
-		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForMetrics)
-		for iNdEx := len(keysForMetrics) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.Metrics[string(keysForMetrics[iNdEx])]
-			baseI := i
-			{
-				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.Token != nil {
+		{
+			size, err := m.Token.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
 			}
-			i--
-			dAtA[i] = 0x12
-			i -= len(keysForMetrics[iNdEx])
-			copy(dAtA[i:], keysForMetrics[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForMetrics[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0x22
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
-	}
-	if m.Pending != nil {
-		i = encodeVarintGenerated(dAtA, i, uint64(*m.Pending))
 		i--
-		dAtA[i] = 0x18
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Step) Marshal() (dAtA []byte, err error) {
+func (m *Scale) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5076,50 +5189,35 @@ func (m *Step) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Step) MarshalTo(dAtA []byte) (int, error) {
+func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Step) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Scale) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
+	i -= len(m.ScalingDelay)
+	copy(dAtA[i:], m.ScalingDelay)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ScalingDelay)))
 	i--
 	dAtA[i] = 0x1a
-	{
-		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
+	i -= len(m.PeekDelay)
+	copy(dAtA[i:], m.PeekDelay)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PeekDelay)))
 	i--
 	dAtA[i] = 0x12
-	{
-		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
+	i -= len(m.DesiredReplicas)
+	copy(dAtA[i:], m.DesiredReplicas)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.DesiredReplicas)))
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *StepList) Marshal() (dAtA []byte, err error) {
+func (m *Sidecar) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5129,32 +5227,18 @@ func (m *StepList) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *StepList) MarshalTo(dAtA []byte) (int, error) {
+func (m *Sidecar) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *StepList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Sidecar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Items) > 0 {
-		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x12
-		}
-	}
 	{
-		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -5166,7 +5250,7 @@ func (m *StepList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *StepSpec) Marshal() (dAtA []byte, err error) {
+func (m *Sink) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5176,31 +5260,19 @@ func (m *StepSpec) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *StepSpec) MarshalTo(dAtA []byte) (int, error) {
+func (m *Sink) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Sink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.Sidecar.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1
-	i--
-	dAtA[i] = 0xe2
-	if m.Dedupe != nil {
+	if m.Volume != nil {
 		{
-			size, err := m.Dedupe.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Volume.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5208,13 +5280,11 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0xda
+		dAtA[i] = 0x42
 	}
-	if m.Expand != nil {
+	if m.DB != nil {
 		{
-			size, err := m.Expand.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.DB.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5222,13 +5292,11 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0xd2
+		dAtA[i] = 0x3a
 	}
-	if m.Flatten != nil {
+	if m.S3 != nil {
 		{
-			size, err := m.Flatten.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.S3.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5236,62 +5304,23 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0xca
-	}
-	{
-		size, err := m.Scale.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1
-	i--
-	dAtA[i] = 0xc2
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
-	i--
-	dAtA[i] = 0x1
-	i--
-	dAtA[i] = 0xb8
-	if len(m.ImagePullSecrets) > 0 {
-		for iNdEx := len(m.ImagePullSecrets) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ImagePullSecrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0xa2
-		}
+		dAtA[i] = 0x32
 	}
-	if len(m.Tolerations) > 0 {
-		for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.HTTP != nil {
+		{
+			size, err := m.HTTP.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
 			}
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0x9a
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x2a
 	}
-	if m.Affinity != nil {
+	if m.Log != nil {
 		{
-			size, err := m.Affinity.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Log.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5299,39 +5328,11 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0x92
-	}
-	if len(m.NodeSelector) > 0 {
-		keysForNodeSelector := make([]string, 0, len(m.NodeSelector))
-		for k := range m.NodeSelector {
-			keysForNodeSelector = append(keysForNodeSelector, string(k))
-		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
-		for iNdEx := len(keysForNodeSelector) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.NodeSelector[string(keysForNodeSelector[iNdEx])]
-			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
-			i--
-			dAtA[i] = 0x12
-			i -= len(keysForNodeSelector[iNdEx])
-			copy(dAtA[i:], keysForNodeSelector[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForNodeSelector[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0x8a
-		}
+		dAtA[i] = 0x22
 	}
-	if m.Metadata != nil {
+	if m.Kafka != nil {
 		{
-			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Kafka.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5339,13 +5340,11 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0x82
+		dAtA[i] = 0x1a
 	}
-	if m.Cat != nil {
+	if m.STAN != nil {
 		{
-			size, err := m.Cat.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.STAN.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5353,30 +5352,39 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x7a
+		dAtA[i] = 0x12
 	}
-	i -= len(m.ServiceAccountName)
-	copy(dAtA[i:], m.ServiceAccountName)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceAccountName)))
+	i -= len(m.Name)
+	copy(dAtA[i:], m.Name)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 	i--
-	dAtA[i] = 0x72
-	if len(m.Volumes) > 0 {
-		for iNdEx := len(m.Volumes) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Volumes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x6a
-		}
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *Source) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	if m.Git != nil {
+	return dAtA[:n], nil
+}
+
+func (m *Source) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Volume != nil {
 		{
-			size, err := m.Git.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Volume.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5384,11 +5392,11 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x62
+		dAtA[i] = 0x4a
 	}
-	if m.Group != nil {
+	if m.S3 != nil {
 		{
-			size, err := m.Group.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.S3.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5396,19 +5404,21 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x5a
+		dAtA[i] = 0x42
 	}
-	i--
-	if m.Terminator {
-		dAtA[i] = 1
-	} else {
-		dAtA[i] = 0
+	{
+		size, err := m.Retry.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x50
-	if m.Map != nil {
+	dAtA[i] = 0x3a
+	if m.DB != nil {
 		{
-			size, err := m.Map.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.DB.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5416,11 +5426,11 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x4a
+		dAtA[i] = 0x32
 	}
-	if m.Filter != nil {
+	if m.HTTP != nil {
 		{
-			size, err := m.Filter.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.HTTP.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5428,11 +5438,11 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x42
+		dAtA[i] = 0x2a
 	}
-	if m.Code != nil {
+	if m.Kafka != nil {
 		{
-			size, err := m.Code.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Kafka.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5440,49 +5450,23 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x3a
-	}
-	i -= len(m.Name)
-	copy(dAtA[i:], m.Name)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
-	i--
-	dAtA[i] = 0x32
-	i -= len(m.RestartPolicy)
-	copy(dAtA[i:], m.RestartPolicy)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RestartPolicy)))
-	i--
-	dAtA[i] = 0x2a
-	if len(m.Sinks) > 0 {
-		for iNdEx := len(m.Sinks) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Sinks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x22
-		}
+		dAtA[i] = 0x22
 	}
-	if len(m.Sources) > 0 {
-		for iNdEx := len(m.Sources) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Sources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.STAN != nil {
+		{
+			size, err := m.STAN.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
 			}
-			i--
-			dAtA[i] = 0x1a
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.Container != nil {
+	if m.Cron != nil {
 		{
-			size, err := m.Container.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Cron.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5490,12 +5474,17 @@ func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x12
 	}
+	i -= len(m.Name)
+	copy(dAtA[i:], m.Name)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *StepStatus) Marshal() (dAtA []byte, err error) {
+func (m *SourceStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5505,47 +5494,29 @@ func (m *StepStatus) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *StepStatus) MarshalTo(dAtA []byte) (int, error) {
+func (m *SourceStatus) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *StepStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *SourceStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i -= len(m.Reason)
-	copy(dAtA[i:], m.Reason)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
-	i--
-	dAtA[i] = 0x42
-	i -= len(m.Selector)
-	copy(dAtA[i:], m.Selector)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Selector)))
-	i--
-	dAtA[i] = 0x3a
-	{
-		size, err := m.LastScaledAt.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	if m.LastPending != nil {
+		i = encodeVarintGenerated(dAtA, i, uint64(*m.LastPending))
+		i--
+		dAtA[i] = 0x28
 	}
-	i--
-	dAtA[i] = 0x32
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
-	i--
-	dAtA[i] = 0x28
-	if len(m.SinkStatues) > 0 {
-		keysForSinkStatues := make([]string, 0, len(m.SinkStatues))
-		for k := range m.SinkStatues {
-			keysForSinkStatues = append(keysForSinkStatues, string(k))
+	if len(m.Metrics) > 0 {
+		keysForMetrics := make([]string, 0, len(m.Metrics))
+		for k := range m.Metrics {
+			keysForMetrics = append(keysForMetrics, string(k))
 		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForSinkStatues)
-		for iNdEx := len(keysForSinkStatues) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.SinkStatues[string(keysForSinkStatues[iNdEx])]
+		github_com_gogo_protobuf_sortkeys.Strings(keysForMetrics)
+		for iNdEx := len(keysForMetrics) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.Metrics[string(keysForMetrics[iNdEx])]
 			baseI := i
 			{
 				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
@@ -5557,9 +5528,9 @@ func (m *StepStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			}
 			i--
 			dAtA[i] = 0x12
-			i -= len(keysForSinkStatues[iNdEx])
-			copy(dAtA[i:], keysForSinkStatues[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForSinkStatues[iNdEx])))
+			i -= len(keysForMetrics[iNdEx])
+			copy(dAtA[i:], keysForMetrics[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForMetrics[iNdEx])))
 			i--
 			dAtA[i] = 0xa
 			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
@@ -5567,49 +5538,15 @@ func (m *StepStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA[i] = 0x22
 		}
 	}
-	if len(m.SourceStatuses) > 0 {
-		keysForSourceStatuses := make([]string, 0, len(m.SourceStatuses))
-		for k := range m.SourceStatuses {
-			keysForSourceStatuses = append(keysForSourceStatuses, string(k))
-		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForSourceStatuses)
-		for iNdEx := len(keysForSourceStatuses) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.SourceStatuses[string(keysForSourceStatuses[iNdEx])]
-			baseI := i
-			{
-				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x12
-			i -= len(keysForSourceStatuses[iNdEx])
-			copy(dAtA[i:], keysForSourceStatuses[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForSourceStatuses[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0x1a
-		}
+	if m.Pending != nil {
+		i = encodeVarintGenerated(dAtA, i, uint64(*m.Pending))
+		i--
+		dAtA[i] = 0x18
 	}
-	i -= len(m.Message)
-	copy(dAtA[i:], m.Message)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
-	i--
-	dAtA[i] = 0x12
-	i -= len(m.Phase)
-	copy(dAtA[i:], m.Phase)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
-	i--
-	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *Storage) Marshal() (dAtA []byte, err error) {
+func (m *Step) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5619,30 +5556,50 @@ func (m *Storage) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Storage) MarshalTo(dAtA []byte) (int, error) {
+func (m *Step) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Storage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Step) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i -= len(m.SubPath)
-	copy(dAtA[i:], m.SubPath)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SubPath)))
+	{
+		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	{
+		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
 	i--
 	dAtA[i] = 0x12
-	i -= len(m.Name)
-	copy(dAtA[i:], m.Name)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	{
+		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
 	i--
 	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
-func (m *TLS) Marshal() (dAtA []byte, err error) {
+func (m *StepList) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5652,77 +5609,32 @@ func (m *TLS) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *TLS) MarshalTo(dAtA []byte) (int, error) {
+func (m *StepList) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *TLS) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *StepList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.KeySecret != nil {
-		{
-			size, err := m.KeySecret.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
-	}
-	if m.CertSecret != nil {
-		{
-			size, err := m.CertSecret.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.CACertSecret != nil {
-		{
-			size, err := m.CACertSecret.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
+	if len(m.Items) > 0 {
+		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
 			}
-			i -= size
-			i = encodeVarintGenerated(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0x12
 		}
-		i--
-		dAtA[i] = 0xa
 	}
-	return len(dAtA) - i, nil
-}
-
-func (m *VolumeSink) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *VolumeSink) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *VolumeSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
 	{
-		size, err := m.VolumeSource.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -5734,7 +5646,7 @@ func (m *VolumeSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *VolumeSource) Marshal() (dAtA []byte, err error) {
+func (m *StepSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5744,26 +5656,18 @@ func (m *VolumeSource) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *VolumeSource) MarshalTo(dAtA []byte) (int, error) {
+func (m *StepSpec) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *VolumeSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *StepSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	i--
-	if m.ReadOnly {
-		dAtA[i] = 1
-	} else {
-		dAtA[i] = 0
-	}
-	i--
-	dAtA[i] = 0x50
 	{
-		size, err := m.VolumeSource.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.Sidecar.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -5771,13 +5675,12 @@ func (m *VolumeSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x4a
-	i = encodeVarintGenerated(dAtA, i, uint64(m.Concurrency))
+	dAtA[i] = 0x1
 	i--
-	dAtA[i] = 0x40
-	if m.PollPeriod != nil {
+	dAtA[i] = 0xe2
+	if m.Dedupe != nil {
 		{
-			size, err := m.PollPeriod.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Dedupe.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -5785,967 +5688,1323 @@ func (m *VolumeSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x32
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xda
 	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGenerated(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
+	if m.Expand != nil {
+		{
+			size, err := m.Expand.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xd2
 	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-
-func (m *AWSCredentials) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.AccessKeyID.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.SecretAccessKey.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.SessionToken.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *AWSEndpoint) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.URL)
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *AbstractStep) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Resources.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *Backoff) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	n += 1 + sovGenerated(uint64(m.Steps))
-	if m.Cap != nil {
-		l = m.Cap.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	if m.Flatten != nil {
+		{
+			size, err := m.Flatten.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xca
 	}
-	n += 1 + sovGenerated(uint64(m.JitterPercentage))
-	if m.Duration != nil {
-		l = m.Duration.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	{
+		size, err := m.Scale.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	n += 1 + sovGenerated(uint64(m.FactorPercentage))
-	return n
-}
-
-func (m *Cat) Size() (n int) {
-	if m == nil {
-		return 0
+	i--
+	dAtA[i] = 0x1
+	i--
+	dAtA[i] = 0xc2
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
+	i--
+	dAtA[i] = 0x1
+	i--
+	dAtA[i] = 0xb8
+	if len(m.ImagePullSecrets) > 0 {
+		for iNdEx := len(m.ImagePullSecrets) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.ImagePullSecrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1
+			i--
+			dAtA[i] = 0xa2
+		}
 	}
-	var l int
-	_ = l
-	l = m.AbstractStep.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *Code) Size() (n int) {
-	if m == nil {
-		return 0
+	if len(m.Tolerations) > 0 {
+		for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1
+			i--
+			dAtA[i] = 0x9a
+		}
 	}
-	var l int
-	_ = l
-	l = len(m.Source)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Runtime)
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *Container) Size() (n int) {
-	if m == nil {
-		return 0
+	if m.Affinity != nil {
+		{
+			size, err := m.Affinity.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x92
 	}
-	var l int
-	_ = l
-	l = len(m.Image)
-	n += 1 + l + sovGenerated(uint64(l))
-	if m.In != nil {
-		l = m.In.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	if len(m.NodeSelector) > 0 {
+		keysForNodeSelector := make([]string, 0, len(m.NodeSelector))
+		for k := range m.NodeSelector {
+			keysForNodeSelector = append(keysForNodeSelector, string(k))
+		}
+		github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
+		for iNdEx := len(keysForNodeSelector) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.NodeSelector[string(keysForNodeSelector[iNdEx])]
+			baseI := i
+			i -= len(v)
+			copy(dAtA[i:], v)
+			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
+			i--
+			dAtA[i] = 0x12
+			i -= len(keysForNodeSelector[iNdEx])
+			copy(dAtA[i:], keysForNodeSelector[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForNodeSelector[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0x1
+			i--
+			dAtA[i] = 0x8a
+		}
 	}
-	if len(m.VolumeMounts) > 0 {
-		for _, e := range m.VolumeMounts {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
+	if m.Metadata != nil {
+		{
+			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x82
 	}
-	if len(m.Command) > 0 {
-		for _, s := range m.Command {
-			l = len(s)
-			n += 1 + l + sovGenerated(uint64(l))
+	if m.Cat != nil {
+		{
+			size, err := m.Cat.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x7a
 	}
-	if len(m.Args) > 0 {
-		for _, s := range m.Args {
-			l = len(s)
-			n += 1 + l + sovGenerated(uint64(l))
+	i -= len(m.ServiceAccountName)
+	copy(dAtA[i:], m.ServiceAccountName)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceAccountName)))
+	i--
+	dAtA[i] = 0x72
+	if len(m.Volumes) > 0 {
+		for iNdEx := len(m.Volumes) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Volumes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x6a
 		}
 	}
-	if len(m.Env) > 0 {
-		for _, e := range m.Env {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
+	if m.Git != nil {
+		{
+			size, err := m.Git.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x62
 	}
-	l = m.Resources.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *Cron) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Schedule)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Layout)
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *DBDataSource) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Value)
-	n += 1 + l + sovGenerated(uint64(l))
-	if m.ValueFrom != nil {
-		l = m.ValueFrom.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	return n
-}
-
-func (m *DBDataSourceFrom) Size() (n int) {
-	if m == nil {
-		return 0
+	if m.Group != nil {
+		{
+			size, err := m.Group.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x5a
 	}
-	var l int
-	_ = l
-	if m.SecretKeyRef != nil {
-		l = m.SecretKeyRef.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	i--
+	if m.Terminator {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
 	}
-	return n
-}
-
-func (m *DBSink) Size() (n int) {
-	if m == nil {
-		return 0
+	i--
+	dAtA[i] = 0x50
+	if m.Map != nil {
+		{
+			size, err := m.Map.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x4a
 	}
-	var l int
-	_ = l
-	l = m.Database.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	if len(m.Actions) > 0 {
-		for _, e := range m.Actions {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
+	if m.Filter != nil {
+		{
+			size, err := m.Filter.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x42
 	}
-	return n
-}
-
-func (m *DBSource) Size() (n int) {
-	if m == nil {
-		return 0
+	if m.Code != nil {
+		{
+			size, err := m.Code.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x3a
 	}
-	var l int
-	_ = l
-	l = m.Database.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Query)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.OffsetColumn)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.PollInterval.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.CommitInterval.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	n += 2
-	return n
-}
-
-func (m *Database) Size() (n int) {
-	if m == nil {
-		return 0
+	i -= len(m.Name)
+	copy(dAtA[i:], m.Name)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	i--
+	dAtA[i] = 0x32
+	i -= len(m.RestartPolicy)
+	copy(dAtA[i:], m.RestartPolicy)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RestartPolicy)))
+	i--
+	dAtA[i] = 0x2a
+	if len(m.Sinks) > 0 {
+		for iNdEx := len(m.Sinks) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Sinks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x22
+		}
 	}
-	var l int
-	_ = l
-	l = len(m.Driver)
-	n += 1 + l + sovGenerated(uint64(l))
-	if m.DataSource != nil {
-		l = m.DataSource.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	if len(m.Sources) > 0 {
+		for iNdEx := len(m.Sources) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Sources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
 	}
-	return n
-}
-
-func (m *Dedupe) Size() (n int) {
-	if m == nil {
-		return 0
+	if m.Container != nil {
+		{
+			size, err := m.Container.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	var l int
-	_ = l
-	l = m.AbstractStep.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.UID)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.MaxSize.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *Expand) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *StepStatus) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	var l int
-	_ = l
-	l = m.AbstractStep.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *Filter) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.AbstractStep.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Expression)
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
+func (m *StepStatus) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Flatten) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *StepStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	l = m.AbstractStep.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *GetPodSpecReq) Size() (n int) {
-	if m == nil {
-		return 0
+	i -= len(m.Reason)
+	copy(dAtA[i:], m.Reason)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
+	i--
+	dAtA[i] = 0x42
+	i -= len(m.Selector)
+	copy(dAtA[i:], m.Selector)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Selector)))
+	i--
+	dAtA[i] = 0x3a
+	{
+		size, err := m.LastScaledAt.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
 	}
-	var l int
-	_ = l
-	l = len(m.Cluster)
-	n += 1 + l + sovGenerated(uint64(l))
-	n += 2
-	l = len(m.PipelineName)
-	n += 1 + l + sovGenerated(uint64(l))
-	n += 1 + sovGenerated(uint64(m.Replica))
-	l = len(m.ImageFormat)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.RunnerImage)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.PullPolicy)
-	n += 1 + l + sovGenerated(uint64(l))
-	n += 1 + sovGenerated(uint64(m.UpdateInterval))
-	l = m.StepStatus.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.Sidecar.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	if len(m.ImagePullSecrets) > 0 {
-		for _, e := range m.ImagePullSecrets {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
+	i--
+	dAtA[i] = 0x32
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
+	i--
+	dAtA[i] = 0x28
+	if len(m.SinkStatues) > 0 {
+		keysForSinkStatues := make([]string, 0, len(m.SinkStatues))
+		for k := range m.SinkStatues {
+			keysForSinkStatues = append(keysForSinkStatues, string(k))
 		}
-	}
-	l = len(m.Hostname)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Subdomain)
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *Git) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Image)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.URL)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Path)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Branch)
-	n += 1 + l + sovGenerated(uint64(l))
-	if len(m.Env) > 0 {
-		for _, e := range m.Env {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
+		github_com_gogo_protobuf_sortkeys.Strings(keysForSinkStatues)
+		for iNdEx := len(keysForSinkStatues) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.SinkStatues[string(keysForSinkStatues[iNdEx])]
+			baseI := i
+			{
+				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+			i -= len(keysForSinkStatues[iNdEx])
+			copy(dAtA[i:], keysForSinkStatues[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForSinkStatues[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0x22
 		}
 	}
-	if len(m.Command) > 0 {
-		for _, s := range m.Command {
-			l = len(s)
-			n += 1 + l + sovGenerated(uint64(l))
+	if len(m.SourceStatuses) > 0 {
+		keysForSourceStatuses := make([]string, 0, len(m.SourceStatuses))
+		for k := range m.SourceStatuses {
+			keysForSourceStatuses = append(keysForSourceStatuses, string(k))
+		}
+		github_com_gogo_protobuf_sortkeys.Strings(keysForSourceStatuses)
+		for iNdEx := len(keysForSourceStatuses) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.SourceStatuses[string(keysForSourceStatuses[iNdEx])]
+			baseI := i
+			{
+				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+			i -= len(keysForSourceStatuses[iNdEx])
+			copy(dAtA[i:], keysForSourceStatuses[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForSourceStatuses[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0x1a
 		}
 	}
-	if m.UsernameSecret != nil {
-		l = m.UsernameSecret.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if m.PasswordSecret != nil {
-		l = m.PasswordSecret.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if m.SSHPrivateKeySecret != nil {
-		l = m.SSHPrivateKeySecret.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	return n
+	i -= len(m.Message)
+	copy(dAtA[i:], m.Message)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Phase)
+	copy(dAtA[i:], m.Phase)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
 }
 
-func (m *Group) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Key)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.EndOfGroup)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Format)
-	n += 1 + l + sovGenerated(uint64(l))
-	if m.Storage != nil {
-		l = m.Storage.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+func (m *Storage) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *HTTP) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
+func (m *Storage) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *HTTPHeader) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *Storage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	l = len(m.Name)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Value)
-	n += 1 + l + sovGenerated(uint64(l))
-	if m.ValueFrom != nil {
-		l = m.ValueFrom.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	return n
+	i -= len(m.SubPath)
+	copy(dAtA[i:], m.SubPath)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SubPath)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Name)
+	copy(dAtA[i:], m.Name)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
 }
 
-func (m *HTTPHeaderSource) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *TLS) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	var l int
-	_ = l
-	l = m.SecretKeyRef.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *HTTPSink) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.URL)
-	n += 1 + l + sovGenerated(uint64(l))
-	if len(m.Headers) > 0 {
-		for _, e := range m.Headers {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
-		}
-	}
-	n += 2
-	return n
+func (m *TLS) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *HTTPSource) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *TLS) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	l = len(m.ServiceName)
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *Interface) Size() (n int) {
-	if m == nil {
-		return 0
+	if m.KeySecret != nil {
+		{
+			size, err := m.KeySecret.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
 	}
-	var l int
-	_ = l
-	n += 2
-	if m.HTTP != nil {
-		l = m.HTTP.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	if m.CertSecret != nil {
+		{
+			size, err := m.CertSecret.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
 	}
-	return n
+	if m.CACertSecret != nil {
+		{
+			size, err := m.CACertSecret.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
-func (m *Kafka) Size() (n int) {
+func (m *VolumeSink) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *VolumeSink) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *VolumeSink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.AbstractVolumeSource.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *VolumeSource) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *VolumeSource) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *VolumeSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	i--
+	if m.ReadOnly {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i--
+	dAtA[i] = 0x50
+	{
+		size, err := m.AbstractVolumeSource.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x4a
+	i = encodeVarintGenerated(dAtA, i, uint64(m.Concurrency))
+	i--
+	dAtA[i] = 0x40
+	if m.PollPeriod != nil {
+		{
+			size, err := m.PollPeriod.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x32
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
+	offset -= sovGenerated(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+
+func (m *AWSCredentials) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Name)
+	l = m.AccessKeyID.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Topic)
+	l = m.SecretAccessKey.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	l = m.KafkaConfig.Size()
+	l = m.SessionToken.Size()
 	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *KafkaAutoCommit) Size() (n int) {
+func (m *AWSEndpoint) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	n += 2
+	l = len(m.URL)
+	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *KafkaConfig) Size() (n int) {
+func (m *AbstractStep) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Brokers) > 0 {
-		for _, s := range m.Brokers {
-			l = len(s)
-			n += 1 + l + sovGenerated(uint64(l))
-		}
-	}
-	l = len(m.Version)
+	l = m.Resources.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.NET != nil {
-		l = m.NET.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	n += 1 + sovGenerated(uint64(m.MaxMessageBytes))
 	return n
 }
 
-func (m *KafkaNET) Size() (n int) {
+func (m *AbstractVolumeSource) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.TLS != nil {
-		l = m.TLS.Size()
+	if m.HostPath != nil {
+		l = m.HostPath.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if m.SASL != nil {
-		l = m.SASL.Size()
+	if m.EmptyDir != nil {
+		l = m.EmptyDir.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.GCEPersistentDisk != nil {
+		l = m.GCEPersistentDisk.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.AWSElasticBlockStore != nil {
+		l = m.AWSElasticBlockStore.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.GitRepo != nil {
+		l = m.GitRepo.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Secret != nil {
+		l = m.Secret.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.NFS != nil {
+		l = m.NFS.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.ISCSI != nil {
+		l = m.ISCSI.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Glusterfs != nil {
+		l = m.Glusterfs.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.PersistentVolumeClaim != nil {
+		l = m.PersistentVolumeClaim.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.RBD != nil {
+		l = m.RBD.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.FlexVolume != nil {
+		l = m.FlexVolume.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Cinder != nil {
+		l = m.Cinder.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.CephFS != nil {
+		l = m.CephFS.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Flocker != nil {
+		l = m.Flocker.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
+	if m.DownwardAPI != nil {
+		l = m.DownwardAPI.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.FC != nil {
+		l = m.FC.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.AzureFile != nil {
+		l = m.AzureFile.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.ConfigMap != nil {
+		l = m.ConfigMap.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.VsphereVolume != nil {
+		l = m.VsphereVolume.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.Quobyte != nil {
+		l = m.Quobyte.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.AzureDisk != nil {
+		l = m.AzureDisk.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.PhotonPersistentDisk != nil {
+		l = m.PhotonPersistentDisk.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.PortworxVolume != nil {
+		l = m.PortworxVolume.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.ScaleIO != nil {
+		l = m.ScaleIO.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.Projected != nil {
+		l = m.Projected.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.StorageOS != nil {
+		l = m.StorageOS.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.CSI != nil {
+		l = m.CSI.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.Ephemeral != nil {
+		l = m.Ephemeral.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
 	return n
 }
 
-func (m *KafkaSink) Size() (n int) {
+func (m *Backoff) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.Kafka.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	n += 2
+	n += 1 + sovGenerated(uint64(m.Steps))
+	if m.Cap != nil {
+		l = m.Cap.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	n += 1 + sovGenerated(uint64(m.JitterPercentage))
+	if m.Duration != nil {
+		l = m.Duration.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	n += 1 + sovGenerated(uint64(m.FactorPercentage))
 	return n
 }
 
-func (m *KafkaSource) Size() (n int) {
+func (m *Cat) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.Kafka.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.StartOffset)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.AutoCommit.Size()
+	l = m.AbstractStep.Size()
 	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *Log) Size() (n int) {
+func (m *Code) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Truncate != nil {
-		n += 1 + sovGenerated(uint64(*m.Truncate))
-	}
+	l = len(m.Source)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Runtime)
+	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *Map) Size() (n int) {
+func (m *Container) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.AbstractStep.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Expression)
+	l = len(m.Image)
 	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *Metadata) Size() (n int) {
-	if m == nil {
-		return 0
+	if m.In != nil {
+		l = m.In.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	var l int
-	_ = l
-	if len(m.Annotations) > 0 {
-		for k, v := range m.Annotations {
-			_ = k
-			_ = v
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
-			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+	if len(m.VolumeMounts) > 0 {
+		for _, e := range m.VolumeMounts {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
 		}
 	}
-	if len(m.Labels) > 0 {
-		for k, v := range m.Labels {
-			_ = k
-			_ = v
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
-			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+	if len(m.Command) > 0 {
+		for _, s := range m.Command {
+			l = len(s)
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	if len(m.Args) > 0 {
+		for _, s := range m.Args {
+			l = len(s)
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	if len(m.Env) > 0 {
+		for _, e := range m.Env {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
 		}
 	}
+	l = m.Resources.Size()
+	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *Metrics) Size() (n int) {
+func (m *Cron) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	n += 1 + sovGenerated(uint64(m.Total))
-	n += 1 + sovGenerated(uint64(m.Errors))
-	l = m.Rate.Size()
+	l = len(m.Schedule)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Layout)
 	n += 1 + l + sovGenerated(uint64(l))
-	n += 1 + sovGenerated(uint64(m.Retries))
-	n += 1 + sovGenerated(uint64(m.TotalBytes))
 	return n
 }
 
-func (m *Pipeline) Size() (n int) {
+func (m *DBDataSource) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.ObjectMeta.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.Spec.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = m.Status.Size()
+	l = len(m.Value)
 	n += 1 + l + sovGenerated(uint64(l))
+	if m.ValueFrom != nil {
+		l = m.ValueFrom.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
 	return n
 }
 
-func (m *PipelineList) Size() (n int) {
+func (m *DBDataSourceFrom) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.ListMeta.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	if len(m.Items) > 0 {
-		for _, e := range m.Items {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
-		}
+	if m.SecretKeyRef != nil {
+		l = m.SecretKeyRef.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
 	return n
 }
 
-func (m *PipelineSpec) Size() (n int) {
+func (m *DBSink) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Steps) > 0 {
-		for _, e := range m.Steps {
+	l = m.Database.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	if len(m.Actions) > 0 {
+		for _, e := range m.Actions {
 			l = e.Size()
 			n += 1 + l + sovGenerated(uint64(l))
 		}
 	}
-	if m.DeletionDelay != nil {
-		l = m.DeletionDelay.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
 	return n
 }
 
-func (m *PipelineStatus) Size() (n int) {
+func (m *DBSource) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Phase)
+	l = m.Database.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Message)
+	l = len(m.Query)
 	n += 1 + l + sovGenerated(uint64(l))
-	if len(m.Conditions) > 0 {
-		for _, e := range m.Conditions {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
-		}
-	}
-	l = m.LastUpdated.Size()
+	l = len(m.OffsetColumn)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.PollInterval.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.CommitInterval.Size()
 	n += 1 + l + sovGenerated(uint64(l))
+	n += 2
 	return n
 }
 
-func (m *S3) Size() (n int) {
+func (m *Database) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Name)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Bucket)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Region)
+	l = len(m.Driver)
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.Credentials != nil {
-		l = m.Credentials.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if m.Endpoint != nil {
-		l = m.Endpoint.Size()
+	if m.DataSource != nil {
+		l = m.DataSource.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
 	return n
 }
 
-func (m *S3Sink) Size() (n int) {
+func (m *Dedupe) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.S3.Size()
+	l = m.AbstractStep.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.UID)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.MaxSize.Size()
 	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *S3Source) Size() (n int) {
+func (m *Expand) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.PollPeriod != nil {
-		l = m.PollPeriod.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	l = m.S3.Size()
+	l = m.AbstractStep.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	n += 1 + sovGenerated(uint64(m.Concurrency))
 	return n
 }
 
-func (m *SASL) Size() (n int) {
+func (m *Filter) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Mechanism)
+	l = m.AbstractStep.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Expression)
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.UserSecret != nil {
-		l = m.UserSecret.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if m.PasswordSecret != nil {
-		l = m.PasswordSecret.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
 	return n
 }
 
-func (m *SQLAction) Size() (n int) {
+func (m *Flatten) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.SQLStatement.Size()
+	l = m.AbstractStep.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.OnRecordNotFound != nil {
-		l = m.OnRecordNotFound.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if m.OnError != nil {
-		l = m.OnError.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
 	return n
 }
 
-func (m *SQLStatement) Size() (n int) {
+func (m *GetPodSpecReq) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.SQL)
+	l = len(m.Cluster)
 	n += 1 + l + sovGenerated(uint64(l))
-	if len(m.Args) > 0 {
-		for _, s := range m.Args {
-			l = len(s)
+	n += 2
+	l = len(m.PipelineName)
+	n += 1 + l + sovGenerated(uint64(l))
+	n += 1 + sovGenerated(uint64(m.Replica))
+	l = len(m.ImageFormat)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.RunnerImage)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.PullPolicy)
+	n += 1 + l + sovGenerated(uint64(l))
+	n += 1 + sovGenerated(uint64(m.UpdateInterval))
+	l = m.StepStatus.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.Sidecar.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	if len(m.ImagePullSecrets) > 0 {
+		for _, e := range m.ImagePullSecrets {
+			l = e.Size()
 			n += 1 + l + sovGenerated(uint64(l))
 		}
 	}
+	l = len(m.Hostname)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Subdomain)
+	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *STAN) Size() (n int) {
+func (m *Git) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Name)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Subject)
+	l = len(m.Image)
 	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.NATSURL)
+	l = len(m.URL)
 	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.ClusterID)
+	l = len(m.Path)
 	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.SubjectPrefix)
+	l = len(m.Branch)
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.Auth != nil {
-		l = m.Auth.Size()
+	if len(m.Env) > 0 {
+		for _, e := range m.Env {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	if len(m.Command) > 0 {
+		for _, s := range m.Command {
+			l = len(s)
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	if m.UsernameSecret != nil {
+		l = m.UsernameSecret.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.PasswordSecret != nil {
+		l = m.PasswordSecret.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.SSHPrivateKeySecret != nil {
+		l = m.SSHPrivateKeySecret.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	l = len(m.NATSMonitoringURL)
-	n += 1 + l + sovGenerated(uint64(l))
-	n += 1 + sovGenerated(uint64(m.MaxInflight))
 	return n
 }
 
-func (m *STANAuth) Size() (n int) {
+func (m *Group) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Token != nil {
-		l = m.Token.Size()
+	l = len(m.Key)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.EndOfGroup)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Format)
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.Storage != nil {
+		l = m.Storage.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
 	return n
 }
 
-func (m *Scale) Size() (n int) {
+func (m *HTTP) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.DesiredReplicas)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.PeekDelay)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.ScalingDelay)
-	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *Sidecar) Size() (n int) {
+func (m *HTTPHeader) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.Resources.Size()
+	l = len(m.Name)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Value)
 	n += 1 + l + sovGenerated(uint64(l))
+	if m.ValueFrom != nil {
+		l = m.ValueFrom.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
 	return n
 }
 
-func (m *Sink) Size() (n int) {
+func (m *HTTPHeaderSource) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Name)
+	l = m.SecretKeyRef.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.STAN != nil {
-		l = m.STAN.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *HTTPSink) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.Kafka != nil {
-		l = m.Kafka.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	var l int
+	_ = l
+	l = len(m.URL)
+	n += 1 + l + sovGenerated(uint64(l))
+	if len(m.Headers) > 0 {
+		for _, e := range m.Headers {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
+		}
 	}
-	if m.Log != nil {
-		l = m.Log.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	n += 2
+	return n
+}
+
+func (m *HTTPSource) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ServiceName)
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *Interface) Size() (n int) {
+	if m == nil {
+		return 0
 	}
+	var l int
+	_ = l
+	n += 2
 	if m.HTTP != nil {
 		l = m.HTTP.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if m.S3 != nil {
-		l = m.S3.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if m.DB != nil {
-		l = m.DB.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *Kafka) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.Volume != nil {
-		l = m.Volume.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	var l int
+	_ = l
+	l = len(m.Name)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Topic)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.KafkaConfig.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *KafkaAutoCommit) Size() (n int) {
+	if m == nil {
+		return 0
 	}
+	var l int
+	_ = l
+	n += 2
 	return n
 }
 
-func (m *Source) Size() (n int) {
+func (m *KafkaConfig) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Name)
+	if len(m.Brokers) > 0 {
+		for _, s := range m.Brokers {
+			l = len(s)
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	l = len(m.Version)
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.Cron != nil {
-		l = m.Cron.Size()
+	if m.NET != nil {
+		l = m.NET.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if m.STAN != nil {
-		l = m.STAN.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	n += 1 + sovGenerated(uint64(m.MaxMessageBytes))
+	return n
+}
+
+func (m *KafkaNET) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.Kafka != nil {
-		l = m.Kafka.Size()
+	var l int
+	_ = l
+	if m.TLS != nil {
+		l = m.TLS.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if m.HTTP != nil {
-		l = m.HTTP.Size()
+	if m.SASL != nil {
+		l = m.SASL.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if m.DB != nil {
-		l = m.DB.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *KafkaSink) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	l = m.Retry.Size()
+	var l int
+	_ = l
+	l = m.Kafka.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.S3 != nil {
-		l = m.S3.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	n += 2
+	return n
+}
+
+func (m *KafkaSource) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.Volume != nil {
-		l = m.Volume.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	var l int
+	_ = l
+	l = m.Kafka.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.StartOffset)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.AutoCommit.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *Log) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Truncate != nil {
+		n += 1 + sovGenerated(uint64(*m.Truncate))
 	}
 	return n
 }
 
-func (m *SourceStatus) Size() (n int) {
+func (m *Map) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Pending != nil {
-		n += 1 + sovGenerated(uint64(*m.Pending))
+	l = m.AbstractStep.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Expression)
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *Metadata) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if len(m.Metrics) > 0 {
-		for k, v := range m.Metrics {
+	var l int
+	_ = l
+	if len(m.Annotations) > 0 {
+		for k, v := range m.Annotations {
 			_ = k
 			_ = v
-			l = v.Size()
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
 			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
 		}
 	}
-	if m.LastPending != nil {
-		n += 1 + sovGenerated(uint64(*m.LastPending))
+	if len(m.Labels) > 0 {
+		for k, v := range m.Labels {
+			_ = k
+			_ = v
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+		}
 	}
 	return n
 }
 
-func (m *Step) Size() (n int) {
+func (m *Metrics) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovGenerated(uint64(m.Total))
+	n += 1 + sovGenerated(uint64(m.Errors))
+	l = m.Rate.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	n += 1 + sovGenerated(uint64(m.Retries))
+	n += 1 + sovGenerated(uint64(m.TotalBytes))
+	return n
+}
+
+func (m *Pipeline) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6760,7 +7019,7 @@ func (m *Step) Size() (n int) {
 	return n
 }
 
-func (m *StepList) Size() (n int) {
+func (m *PipelineList) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6777,152 +7036,152 @@ func (m *StepList) Size() (n int) {
 	return n
 }
 
-func (m *StepSpec) Size() (n int) {
+func (m *PipelineSpec) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Container != nil {
-		l = m.Container.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if len(m.Sources) > 0 {
-		for _, e := range m.Sources {
+	if len(m.Steps) > 0 {
+		for _, e := range m.Steps {
 			l = e.Size()
 			n += 1 + l + sovGenerated(uint64(l))
 		}
 	}
-	if len(m.Sinks) > 0 {
-		for _, e := range m.Sinks {
+	if m.DeletionDelay != nil {
+		l = m.DeletionDelay.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	return n
+}
+
+func (m *PipelineStatus) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Phase)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Message)
+	n += 1 + l + sovGenerated(uint64(l))
+	if len(m.Conditions) > 0 {
+		for _, e := range m.Conditions {
 			l = e.Size()
 			n += 1 + l + sovGenerated(uint64(l))
 		}
 	}
-	l = len(m.RestartPolicy)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Name)
+	l = m.LastUpdated.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.Code != nil {
-		l = m.Code.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *S3) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.Filter != nil {
-		l = m.Filter.Size()
+	var l int
+	_ = l
+	l = len(m.Name)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Bucket)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Region)
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.Credentials != nil {
+		l = m.Credentials.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if m.Map != nil {
-		l = m.Map.Size()
+	if m.Endpoint != nil {
+		l = m.Endpoint.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	n += 2
-	if m.Group != nil {
-		l = m.Group.Size()
-		n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *S3Sink) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.Git != nil {
-		l = m.Git.Size()
+	var l int
+	_ = l
+	l = m.S3.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *S3Source) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PollPeriod != nil {
+		l = m.PollPeriod.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if len(m.Volumes) > 0 {
-		for _, e := range m.Volumes {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
-		}
+	l = m.S3.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	n += 1 + sovGenerated(uint64(m.Concurrency))
+	return n
+}
+
+func (m *SASL) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	l = len(m.ServiceAccountName)
+	var l int
+	_ = l
+	l = len(m.Mechanism)
 	n += 1 + l + sovGenerated(uint64(l))
-	if m.Cat != nil {
-		l = m.Cat.Size()
+	if m.UserSecret != nil {
+		l = m.UserSecret.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if m.Metadata != nil {
-		l = m.Metadata.Size()
-		n += 2 + l + sovGenerated(uint64(l))
-	}
-	if len(m.NodeSelector) > 0 {
-		for k, v := range m.NodeSelector {
-			_ = k
-			_ = v
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
-			n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
-		}
-	}
-	if m.Affinity != nil {
-		l = m.Affinity.Size()
-		n += 2 + l + sovGenerated(uint64(l))
-	}
-	if len(m.Tolerations) > 0 {
-		for _, e := range m.Tolerations {
-			l = e.Size()
-			n += 2 + l + sovGenerated(uint64(l))
-		}
-	}
-	if len(m.ImagePullSecrets) > 0 {
-		for _, e := range m.ImagePullSecrets {
-			l = e.Size()
-			n += 2 + l + sovGenerated(uint64(l))
-		}
+	if m.PasswordSecret != nil {
+		l = m.PasswordSecret.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	n += 2 + sovGenerated(uint64(m.Replicas))
-	l = m.Scale.Size()
-	n += 2 + l + sovGenerated(uint64(l))
-	if m.Flatten != nil {
-		l = m.Flatten.Size()
-		n += 2 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *SQLAction) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.Expand != nil {
-		l = m.Expand.Size()
-		n += 2 + l + sovGenerated(uint64(l))
+	var l int
+	_ = l
+	l = m.SQLStatement.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.OnRecordNotFound != nil {
+		l = m.OnRecordNotFound.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	if m.Dedupe != nil {
-		l = m.Dedupe.Size()
-		n += 2 + l + sovGenerated(uint64(l))
+	if m.OnError != nil {
+		l = m.OnError.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	l = m.Sidecar.Size()
-	n += 2 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *StepStatus) Size() (n int) {
+func (m *SQLStatement) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Phase)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Message)
+	l = len(m.SQL)
 	n += 1 + l + sovGenerated(uint64(l))
-	if len(m.SourceStatuses) > 0 {
-		for k, v := range m.SourceStatuses {
-			_ = k
-			_ = v
-			l = v.Size()
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
-			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
-		}
-	}
-	if len(m.SinkStatues) > 0 {
-		for k, v := range m.SinkStatues {
-			_ = k
-			_ = v
-			l = v.Size()
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
-			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+	if len(m.Args) > 0 {
+		for _, s := range m.Args {
+			l = len(s)
+			n += 1 + l + sovGenerated(uint64(l))
 		}
 	}
-	n += 1 + sovGenerated(uint64(m.Replicas))
-	l = m.LastScaledAt.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Selector)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Reason)
-	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *Storage) Size() (n int) {
+func (m *STAN) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6930,328 +7189,714 @@ func (m *Storage) Size() (n int) {
 	_ = l
 	l = len(m.Name)
 	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.SubPath)
+	l = len(m.Subject)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.NATSURL)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.ClusterID)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.SubjectPrefix)
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.Auth != nil {
+		l = m.Auth.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	l = len(m.NATSMonitoringURL)
 	n += 1 + l + sovGenerated(uint64(l))
+	n += 1 + sovGenerated(uint64(m.MaxInflight))
 	return n
 }
 
-func (m *TLS) Size() (n int) {
+func (m *STANAuth) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.CACertSecret != nil {
-		l = m.CACertSecret.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if m.CertSecret != nil {
-		l = m.CertSecret.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	if m.KeySecret != nil {
-		l = m.KeySecret.Size()
+	if m.Token != nil {
+		l = m.Token.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
 	return n
 }
 
-func (m *VolumeSink) Size() (n int) {
+func (m *Scale) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.VolumeSource.Size()
+	l = len(m.DesiredReplicas)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.PeekDelay)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.ScalingDelay)
 	n += 1 + l + sovGenerated(uint64(l))
 	return n
 }
 
-func (m *VolumeSource) Size() (n int) {
+func (m *Sidecar) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.PollPeriod != nil {
-		l = m.PollPeriod.Size()
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	n += 1 + sovGenerated(uint64(m.Concurrency))
-	l = m.VolumeSource.Size()
+	l = m.Resources.Size()
 	n += 1 + l + sovGenerated(uint64(l))
-	n += 2
 	return n
 }
 
-func sovGenerated(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-
-func sozGenerated(x uint64) (n int) {
-	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-
-func (this *AWSCredentials) String() string {
-	if this == nil {
-		return "nil"
+func (m *Sink) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	s := strings.Join([]string{
-		`&AWSCredentials{`,
-		`AccessKeyID:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AccessKeyID), "SecretKeySelector", "v1.SecretKeySelector", 1), `&`, ``, 1) + `,`,
-		`SecretAccessKey:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SecretAccessKey), "SecretKeySelector", "v1.SecretKeySelector", 1), `&`, ``, 1) + `,`,
-		`SessionToken:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SessionToken), "SecretKeySelector", "v1.SecretKeySelector", 1), `&`, ``, 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *AWSEndpoint) String() string {
-	if this == nil {
-		return "nil"
+	var l int
+	_ = l
+	l = len(m.Name)
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.STAN != nil {
+		l = m.STAN.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	s := strings.Join([]string{
-		`&AWSEndpoint{`,
-		`URL:` + fmt.Sprintf("%v", this.URL) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *AbstractStep) String() string {
-	if this == nil {
-		return "nil"
+	if m.Kafka != nil {
+		l = m.Kafka.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	s := strings.Join([]string{
-		`&AbstractStep{`,
-		`Resources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Resources), "ResourceRequirements", "v1.ResourceRequirements", 1), `&`, ``, 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *Backoff) String() string {
-	if this == nil {
-		return "nil"
+	if m.Log != nil {
+		l = m.Log.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	s := strings.Join([]string{
-		`&Backoff{`,
-		`Steps:` + fmt.Sprintf("%v", this.Steps) + `,`,
-		`Cap:` + strings.Replace(fmt.Sprintf("%v", this.Cap), "Duration", "v11.Duration", 1) + `,`,
-		`JitterPercentage:` + fmt.Sprintf("%v", this.JitterPercentage) + `,`,
-		`Duration:` + strings.Replace(fmt.Sprintf("%v", this.Duration), "Duration", "v11.Duration", 1) + `,`,
-		`FactorPercentage:` + fmt.Sprintf("%v", this.FactorPercentage) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *Cat) String() string {
-	if this == nil {
-		return "nil"
+	if m.HTTP != nil {
+		l = m.HTTP.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	s := strings.Join([]string{
-		`&Cat{`,
-		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *Code) String() string {
-	if this == nil {
-		return "nil"
+	if m.S3 != nil {
+		l = m.S3.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	s := strings.Join([]string{
-		`&Code{`,
-		`Source:` + fmt.Sprintf("%v", this.Source) + `,`,
-		`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`,
-		`}`,
-	}, "")
-	return s
+	if m.DB != nil {
+		l = m.DB.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Volume != nil {
+		l = m.Volume.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	return n
 }
 
-func (this *Container) String() string {
-	if this == nil {
-		return "nil"
+func (m *Source) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	repeatedStringForVolumeMounts := "[]VolumeMount{"
-	for _, f := range this.VolumeMounts {
-		repeatedStringForVolumeMounts += fmt.Sprintf("%v", f) + ","
+	var l int
+	_ = l
+	l = len(m.Name)
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.Cron != nil {
+		l = m.Cron.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	repeatedStringForVolumeMounts += "}"
-	repeatedStringForEnv := "[]EnvVar{"
-	for _, f := range this.Env {
-		repeatedStringForEnv += fmt.Sprintf("%v", f) + ","
+	if m.STAN != nil {
+		l = m.STAN.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	repeatedStringForEnv += "}"
-	s := strings.Join([]string{
-		`&Container{`,
-		`Image:` + fmt.Sprintf("%v", this.Image) + `,`,
-		`In:` + strings.Replace(this.In.String(), "Interface", "Interface", 1) + `,`,
-		`VolumeMounts:` + repeatedStringForVolumeMounts + `,`,
-		`Command:` + fmt.Sprintf("%v", this.Command) + `,`,
-		`Args:` + fmt.Sprintf("%v", this.Args) + `,`,
-		`Env:` + repeatedStringForEnv + `,`,
-		`Resources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Resources), "ResourceRequirements", "v1.ResourceRequirements", 1), `&`, ``, 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *Cron) String() string {
-	if this == nil {
-		return "nil"
+	if m.Kafka != nil {
+		l = m.Kafka.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	s := strings.Join([]string{
-		`&Cron{`,
-		`Schedule:` + fmt.Sprintf("%v", this.Schedule) + `,`,
-		`Layout:` + fmt.Sprintf("%v", this.Layout) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *DBDataSource) String() string {
-	if this == nil {
-		return "nil"
+	if m.HTTP != nil {
+		l = m.HTTP.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	s := strings.Join([]string{
-		`&DBDataSource{`,
-		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
-		`ValueFrom:` + strings.Replace(this.ValueFrom.String(), "DBDataSourceFrom", "DBDataSourceFrom", 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *DBDataSourceFrom) String() string {
-	if this == nil {
-		return "nil"
+	if m.DB != nil {
+		l = m.DB.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	s := strings.Join([]string{
-		`&DBDataSourceFrom{`,
-		`SecretKeyRef:` + strings.Replace(fmt.Sprintf("%v", this.SecretKeyRef), "SecretKeySelector", "v1.SecretKeySelector", 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *DBSink) String() string {
-	if this == nil {
-		return "nil"
+	l = m.Retry.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.S3 != nil {
+		l = m.S3.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	repeatedStringForActions := "[]SQLAction{"
-	for _, f := range this.Actions {
-		repeatedStringForActions += strings.Replace(strings.Replace(f.String(), "SQLAction", "SQLAction", 1), `&`, ``, 1) + ","
+	if m.Volume != nil {
+		l = m.Volume.Size()
+		n += 1 + l + sovGenerated(uint64(l))
 	}
-	repeatedStringForActions += "}"
-	s := strings.Join([]string{
-		`&DBSink{`,
-		`Database:` + strings.Replace(strings.Replace(this.Database.String(), "Database", "Database", 1), `&`, ``, 1) + `,`,
-		`Actions:` + repeatedStringForActions + `,`,
-		`}`,
-	}, "")
-	return s
+	return n
 }
 
-func (this *DBSource) String() string {
-	if this == nil {
-		return "nil"
+func (m *SourceStatus) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	s := strings.Join([]string{
-		`&DBSource{`,
-		`Database:` + strings.Replace(strings.Replace(this.Database.String(), "Database", "Database", 1), `&`, ``, 1) + `,`,
-		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
-		`OffsetColumn:` + fmt.Sprintf("%v", this.OffsetColumn) + `,`,
-		`PollInterval:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.PollInterval), "Duration", "v11.Duration", 1), `&`, ``, 1) + `,`,
-		`CommitInterval:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CommitInterval), "Duration", "v11.Duration", 1), `&`, ``, 1) + `,`,
-		`InitSchema:` + fmt.Sprintf("%v", this.InitSchema) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *Database) String() string {
-	if this == nil {
-		return "nil"
+	var l int
+	_ = l
+	if m.Pending != nil {
+		n += 1 + sovGenerated(uint64(*m.Pending))
 	}
-	s := strings.Join([]string{
-		`&Database{`,
-		`Driver:` + fmt.Sprintf("%v", this.Driver) + `,`,
-		`DataSource:` + strings.Replace(this.DataSource.String(), "DBDataSource", "DBDataSource", 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
-func (this *Dedupe) String() string {
-	if this == nil {
-		return "nil"
+	if len(m.Metrics) > 0 {
+		for k, v := range m.Metrics {
+			_ = k
+			_ = v
+			l = v.Size()
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+		}
 	}
-	s := strings.Join([]string{
-		`&Dedupe{`,
-		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
-		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
-		`MaxSize:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.MaxSize), "Quantity", "resource.Quantity", 1), `&`, ``, 1) + `,`,
-		`}`,
-	}, "")
-	return s
+	if m.LastPending != nil {
+		n += 1 + sovGenerated(uint64(*m.LastPending))
+	}
+	return n
 }
 
-func (this *Expand) String() string {
-	if this == nil {
-		return "nil"
+func (m *Step) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	s := strings.Join([]string{
-		`&Expand{`,
-		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
-		`}`,
-	}, "")
-	return s
+	var l int
+	_ = l
+	l = m.ObjectMeta.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.Spec.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.Status.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
 }
 
-func (this *Filter) String() string {
-	if this == nil {
-		return "nil"
+func (m *StepList) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.ListMeta.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	if len(m.Items) > 0 {
+		for _, e := range m.Items {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *StepSpec) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Container != nil {
+		l = m.Container.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if len(m.Sources) > 0 {
+		for _, e := range m.Sources {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	if len(m.Sinks) > 0 {
+		for _, e := range m.Sinks {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	l = len(m.RestartPolicy)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Name)
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.Code != nil {
+		l = m.Code.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Filter != nil {
+		l = m.Filter.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Map != nil {
+		l = m.Map.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	n += 2
+	if m.Group != nil {
+		l = m.Group.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Git != nil {
+		l = m.Git.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if len(m.Volumes) > 0 {
+		for _, e := range m.Volumes {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
+		}
+	}
+	l = len(m.ServiceAccountName)
+	n += 1 + l + sovGenerated(uint64(l))
+	if m.Cat != nil {
+		l = m.Cat.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.Metadata != nil {
+		l = m.Metadata.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if len(m.NodeSelector) > 0 {
+		for k, v := range m.NodeSelector {
+			_ = k
+			_ = v
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+			n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize))
+		}
+	}
+	if m.Affinity != nil {
+		l = m.Affinity.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if len(m.Tolerations) > 0 {
+		for _, e := range m.Tolerations {
+			l = e.Size()
+			n += 2 + l + sovGenerated(uint64(l))
+		}
+	}
+	if len(m.ImagePullSecrets) > 0 {
+		for _, e := range m.ImagePullSecrets {
+			l = e.Size()
+			n += 2 + l + sovGenerated(uint64(l))
+		}
+	}
+	n += 2 + sovGenerated(uint64(m.Replicas))
+	l = m.Scale.Size()
+	n += 2 + l + sovGenerated(uint64(l))
+	if m.Flatten != nil {
+		l = m.Flatten.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.Expand != nil {
+		l = m.Expand.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	if m.Dedupe != nil {
+		l = m.Dedupe.Size()
+		n += 2 + l + sovGenerated(uint64(l))
+	}
+	l = m.Sidecar.Size()
+	n += 2 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *StepStatus) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Phase)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Message)
+	n += 1 + l + sovGenerated(uint64(l))
+	if len(m.SourceStatuses) > 0 {
+		for k, v := range m.SourceStatuses {
+			_ = k
+			_ = v
+			l = v.Size()
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+		}
+	}
+	if len(m.SinkStatues) > 0 {
+		for k, v := range m.SinkStatues {
+			_ = k
+			_ = v
+			l = v.Size()
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+		}
+	}
+	n += 1 + sovGenerated(uint64(m.Replicas))
+	l = m.LastScaledAt.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Selector)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Reason)
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *Storage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Name)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.SubPath)
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *TLS) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CACertSecret != nil {
+		l = m.CACertSecret.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.CertSecret != nil {
+		l = m.CertSecret.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	if m.KeySecret != nil {
+		l = m.KeySecret.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	return n
+}
+
+func (m *VolumeSink) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.AbstractVolumeSource.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
+func (m *VolumeSource) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PollPeriod != nil {
+		l = m.PollPeriod.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
+	n += 1 + sovGenerated(uint64(m.Concurrency))
+	l = m.AbstractVolumeSource.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	n += 2
+	return n
+}
+
+func sovGenerated(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+
+func sozGenerated(x uint64) (n int) {
+	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+func (this *AWSCredentials) String() string {
+	if this == nil {
+		return "nil"
 	}
 	s := strings.Join([]string{
-		`&Filter{`,
-		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
-		`Expression:` + fmt.Sprintf("%v", this.Expression) + `,`,
+		`&AWSCredentials{`,
+		`AccessKeyID:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AccessKeyID), "SecretKeySelector", "v1.SecretKeySelector", 1), `&`, ``, 1) + `,`,
+		`SecretAccessKey:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SecretAccessKey), "SecretKeySelector", "v1.SecretKeySelector", 1), `&`, ``, 1) + `,`,
+		`SessionToken:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SessionToken), "SecretKeySelector", "v1.SecretKeySelector", 1), `&`, ``, 1) + `,`,
 		`}`,
 	}, "")
 	return s
 }
 
-func (this *Flatten) String() string {
+func (this *AWSEndpoint) String() string {
 	if this == nil {
 		return "nil"
 	}
 	s := strings.Join([]string{
-		`&Flatten{`,
-		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
+		`&AWSEndpoint{`,
+		`URL:` + fmt.Sprintf("%v", this.URL) + `,`,
 		`}`,
 	}, "")
 	return s
 }
 
-func (this *GetPodSpecReq) String() string {
+func (this *AbstractStep) String() string {
 	if this == nil {
 		return "nil"
 	}
-	repeatedStringForImagePullSecrets := "[]LocalObjectReference{"
-	for _, f := range this.ImagePullSecrets {
-		repeatedStringForImagePullSecrets += fmt.Sprintf("%v", f) + ","
-	}
-	repeatedStringForImagePullSecrets += "}"
 	s := strings.Join([]string{
-		`&GetPodSpecReq{`,
-		`Cluster:` + fmt.Sprintf("%v", this.Cluster) + `,`,
-		`Debug:` + fmt.Sprintf("%v", this.Debug) + `,`,
-		`PipelineName:` + fmt.Sprintf("%v", this.PipelineName) + `,`,
-		`Replica:` + fmt.Sprintf("%v", this.Replica) + `,`,
-		`ImageFormat:` + fmt.Sprintf("%v", this.ImageFormat) + `,`,
+		`&AbstractStep{`,
+		`Resources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Resources), "ResourceRequirements", "v1.ResourceRequirements", 1), `&`, ``, 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *AbstractVolumeSource) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&AbstractVolumeSource{`,
+		`HostPath:` + strings.Replace(fmt.Sprintf("%v", this.HostPath), "HostPathVolumeSource", "v1.HostPathVolumeSource", 1) + `,`,
+		`EmptyDir:` + strings.Replace(fmt.Sprintf("%v", this.EmptyDir), "EmptyDirVolumeSource", "v1.EmptyDirVolumeSource", 1) + `,`,
+		`GCEPersistentDisk:` + strings.Replace(fmt.Sprintf("%v", this.GCEPersistentDisk), "GCEPersistentDiskVolumeSource", "v1.GCEPersistentDiskVolumeSource", 1) + `,`,
+		`AWSElasticBlockStore:` + strings.Replace(fmt.Sprintf("%v", this.AWSElasticBlockStore), "AWSElasticBlockStoreVolumeSource", "v1.AWSElasticBlockStoreVolumeSource", 1) + `,`,
+		`GitRepo:` + strings.Replace(fmt.Sprintf("%v", this.GitRepo), "GitRepoVolumeSource", "v1.GitRepoVolumeSource", 1) + `,`,
+		`Secret:` + strings.Replace(fmt.Sprintf("%v", this.Secret), "SecretVolumeSource", "v1.SecretVolumeSource", 1) + `,`,
+		`NFS:` + strings.Replace(fmt.Sprintf("%v", this.NFS), "NFSVolumeSource", "v1.NFSVolumeSource", 1) + `,`,
+		`ISCSI:` + strings.Replace(fmt.Sprintf("%v", this.ISCSI), "ISCSIVolumeSource", "v1.ISCSIVolumeSource", 1) + `,`,
+		`Glusterfs:` + strings.Replace(fmt.Sprintf("%v", this.Glusterfs), "GlusterfsVolumeSource", "v1.GlusterfsVolumeSource", 1) + `,`,
+		`PersistentVolumeClaim:` + strings.Replace(fmt.Sprintf("%v", this.PersistentVolumeClaim), "PersistentVolumeClaimVolumeSource", "v1.PersistentVolumeClaimVolumeSource", 1) + `,`,
+		`RBD:` + strings.Replace(fmt.Sprintf("%v", this.RBD), "RBDVolumeSource", "v1.RBDVolumeSource", 1) + `,`,
+		`FlexVolume:` + strings.Replace(fmt.Sprintf("%v", this.FlexVolume), "FlexVolumeSource", "v1.FlexVolumeSource", 1) + `,`,
+		`Cinder:` + strings.Replace(fmt.Sprintf("%v", this.Cinder), "CinderVolumeSource", "v1.CinderVolumeSource", 1) + `,`,
+		`CephFS:` + strings.Replace(fmt.Sprintf("%v", this.CephFS), "CephFSVolumeSource", "v1.CephFSVolumeSource", 1) + `,`,
+		`Flocker:` + strings.Replace(fmt.Sprintf("%v", this.Flocker), "FlockerVolumeSource", "v1.FlockerVolumeSource", 1) + `,`,
+		`DownwardAPI:` + strings.Replace(fmt.Sprintf("%v", this.DownwardAPI), "DownwardAPIVolumeSource", "v1.DownwardAPIVolumeSource", 1) + `,`,
+		`FC:` + strings.Replace(fmt.Sprintf("%v", this.FC), "FCVolumeSource", "v1.FCVolumeSource", 1) + `,`,
+		`AzureFile:` + strings.Replace(fmt.Sprintf("%v", this.AzureFile), "AzureFileVolumeSource", "v1.AzureFileVolumeSource", 1) + `,`,
+		`ConfigMap:` + strings.Replace(fmt.Sprintf("%v", this.ConfigMap), "ConfigMapVolumeSource", "v1.ConfigMapVolumeSource", 1) + `,`,
+		`VsphereVolume:` + strings.Replace(fmt.Sprintf("%v", this.VsphereVolume), "VsphereVirtualDiskVolumeSource", "v1.VsphereVirtualDiskVolumeSource", 1) + `,`,
+		`Quobyte:` + strings.Replace(fmt.Sprintf("%v", this.Quobyte), "QuobyteVolumeSource", "v1.QuobyteVolumeSource", 1) + `,`,
+		`AzureDisk:` + strings.Replace(fmt.Sprintf("%v", this.AzureDisk), "AzureDiskVolumeSource", "v1.AzureDiskVolumeSource", 1) + `,`,
+		`PhotonPersistentDisk:` + strings.Replace(fmt.Sprintf("%v", this.PhotonPersistentDisk), "PhotonPersistentDiskVolumeSource", "v1.PhotonPersistentDiskVolumeSource", 1) + `,`,
+		`PortworxVolume:` + strings.Replace(fmt.Sprintf("%v", this.PortworxVolume), "PortworxVolumeSource", "v1.PortworxVolumeSource", 1) + `,`,
+		`ScaleIO:` + strings.Replace(fmt.Sprintf("%v", this.ScaleIO), "ScaleIOVolumeSource", "v1.ScaleIOVolumeSource", 1) + `,`,
+		`Projected:` + strings.Replace(fmt.Sprintf("%v", this.Projected), "ProjectedVolumeSource", "v1.ProjectedVolumeSource", 1) + `,`,
+		`StorageOS:` + strings.Replace(fmt.Sprintf("%v", this.StorageOS), "StorageOSVolumeSource", "v1.StorageOSVolumeSource", 1) + `,`,
+		`CSI:` + strings.Replace(fmt.Sprintf("%v", this.CSI), "CSIVolumeSource", "v1.CSIVolumeSource", 1) + `,`,
+		`Ephemeral:` + strings.Replace(fmt.Sprintf("%v", this.Ephemeral), "EphemeralVolumeSource", "v1.EphemeralVolumeSource", 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Backoff) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Backoff{`,
+		`Steps:` + fmt.Sprintf("%v", this.Steps) + `,`,
+		`Cap:` + strings.Replace(fmt.Sprintf("%v", this.Cap), "Duration", "v11.Duration", 1) + `,`,
+		`JitterPercentage:` + fmt.Sprintf("%v", this.JitterPercentage) + `,`,
+		`Duration:` + strings.Replace(fmt.Sprintf("%v", this.Duration), "Duration", "v11.Duration", 1) + `,`,
+		`FactorPercentage:` + fmt.Sprintf("%v", this.FactorPercentage) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Cat) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Cat{`,
+		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Code) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Code{`,
+		`Source:` + fmt.Sprintf("%v", this.Source) + `,`,
+		`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Container) String() string {
+	if this == nil {
+		return "nil"
+	}
+	repeatedStringForVolumeMounts := "[]VolumeMount{"
+	for _, f := range this.VolumeMounts {
+		repeatedStringForVolumeMounts += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForVolumeMounts += "}"
+	repeatedStringForEnv := "[]EnvVar{"
+	for _, f := range this.Env {
+		repeatedStringForEnv += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForEnv += "}"
+	s := strings.Join([]string{
+		`&Container{`,
+		`Image:` + fmt.Sprintf("%v", this.Image) + `,`,
+		`In:` + strings.Replace(this.In.String(), "Interface", "Interface", 1) + `,`,
+		`VolumeMounts:` + repeatedStringForVolumeMounts + `,`,
+		`Command:` + fmt.Sprintf("%v", this.Command) + `,`,
+		`Args:` + fmt.Sprintf("%v", this.Args) + `,`,
+		`Env:` + repeatedStringForEnv + `,`,
+		`Resources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Resources), "ResourceRequirements", "v1.ResourceRequirements", 1), `&`, ``, 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Cron) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Cron{`,
+		`Schedule:` + fmt.Sprintf("%v", this.Schedule) + `,`,
+		`Layout:` + fmt.Sprintf("%v", this.Layout) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *DBDataSource) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&DBDataSource{`,
+		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
+		`ValueFrom:` + strings.Replace(this.ValueFrom.String(), "DBDataSourceFrom", "DBDataSourceFrom", 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *DBDataSourceFrom) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&DBDataSourceFrom{`,
+		`SecretKeyRef:` + strings.Replace(fmt.Sprintf("%v", this.SecretKeyRef), "SecretKeySelector", "v1.SecretKeySelector", 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *DBSink) String() string {
+	if this == nil {
+		return "nil"
+	}
+	repeatedStringForActions := "[]SQLAction{"
+	for _, f := range this.Actions {
+		repeatedStringForActions += strings.Replace(strings.Replace(f.String(), "SQLAction", "SQLAction", 1), `&`, ``, 1) + ","
+	}
+	repeatedStringForActions += "}"
+	s := strings.Join([]string{
+		`&DBSink{`,
+		`Database:` + strings.Replace(strings.Replace(this.Database.String(), "Database", "Database", 1), `&`, ``, 1) + `,`,
+		`Actions:` + repeatedStringForActions + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *DBSource) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&DBSource{`,
+		`Database:` + strings.Replace(strings.Replace(this.Database.String(), "Database", "Database", 1), `&`, ``, 1) + `,`,
+		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
+		`OffsetColumn:` + fmt.Sprintf("%v", this.OffsetColumn) + `,`,
+		`PollInterval:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.PollInterval), "Duration", "v11.Duration", 1), `&`, ``, 1) + `,`,
+		`CommitInterval:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CommitInterval), "Duration", "v11.Duration", 1), `&`, ``, 1) + `,`,
+		`InitSchema:` + fmt.Sprintf("%v", this.InitSchema) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Database) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Database{`,
+		`Driver:` + fmt.Sprintf("%v", this.Driver) + `,`,
+		`DataSource:` + strings.Replace(this.DataSource.String(), "DBDataSource", "DBDataSource", 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Dedupe) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Dedupe{`,
+		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
+		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
+		`MaxSize:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.MaxSize), "Quantity", "resource.Quantity", 1), `&`, ``, 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Expand) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Expand{`,
+		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Filter) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Filter{`,
+		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
+		`Expression:` + fmt.Sprintf("%v", this.Expression) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *Flatten) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{
+		`&Flatten{`,
+		`AbstractStep:` + strings.Replace(strings.Replace(this.AbstractStep.String(), "AbstractStep", "AbstractStep", 1), `&`, ``, 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+
+func (this *GetPodSpecReq) String() string {
+	if this == nil {
+		return "nil"
+	}
+	repeatedStringForImagePullSecrets := "[]LocalObjectReference{"
+	for _, f := range this.ImagePullSecrets {
+		repeatedStringForImagePullSecrets += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForImagePullSecrets += "}"
+	s := strings.Join([]string{
+		`&GetPodSpecReq{`,
+		`Cluster:` + fmt.Sprintf("%v", this.Cluster) + `,`,
+		`Debug:` + fmt.Sprintf("%v", this.Debug) + `,`,
+		`PipelineName:` + fmt.Sprintf("%v", this.PipelineName) + `,`,
+		`Replica:` + fmt.Sprintf("%v", this.Replica) + `,`,
+		`ImageFormat:` + fmt.Sprintf("%v", this.ImageFormat) + `,`,
 		`RunnerImage:` + fmt.Sprintf("%v", this.RunnerImage) + `,`,
 		`PullPolicy:` + fmt.Sprintf("%v", this.PullPolicy) + `,`,
 		`UpdateInterval:` + fmt.Sprintf("%v", this.UpdateInterval) + `,`,
@@ -7989,7 +8634,7 @@ func (this *VolumeSink) String() string {
 	}
 	s := strings.Join([]string{
 		`&VolumeSink{`,
-		`VolumeSource:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.VolumeSource), "VolumeSource", "v1.VolumeSource", 1), `&`, ``, 1) + `,`,
+		`AbstractVolumeSource:` + strings.Replace(strings.Replace(this.AbstractVolumeSource.String(), "AbstractVolumeSource", "AbstractVolumeSource", 1), `&`, ``, 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -8003,7 +8648,7 @@ func (this *VolumeSource) String() string {
 		`&VolumeSource{`,
 		`PollPeriod:` + strings.Replace(fmt.Sprintf("%v", this.PollPeriod), "Duration", "v11.Duration", 1) + `,`,
 		`Concurrency:` + fmt.Sprintf("%v", this.Concurrency) + `,`,
-		`VolumeSource:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.VolumeSource), "VolumeSource", "v1.VolumeSource", 1), `&`, ``, 1) + `,`,
+		`AbstractVolumeSource:` + strings.Replace(strings.Replace(this.AbstractVolumeSource.String(), "AbstractVolumeSource", "AbstractVolumeSource", 1), `&`, ``, 1) + `,`,
 		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
 		`}`,
 	}, "")
@@ -8029,28 +8674,1065 @@ func (m *AWSCredentials) Unmarshal(dAtA []byte) error {
 			if shift >= 64 {
 				return ErrIntOverflowGenerated
 			}
-			if iNdEx >= l {
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AWSCredentials: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AWSCredentials: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AccessKeyID", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.AccessKeyID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SecretAccessKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.SecretAccessKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SessionToken", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.SessionToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
+func (m *AWSEndpoint) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenerated
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AWSEndpoint: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AWSEndpoint: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.URL = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
+func (m *AbstractStep) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenerated
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AbstractStep: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AbstractStep: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
+func (m *AbstractVolumeSource) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenerated
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AbstractVolumeSource: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AbstractVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.HostPath == nil {
+				m.HostPath = &v1.HostPathVolumeSource{}
+			}
+			if err := m.HostPath.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EmptyDir", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.EmptyDir == nil {
+				m.EmptyDir = &v1.EmptyDirVolumeSource{}
+			}
+			if err := m.EmptyDir.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GCEPersistentDisk", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.GCEPersistentDisk == nil {
+				m.GCEPersistentDisk = &v1.GCEPersistentDiskVolumeSource{}
+			}
+			if err := m.GCEPersistentDisk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AWSElasticBlockStore", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AWSElasticBlockStore == nil {
+				m.AWSElasticBlockStore = &v1.AWSElasticBlockStoreVolumeSource{}
+			}
+			if err := m.AWSElasticBlockStore.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GitRepo", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.GitRepo == nil {
+				m.GitRepo = &v1.GitRepoVolumeSource{}
+			}
+			if err := m.GitRepo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Secret", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Secret == nil {
+				m.Secret = &v1.SecretVolumeSource{}
+			}
+			if err := m.Secret.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NFS", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.NFS == nil {
+				m.NFS = &v1.NFSVolumeSource{}
+			}
+			if err := m.NFS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ISCSI", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ISCSI == nil {
+				m.ISCSI = &v1.ISCSIVolumeSource{}
+			}
+			if err := m.ISCSI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Glusterfs", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Glusterfs == nil {
+				m.Glusterfs = &v1.GlusterfsVolumeSource{}
+			}
+			if err := m.Glusterfs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 10:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeClaim", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.PersistentVolumeClaim == nil {
+				m.PersistentVolumeClaim = &v1.PersistentVolumeClaimVolumeSource{}
+			}
+			if err := m.PersistentVolumeClaim.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RBD", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.RBD == nil {
+				m.RBD = &v1.RBDVolumeSource{}
+			}
+			if err := m.RBD.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 12:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FlexVolume", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.FlexVolume == nil {
+				m.FlexVolume = &v1.FlexVolumeSource{}
+			}
+			if err := m.FlexVolume.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 13:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Cinder", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Cinder == nil {
+				m.Cinder = &v1.CinderVolumeSource{}
+			}
+			if err := m.Cinder.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 14:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CephFS", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.CephFS == nil {
+				m.CephFS = &v1.CephFSVolumeSource{}
+			}
+			if err := m.CephFS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 15:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Flocker", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Flocker == nil {
+				m.Flocker = &v1.FlockerVolumeSource{}
+			}
+			if err := m.Flocker.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 16:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DownwardAPI", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.DownwardAPI == nil {
+				m.DownwardAPI = &v1.DownwardAPIVolumeSource{}
+			}
+			if err := m.DownwardAPI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 17:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FC", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.FC == nil {
+				m.FC = &v1.FCVolumeSource{}
+			}
+			if err := m.FC.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 18:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AzureFile", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AzureFile == nil {
+				m.AzureFile = &v1.AzureFileVolumeSource{}
+			}
+			if err := m.AzureFile.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 19:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ConfigMap", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ConfigMap == nil {
+				m.ConfigMap = &v1.ConfigMapVolumeSource{}
+			}
+			if err := m.ConfigMap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 20:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VsphereVolume", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			if m.VsphereVolume == nil {
+				m.VsphereVolume = &v1.VsphereVirtualDiskVolumeSource{}
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: AWSCredentials: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: AWSCredentials: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+			if err := m.VsphereVolume.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 21:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AccessKeyID", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Quobyte", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8077,13 +9759,16 @@ func (m *AWSCredentials) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.AccessKeyID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Quobyte == nil {
+				m.Quobyte = &v1.QuobyteVolumeSource{}
+			}
+			if err := m.Quobyte.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
+		case 22:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SecretAccessKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AzureDisk", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8110,13 +9795,16 @@ func (m *AWSCredentials) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.SecretAccessKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.AzureDisk == nil {
+				m.AzureDisk = &v1.AzureDiskVolumeSource{}
+			}
+			if err := m.AzureDisk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
+		case 23:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SessionToken", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PhotonPersistentDisk", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8143,66 +9831,90 @@ func (m *AWSCredentials) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.SessionToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.PhotonPersistentDisk == nil {
+				m.PhotonPersistentDisk = &v1.PhotonPersistentDiskVolumeSource{}
+			}
+			if err := m.PhotonPersistentDisk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenerated(dAtA[iNdEx:])
-			if err != nil {
-				return err
+		case 24:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PortworxVolume", wireType)
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
 				return ErrInvalidLengthGenerated
 			}
-			if (iNdEx + skippy) > l {
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-
-func (m *AWSEndpoint) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowGenerated
+			if m.PortworxVolume == nil {
+				m.PortworxVolume = &v1.PortworxVolumeSource{}
 			}
-			if iNdEx >= l {
+			if err := m.PortworxVolume.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 25:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ScaleIO", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			if m.ScaleIO == nil {
+				m.ScaleIO = &v1.ScaleIOVolumeSource{}
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: AWSEndpoint: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: AWSEndpoint: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+			if err := m.ScaleIO.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 26:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Projected", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowGenerated
@@ -8212,78 +9924,103 @@ func (m *AWSEndpoint) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthGenerated
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthGenerated
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.URL = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenerated(dAtA[iNdEx:])
-			if err != nil {
+			if m.Projected == nil {
+				m.Projected = &v1.ProjectedVolumeSource{}
+			}
+			if err := m.Projected.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			iNdEx = postIndex
+		case 27:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StorageOS", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
 				return ErrInvalidLengthGenerated
 			}
-			if (iNdEx + skippy) > l {
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-
-func (m *AbstractStep) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowGenerated
+			if m.StorageOS == nil {
+				m.StorageOS = &v1.StorageOSVolumeSource{}
 			}
-			if iNdEx >= l {
+			if err := m.StorageOS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 28:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CSI", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			if m.CSI == nil {
+				m.CSI = &v1.CSIVolumeSource{}
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: AbstractStep: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: AbstractStep: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+			if err := m.CSI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 29:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Ephemeral", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8310,7 +10047,10 @@ func (m *AbstractStep) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Ephemeral == nil {
+				m.Ephemeral = &v1.EphemeralVolumeSource{}
+			}
+			if err := m.Ephemeral.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -18244,7 +19984,7 @@ func (m *VolumeSink) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VolumeSource", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AbstractVolumeSource", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -18271,7 +20011,7 @@ func (m *VolumeSink) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.VolumeSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.AbstractVolumeSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -18383,7 +20123,7 @@ func (m *VolumeSource) Unmarshal(dAtA []byte) error {
 			}
 		case 9:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VolumeSource", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AbstractVolumeSource", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -18410,7 +20150,7 @@ func (m *VolumeSource) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.VolumeSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.AbstractVolumeSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/api/v1alpha1/generated.proto b/api/v1alpha1/generated.proto
index 4e48ac27..ed00cb93 100644
--- a/api/v1alpha1/generated.proto
+++ b/api/v1alpha1/generated.proto
@@ -43,6 +43,171 @@ message AbstractStep {
   optional k8s.io.api.core.v1.ResourceRequirements resources = 1;
 }
 
+message AbstractVolumeSource {
+  // HostPath represents a pre-existing file or directory on the host
+  // machine that is directly exposed to the container. This is generally
+  // used for system agents or other privileged things that are allowed
+  // to see the host machine. Most containers will NOT need this.
+  // More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath
+  // ---
+  // TODO(jonesdl) We need to restrict who can use host directory mounts and who can/can not
+  // mount host directories as read/write.
+  // +optional
+  optional k8s.io.api.core.v1.HostPathVolumeSource hostPath = 1;
+
+  // EmptyDir represents a temporary directory that shares a pod's lifetime.
+  // More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir
+  // +optional
+  optional k8s.io.api.core.v1.EmptyDirVolumeSource emptyDir = 2;
+
+  // GCEPersistentDisk represents a GCE Disk resource that is attached to a
+  // kubelet's host machine and then exposed to the pod.
+  // More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
+  // +optional
+  optional k8s.io.api.core.v1.GCEPersistentDiskVolumeSource gcePersistentDisk = 3;
+
+  // AWSElasticBlockStore represents an AWS Disk resource that is attached to a
+  // kubelet's host machine and then exposed to the pod.
+  // More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
+  // +optional
+  optional k8s.io.api.core.v1.AWSElasticBlockStoreVolumeSource awsElasticBlockStore = 4;
+
+  // GitRepo represents a git repository at a particular revision.
+  // DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an
+  // EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir
+  // into the Pod's container.
+  // +optional
+  optional k8s.io.api.core.v1.GitRepoVolumeSource gitRepo = 5;
+
+  // Secret represents a secret that should populate this volume.
+  // More info: https://kubernetes.io/docs/concepts/storage/volumes#secret
+  // +optional
+  optional k8s.io.api.core.v1.SecretVolumeSource secret = 6;
+
+  // NFS represents an NFS mount on the host that shares a pod's lifetime
+  // More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs
+  // +optional
+  optional k8s.io.api.core.v1.NFSVolumeSource nfs = 7;
+
+  // ISCSI represents an ISCSI Disk resource that is attached to a
+  // kubelet's host machine and then exposed to the pod.
+  // More info: https://examples.k8s.io/volumes/iscsi/README.md
+  // +optional
+  optional k8s.io.api.core.v1.ISCSIVolumeSource iscsi = 8;
+
+  // Glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime.
+  // More info: https://examples.k8s.io/volumes/glusterfs/README.md
+  // +optional
+  optional k8s.io.api.core.v1.GlusterfsVolumeSource glusterfs = 9;
+
+  // PersistentVolumeClaimVolumeSource represents a reference to a
+  // PersistentVolumeClaim in the same namespace.
+  // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
+  // +optional
+  optional k8s.io.api.core.v1.PersistentVolumeClaimVolumeSource persistentVolumeClaim = 10;
+
+  // RBD represents a Rados Block Device mount on the host that shares a pod's lifetime.
+  // More info: https://examples.k8s.io/volumes/rbd/README.md
+  // +optional
+  optional k8s.io.api.core.v1.RBDVolumeSource rbd = 11;
+
+  // FlexVolume represents a generic volume resource that is
+  // provisioned/attached using an exec based plugin.
+  // +optional
+  optional k8s.io.api.core.v1.FlexVolumeSource flexVolume = 12;
+
+  // Cinder represents a cinder volume attached and mounted on kubelets host machine.
+  // More info: https://examples.k8s.io/mysql-cinder-pd/README.md
+  // +optional
+  optional k8s.io.api.core.v1.CinderVolumeSource cinder = 13;
+
+  // CephFS represents a Ceph FS mount on the host that shares a pod's lifetime
+  // +optional
+  optional k8s.io.api.core.v1.CephFSVolumeSource cephfs = 14;
+
+  // Flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running
+  // +optional
+  optional k8s.io.api.core.v1.FlockerVolumeSource flocker = 15;
+
+  // DownwardAPI represents downward API about the pod that should populate this volume
+  // +optional
+  optional k8s.io.api.core.v1.DownwardAPIVolumeSource downwardAPI = 16;
+
+  // FC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.
+  // +optional
+  optional k8s.io.api.core.v1.FCVolumeSource fc = 17;
+
+  // AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
+  // +optional
+  optional k8s.io.api.core.v1.AzureFileVolumeSource azureFile = 18;
+
+  // ConfigMap represents a configMap that should populate this volume
+  // +optional
+  optional k8s.io.api.core.v1.ConfigMapVolumeSource configMap = 19;
+
+  // VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine
+  // +optional
+  optional k8s.io.api.core.v1.VsphereVirtualDiskVolumeSource vsphereVolume = 20;
+
+  // Quobyte represents a Quobyte mount on the host that shares a pod's lifetime
+  // +optional
+  optional k8s.io.api.core.v1.QuobyteVolumeSource quobyte = 21;
+
+  // AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.
+  // +optional
+  optional k8s.io.api.core.v1.AzureDiskVolumeSource azureDisk = 22;
+
+  // PhotonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine
+  optional k8s.io.api.core.v1.PhotonPersistentDiskVolumeSource photonPersistentDisk = 23;
+
+  // Items for all in one resources secrets, configmaps, and downward API
+  optional k8s.io.api.core.v1.ProjectedVolumeSource projected = 26;
+
+  // PortworxVolume represents a portworx volume attached and mounted on kubelets host machine
+  // +optional
+  optional k8s.io.api.core.v1.PortworxVolumeSource portworxVolume = 24;
+
+  // ScaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.
+  // +optional
+  optional k8s.io.api.core.v1.ScaleIOVolumeSource scaleIO = 25;
+
+  // StorageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.
+  // +optional
+  optional k8s.io.api.core.v1.StorageOSVolumeSource storageos = 27;
+
+  // CSI (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).
+  // +optional
+  optional k8s.io.api.core.v1.CSIVolumeSource csi = 28;
+
+  // Ephemeral represents a volume that is handled by a cluster storage driver (Alpha feature).
+  // The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts,
+  // and deleted when the pod is removed.
+  //
+  // Use this if:
+  // a) the volume is only needed while the pod runs,
+  // b) features of normal volumes like restoring from snapshot or capacity
+  //    tracking are needed,
+  // c) the storage driver is specified through a storage class, and
+  // d) the storage driver supports dynamic volume provisioning through
+  //    a PersistentVolumeClaim (see EphemeralVolumeSource for more
+  //    information on the connection between this volume type
+  //    and PersistentVolumeClaim).
+  //
+  // Use PersistentVolumeClaim or one of the vendor-specific
+  // APIs for volumes that persist for longer than the lifecycle
+  // of an individual pod.
+  //
+  // Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to
+  // be used that way - see the documentation of the driver for
+  // more information.
+  //
+  // A pod can use both types of ephemeral volumes and
+  // persistent volumes at the same time.
+  //
+  // +optional
+  optional k8s.io.api.core.v1.EphemeralVolumeSource ephemeral = 29;
+}
+
 message Backoff {
   // +kubebuilder:default="100ms"
   optional k8s.io.apimachinery.pkg.apis.meta.v1.Duration duration = 4;
@@ -646,11 +811,11 @@ message TLS {
 }
 
 message VolumeSink {
-  optional k8s.io.api.core.v1.VolumeSource volumeSource = 1;
+  optional AbstractVolumeSource abstractVolumeSource = 1;
 }
 
 message VolumeSource {
-  optional k8s.io.api.core.v1.VolumeSource volumeSource = 9;
+  optional AbstractVolumeSource abstractVolumeSource = 9;
 
   // +kubebuilder:default="1m"
   optional k8s.io.apimachinery.pkg.apis.meta.v1.Duration pollPeriod = 6;
diff --git a/api/v1alpha1/http_source.go b/api/v1alpha1/http_source.go
index d75d71a8..6da17de0 100644
--- a/api/v1alpha1/http_source.go
+++ b/api/v1alpha1/http_source.go
@@ -1,5 +1,13 @@
 package v1alpha1
 
+import (
+	"fmt"
+)
+
 type HTTPSource struct {
 	ServiceName string `json:"serviceName,omitempty" protobuf:"bytes,1,opt,name=serviceName"` // the service name to create, defaults to `${pipelineName}-${stepName}`.
 }
+
+func (in HTTPSource) GenURN(cluster, namespace string) string {
+	return fmt.Sprintf("urn:dataflow:http:https://%s.svc.%s.%s", in.ServiceName, namespace, cluster)
+}
diff --git a/api/v1alpha1/kafka.go b/api/v1alpha1/kafka.go
index b77254b4..7817c40c 100644
--- a/api/v1alpha1/kafka.go
+++ b/api/v1alpha1/kafka.go
@@ -1,5 +1,9 @@
 package v1alpha1
 
+import (
+	"fmt"
+)
+
 type KafkaNET struct {
 	TLS  *TLS  `json:"tls,omitempty" protobuf:"bytes,1,opt,name=tls"`
 	SASL *SASL `json:"sasl,omitempty" protobuf:"bytes,2,opt,name=sasl"`
@@ -18,3 +22,7 @@ type Kafka struct {
 	KafkaConfig `json:",inline" protobuf:"bytes,4,opt,name=kafkaConfig"`
 	Topic       string `json:"topic" protobuf:"bytes,3,opt,name=topic"`
 }
+
+func (in Kafka) GenURN(cluster, namespace string) string {
+	return fmt.Sprintf("urn:dataflow:kafka:%s:%s", in.Brokers[0], in.Topic)
+}
diff --git a/api/v1alpha1/meta.go b/api/v1alpha1/meta.go
new file mode 100644
index 00000000..8758807e
--- /dev/null
+++ b/api/v1alpha1/meta.go
@@ -0,0 +1,80 @@
+package v1alpha1
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+type meta struct{ string }
+
+func (m meta) String() string { return m.string }
+
+var (
+	// MetaID is a unique ID for the message.
+	// Required.
+	// https://github.com/cloudevents/spec/blob/master/spec.md#id
+	MetaID = meta{"id"}
+	// MetaSource is the source of the messages as a Unique Resource Identifier (URI).
+	// Required.
+	// https://github.com/cloudevents/spec/blob/master/spec.md#source-1
+	MetaSource = meta{"source"}
+	// MetaTime is the time of the message. As meta-data, this might be different to the event-time (which might be within the message).
+	// For example, it might be the last-modified time of a file, but the file itself was created at another time.
+	// Optional.
+	// https://github.com/cloudevents/spec/blob/master/spec.md#time
+	MetaTime = meta{"time"}
+)
+
+func ContextWithMeta(ctx context.Context, source, id string, time time.Time) context.Context {
+	return context.WithValue(
+		context.WithValue(
+			context.WithValue(
+				ctx,
+				MetaSource,
+				source,
+			),
+			MetaID,
+			id,
+		),
+		MetaTime,
+		time,
+	)
+}
+
+func MetaFromContext(ctx context.Context) (source, id string, t time.Time, err error) {
+	source, ok := ctx.Value(MetaSource).(string)
+	if !ok {
+		return "", "", time.Time{}, fmt.Errorf("failed to get source from context")
+	}
+	id, ok = ctx.Value(MetaID).(string)
+	if !ok {
+		return "", "", time.Time{}, fmt.Errorf("failed to get id from context")
+	}
+	t, ok = ctx.Value(MetaTime).(time.Time)
+	if !ok {
+		return "", "", time.Time{}, fmt.Errorf("failed to get time from context")
+	}
+	return source, id, t, nil
+}
+
+func MetaInject(ctx context.Context, h http.Header) error {
+	source, id, t, err := MetaFromContext(ctx)
+	if err != nil {
+		return err
+	}
+	h.Add(MetaSource.String(), source)
+	h.Add(MetaID.String(), id)
+	h.Add(MetaTime.String(), t.Format(time.RFC3339))
+	return nil
+}
+
+func MetaExtract(ctx context.Context, h http.Header) context.Context {
+	t, _ := time.Parse(time.RFC3339, h.Get(MetaTime.String()))
+	return ContextWithMeta(ctx,
+		h.Get(MetaSource.String()),
+		h.Get(MetaID.String()),
+		t,
+	)
+}
diff --git a/api/v1alpha1/s3.go b/api/v1alpha1/s3.go
index 0e042f77..8a6f39c7 100644
--- a/api/v1alpha1/s3.go
+++ b/api/v1alpha1/s3.go
@@ -1,5 +1,9 @@
 package v1alpha1
 
+import (
+	"fmt"
+)
+
 type S3 struct {
 	// +kubebuilder:default=default
 	Name        string          `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
@@ -8,3 +12,8 @@ type S3 struct {
 	Credentials *AWSCredentials `json:"credentials,omitempty" protobuf:"bytes,4,opt,name=credentials"`
 	Endpoint    *AWSEndpoint    `json:"endpoint,omitempty" protobuf:"bytes,5,opt,name=endpoint"`
 }
+
+func (in S3) GenURN(cluster, namespace string) string {
+	// An Amazon S3 bucket name is globally unique, and the namespace is shared by all AWS accounts.
+	return fmt.Sprintf("urn:dataflow:s3:%s", in.Bucket)
+}
diff --git a/api/v1alpha1/source.go b/api/v1alpha1/source.go
index 09ddbed9..5b1370d7 100644
--- a/api/v1alpha1/source.go
+++ b/api/v1alpha1/source.go
@@ -1,5 +1,9 @@
 package v1alpha1
 
+import (
+	"fmt"
+)
+
 type Source struct {
 	// +kubebuilder:default=default
 	Name   string        `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
@@ -13,3 +17,26 @@ type Source struct {
 	// +kubebuilder:default={duration: "100ms", steps: 20, factorPercentage: 200, jitterPercentage: 10}
 	Retry Backoff `json:"retry,omitempty" protobuf:"bytes,7,opt,name=retry"`
 }
+
+func (s Source) get() urner {
+	if v := s.Cron; v != nil {
+		return v
+	} else if v := s.DB; v != nil {
+		return v
+	} else if v := s.HTTP; v != nil {
+		return v
+	} else if v := s.Kafka; v != nil {
+		return v
+	} else if v := s.S3; v != nil {
+		return v
+	} else if v := s.STAN; v != nil {
+		return v
+	} else if v := s.Volume; v != nil {
+		return v
+	}
+	panic(fmt.Errorf("invalid source %q", s.Name))
+}
+
+func (s Source) GenURN(cluster, namespace string) string {
+	return s.get().GenURN(cluster, namespace)
+}
diff --git a/api/v1alpha1/stan.go b/api/v1alpha1/stan.go
index ebf05ec8..a44f965f 100644
--- a/api/v1alpha1/stan.go
+++ b/api/v1alpha1/stan.go
@@ -1,6 +1,8 @@
 package v1alpha1
 
 import (
+	"fmt"
+
 	corev1 "k8s.io/api/core/v1"
 )
 
@@ -26,6 +28,10 @@ type STAN struct {
 	MaxInflight uint32 `json:"maxInflight,omitempty" protobuf:"bytes,9,opt,name=maxInflight"`
 }
 
+func (s STAN) GenURN(cluster, namespace string) string {
+	return fmt.Sprintf("urn:dataflow:stan:%s:%s", s.NATSURL, s.Subject)
+}
+
 type STANAuth struct {
 	Token *corev1.SecretKeySelector `json:"token,omitempty" protobuf:"bytes,1,opt,name=token"`
 }
diff --git a/api/v1alpha1/step_types.go b/api/v1alpha1/step_types.go
index 5237f729..af5d3d54 100644
--- a/api/v1alpha1/step_types.go
+++ b/api/v1alpha1/step_types.go
@@ -73,7 +73,7 @@ func (in Step) GetPodSpec(req GetPodSpecReq) corev1.PodSpec {
 			name := fmt.Sprintf("source-%s", source.Name)
 			volumes = append(volumes, corev1.Volume{
 				Name:         name,
-				VolumeSource: x.VolumeSource,
+				VolumeSource: corev1.VolumeSource(x.AbstractVolumeSource),
 			})
 			volumeMounts = append(volumeMounts, corev1.VolumeMount{
 				Name:      name,
@@ -87,7 +87,7 @@ func (in Step) GetPodSpec(req GetPodSpecReq) corev1.PodSpec {
 			name := fmt.Sprintf("sink-%s", source.Name)
 			volumes = append(volumes, corev1.Volume{
 				Name:         name,
-				VolumeSource: x.VolumeSource,
+				VolumeSource: corev1.VolumeSource(x.AbstractVolumeSource),
 			})
 			volumeMounts = append(volumeMounts, corev1.VolumeMount{
 				Name:      name,
@@ -100,6 +100,7 @@ func (in Step) GetPodSpec(req GetPodSpecReq) corev1.PodSpec {
 		{Name: EnvCluster, Value: req.Cluster},
 		{Name: EnvDebug, Value: strconv.FormatBool(req.Debug)},
 		{Name: EnvNamespace, ValueFrom: &corev1.EnvVarSource{FieldRef: &corev1.ObjectFieldSelector{FieldPath: "metadata.namespace"}}},
+		{Name: EnvPod, ValueFrom: &corev1.EnvVarSource{FieldRef: &corev1.ObjectFieldSelector{FieldPath: "metadata.name"}}},
 		{Name: EnvPipelineName, Value: req.PipelineName},
 		{Name: EnvReplica, Value: strconv.Itoa(int(req.Replica))},
 		{Name: EnvStep, Value: string(step)},
diff --git a/api/v1alpha1/urner.go b/api/v1alpha1/urner.go
new file mode 100644
index 00000000..dd7d04fa
--- /dev/null
+++ b/api/v1alpha1/urner.go
@@ -0,0 +1,7 @@
+package v1alpha1
+
+// what a strange name - "URN" + "er"
+// why? https://golang.org/doc/effective_go#interface-names
+type urner interface { // only private to defeat codegen
+	GenURN(cluster, namespace string) string
+}
diff --git a/api/v1alpha1/volume_sink.go b/api/v1alpha1/volume_sink.go
index 50e95393..e9072585 100644
--- a/api/v1alpha1/volume_sink.go
+++ b/api/v1alpha1/volume_sink.go
@@ -1,7 +1,5 @@
 package v1alpha1
 
-import corev1 "k8s.io/api/core/v1"
-
 type VolumeSink struct {
-	corev1.VolumeSource `json:",inline" protobuf:"bytes,1,opt,name=volumeSource"`
+	AbstractVolumeSource `json:",inline" protobuf:"bytes,1,opt,name=abstractVolumeSource"`
 }
diff --git a/api/v1alpha1/volume_source.go b/api/v1alpha1/volume_source.go
index 1160fd43..c52b439f 100644
--- a/api/v1alpha1/volume_source.go
+++ b/api/v1alpha1/volume_source.go
@@ -1,12 +1,11 @@
 package v1alpha1
 
 import (
-	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 type VolumeSource struct {
-	corev1.VolumeSource `json:",inline" protobuf:"bytes,9,opt,name=volumeSource"`
+	AbstractVolumeSource `json:",inline" protobuf:"bytes,9,opt,name=abstractVolumeSource"`
 	// +kubebuilder:default="1m"
 	PollPeriod *metav1.Duration `json:"pollPeriod,omitempty" protobuf:"bytes,6,opt,name=pollPeriod"`
 	// +kubebuilder:default=1
diff --git a/api/v1alpha1/zz_generated.deepcopy.go b/api/v1alpha1/zz_generated.deepcopy.go
index 97f5a205..2c2eab2d 100644
--- a/api/v1alpha1/zz_generated.deepcopy.go
+++ b/api/v1alpha1/zz_generated.deepcopy.go
@@ -21,8 +21,8 @@ limitations under the License.
 package v1alpha1
 
 import (
-	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 )
 
@@ -75,17 +75,177 @@ func (in *AbstractStep) DeepCopy() *AbstractStep {
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *AbstractVolumeSource) DeepCopyInto(out *AbstractVolumeSource) {
+	*out = *in
+	if in.HostPath != nil {
+		in, out := &in.HostPath, &out.HostPath
+		*out = new(v1.HostPathVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.EmptyDir != nil {
+		in, out := &in.EmptyDir, &out.EmptyDir
+		*out = new(v1.EmptyDirVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.GCEPersistentDisk != nil {
+		in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk
+		*out = new(v1.GCEPersistentDiskVolumeSource)
+		**out = **in
+	}
+	if in.AWSElasticBlockStore != nil {
+		in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore
+		*out = new(v1.AWSElasticBlockStoreVolumeSource)
+		**out = **in
+	}
+	if in.GitRepo != nil {
+		in, out := &in.GitRepo, &out.GitRepo
+		*out = new(v1.GitRepoVolumeSource)
+		**out = **in
+	}
+	if in.Secret != nil {
+		in, out := &in.Secret, &out.Secret
+		*out = new(v1.SecretVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.NFS != nil {
+		in, out := &in.NFS, &out.NFS
+		*out = new(v1.NFSVolumeSource)
+		**out = **in
+	}
+	if in.ISCSI != nil {
+		in, out := &in.ISCSI, &out.ISCSI
+		*out = new(v1.ISCSIVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Glusterfs != nil {
+		in, out := &in.Glusterfs, &out.Glusterfs
+		*out = new(v1.GlusterfsVolumeSource)
+		**out = **in
+	}
+	if in.PersistentVolumeClaim != nil {
+		in, out := &in.PersistentVolumeClaim, &out.PersistentVolumeClaim
+		*out = new(v1.PersistentVolumeClaimVolumeSource)
+		**out = **in
+	}
+	if in.RBD != nil {
+		in, out := &in.RBD, &out.RBD
+		*out = new(v1.RBDVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.FlexVolume != nil {
+		in, out := &in.FlexVolume, &out.FlexVolume
+		*out = new(v1.FlexVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Cinder != nil {
+		in, out := &in.Cinder, &out.Cinder
+		*out = new(v1.CinderVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.CephFS != nil {
+		in, out := &in.CephFS, &out.CephFS
+		*out = new(v1.CephFSVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Flocker != nil {
+		in, out := &in.Flocker, &out.Flocker
+		*out = new(v1.FlockerVolumeSource)
+		**out = **in
+	}
+	if in.DownwardAPI != nil {
+		in, out := &in.DownwardAPI, &out.DownwardAPI
+		*out = new(v1.DownwardAPIVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.FC != nil {
+		in, out := &in.FC, &out.FC
+		*out = new(v1.FCVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.AzureFile != nil {
+		in, out := &in.AzureFile, &out.AzureFile
+		*out = new(v1.AzureFileVolumeSource)
+		**out = **in
+	}
+	if in.ConfigMap != nil {
+		in, out := &in.ConfigMap, &out.ConfigMap
+		*out = new(v1.ConfigMapVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.VsphereVolume != nil {
+		in, out := &in.VsphereVolume, &out.VsphereVolume
+		*out = new(v1.VsphereVirtualDiskVolumeSource)
+		**out = **in
+	}
+	if in.Quobyte != nil {
+		in, out := &in.Quobyte, &out.Quobyte
+		*out = new(v1.QuobyteVolumeSource)
+		**out = **in
+	}
+	if in.AzureDisk != nil {
+		in, out := &in.AzureDisk, &out.AzureDisk
+		*out = new(v1.AzureDiskVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.PhotonPersistentDisk != nil {
+		in, out := &in.PhotonPersistentDisk, &out.PhotonPersistentDisk
+		*out = new(v1.PhotonPersistentDiskVolumeSource)
+		**out = **in
+	}
+	if in.Projected != nil {
+		in, out := &in.Projected, &out.Projected
+		*out = new(v1.ProjectedVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.PortworxVolume != nil {
+		in, out := &in.PortworxVolume, &out.PortworxVolume
+		*out = new(v1.PortworxVolumeSource)
+		**out = **in
+	}
+	if in.ScaleIO != nil {
+		in, out := &in.ScaleIO, &out.ScaleIO
+		*out = new(v1.ScaleIOVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.StorageOS != nil {
+		in, out := &in.StorageOS, &out.StorageOS
+		*out = new(v1.StorageOSVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.CSI != nil {
+		in, out := &in.CSI, &out.CSI
+		*out = new(v1.CSIVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Ephemeral != nil {
+		in, out := &in.Ephemeral, &out.Ephemeral
+		*out = new(v1.EphemeralVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AbstractVolumeSource.
+func (in *AbstractVolumeSource) DeepCopy() *AbstractVolumeSource {
+	if in == nil {
+		return nil
+	}
+	out := new(AbstractVolumeSource)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *Backoff) DeepCopyInto(out *Backoff) {
 	*out = *in
 	if in.Duration != nil {
 		in, out := &in.Duration, &out.Duration
-		*out = new(v1.Duration)
+		*out = new(metav1.Duration)
 		**out = **in
 	}
 	if in.Cap != nil {
 		in, out := &in.Cap, &out.Cap
-		*out = new(v1.Duration)
+		*out = new(metav1.Duration)
 		**out = **in
 	}
 }
@@ -136,7 +296,7 @@ func (in *Container) DeepCopyInto(out *Container) {
 	*out = *in
 	if in.VolumeMounts != nil {
 		in, out := &in.VolumeMounts, &out.VolumeMounts
-		*out = make([]corev1.VolumeMount, len(*in))
+		*out = make([]v1.VolumeMount, len(*in))
 		for i := range *in {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
@@ -158,7 +318,7 @@ func (in *Container) DeepCopyInto(out *Container) {
 	}
 	if in.Env != nil {
 		in, out := &in.Env, &out.Env
-		*out = make([]corev1.EnvVar, len(*in))
+		*out = make([]v1.EnvVar, len(*in))
 		for i := range *in {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
@@ -216,7 +376,7 @@ func (in *DBDataSourceFrom) DeepCopyInto(out *DBDataSourceFrom) {
 	*out = *in
 	if in.SecretKeyRef != nil {
 		in, out := &in.SecretKeyRef, &out.SecretKeyRef
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 }
@@ -364,7 +524,7 @@ func (in *GetPodSpecReq) DeepCopyInto(out *GetPodSpecReq) {
 	in.Sidecar.DeepCopyInto(&out.Sidecar)
 	if in.ImagePullSecrets != nil {
 		in, out := &in.ImagePullSecrets, &out.ImagePullSecrets
-		*out = make([]corev1.LocalObjectReference, len(*in))
+		*out = make([]v1.LocalObjectReference, len(*in))
 		copy(*out, *in)
 	}
 }
@@ -389,22 +549,22 @@ func (in *Git) DeepCopyInto(out *Git) {
 	}
 	if in.UsernameSecret != nil {
 		in, out := &in.UsernameSecret, &out.UsernameSecret
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 	if in.PasswordSecret != nil {
 		in, out := &in.PasswordSecret, &out.PasswordSecret
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 	if in.SSHPrivateKeySecret != nil {
 		in, out := &in.SSHPrivateKeySecret, &out.SSHPrivateKeySecret
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 	if in.Env != nil {
 		in, out := &in.Env, &out.Env
-		*out = make([]corev1.EnvVar, len(*in))
+		*out = make([]v1.EnvVar, len(*in))
 		for i := range *in {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
@@ -815,7 +975,7 @@ func (in *PipelineSpec) DeepCopyInto(out *PipelineSpec) {
 	}
 	if in.DeletionDelay != nil {
 		in, out := &in.DeletionDelay, &out.DeletionDelay
-		*out = new(v1.Duration)
+		*out = new(metav1.Duration)
 		**out = **in
 	}
 }
@@ -835,7 +995,7 @@ func (in *PipelineStatus) DeepCopyInto(out *PipelineStatus) {
 	*out = *in
 	if in.Conditions != nil {
 		in, out := &in.Conditions, &out.Conditions
-		*out = make([]v1.Condition, len(*in))
+		*out = make([]metav1.Condition, len(*in))
 		for i := range *in {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
@@ -900,7 +1060,7 @@ func (in *S3Source) DeepCopyInto(out *S3Source) {
 	in.S3.DeepCopyInto(&out.S3)
 	if in.PollPeriod != nil {
 		in, out := &in.PollPeriod, &out.PollPeriod
-		*out = new(v1.Duration)
+		*out = new(metav1.Duration)
 		**out = **in
 	}
 }
@@ -920,12 +1080,12 @@ func (in *SASL) DeepCopyInto(out *SASL) {
 	*out = *in
 	if in.UserSecret != nil {
 		in, out := &in.UserSecret, &out.UserSecret
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 	if in.PasswordSecret != nil {
 		in, out := &in.PasswordSecret, &out.PasswordSecret
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 }
@@ -1011,7 +1171,7 @@ func (in *STANAuth) DeepCopyInto(out *STANAuth) {
 	*out = *in
 	if in.Token != nil {
 		in, out := &in.Token, &out.Token
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 }
@@ -1361,7 +1521,7 @@ func (in *StepSpec) DeepCopyInto(out *StepSpec) {
 	}
 	if in.Volumes != nil {
 		in, out := &in.Volumes, &out.Volumes
-		*out = make([]corev1.Volume, len(*in))
+		*out = make([]v1.Volume, len(*in))
 		for i := range *in {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
@@ -1380,12 +1540,12 @@ func (in *StepSpec) DeepCopyInto(out *StepSpec) {
 	}
 	if in.Affinity != nil {
 		in, out := &in.Affinity, &out.Affinity
-		*out = new(corev1.Affinity)
+		*out = new(v1.Affinity)
 		(*in).DeepCopyInto(*out)
 	}
 	if in.Tolerations != nil {
 		in, out := &in.Tolerations, &out.Tolerations
-		*out = make([]corev1.Toleration, len(*in))
+		*out = make([]v1.Toleration, len(*in))
 		for i := range *in {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
@@ -1393,7 +1553,7 @@ func (in *StepSpec) DeepCopyInto(out *StepSpec) {
 	in.Sidecar.DeepCopyInto(&out.Sidecar)
 	if in.ImagePullSecrets != nil {
 		in, out := &in.ImagePullSecrets, &out.ImagePullSecrets
-		*out = make([]corev1.LocalObjectReference, len(*in))
+		*out = make([]v1.LocalObjectReference, len(*in))
 		copy(*out, *in)
 	}
 }
@@ -1458,17 +1618,17 @@ func (in *TLS) DeepCopyInto(out *TLS) {
 	*out = *in
 	if in.CACertSecret != nil {
 		in, out := &in.CACertSecret, &out.CACertSecret
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 	if in.CertSecret != nil {
 		in, out := &in.CertSecret, &out.CertSecret
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 	if in.KeySecret != nil {
 		in, out := &in.KeySecret, &out.KeySecret
-		*out = new(corev1.SecretKeySelector)
+		*out = new(v1.SecretKeySelector)
 		(*in).DeepCopyInto(*out)
 	}
 }
@@ -1486,7 +1646,7 @@ func (in *TLS) DeepCopy() *TLS {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *VolumeSink) DeepCopyInto(out *VolumeSink) {
 	*out = *in
-	in.VolumeSource.DeepCopyInto(&out.VolumeSource)
+	in.AbstractVolumeSource.DeepCopyInto(&out.AbstractVolumeSource)
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeSink.
@@ -1502,10 +1662,10 @@ func (in *VolumeSink) DeepCopy() *VolumeSink {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *VolumeSource) DeepCopyInto(out *VolumeSource) {
 	*out = *in
-	in.VolumeSource.DeepCopyInto(&out.VolumeSource)
+	in.AbstractVolumeSource.DeepCopyInto(&out.AbstractVolumeSource)
 	if in.PollPeriod != nil {
 		in, out := &in.PollPeriod, &out.PollPeriod
-		*out = new(v1.Duration)
+		*out = new(metav1.Duration)
 		**out = **in
 	}
 }
diff --git a/docs/FEATURES.md b/docs/FEATURES.md
index 917ceeb5..a6f28491 100644
--- a/docs/FEATURES.md
+++ b/docs/FEATURES.md
@@ -36,6 +36,7 @@ alpha/beta/stable.
 | Kafka source | v0.0.59 | | |
 | Log sink | |  v0.0.59 |  |
 | Map step | v0.0.59 | v0.0.70 | |
+| Meta-data | v0.0.102 | | |
 | NATS Streaming sink | v0.0.59 | | |
 | NATS Streaming source | v0.0.59 | | |
 | NodeJS SDK | v0.0.78 | | |
diff --git a/docs/META.md b/docs/META.md
new file mode 100644
index 00000000..67497d7e
--- /dev/null
+++ b/docs/META.md
@@ -0,0 +1,32 @@
+# Meta-data
+
+Messages come with meta-data that can be accessed via the messages context:
+
+| Name | Description |
+|---|---|
+| `source` | A URN for the source the message came from |
+| `id` | A unique identifier for the messages within the source |
+
+`source+id` is intended to be globally unique.
+
+Source:
+
+* Cron: `urn:dataflow:cron:${schedule}`
+* Database: `urn:dataflow:db:${dbURL}` or `urn:dataflow:db:${secret}.secret.${namespace}.${cluster}`
+* HTTP: `urn:dataflow:http:https://${serviceName}.svc.${namespace}.${cluster}` or `urn:dataflow:http:${endpoint}`
+* Kafka: `urn:dataflow:kafka:${broker[0]}:${topic}`
+* S3: `urn:dataflow:s3:${bucket}`
+* STAN: `urn:dataflow:stan:${natsURL}:${subject}`
+* Volume:
+    * `urn:dataflow:volume:configmap:${configmap}.configmap.${namespace}.${cluster}`
+    * `urn:dataflow:volume:secret:${secret}.secret.${namespace}.${cluster}`
+
+IDs:
+
+* Cron: `${now}`
+* Database: `${offset}`
+* HTTP: `${randomGUID}`
+* Kafka: `${partition}-${offset}`
+* S3: `${key}`
+* STAN: `${sequence}`
+* Volume: `${filename}`
diff --git a/runner/dedupe/dedupe.go b/runner/dedupe/dedupe.go
index da417189..561af844 100644
--- a/runner/dedupe/dedupe.go
+++ b/runner/dedupe/dedupe.go
@@ -56,7 +56,11 @@ func Exec(ctx context.Context, x string, maxSize resource.Quantity) error {
 	}, 15*time.Second, 1.2, true, ctx.Done())
 
 	return golang.StartWithContext(ctx, func(ctx context.Context, msg []byte) ([]byte, error) {
-		r, err := expr.Run(prog, util.ExprEnv(msg))
+		env, err := util.ExprEnv(ctx, msg)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create expr env: %w", err)
+		}
+		r, err := expr.Run(prog, env)
 		if err != nil {
 			return nil, fmt.Errorf("failed to execute program: %w", err)
 		}
diff --git a/runner/filter/filter.go b/runner/filter/filter.go
index 4f4c9bf0..8577c84f 100644
--- a/runner/filter/filter.go
+++ b/runner/filter/filter.go
@@ -17,7 +17,11 @@ func Exec(ctx context.Context, x string) error {
 		return fmt.Errorf("failed to compile %q: %w", x, err)
 	}
 	return golang.StartWithContext(ctx, func(ctx context.Context, msg []byte) ([]byte, error) {
-		res, err := expr.Run(prog, util.ExprEnv(msg))
+		env, err := util.ExprEnv(ctx, msg)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create expr env: %w", err)
+		}
+		res, err := expr.Run(prog, env)
 		if err != nil {
 			return nil, fmt.Errorf("failed to run program %x: %w", x, err)
 		}
diff --git a/runner/group/group.go b/runner/group/group.go
index 052e0b13..b357b1cd 100644
--- a/runner/group/group.go
+++ b/runner/group/group.go
@@ -46,7 +46,11 @@ func Exec(ctx context.Context, key string, endOfGroup string, groupFormat dfv1.G
 		return fmt.Errorf("failed to compile %q: %w", endOfGroup, err)
 	}
 	return golang.StartWithContext(ctx, func(ctx context.Context, msg []byte) ([]byte, error) {
-		res, err := expr.Run(prog, util.ExprEnv(msg))
+		env, err := util.ExprEnv(ctx, msg)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create expr env: %w", err)
+		}
+		res, err := expr.Run(prog, env)
 		if err != nil {
 			return nil, fmt.Errorf("failed to run program %q: %w", key, err)
 		}
@@ -63,7 +67,11 @@ func Exec(ctx context.Context, key string, endOfGroup string, groupFormat dfv1.G
 			if err := ioutil.WriteFile(path, msg, 0o600); err != nil {
 				return nil, fmt.Errorf("failed to create message file %q: %w", path, err)
 			}
-			res, err = expr.Run(endProg, util.ExprEnv(msg))
+			env, err := util.ExprEnv(ctx, msg)
+			if err != nil {
+				return nil, fmt.Errorf("failed to create expr env: %w", err)
+			}
+			res, err = expr.Run(endProg, env)
 			if err != nil {
 				return nil, fmt.Errorf("failed to run program %q: %w", endOfGroup, err)
 			}
diff --git a/runner/map/map.go b/runner/map/map.go
index 005a6ccb..3034a90d 100644
--- a/runner/map/map.go
+++ b/runner/map/map.go
@@ -17,7 +17,11 @@ func Exec(ctx context.Context, x string) error {
 		return fmt.Errorf("failed to compile %q: %w", x, err)
 	}
 	return golang.StartWithContext(ctx, func(ctx context.Context, msg []byte) ([]byte, error) {
-		res, err := expr.Run(prog, util.ExprEnv(msg))
+		env, err := util.ExprEnv(ctx, msg)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create expr env: %w", err)
+		}
+		res, err := expr.Run(prog, env)
 		if err != nil {
 			return nil, err
 		}
diff --git a/runner/sidecar/in.go b/runner/sidecar/in.go
index 10e2c4d7..20b86b52 100644
--- a/runner/sidecar/in.go
+++ b/runner/sidecar/in.go
@@ -84,6 +84,9 @@ func connectIn(ctx context.Context, sink func(context.Context, []byte) error) (f
 			if err := opentracing.GlobalTracer().Inject(span.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header)); err != nil {
 				return fmt.Errorf("failed to inject tracing headers: %w", err)
 			}
+			if err := dfv1.MetaInject(ctx, req.Header); err != nil {
+				return err
+			}
 			if resp, err := httpClient.Do(req); err != nil {
 				return fmt.Errorf("failed to send to main: %w", err)
 			} else {
diff --git a/runner/sidecar/out.go b/runner/sidecar/out.go
index 21860c7c..3ac435ef 100644
--- a/runner/sidecar/out.go
+++ b/runner/sidecar/out.go
@@ -7,10 +7,11 @@ import (
 	"io/ioutil"
 	"net/http"
 	"os"
+	"time"
 
 	dfv1 "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
+	"github.com/google/uuid"
 	"github.com/opentracing/opentracing-go"
-
 	runtimeutil "k8s.io/apimachinery/pkg/util/runtime"
 )
 
@@ -41,7 +42,7 @@ func connectOutHTTP(sink func(context.Context, []byte) error) {
 			return
 		}
 		if err := sink(
-			ctx,
+			dfv1.ContextWithMeta(ctx, fmt.Sprintf("urn:dataflow:pod:%s.pod.%s.%s:messages", pod, namespace, cluster), uuid.New().String(), time.Now()),
 			data,
 		); err != nil {
 			logger.Error(err, "failed to send message from main to sink")
@@ -70,7 +71,7 @@ func connectOutFIFO(ctx context.Context, sink func(context.Context, []byte) erro
 			scanner := bufio.NewScanner(fifo)
 			for scanner.Scan() {
 				if err := sink(
-					ctx,
+					dfv1.ContextWithMeta(ctx, fmt.Sprintf("urn:dataflow:pod:%s.pod.%s.%s:fifo", pod, namespace, cluster), uuid.New().String(), time.Now()),
 					scanner.Bytes(),
 				); err != nil {
 					return fmt.Errorf("failed to send message from main to sink: %w", err)
diff --git a/runner/sidecar/sidecar.go b/runner/sidecar/sidecar.go
index 6b825ba1..45432988 100644
--- a/runner/sidecar/sidecar.go
+++ b/runner/sidecar/sidecar.go
@@ -37,6 +37,7 @@ var (
 	logger              = sharedutil.NewLogger()
 	cluster             = os.Getenv(dfv1.EnvCluster)
 	namespace           = os.Getenv(dfv1.EnvNamespace)
+	pod                 = os.Getenv(dfv1.EnvPod)
 	patchMu             = sync.Mutex{}
 	pipelineName        = os.Getenv(dfv1.EnvPipelineName)
 	ready               = false // we are ready to serve HTTP requests, also updates pod status condition
@@ -308,7 +309,12 @@ func enrichSpec(ctx context.Context) error {
 
 func enrichSources(ctx context.Context) error {
 	for i, source := range step.Spec.Sources {
-		if x := source.STAN; x != nil {
+		if x := source.HTTP; x != nil {
+			if x.ServiceName == "" {
+				x.ServiceName = pipelineName + "-" + stepName
+			}
+			source.HTTP = x
+		} else if x := source.STAN; x != nil {
 			if err := enrichSTAN(ctx, x); err != nil {
 				return err
 			}
diff --git a/runner/sidecar/sink/db/db.go b/runner/sidecar/sink/db/db.go
index 7e0b61c9..dc0e221a 100644
--- a/runner/sidecar/sink/db/db.go
+++ b/runner/sidecar/sink/db/db.go
@@ -104,7 +104,7 @@ func (d dbSink) Sink(ctx context.Context, msg []byte) error {
 }
 
 func (d dbSink) execStatement(ctx context.Context, tx *sql.Tx, sql string, args []string, msg []byte) (sql.Result, error) {
-	span, _ := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("kafka-sink-%s", d.sinkName))
+	span, ctx := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("kafka-sink-%s", d.sinkName))
 	defer span.Finish()
 	stmt, err := tx.Prepare(sql)
 	if err != nil {
@@ -114,7 +114,11 @@ func (d dbSink) execStatement(ctx context.Context, tx *sql.Tx, sql string, args
 	l := []interface{}{}
 	for _, arg := range args {
 		prog := d.progs[arg]
-		res, err := expr.Run(prog, util.ExprEnv(msg))
+		env, err := util.ExprEnv(ctx, msg)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create expr env: %w", err)
+		}
+		res, err := expr.Run(prog, env)
 		if err != nil {
 			return nil, err
 		}
diff --git a/runner/sidecar/sink/http/http.go b/runner/sidecar/sink/http/http.go
index 717e0e2a..5f491aba 100644
--- a/runner/sidecar/sink/http/http.go
+++ b/runner/sidecar/sink/http/http.go
@@ -57,10 +57,13 @@ func (h httpSink) Sink(ctx context.Context, msg []byte) error {
 	if err != nil {
 		return fmt.Errorf("failed to create HTTP request: %w", err)
 	}
-	req.Header = h.header
+	req.Header = h.header.Clone() // must clone to prevent concurrency issues
 	if err := opentracing.GlobalTracer().Inject(span.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header)); err != nil {
 		return fmt.Errorf("failed to inject tracing headers: %w", err)
 	}
+	if err := dfv1.MetaInject(ctx, req.Header); err != nil {
+		return err
+	}
 	if resp, err := h.client.Do(req); err != nil {
 		return fmt.Errorf("failed to send HTTP request: %w", err)
 	} else {
diff --git a/runner/sidecar/sink/kafka/kafka.go b/runner/sidecar/sink/kafka/kafka.go
index 3942625f..a5c74988 100644
--- a/runner/sidecar/sink/kafka/kafka.go
+++ b/runner/sidecar/sink/kafka/kafka.go
@@ -107,11 +107,19 @@ func New(ctx context.Context, sinkName string, secretInterface corev1.SecretInte
 }
 
 func (h kafkaSink) Sink(ctx context.Context, msg []byte) error {
-	span, _ := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("kafka-sink-%s", h.sinkName))
+	span, ctx := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("kafka-sink-%s", h.sinkName))
 	defer span.Finish()
+	source, id, _, err := dfv1.MetaFromContext(ctx)
+	if err != nil {
+		return err
+	}
 	return h.producer.SendMessage(
 		ctx,
 		&sarama.ProducerMessage{
+			Headers: []sarama.RecordHeader{
+				{Key: []byte("source"), Value: []byte(source)},
+				{Key: []byte("id"), Value: []byte(id)},
+			},
 			Value: sarama.ByteEncoder(msg),
 			Topic: h.topic,
 		},
diff --git a/runner/sidecar/sink/log/log.go b/runner/sidecar/sink/log/log.go
index cd0ec8bc..0be29cc2 100644
--- a/runner/sidecar/sink/log/log.go
+++ b/runner/sidecar/sink/log/log.go
@@ -22,12 +22,16 @@ func New(sinkName string, x dfv1.Log) sink.Interface {
 }
 
 func (s logSink) Sink(ctx context.Context, msg []byte) error {
-	span, _ := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("log-sink-%s", s.sinkName))
+	span, ctx := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("log-sink-%s", s.sinkName))
 	defer span.Finish()
 	text := string(msg)
 	if s.truncate != nil && len(text) > int(*s.truncate) {
 		text = text[0:*s.truncate]
 	}
-	logger.Info(text, "type", "log")
+	source, id, _, err := dfv1.MetaFromContext(ctx)
+	if err != nil {
+		return err
+	}
+	logger.Info(text, "type", "log", "source", source, "id", id)
 	return nil
 }
diff --git a/runner/sidecar/sink/s3/s3.go b/runner/sidecar/sink/s3/s3.go
index ac6afc49..a9498262 100644
--- a/runner/sidecar/sink/s3/s3.go
+++ b/runner/sidecar/sink/s3/s3.go
@@ -15,6 +15,7 @@ import (
 	apierr "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	v1 "k8s.io/client-go/kubernetes/typed/core/v1"
+	"k8s.io/utils/pointer"
 )
 
 type s3Sink struct {
@@ -85,10 +86,15 @@ func (h s3Sink) Sink(ctx context.Context, msg []byte) error {
 	if err != nil {
 		return fmt.Errorf("failed to open %q: %w", m.Path, err)
 	}
+	source, id, _, err := dfv1.MetaFromContext(ctx)
+	if err != nil {
+		return err
+	}
 	_, err = h.client.PutObject(ctx, &s3.PutObjectInput{
-		Bucket: &h.bucket,
-		Key:    &m.Key,
-		Body:   f,
+		Bucket:  &h.bucket,
+		Key:     &m.Key,
+		Body:    f,
+		Tagging: pointer.StringPtr(fmt.Sprintf("%s=%s,%s=%s", dfv1.MetaSource, source, dfv1.MetaID, id)),
 	}, s3.WithAPIOptions(
 		// https://aws.github.io/aws-sdk-go-v2/docs/sdk-utilities/s3/#unseekable-streaming-input
 		v4.SwapComputePayloadSHA256ForUnsignedPayloadMiddleware,
diff --git a/runner/sidecar/source/cron/cron.go b/runner/sidecar/source/cron/cron.go
index 7e31371a..f12ea284 100644
--- a/runner/sidecar/source/cron/cron.go
+++ b/runner/sidecar/source/cron/cron.go
@@ -8,6 +8,7 @@ import (
 	dfv1 "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
 	"github.com/argoproj-labs/argo-dataflow/runner/sidecar/source"
 	sharedutil "github.com/argoproj-labs/argo-dataflow/shared/util"
+	"github.com/google/uuid"
 	"github.com/opentracing/opentracing-go"
 	"github.com/robfig/cron/v3"
 	"k8s.io/apimachinery/pkg/util/runtime"
@@ -19,7 +20,7 @@ type cronSource struct {
 	crn *cron.Cron
 }
 
-func New(ctx context.Context, sourceName string, x dfv1.Cron, process source.Process) (source.Interface, error) {
+func New(ctx context.Context, sourceName, sourceURN string, x dfv1.Cron, process source.Process) (source.Interface, error) {
 	crn := cron.New(
 		cron.WithParser(cron.NewParser(cron.SecondOptional|cron.Minute|cron.Hour|cron.Dom|cron.Month|cron.Dow|cron.Descriptor)),
 		cron.WithChain(cron.Recover(logger)),
@@ -34,7 +35,10 @@ func New(ctx context.Context, sourceName string, x dfv1.Cron, process source.Pro
 		span, ctx := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("cron-source-%s", sourceName))
 		defer span.Finish()
 		msg := []byte(time.Now().Format(x.Layout))
-		if err := process(ctx, msg); err != nil {
+		if err := process(
+			dfv1.ContextWithMeta(ctx, sourceURN, uuid.New().String(), time.Now()),
+			msg,
+		); err != nil {
 			logger.Error(err, "failed to process message")
 		}
 	})
diff --git a/runner/sidecar/source/db/db.go b/runner/sidecar/source/db/db.go
index 6683de6e..270d3290 100644
--- a/runner/sidecar/source/db/db.go
+++ b/runner/sidecar/source/db/db.go
@@ -7,13 +7,14 @@ import (
 	"fmt"
 	"time"
 
+	"k8s.io/apimachinery/pkg/util/runtime"
+
 	dfv1 "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
 	"github.com/argoproj-labs/argo-dataflow/runner/sidecar/source"
 	sharedutil "github.com/argoproj-labs/argo-dataflow/shared/util"
 	_ "github.com/go-sql-driver/mysql"
 	"github.com/opentracing/opentracing-go"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/runtime"
 	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
 )
 
@@ -32,7 +33,7 @@ type dbSource struct {
 	db *sql.DB
 }
 
-func New(ctx context.Context, secretInterface corev1.SecretInterface, cluster, namespace, pipelineName, stepName, sourceName string, x dfv1.DBSource, process source.Process) (source.Interface, error) {
+func New(ctx context.Context, secretInterface corev1.SecretInterface, cluster, namespace, pipelineName, stepName, sourceName, sourceURN string, x dfv1.DBSource, process source.Process) (source.Interface, error) {
 	dataSource, err := getDataSource(ctx, secretInterface, x)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find data source: %w", err)
@@ -72,7 +73,7 @@ func New(ctx context.Context, secretInterface corev1.SecretInterface, cluster, n
 			case <-ctx.Done():
 				return
 			default:
-				if err = queryData(ctx, db, x.Query, x.OffsetColumn, offset, func(ctx context.Context, d rowData) error {
+				if err = queryData(ctx, db, sourceURN, x.Query, x.OffsetColumn, offset, func(ctx context.Context, d rowData) error {
 					span, ctx := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("db-source-%s", sourceName))
 					defer span.Finish()
 					jsonData, err := json.Marshal(d)
@@ -157,7 +158,7 @@ func insertOffset(ctx context.Context, db *sql.DB, uid, remark, offset string) (
 	}
 }
 
-func queryData(ctx context.Context, db *sql.DB, query, offsetColumn, offset string, f func(context.Context, rowData) error) error {
+func queryData(ctx context.Context, db *sql.DB, sourceURN, query, offsetColumn, offset string, f func(context.Context, rowData) error) error {
 	sql := fmt.Sprintf("select * from (%s) as dataflow_query_table order by %s", query, offsetColumn)
 	params := []interface{}{}
 	if offset != "" {
@@ -199,7 +200,11 @@ func queryData(ctx context.Context, db *sql.DB, query, offsetColumn, offset stri
 				entry[col] = val
 			}
 		}
-		if err = f(ctx, entry); err != nil {
+		id := fmt.Sprint(entry[offsetColumn])
+		if err = f(
+			dfv1.ContextWithMeta(ctx, sourceURN, id, time.Now()),
+			entry,
+		); err != nil {
 			logger.Error(err, "failed to process message")
 		}
 	}
diff --git a/runner/sidecar/source/http/http.go b/runner/sidecar/source/http/http.go
index 843acced..70bde87f 100644
--- a/runner/sidecar/source/http/http.go
+++ b/runner/sidecar/source/http/http.go
@@ -4,8 +4,11 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"time"
 
+	dfv1 "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
 	"github.com/argoproj-labs/argo-dataflow/runner/sidecar/source"
+	"github.com/google/uuid"
 	"github.com/opentracing/opentracing-go"
 	"github.com/opentracing/opentracing-go/ext"
 )
@@ -14,7 +17,7 @@ type httpSource struct {
 	ready bool
 }
 
-func New(sourceName, authorization string, process source.Process) source.Interface {
+func New(sourceURN, sourceName, authorization string, process source.Process) source.Interface {
 	h := &httpSource{true}
 	http.HandleFunc("/sources/"+sourceName, func(w http.ResponseWriter, r *http.Request) {
 		wireContext, err := opentracing.GlobalTracer().Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(r.Header))
@@ -42,7 +45,10 @@ func New(sourceName, authorization string, process source.Process) source.Interf
 			_, _ = w.Write([]byte(err.Error()))
 			return
 		}
-		if err := process(ctx, msg); err != nil {
+		if err := process(
+			dfv1.ContextWithMeta(ctx, sourceURN, uuid.New().String(), time.Now()),
+			msg,
+		); err != nil {
 			w.WriteHeader(500)
 			_, _ = w.Write([]byte(err.Error()))
 		} else {
diff --git a/runner/sidecar/source/kafka/handler.go b/runner/sidecar/source/kafka/handler.go
index 31278f61..73582f1d 100644
--- a/runner/sidecar/source/kafka/handler.go
+++ b/runner/sidecar/source/kafka/handler.go
@@ -13,6 +13,7 @@ import (
 
 type handler struct {
 	sourceName   string
+	sourceURN    string
 	process      source.Process
 	i            int
 	manualCommit bool
@@ -49,5 +50,8 @@ func (h handler) processMessage(ctx context.Context, msg *sarama.ConsumerMessage
 	defer runtime.HandleCrash()
 	span, ctx := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("kafka-source-%s", h.sourceName))
 	defer span.Finish()
-	return h.process(ctx, msg.Value)
+	return h.process(
+		dfv1.ContextWithMeta(ctx, h.sourceURN, fmt.Sprintf("%d-%d", msg.Partition, msg.Offset), msg.Timestamp),
+		msg.Value,
+	)
 }
diff --git a/runner/sidecar/source/kafka/kafka.go b/runner/sidecar/source/kafka/kafka.go
index 17c0a77c..cd99dd5c 100644
--- a/runner/sidecar/source/kafka/kafka.go
+++ b/runner/sidecar/source/kafka/kafka.go
@@ -26,7 +26,7 @@ type kafkaSource struct {
 	topic         string
 }
 
-func New(ctx context.Context, secretInterface corev1.SecretInterface, consumerGroupID, sourceName string, x dfv1.KafkaSource, process source.Process) (source.Interface, error) {
+func New(ctx context.Context, secretInterface corev1.SecretInterface, consumerGroupID, sourceName, sourceURN string, x dfv1.KafkaSource, process source.Process) (source.Interface, error) {
 	config, err := kafka.GetConfig(ctx, secretInterface, x.Kafka.KafkaConfig)
 	if err != nil {
 		return nil, err
@@ -51,7 +51,7 @@ func New(ctx context.Context, secretInterface corev1.SecretInterface, consumerGr
 	if err != nil {
 		return nil, err
 	}
-	h := handler{sourceName, process, 0, !x.AutoCommit.Enable}
+	h := handler{sourceName, sourceURN, process, 0, !x.AutoCommit.Enable}
 	go wait.JitterUntil(func() {
 		defer runtime.HandleCrash()
 		ctx := context.Background()
diff --git a/runner/sidecar/source/loadbalanced/loadbalanced.go b/runner/sidecar/source/loadbalanced/loadbalanced.go
index c6d3c21c..10f4ce5e 100644
--- a/runner/sidecar/source/loadbalanced/loadbalanced.go
+++ b/runner/sidecar/source/loadbalanced/loadbalanced.go
@@ -35,6 +35,7 @@ type NewReq struct {
 	PipelineName string
 	StepName     string
 	SourceName   string
+	SourceURN    string
 	LeadReplica  bool
 	Concurrency  int
 	PollPeriod   time.Duration
@@ -49,7 +50,7 @@ func New(ctx context.Context, r NewReq) (source.HasPending, error) {
 	// (b) it would be good to limit the size of this work queue and have the `Add
 	jobs := workqueue.New()
 	authorization := sharedutil.RandString()
-	httpSource := httpsource.New(r.SourceName, authorization, r.Process)
+	httpSource := httpsource.New(r.SourceURN, r.SourceName, authorization, r.Process)
 	if r.LeadReplica {
 		endpoint := "https://" + r.PipelineName + "-" + r.StepName + "/sources/" + r.SourceName
 		t := http.DefaultTransport.(*http.Transport).Clone()
diff --git a/runner/sidecar/source/s3/s3.go b/runner/sidecar/source/s3/s3.go
index 11d21e1a..a4159c2a 100644
--- a/runner/sidecar/source/s3/s3.go
+++ b/runner/sidecar/source/s3/s3.go
@@ -26,7 +26,7 @@ type message struct {
 	Path string `json:"path"`
 }
 
-func New(ctx context.Context, secretInterface corev1.SecretInterface, pipelineName, stepName, sourceName string, x dfv1.S3Source, process source.Process, leadReplica bool) (source.HasPending, error) {
+func New(ctx context.Context, secretInterface corev1.SecretInterface, pipelineName, stepName, sourceName, sourceURN string, x dfv1.S3Source, process source.Process, leadReplica bool) (source.HasPending, error) {
 	logger := sharedutil.NewLogger().WithValues("source", x.Name, "bucket", x.Bucket)
 	var accessKeyID string
 	{
@@ -83,6 +83,7 @@ func New(ctx context.Context, secretInterface corev1.SecretInterface, pipelineNa
 		PipelineName: pipelineName,
 		StepName:     stepName,
 		SourceName:   sourceName,
+		SourceURN:    sourceURN,
 		LeadReplica:  leadReplica,
 		Concurrency:  int(x.Concurrency),
 		PollPeriod:   x.PollPeriod.Duration,
@@ -112,7 +113,10 @@ func New(ctx context.Context, secretInterface corev1.SecretInterface, pipelineNa
 					logger.Error(err, "failed to copy object to FIFO", "path", path)
 				}
 			}()
-			return process(ctx, []byte(sharedutil.MustJSON(message{Key: key, Path: path})))
+			return process(
+				dfv1.ContextWithMeta(ctx, sourceURN, key, *output.LastModified),
+				[]byte(sharedutil.MustJSON(message{Key: key, Path: path})),
+			)
 		},
 		ListItems: func() ([]interface{}, error) {
 			list, err := client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(x.Bucket)})
diff --git a/runner/sidecar/source/stan/stan.go b/runner/sidecar/source/stan/stan.go
index febbaab3..a45c47b2 100644
--- a/runner/sidecar/source/stan/stan.go
+++ b/runner/sidecar/source/stan/stan.go
@@ -29,7 +29,7 @@ type stanSource struct {
 	queueName         string
 }
 
-func New(ctx context.Context, secretInterface corev1.SecretInterface, cluster, namespace, pipelineName, stepName string, replica int, sourceName string, x dfv1.STAN, process source.Process) (source.Interface, error) {
+func New(ctx context.Context, secretInterface corev1.SecretInterface, cluster, namespace, pipelineName, stepName, sourceURN string, replica int, sourceName string, x dfv1.STAN, process source.Process) (source.Interface, error) {
 	genClientID := func() string {
 		// In a particular situation, the stan connection status is inconsistent between stan server and client,
 		// the connection is lost from client side, but the server still thinks it's alive. In this case, use
@@ -55,7 +55,10 @@ func New(ctx context.Context, secretInterface corev1.SecretInterface, cluster, n
 		sub, err := conn.QueueSubscribe(x.Subject, queueName, func(msg *stan.Msg) {
 			span, ctx := opentracing.StartSpanFromContext(ctx, fmt.Sprintf("stan-source-%s", sourceName))
 			defer span.Finish()
-			if err := process(ctx, msg.Data); err != nil {
+			if err := process(
+				dfv1.ContextWithMeta(ctx, sourceURN, fmt.Sprint(msg.Sequence), time.Unix(0, msg.Timestamp)),
+				msg.Data,
+			); err != nil {
 				logger.Error(err, "failed to process message")
 			} else if err := msg.Ack(); err != nil {
 				logger.Error(err, "failed to ack message", "source", sourceName)
diff --git a/runner/sidecar/source/volume/volume.go b/runner/sidecar/source/volume/volume.go
index 25d09fb6..4af0782d 100644
--- a/runner/sidecar/source/volume/volume.go
+++ b/runner/sidecar/source/volume/volume.go
@@ -7,6 +7,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 
 	"github.com/opentracing/opentracing-go"
 
@@ -20,7 +21,7 @@ type message struct {
 	Path string `json:"path"`
 }
 
-func New(ctx context.Context, pipelineName, stepName, sourceName string, x dfv1.VolumeSource, process source.Process, leadReplica bool) (source.HasPending, error) {
+func New(ctx context.Context, pipelineName, stepName, sourceName, sourceURN string, x dfv1.VolumeSource, process source.Process, leadReplica bool) (source.HasPending, error) {
 	logger := sharedutil.NewLogger().WithValues("source", sourceName)
 	dir := filepath.Join(dfv1.PathVarRun, "sources", sourceName)
 	return loadbalanced.New(ctx, loadbalanced.NewReq{
@@ -28,6 +29,7 @@ func New(ctx context.Context, pipelineName, stepName, sourceName string, x dfv1.
 		PipelineName: pipelineName,
 		StepName:     stepName,
 		SourceName:   sourceName,
+		SourceURN:    sourceURN,
 		LeadReplica:  leadReplica,
 		Concurrency:  int(x.Concurrency),
 		PollPeriod:   x.PollPeriod.Duration,
@@ -36,7 +38,10 @@ func New(ctx context.Context, pipelineName, stepName, sourceName string, x dfv1.
 			defer span.Finish()
 			key := string(msg)
 			path := filepath.Join(dir, key)
-			return process(ctx, []byte(sharedutil.MustJSON(message{Path: path})))
+			return process(
+				dfv1.ContextWithMeta(ctx, sourceURN, key, time.Now()),
+				[]byte(sharedutil.MustJSON(message{Path: path})),
+			)
 		},
 		ListItems: func() ([]interface{}, error) {
 			var keys []interface{}
diff --git a/runner/sidecar/sources.go b/runner/sidecar/sources.go
index 87a6fd5d..78039271 100644
--- a/runner/sidecar/sources.go
+++ b/runner/sidecar/sources.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"
 
+	dfv1 "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
 	"github.com/argoproj-labs/argo-dataflow/runner/sidecar/source"
 	"github.com/argoproj-labs/argo-dataflow/runner/sidecar/source/cron"
 	dbsource "github.com/argoproj-labs/argo-dataflow/runner/sidecar/source/db"
@@ -58,7 +59,8 @@ func connectSources(ctx context.Context, process func(context.Context, []byte) e
 	sources := make(map[string]source.Interface)
 	for _, s := range step.Spec.Sources {
 		sourceName := s.Name
-		logger.Info("connecting source", "source", sharedutil.MustJSON(s))
+		sourceURN := s.GenURN(cluster, namespace)
+		logger.Info("connecting source", "source", sharedutil.MustJSON(s), "urn", sourceURN)
 		if _, exists := sources[sourceName]; exists {
 			return fmt.Errorf("duplicate source named %q", sourceName)
 		}
@@ -86,11 +88,18 @@ func connectSources(ctx context.Context, process func(context.Context, []byte) e
 						withLock(func() { step.Status.SourceStatuses.IncrRetries(sourceName, replica) })
 					}
 					// we need to copy anything except the timeout from the parent context
+					source, id, t, err := dfv1.MetaFromContext(ctx)
+					if err != nil {
+						return err
+					}
 					ctx, cancel := context.WithTimeout(
-						opentracing.ContextWithSpan(context.Background(), span),
+						dfv1.ContextWithMeta(
+							opentracing.ContextWithSpan(context.Background(), span),
+							source, id, t,
+						),
 						15*time.Second,
 					)
-					err := process(ctx, msg)
+					err = process(ctx, msg)
 					cancel()
 					if err == nil {
 						return nil
@@ -106,20 +115,20 @@ func connectSources(ctx context.Context, process func(context.Context, []byte) e
 			}
 		}
 		if x := s.Cron; x != nil {
-			if y, err := cron.New(ctx, sourceName, *x, processWithRetry); err != nil {
+			if y, err := cron.New(ctx, sourceName, sourceURN, *x, processWithRetry); err != nil {
 				return err
 			} else {
 				sources[sourceName] = y
 			}
 		} else if x := s.STAN; x != nil {
-			if y, err := stan.New(ctx, secretInterface, cluster, namespace, pipelineName, stepName, replica, sourceName, *x, processWithRetry); err != nil {
+			if y, err := stan.New(ctx, secretInterface, cluster, namespace, pipelineName, stepName, sourceURN, replica, sourceName, *x, processWithRetry); err != nil {
 				return err
 			} else {
 				sources[sourceName] = y
 			}
 		} else if x := s.Kafka; x != nil {
 			groupID := sharedutil.GetSourceUID(cluster, namespace, pipelineName, stepName, sourceName)
-			if y, err := kafkasource.New(ctx, secretInterface, groupID, sourceName, *x, processWithRetry); err != nil {
+			if y, err := kafkasource.New(ctx, secretInterface, groupID, sourceName, sourceURN, *x, processWithRetry); err != nil {
 				return err
 			} else {
 				sources[sourceName] = y
@@ -130,21 +139,21 @@ func connectSources(ctx context.Context, process func(context.Context, []byte) e
 			if err != nil {
 				return fmt.Errorf("failed to get secret %q: %w", step.Name, err)
 			}
-			sources[sourceName] = httpsource.New(sourceName, string(secret.Data[fmt.Sprintf("sources.%s.http.authorization", sourceName)]), processWithRetry)
+			sources[sourceName] = httpsource.New(sourceURN, sourceName, string(secret.Data[fmt.Sprintf("sources.%s.http.authorization", sourceName)]), processWithRetry)
 		} else if x := s.S3; x != nil {
-			if y, err := s3source.New(ctx, secretInterface, pipelineName, stepName, sourceName, *x, processWithRetry, leadReplica()); err != nil {
+			if y, err := s3source.New(ctx, secretInterface, pipelineName, stepName, sourceName, sourceURN, *x, processWithRetry, leadReplica()); err != nil {
 				return err
 			} else {
 				sources[sourceName] = y
 			}
 		} else if x := s.DB; x != nil {
-			if y, err := dbsource.New(ctx, secretInterface, cluster, namespace, pipelineName, stepName, sourceName, *x, processWithRetry); err != nil {
+			if y, err := dbsource.New(ctx, secretInterface, cluster, namespace, pipelineName, stepName, sourceName, sourceURN, *x, processWithRetry); err != nil {
 				return err
 			} else {
 				sources[sourceName] = y
 			}
 		} else if x := s.Volume; x != nil {
-			if y, err := volumeSource.New(ctx, pipelineName, stepName, sourceName, *x, processWithRetry, leadReplica()); err != nil {
+			if y, err := volumeSource.New(ctx, pipelineName, stepName, sourceName, sourceURN, *x, processWithRetry, leadReplica()); err != nil {
 				return err
 			} else {
 				sources[sourceName] = y
diff --git a/runner/util/expr_env.go b/runner/util/expr_env.go
index 4f3f5f0f..5f455bf6 100644
--- a/runner/util/expr_env.go
+++ b/runner/util/expr_env.go
@@ -1,10 +1,14 @@
 package util
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"strconv"
+	time "time"
+
+	dfv1 "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
 
 	"github.com/Masterminds/sprig"
 )
@@ -15,9 +19,18 @@ var io = map[string]interface{}{
 	"cat": cat,
 }
 
-func ExprEnv(msg []byte) map[string]interface{} {
+func ExprEnv(ctx context.Context, msg []byte) (map[string]interface{}, error) {
+	source, id, t, err := dfv1.MetaFromContext(ctx)
+	if err != nil {
+		return nil, err
+	}
 	return map[string]interface{}{
 		// values
+		"ctx": map[string]string{
+			"source": source,
+			"id":     id,
+			"time":   t.Format(time.RFC3339),
+		},
 		"msg": msg,
 		// funcs
 		"bytes":  _bytes,
@@ -28,7 +41,7 @@ func ExprEnv(msg []byte) map[string]interface{} {
 		"sprig":  _sprig,
 		"sha1":   _sha1,
 		"io":     io,
-	}
+	}, nil
 }
 
 func _bytes(v interface{}) []byte {
diff --git a/sdks/golang/start.go b/sdks/golang/start.go
index 70cbec46..f5763fb0 100644
--- a/sdks/golang/start.go
+++ b/sdks/golang/start.go
@@ -5,6 +5,8 @@ import (
 	"io/ioutil"
 	"log"
 	"net/http"
+
+	dfv1 "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
 )
 
 func Start(handler func(ctx context.Context, msg []byte) ([]byte, error)) {
@@ -19,12 +21,13 @@ func StartWithContext(ctx context.Context, handler func(ctx context.Context, msg
 		w.WriteHeader(204)
 	})
 	http.HandleFunc("/messages", func(w http.ResponseWriter, r *http.Request) {
+		ctx := dfv1.MetaExtract(r.Context(), r.Header)
 		defer func() { _ = r.Body.Close() }()
 		out, err := func() ([]byte, error) {
 			if in, err := ioutil.ReadAll(r.Body); err != nil {
 				return nil, err
 			} else {
-				return handler(r.Context(), in)
+				return handler(ctx, in)
 			}
 		}()
 		if err != nil {


Test patch:
diff --git a/api/v1alpha1/abstract_volume_source_test.go b/api/v1alpha1/abstract_volume_source_test.go
new file mode 100644
index 00000000..4ebe28de
--- /dev/null
+++ b/api/v1alpha1/abstract_volume_source_test.go
@@ -0,0 +1,39 @@
+package v1alpha1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	corev1 "k8s.io/api/core/v1"
+)
+
+var cluster, namespace = "my-cluster", "my-ns"
+
+func TestAbstractVolumeSource_GenURN(t *testing.T) {
+	t.Run("ConfigMap", func(t *testing.T) {
+		urn := AbstractVolumeSource{
+			ConfigMap: &corev1.ConfigMapVolumeSource{
+				LocalObjectReference: corev1.LocalObjectReference{
+					Name: "my-name",
+				},
+			},
+		}.GenURN(cluster, namespace)
+		assert.Equal(t, "urn:dataflow:volume:configmap:my-name.configmap.my-ns.my-cluster", urn)
+	})
+	t.Run("PersistentVolumeClaim", func(t *testing.T) {
+		urn := AbstractVolumeSource{
+			PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
+				ClaimName: "my-name",
+			},
+		}.GenURN(cluster, namespace)
+		assert.Equal(t, "urn:dataflow:volume:persistentvolumeclaim:my-name.persistentvolumeclaim.my-ns.my-cluster", urn)
+	})
+	t.Run("Secret", func(t *testing.T) {
+		urn := AbstractVolumeSource{
+			Secret: &corev1.SecretVolumeSource{
+				SecretName: "my-name",
+			},
+		}.GenURN(cluster, namespace)
+		assert.Equal(t, "urn:dataflow:volume:secret:my-name.secret.my-ns.my-cluster", urn)
+	})
+}
diff --git a/api/v1alpha1/cron_test.go b/api/v1alpha1/cron_test.go
new file mode 100644
index 00000000..60e512ca
--- /dev/null
+++ b/api/v1alpha1/cron_test.go
@@ -0,0 +1,12 @@
+package v1alpha1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCron_GenURN(t *testing.T) {
+	urn := Cron{Schedule: "* * * * *"}.GenURN(cluster, namespace)
+	assert.Equal(t, "urn:dataflow:cron:* * * * *", urn)
+}
diff --git a/api/v1alpha1/db_test.go b/api/v1alpha1/db_test.go
new file mode 100644
index 00000000..18b88a0c
--- /dev/null
+++ b/api/v1alpha1/db_test.go
@@ -0,0 +1,22 @@
+package v1alpha1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	corev1 "k8s.io/api/core/v1"
+)
+
+func TestDatabase_GenURN(t *testing.T) {
+	t.Run("Value", func(t *testing.T) {
+		urn := Database{DataSource: &DBDataSource{Value: "my-value"}}.GenURN(cluster, namespace)
+		assert.Equal(t, "urn:dataflow:db:my-value", urn)
+	})
+	t.Run("ValueFrom", func(t *testing.T) {
+		urn := Database{DataSource: &DBDataSource{ValueFrom: &DBDataSourceFrom{SecretKeyRef: &corev1.SecretKeySelector{
+			LocalObjectReference: corev1.LocalObjectReference{Name: "my-name"},
+			Key:                  "my-key",
+		}}}}.GenURN(cluster, namespace)
+		assert.Equal(t, "urn:dataflow:db:my-name.secret.my-ns.my-cluster:my-key", urn)
+	})
+}
diff --git a/api/v1alpha1/http_source_test.go b/api/v1alpha1/http_source_test.go
new file mode 100644
index 00000000..e09d15f3
--- /dev/null
+++ b/api/v1alpha1/http_source_test.go
@@ -0,0 +1,14 @@
+package v1alpha1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHTTPSource_GenURN(t *testing.T) {
+	urn := HTTPSource{
+		ServiceName: "my-name",
+	}.GenURN(cluster, namespace)
+	assert.Equal(t, "urn:dataflow:http:https://my-name.svc.my-ns.my-cluster", urn)
+}
diff --git a/api/v1alpha1/kafka_test.go b/api/v1alpha1/kafka_test.go
new file mode 100644
index 00000000..d325699d
--- /dev/null
+++ b/api/v1alpha1/kafka_test.go
@@ -0,0 +1,17 @@
+package v1alpha1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestKafka_GenURN(t *testing.T) {
+	urn := Kafka{
+		KafkaConfig: KafkaConfig{
+			Brokers: []string{"my-broker"},
+		},
+		Topic: "my-topic",
+	}.GenURN(cluster, namespace)
+	assert.Equal(t, "urn:dataflow:kafka:my-broker:my-topic", urn)
+}
diff --git a/api/v1alpha1/meta_test.go b/api/v1alpha1/meta_test.go
new file mode 100644
index 00000000..04ab9ef8
--- /dev/null
+++ b/api/v1alpha1/meta_test.go
@@ -0,0 +1,20 @@
+package v1alpha1
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestContextWithMeta(t *testing.T) {
+	var timestamp time.Time
+	ctx := ContextWithMeta(context.Background(), "my-source", "my-id", timestamp)
+
+	source, id, t2, err := MetaFromContext(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, "my-source", source)
+	assert.Equal(t, "my-id", id)
+	assert.Equal(t, timestamp, t2)
+}
diff --git a/api/v1alpha1/s3_test.go b/api/v1alpha1/s3_test.go
new file mode 100644
index 00000000..7f29c556
--- /dev/null
+++ b/api/v1alpha1/s3_test.go
@@ -0,0 +1,12 @@
+package v1alpha1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestS3_GenURN(t *testing.T) {
+	urn := S3{Bucket: "my-bucket"}.GenURN(cluster, namespace)
+	assert.Equal(t, "urn:dataflow:s3:my-bucket", urn)
+}
diff --git a/api/v1alpha1/stan_test.go b/api/v1alpha1/stan_test.go
new file mode 100644
index 00000000..a89b580b
--- /dev/null
+++ b/api/v1alpha1/stan_test.go
@@ -0,0 +1,12 @@
+package v1alpha1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSTAN_GenURN(t *testing.T) {
+	urn := STAN{NATSURL: "my-url", Subject: "my-subject"}.GenURN(cluster, namespace)
+	assert.Equal(t, "urn:dataflow:stan:my-url:my-subject", urn)
+}
diff --git a/api/v1alpha1/step_types_test.go b/api/v1alpha1/step_types_test.go
index 0f11203d..13db97d8 100644
--- a/api/v1alpha1/step_types_test.go
+++ b/api/v1alpha1/step_types_test.go
@@ -20,6 +20,7 @@ func TestStep_GetPodSpec(t *testing.T) {
 				{Name: "ARGO_DATAFLOW_CLUSTER", Value: "my-cluster"},
 				{Name: "ARGO_DATAFLOW_DEBUG", Value: "false"},
 				{Name: "ARGO_DATAFLOW_NAMESPACE", ValueFrom: &corev1.EnvVarSource{FieldRef: &corev1.ObjectFieldSelector{FieldPath: "metadata.namespace"}}},
+				{Name: "ARGO_DATAFLOW_POD", ValueFrom: &corev1.EnvVarSource{FieldRef: &corev1.ObjectFieldSelector{FieldPath: "metadata.name"}}},
 				{Name: "ARGO_DATAFLOW_PIPELINE_NAME", Value: "my-pl"},
 				{Name: "ARGO_DATAFLOW_REPLICA", Value: fmt.Sprintf("%d", replica)},
 				{Name: "ARGO_DATAFLOW_STEP", Value: `{"metadata":{"creationTimestamp":null},"spec":{"name":"main","cat":{"resources":{"limits":{"cpu":"500m","memory":"256Mi"},"requests":{"cpu":"100m","memory":"64Mi"}}},"scale":{},"sidecar":{"resources":{}}},"status":{"phase":"","replicas":0,"lastScaledAt":null}}`},
diff --git a/test/e2e/volume_sink_test.go b/test/e2e/volume_sink_test.go
index a247e678..2b76534d 100644
--- a/test/e2e/volume_sink_test.go
+++ b/test/e2e/volume_sink_test.go
@@ -32,7 +32,7 @@ func Handler(ctx context.Context, m []byte) ([]byte, error) {
 }`,
 					},
 					Sources: []Source{{HTTP: &HTTPSource{}}},
-					Sinks:   []Sink{{Volume: &VolumeSink{VolumeSource: corev1.VolumeSource{EmptyDir: &corev1.EmptyDirVolumeSource{}}}}},
+					Sinks:   []Sink{{Volume: &VolumeSink{AbstractVolumeSource: AbstractVolumeSource{EmptyDir: &corev1.EmptyDirVolumeSource{}}}}},
 				},
 			},
 		},
diff --git a/test/e2e/volume_source_test.go b/test/e2e/volume_source_test.go
index e88671f1..82f3a174 100644
--- a/test/e2e/volume_source_test.go
+++ b/test/e2e/volume_source_test.go
@@ -31,7 +31,7 @@ func TestVolumeSource(t *testing.T) {
 					Map:  &Map{Expression: "io.cat(object(msg).path)"},
 					Sources: []Source{{Volume: &VolumeSource{
 						ReadOnly: true,
-						VolumeSource: corev1.VolumeSource{
+						AbstractVolumeSource: AbstractVolumeSource{
 							ConfigMap: &corev1.ConfigMapVolumeSource{
 								LocalObjectReference: corev1.LocalObjectReference{
 									Name: "test-volume-source",
diff --git a/test/http-stress/http_stress_test.go b/test/http-stress/http_stress_test.go
index b4f7c019..90ae98a5 100644
--- a/test/http-stress/http_stress_test.go
+++ b/test/http-stress/http_stress_test.go
@@ -10,7 +10,6 @@ import (
 	. "github.com/argoproj-labs/argo-dataflow/test/stress"
 
 	v1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
@@ -25,7 +24,7 @@ func TestHTTPSourceStress(t *testing.T) {
 				Cat: &Cat{
 					AbstractStep: AbstractStep{Resources: v1.ResourceRequirements{
 						Requests: v1.ResourceList{
-							v1.ResourceMemory: resource.MustParse("512Mi"),
+							v1.ResourceMemory: Params.ResourceMemory,
 						},
 					}},
 				},
@@ -34,7 +33,7 @@ func TestHTTPSourceStress(t *testing.T) {
 				Sinks:    []Sink{DefaultLogSink},
 				Sidecar: Sidecar{Resources: v1.ResourceRequirements{
 					Requests: v1.ResourceList{
-						v1.ResourceMemory: resource.MustParse("512Mi"),
+						v1.ResourceMemory: Params.ResourceMemory,
 					},
 				}},
 			}},
@@ -67,7 +66,7 @@ func TestHTTPSinkStress(t *testing.T) {
 				Name: "main",
 				Cat: &Cat{AbstractStep: AbstractStep{Resources: v1.ResourceRequirements{
 					Requests: v1.ResourceList{
-						v1.ResourceMemory: resource.MustParse("512Mi"),
+						v1.ResourceMemory: Params.ResourceMemory,
 					},
 				}}},
 				Replicas: Params.Replicas,
@@ -75,7 +74,7 @@ func TestHTTPSinkStress(t *testing.T) {
 				Sinks:    []Sink{{HTTP: &HTTPSink{URL: "http://testapi/count/incr"}}, DefaultLogSink},
 				Sidecar: Sidecar{Resources: v1.ResourceRequirements{
 					Requests: v1.ResourceList{
-						v1.ResourceMemory: resource.MustParse("512Mi"),
+						v1.ResourceMemory: Params.ResourceMemory,
 					},
 				}},
 			}},
@@ -83,6 +82,7 @@ func TestHTTPSinkStress(t *testing.T) {
 	})
 
 	WaitForPipeline()
+	WaitForPod()
 
 	defer StartPortForward("http-main-0")()
 
diff --git a/test/http-stress/test-results.json b/test/http-stress/test-results.json
index 0bfc2a7f..b278887c 100644
--- a/test/http-stress/test-results.json
+++ b/test/http-stress/test-results.json
@@ -1,5 +1,5 @@
 {
-  "TestHTTPSinkStress/.tps": 700,
+  "TestHTTPSinkStress/.tps": 500,
   "TestHTTPSinkStress/N=10,messageSize=100.tps": 0,
   "TestHTTPSinkStress/N=10,messageSize=1000.tps": 500,
   "TestHTTPSinkStress/messageSize=1000.tps": 450,
diff --git a/test/kafka-stress/kafka_stress_test.go b/test/kafka-stress/kafka_stress_test.go
index b81af67e..a7eeb613 100644
--- a/test/kafka-stress/kafka_stress_test.go
+++ b/test/kafka-stress/kafka_stress_test.go
@@ -5,10 +5,8 @@ package kafka_stress
 import (
 	"testing"
 
-	v1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/resource"
-
 	. "github.com/argoproj-labs/argo-dataflow/test/stress"
+	v1 "k8s.io/api/core/v1"
 
 	. "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
 	. "github.com/argoproj-labs/argo-dataflow/test"
@@ -30,7 +28,7 @@ func TestKafkaSourceStress(t *testing.T) {
 				Cat: &Cat{
 					AbstractStep: AbstractStep{Resources: v1.ResourceRequirements{
 						Requests: v1.ResourceList{
-							v1.ResourceMemory: resource.MustParse("1Gi"),
+							v1.ResourceMemory: Params.ResourceMemory,
 						},
 					}},
 				},
@@ -70,7 +68,7 @@ func TestKafkaSinkStress(t *testing.T) {
 				Cat: &Cat{
 					AbstractStep: AbstractStep{Resources: v1.ResourceRequirements{
 						Requests: v1.ResourceList{
-							v1.ResourceMemory: resource.MustParse("1Gi"),
+							v1.ResourceMemory: Params.ResourceMemory,
 						},
 					}},
 				},
diff --git a/test/stan-stress/stan_stress_test.go b/test/stan-stress/stan_stress_test.go
index e9dae0be..42901e51 100644
--- a/test/stan-stress/stan_stress_test.go
+++ b/test/stan-stress/stan_stress_test.go
@@ -5,10 +5,8 @@ package stan_stress
 import (
 	"testing"
 
-	v1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/resource"
-
 	. "github.com/argoproj-labs/argo-dataflow/test/stress"
+	v1 "k8s.io/api/core/v1"
 
 	. "github.com/argoproj-labs/argo-dataflow/api/v1alpha1"
 	. "github.com/argoproj-labs/argo-dataflow/test"
@@ -33,7 +31,7 @@ func TestStanSourceStress(t *testing.T) {
 				Sinks:    []Sink{DefaultLogSink},
 				Sidecar: Sidecar{Resources: v1.ResourceRequirements{
 					Requests: v1.ResourceList{
-						v1.ResourceMemory: resource.MustParse("1Gi"),
+						v1.ResourceMemory: Params.ResourceMemory,
 					},
 				}},
 			}},
@@ -72,7 +70,7 @@ func TestStanSinkStress(t *testing.T) {
 				Sinks:    []Sink{{STAN: &STAN{Subject: sinkSubject}}, DefaultLogSink},
 				Sidecar: Sidecar{Resources: v1.ResourceRequirements{
 					Requests: v1.ResourceList{
-						v1.ResourceMemory: resource.MustParse("1Gi"),
+						v1.ResourceMemory: Params.ResourceMemory,
 					},
 				}},
 			}},
diff --git a/test/stress/params.go b/test/stress/params.go
index ee6663ab..f6605665 100644
--- a/test/stress/params.go
+++ b/test/stress/params.go
@@ -7,21 +7,25 @@ import (
 	"os"
 	"time"
 
+	"k8s.io/apimachinery/pkg/api/resource"
+
 	sharedutil "github.com/argoproj-labs/argo-dataflow/shared/util"
 )
 
 var Params = struct {
-	N           int
-	Replicas    uint32
-	Timeout     time.Duration
-	Async       bool
-	MessageSize int
+	N              int
+	Replicas       uint32
+	Timeout        time.Duration
+	Async          bool
+	MessageSize    int
+	ResourceMemory resource.Quantity
 }{
-	N:           sharedutil.GetEnvInt("N", 10000),
-	Replicas:    uint32(sharedutil.GetEnvInt("REPLICAS", 1)),
-	Timeout:     sharedutil.GetEnvDuration("TIMEOUT", 3*time.Minute),
-	Async:       os.Getenv("ASYNC") == "true",
-	MessageSize: sharedutil.GetEnvInt("MESSAGE_SIZE", 0),
+	N:              sharedutil.GetEnvInt("N", 10000),
+	Replicas:       uint32(sharedutil.GetEnvInt("REPLICAS", 1)),
+	Timeout:        sharedutil.GetEnvDuration("TIMEOUT", 3*time.Minute),
+	Async:          os.Getenv("ASYNC") == "true",
+	MessageSize:    sharedutil.GetEnvInt("MESSAGE_SIZE", 0),
+	ResourceMemory: resource.MustParse("256Mi"),
 }
 
 func init() {